12#include "ruby/internal/config.h"
31# include <AvailabilityMacros.h>
35#include "internal/class.h"
36#include "internal/error.h"
37#include "internal/eval.h"
38#include "internal/hash.h"
39#include "internal/io.h"
40#include "internal/load.h"
41#include "internal/object.h"
42#include "internal/process.h"
43#include "internal/string.h"
44#include "internal/symbol.h"
45#include "internal/thread.h"
46#include "internal/variable.h"
50#include "ruby_assert.h"
66#define WIFEXITED(status) 1
70#define WEXITSTATUS(status) (status)
75int rb_str_end_with_asciichar(
VALUE str,
int c);
77long rb_backtrace_length_limit = -1;
81static VALUE rb_mWarning;
82static VALUE rb_cWarningBuffer;
86static ID id_deprecated;
87static ID id_experimental;
88static ID id_performance;
89static ID id_strict_unused_block;
90static VALUE sym_category;
91static VALUE sym_highlight;
96extern const char *rb_dynamic_description;
101#define defined_error(name, num) if (err == (num)) return (name);
102#define undefined_error(name)
103#include "known_errors.inc"
105#undef undefined_error
110err_position_0(
char *buf,
long len,
const char *file,
int line)
115 else if (line == 0) {
116 return snprintf(buf,
len,
"%s: ", file);
119 return snprintf(buf,
len,
"%s:%d: ", file, line);
125err_vcatf(
VALUE str, const
char *pre, const
char *file,
int line,
126 const
char *fmt, va_list args)
130 if (line) rb_str_catf(str,
":%d", line);
134 rb_str_vcatf(str, fmt, args);
141rb_syntax_error_append(
VALUE exc,
VALUE file,
int line,
int column,
144 const char *fn =
NIL_P(file) ? NULL : RSTRING_PTR(file);
146 VALUE mesg = rb_enc_str_new(0, 0, enc);
147 err_vcatf(mesg, NULL, fn, line, fmt, args);
149 rb_write_error_str(mesg);
153 exc = syntax_error_with_path(exc, file, &mesg, enc);
154 err_vcatf(mesg, NULL, fn, line, fmt, args);
160static unsigned int warning_disabled_categories = (
162 ~RB_WARN_CATEGORY_DEFAULT_BITS);
165rb_warning_category_mask(
VALUE category)
167 return 1U << rb_warning_category_from_name(category);
171rb_warning_category_from_name(
VALUE category)
177 !st_lookup(warning_categories.id2enum, cat_id, &cat_value)) {
178 rb_raise(
rb_eArgError,
"unknown category: %"PRIsVALUE, category);
187 if (!st_lookup(warning_categories.enum2id, category, &
id)) {
188 rb_raise(
rb_eArgError,
"invalid category: %d", (
int)category);
194rb_warning_category_update(
unsigned int mask,
unsigned int bits)
196 warning_disabled_categories &= ~mask;
197 warning_disabled_categories |= mask & ~bits;
203 return !(warning_disabled_categories & (1U << category));
231 return RBOOL(rb_warning_category_enabled_p(cat));
245 unsigned int mask = rb_warning_category_mask(category);
246 unsigned int disabled = warning_disabled_categories;
251 warning_disabled_categories = disabled;
263rb_warning_s_categories(
VALUE mod)
265 st_index_t num = warning_categories.id2enum->num_entries;
267 num = st_keys(warning_categories.id2enum, ids, num);
268 VALUE ary = rb_ary_new_capa(num);
269 for (st_index_t i = 0; i < num; ++i) {
270 rb_ary_push(ary,
ID2SYM(ids[i]));
272 return rb_ary_freeze(ary);
287rb_warning_s_warn(
int argc,
VALUE *argv,
VALUE mod)
298 if (!
NIL_P(category)) {
300 if (!rb_warning_category_enabled_p(cat))
return Qnil;
302 rb_write_error_str(str);
343 return rb_funcallv(mod, id_warn, 1, &str);
348rb_warning_warn_arity(
void)
351 return me ? rb_method_entry_arity(me) : 1;
358 rb_warning_category_from_name(category);
361 if (rb_warning_warn_arity() == 1) {
362 return rb_warning_warn(rb_mWarning, str);
367 args[1] = rb_hash_new();
368 rb_hash_aset(args[1], sym_category, category);
374rb_write_warning_str(
VALUE str)
376 rb_warning_warn(rb_mWarning, str);
381warn_vsprintf(
rb_encoding *enc, const
char *file,
int line, const
char *fmt, va_list args)
383 VALUE str = rb_enc_str_new(0, 0, enc);
385 err_vcatf(str,
"warning: ", file, line, fmt, args);
389#define with_warn_vsprintf(enc, file, line, fmt) \
392 va_start(args, fmt); \
393 str = warn_vsprintf(enc, file, line, fmt, args); \
397rb_compile_warn(
const char *file,
int line,
const char *fmt, ...)
400 with_warn_vsprintf(NULL, file, line, fmt) {
401 rb_write_warning_str(str);
397rb_compile_warn(
const char *file,
int line,
const char *fmt, ...) {
…}
407rb_enc_compile_warn(
rb_encoding *enc,
const char *file,
int line,
const char *fmt, ...)
410 with_warn_vsprintf(enc, file, line, fmt) {
411 rb_write_warning_str(str);
418rb_compile_warning(
const char *file,
int line,
const char *fmt, ...)
421 with_warn_vsprintf(NULL, file, line, fmt) {
422 rb_write_warning_str(str);
418rb_compile_warning(
const char *file,
int line,
const char *fmt, ...) {
…}
429rb_enc_compile_warning(
rb_encoding *enc,
const char *file,
int line,
const char *fmt, ...)
432 with_warn_vsprintf(enc, file, line, fmt) {
433 rb_write_warning_str(str);
442 with_warn_vsprintf(NULL, file, line, fmt) {
443 rb_warn_category(str, rb_warning_category_to_name(category));
450warning_string(
rb_encoding *enc, const
char *fmt, va_list args)
453 const char *file = rb_source_location_cstr(&line);
454 return warn_vsprintf(enc, file, line, fmt, args);
457#define with_warning_string(mesg, enc, fmt) \
458 with_warning_string_from(mesg, enc, fmt, fmt)
459#define with_warning_string_from(mesg, enc, fmt, last_arg) \
461 va_list args; va_start(args, last_arg); \
462 mesg = warning_string(enc, fmt, args); \
469 with_warning_string(mesg, 0, fmt) {
470 rb_write_warning_str(mesg);
479 with_warning_string(mesg, 0, fmt) {
480 rb_warn_category(mesg, rb_warning_category_to_name(category));
489 with_warning_string(mesg, enc, fmt) {
490 rb_write_warning_str(mesg);
500 with_warning_string(mesg, 0, fmt) {
501 rb_write_warning_str(mesg);
511 with_warning_string(mesg, 0, fmt) {
512 rb_warn_category(mesg, rb_warning_category_to_name(category));
518rb_warning_string(
const char *fmt, ...)
520 with_warning_string(mesg, 0, fmt) {
527rb_enc_warning(
rb_encoding *enc,
const char *fmt, ...)
530 with_warning_string(mesg, enc, fmt) {
531 rb_write_warning_str(mesg);
538deprecation_warning_enabled(
void)
546warn_deprecated(
VALUE mesg,
const char *removal,
const char *suggest)
551 rb_str_catf(mesg,
" and will be removed in Ruby %s", removal);
553 if (suggest) rb_str_catf(mesg,
"; use %s instead", suggest);
555 rb_warn_category(mesg,
ID2SYM(id_deprecated));
559rb_warn_deprecated(
const char *fmt,
const char *suggest, ...)
561 if (!deprecation_warning_enabled())
return;
563 with_warning_string_from(mesg, 0, fmt, suggest) {
564 warn_deprecated(mesg, NULL, suggest);
569rb_warn_deprecated_to_remove(
const char *removal,
const char *fmt,
const char *suggest, ...)
571 if (!deprecation_warning_enabled())
return;
573 with_warning_string_from(mesg, 0, fmt, suggest) {
574 warn_deprecated(mesg, removal, suggest);
579rb_warn_reserved_name(
const char *coming,
const char *fmt, ...)
581 if (!deprecation_warning_enabled())
return;
583 with_warning_string_from(mesg, 0, fmt, fmt) {
585 rb_str_catf(mesg,
" is reserved for Ruby %s\n", coming);
586 rb_warn_category(mesg,
ID2SYM(id_deprecated));
591end_with_asciichar(
VALUE str,
int c)
594 rb_str_end_with_asciichar(str, c);
599warning_write(
int argc,
VALUE *argv,
VALUE buf)
618 if (!
NIL_P(uplevel)) {
623 location = rb_ec_backtrace_location_ary(ec, lev + 1, 1, TRUE);
624 if (!
NIL_P(location)) {
625 location = rb_ary_entry(location, 0);
628 if (argc > 1 || !
NIL_P(uplevel) || !end_with_asciichar(str,
'\n')) {
630 if (
NIL_P(uplevel)) {
633 else if (
NIL_P(location) ||
638 str = rb_sprintf(
"%s:%ld: warning: ",
642 RBASIC_SET_CLASS(str, rb_cWarningBuffer);
643 rb_io_puts(argc, argv, str);
647 if (!
NIL_P(category)) {
648 category = rb_to_symbol_type(category);
649 rb_warning_category_from_name(category);
652 if (exc == rb_mWarning) {
654 rb_write_error_str(str);
657 rb_warn_category(str, category);
663#define MAX_BUG_REPORTERS 0x100
666 void (*func)(
FILE *out,
void *data);
670static int bug_reporters_size;
673rb_bug_reporter_add(
void (*func)(
FILE *,
void *),
void *data)
676 if (bug_reporters_size >= MAX_BUG_REPORTERS) {
680 reporter->func = func;
681 reporter->data = data;
690#if defined __CYGWIN__ || defined DOSISH
691# define PATH_SEP_ENCODING 1
693 if (x ==
':')
return true;
694 if (x ==
'\\')
return true;
704static const char PATHSEP_REPLACE =
'!';
707append_pathname(
char *p,
const char *pe,
VALUE str)
709#ifdef PATH_SEP_ENCODING
712 const char *s = RSTRING_PTR(str);
713 const char *
const se = s + RSTRING_LEN(str);
718 while (p < pe && s < se && (c = *s) !=
'\0') {
720 if (s == se || !*s)
break;
721 if (path_sep_p(s[1]))
goto skipsep;
723 else if (path_sep_p(c)) {
725 *p++ = PATHSEP_REPLACE;
727 while (++s < se && path_sep_p(*s));
730 const char *
const ss = s;
731 while (p < pe && s < se && *s && !path_sep_p(*s)) {
732#ifdef PATH_SEP_ENCODING
733 int n = rb_enc_mbclen(s, se, enc);
740 if (s > ss) memcpy(p - (s - ss), ss, s - ss);
747append_basename(
char *p,
const char *pe,
struct path_string *path,
VALUE str)
750#ifdef PATH_SEP_ENCODING
753 const char *
const b = RSTRING_PTR(str), *
const e =
RSTRING_END(str), *p = e;
756 if (path_sep_p(p[-1])) {
757#ifdef PATH_SEP_ENCODING
758 const char *t = rb_enc_prev_char(b, p, e, enc);
773 size_t n = path->len;
774 if (p + n > pe) n = pe - p;
775 memcpy(p, path->ptr, n);
780finish_report(
FILE *out, rb_pid_t pid)
782 if (out != stdout && out != stderr) fclose(out);
783#ifdef HAVE_WORKING_FORK
784 if (pid > 0) waitpid(pid, NULL, 0);
813expand_report_argument(
const char **input_template,
struct report_expansion *values,
814 char *buf,
size_t size,
bool word)
817 char *end = buf + size;
818 const char *
template = *input_template;
821 if (p >= end-1 || !*
template)
return NULL;
823 char c = *
template++;
825 if (!store)
continue;
828 switch (c = *
template++) {
830 p = append_basename(p, end, &values->exe,
rb_argv0);
833 p = append_pathname(p, end,
rb_argv0);
836 p = append_basename(p, end, &values->script, GET_VM()->orig_progname);
839 p = append_pathname(p, end, GET_VM()->orig_progname);
842 if (!values->pid) values->pid = getpid();
847 if (!values->time) values->time = time(NULL);
848 snprintf(p, end-p,
"%" PRI_TIMET_PREFIX
"d", values->time);
852 if (c >=
'0' && c <=
'7') {
853 c = (
unsigned char)ruby_scan_oct(
template-1, 3, &n);
855 if (!c) store =
false;
860 if (p < end-1) *p++ = c;
862 *input_template =
template;
867FILE *ruby_popen_writer(
char *
const *argv, rb_pid_t *pid);
870open_report_path(
const char *
template,
char *buf,
size_t size, rb_pid_t *pid)
874 if (!
template)
return NULL;
875 if (0) fprintf(stderr,
"RUBY_CRASH_REPORT=%s\n", buf);
876 if (*
template ==
'|') {
877 char *argv[16], *bufend = buf + size, *p;
880 for (argc = 0; argc < numberof(argv) - 1; ++argc) {
881 while (*
template &&
ISSPACE(*
template))
template++;
882 p = expand_report_argument(&
template, &values, buf, bufend-buf,
true);
888 if (!p)
return ruby_popen_writer(argv, pid);
890 else if (*
template) {
891 expand_report_argument(&
template, &values, buf, size,
false);
892 return fopen(buf,
"w");
897static const char *crash_report;
900#define REPORT_BUG_BUFSIZ 256
902bug_report_file(
const char *file,
int line, rb_pid_t *pid)
904 char buf[REPORT_BUG_BUFSIZ];
905 const char *report = crash_report;
906 if (!report) report = getenv(
"RUBY_CRASH_REPORT");
907 FILE *out = open_report_path(report, buf,
sizeof(buf), pid);
908 int len = err_position_0(buf,
sizeof(buf), file, line);
911 if ((ssize_t)fwrite(buf, 1,
len, out) == (ssize_t)
len)
return out;
914 if ((ssize_t)fwrite(buf, 1,
len, stderr) == (ssize_t)
len) {
917 if ((ssize_t)fwrite(buf, 1,
len, stdout) == (ssize_t)
len) {
924FUNC_MINIMIZED(
static void bug_important_message(
FILE *out,
const char *
const msg,
size_t len));
927bug_important_message(
FILE *out,
const char *
const msg,
size_t len)
929 const char *
const endmsg = msg +
len;
933 if (isatty(fileno(out))) {
934 static const char red[] =
"\033[;31;1;7m";
935 static const char green[] =
"\033[;32;7m";
936 static const char reset[] =
"\033[m";
937 const char *e = strchr(p,
'\n');
938 const int w = (int)(e - p);
940 int i = (int)(e - p);
941 fputs(*p ==
' ' ? green : red, out);
942 fwrite(p, 1, e - p, out);
943 for (; i < w; ++i) fputc(
' ', out);
946 }
while ((p = e + 1) < endmsg && (e = strchr(p,
'\n')) != 0 && e > p + 1);
948 fwrite(p, 1, endmsg - p, out);
951#undef CRASH_REPORTER_MAY_BE_CREATED
952#if defined(__APPLE__) && \
953 (!defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_6 || defined(__POWERPC__))
954# define CRASH_REPORTER_MAY_BE_CREATED
957preface_dump(
FILE *out)
960 static const char msg[] =
""
961 "-- Crash Report log information "
962 "--------------------------------------------\n"
963 " See Crash Report log file in one of the following locations:\n"
964# ifdef CRASH_REPORTER_MAY_BE_CREATED
965 " * ~/Library/Logs/CrashReporter\n"
966 " * /Library/Logs/CrashReporter\n"
968 " * ~/Library/Logs/DiagnosticReports\n"
969 " * /Library/Logs/DiagnosticReports\n"
970 " for more details.\n"
971 "Don't forget to include the above Crash Report log file in bug reports.\n"
973 const size_t msglen =
sizeof(msg) - 1;
975 const char *msg = NULL;
976 const size_t msglen = 0;
978 bug_important_message(out, msg, msglen);
982postscript_dump(
FILE *out)
985 static const char msg[] =
""
988 "\n""Don't forget to include the Crash Report log file under\n"
989# ifdef CRASH_REPORTER_MAY_BE_CREATED
992 "DiagnosticReports directory in bug reports.\n"
995 const size_t msglen =
sizeof(msg) - 1;
997 const char *msg = NULL;
998 const size_t msglen = 0;
1000 bug_important_message(out, msg, msglen);
1005bug_report_begin_valist(
FILE *out, const
char *fmt, va_list args)
1007 char buf[REPORT_BUG_BUFSIZ];
1009 fputs(
"[BUG] ", out);
1010 vsnprintf(buf,
sizeof(buf), fmt, args);
1012 snprintf(buf,
sizeof(buf),
"\n%s\n\n", rb_dynamic_description);
1017#define bug_report_begin(out, fmt) do { \
1019 va_start(args, fmt); \
1020 bug_report_begin_valist(out, fmt, args); \
1025bug_report_end(
FILE *out, rb_pid_t pid)
1030 for (i=0; i<bug_reporters_size; i++) {
1032 (*reporter->func)(out, reporter->data);
1035 postscript_dump(out);
1036 finish_report(out, pid);
1039#define report_bug(file, line, fmt, ctx) do { \
1040 rb_pid_t pid = -1; \
1041 FILE *out = bug_report_file(file, line, &pid); \
1043 bug_report_begin(out, fmt); \
1044 rb_vm_bugreport(ctx, out); \
1045 bug_report_end(out, pid); \
1049#define report_bug_valist(file, line, fmt, ctx, args) do { \
1050 rb_pid_t pid = -1; \
1051 FILE *out = bug_report_file(file, line, &pid); \
1053 bug_report_begin_valist(out, fmt, args); \
1054 rb_vm_bugreport(ctx, out); \
1055 bug_report_end(out, pid); \
1060ruby_set_crash_report(
const char *
template)
1062 crash_report =
template;
1065 char buf[REPORT_BUG_BUFSIZ];
1066 FILE *out = open_report_path(
template, buf,
sizeof(buf), &pid);
1068 time_t t = time(NULL);
1069 fprintf(out,
"ruby_test_bug_report: %s", ctime(&t));
1070 finish_report(out, pid);
1075NORETURN(
static void die(
void));
1079#if defined(_WIN32) && defined(RUBY_MSVCRT_VERSION) && RUBY_MSVCRT_VERSION >= 80
1080 _set_abort_behavior( 0, _CALL_REPORTFAULT);
1088rb_bug_without_die_internal(const
char *fmt, va_list args)
1090 const char *file = NULL;
1094 file = rb_source_location_cstr(&line);
1097 report_bug_valist(file, line, fmt, NULL, args);
1102rb_bug_without_die(const
char *fmt, ...)
1105 va_start(args, fmt);
1106 rb_bug_without_die_internal(fmt, args);
1111rb_bug(
const char *fmt, ...)
1114 va_start(args, fmt);
1115 rb_bug_without_die_internal(fmt, args);
1111rb_bug(
const char *fmt, ...) {
…}
1121rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler,
int sig,
const void *ctx,
const char *fmt, ...)
1123 const char *file = NULL;
1127 file = rb_source_location_cstr(&line);
1130 report_bug(file, line, fmt, ctx);
1132 if (default_sighandler) default_sighandler(sig);
1143 rb_bug(
"%s: errno == 0 (NOERROR)", mesg);
1145 const char *errno_str = rb_strerrno(errno_arg);
1147 rb_bug(
"%s: %s (%s)", mesg, strerror(errno_arg), errno_str);
1149 rb_bug(
"%s: %s (%d)", mesg, strerror(errno_arg), errno_arg);
1157#define write_or_abort(fd, str, len) (write((fd), (str), (len)) < 0 ? abort() : (void)0)
1158#define WRITE_CONST(fd,str) write_or_abort((fd),(str),sizeof(str) - 1)
1161rb_async_bug_errno(
const char *mesg,
int errno_arg)
1163 WRITE_CONST(2,
"[ASYNC BUG] ");
1164 write_or_abort(2, mesg, strlen(mesg));
1165 WRITE_CONST(2,
"\n");
1167 if (errno_arg == 0) {
1168 WRITE_CONST(2,
"errno == 0 (NOERROR)\n");
1171 const char *errno_str = rb_strerrno(errno_arg);
1174 errno_str =
"undefined errno";
1175 write_or_abort(2, errno_str, strlen(errno_str));
1177 WRITE_CONST(2,
"\n\n");
1178 write_or_abort(2, rb_dynamic_description, strlen(rb_dynamic_description));
1183rb_report_bug_valist(
VALUE file,
int line,
const char *fmt, va_list args)
1185 report_bug_valist(RSTRING_PTR(file), line, fmt, NULL, args);
1189rb_assert_failure(
const char *file,
int line,
const char *name,
const char *expr)
1191 rb_assert_failure_detail(file, line, name, expr, NULL);
1195rb_assert_failure_detail(
const char *file,
int line,
const char *name,
const char *expr,
1196 const char *fmt, ...)
1199 FILE *out = bug_report_file(file, line, &pid);
1201 fputs(
"Assertion Failed: ", out);
1202 if (name) fprintf(out,
"%s:", name);
1207 va_start(args, fmt);
1209 vfprintf(out, fmt, args);
1212 fprintf(out,
"\n%s\n\n", rb_dynamic_description);
1215 rb_vm_bugreport(NULL, out);
1216 bug_report_end(out, pid);
1222static const char builtin_types[][10] = {
1255rb_builtin_type_name(
int t)
1258 if ((
unsigned int)t >= numberof(builtin_types))
return 0;
1259 name = builtin_types[t];
1260 if (*name)
return name;
1265displaying_class_of(
VALUE x)
1268 case Qfalse:
return rb_fstring_cstr(
"false");
1269 case Qnil:
return rb_fstring_cstr(
"nil");
1270 case Qtrue:
return rb_fstring_cstr(
"true");
1276builtin_class_name(
VALUE x)
1302rb_builtin_class_name(
VALUE x)
1304 const char *etype = builtin_class_name(x);
1312COLDFUNC NORETURN(
static void unexpected_type(
VALUE,
int,
int));
1313#define UNDEF_LEAKED "undef leaked to the Ruby space"
1316unexpected_type(
VALUE x,
int xt,
int t)
1318 const char *tname = rb_builtin_type_name(t);
1322 mesg = rb_sprintf(
"wrong argument type %"PRIsVALUE
" (expected %s)",
1323 displaying_class_of(x), tname);
1326 else if (xt >
T_MASK && xt <= 0x3f) {
1327 mesg = rb_sprintf(
"unknown type 0x%x (0x%x given, probably comes"
1328 " from extension library for ruby 1.8)", t, xt);
1331 mesg = rb_sprintf(
"unknown type 0x%x (0x%x given)", t, xt);
1341 if (RB_UNLIKELY(UNDEF_P(x))) {
1342 rb_bug(UNDEF_LEAKED);
1346 if (xt != t || (xt ==
T_DATA && rbimpl_rtypeddata_p(x))) {
1355 unexpected_type(x, xt, t);
1362 if (RB_UNLIKELY(UNDEF_P(x))) {
1363 rb_bug(UNDEF_LEAKED);
1366 unexpected_type(x,
TYPE(x), t);
1373 if (child == parent)
return 1;
1389#undef rb_typeddata_is_instance_of
1393 return rb_typeddata_is_instance_of_inline(obj, data_type);
1402 actual = displaying_class_of(obj);
1405 actual = displaying_class_of(obj);
1412 return RTYPEDDATA_GET_DATA(obj);
1416 rb_raise(
rb_eTypeError,
"wrong argument type %"PRIsVALUE
" (expected %s)",
1452static VALUE rb_eNOERROR;
1454ID ruby_static_id_cause;
1455#define id_cause ruby_static_id_cause
1456static ID id_message, id_detailed_message, id_backtrace;
1457static ID id_key, id_matchee, id_args, id_Errno, id_errno, id_i_path;
1458static ID id_receiver, id_recv, id_iseq, id_local_variables;
1459static ID id_private_call_p, id_top, id_bottom;
1461#define id_bt_locations idBt_locations
1462#define id_mesg idMesg
1463#define id_name idName
1465#undef rb_exc_new_cstr
1483 rb_yjit_lazy_push_frame(GET_EC()->cfp->pc);
1518exc_initialize(
int argc,
VALUE *argv,
VALUE exc)
1523 return exc_init(exc, arg);
1552exc_exception(
int argc,
VALUE *argv,
VALUE self)
1557 if (argc == 0)
return self;
1558 if (argc == 1 && self == argv[0])
return self;
1580 VALUE mesg = rb_attr_get(exc, idMesg);
1590rb_get_message(
VALUE exc)
1593 if (UNDEF_P(e))
return Qnil;
1608 if (UNDEF_P(e))
return Qnil;
1620exc_s_to_tty_p(
VALUE self)
1622 return RBOOL(rb_stderr_tty_p());
1626check_highlight_keyword(
VALUE opt,
int auto_tty_detect)
1631 highlight = rb_hash_lookup(opt, sym_highlight);
1633 switch (highlight) {
1635 rb_bool_expected(highlight,
"highlight", TRUE);
1641 if (
NIL_P(highlight)) {
1642 highlight = RBOOL(auto_tty_detect && rb_stderr_tty_p());
1649check_order_keyword(
VALUE opt)
1654 static VALUE kw_order;
1657 order = rb_hash_lookup(opt, kw_order);
1659 if (order !=
Qnil) {
1661 if (
id == id_bottom) order =
Qtrue;
1662 else if (
id == id_top) order =
Qfalse;
1665 "order: %+"PRIsVALUE, order);
1725exc_full_message(
int argc,
VALUE *argv,
VALUE exc)
1727 VALUE opt, str, emesg, errat;
1728 VALUE highlight, order;
1732 highlight = check_highlight_keyword(opt, 1);
1733 order = check_order_keyword(opt);
1736 if (
NIL_P(opt)) opt = rb_hash_new();
1737 rb_hash_aset(opt, sym_highlight, highlight);
1741 errat = rb_get_backtrace(exc);
1742 emesg = rb_get_detailed_message(exc, opt);
1744 rb_error_write(exc, emesg, errat, str, opt, highlight, order);
1758exc_message(
VALUE exc)
1760 return rb_funcallv(exc, idTo_s, 0, 0);
1809exc_detailed_message(
int argc,
VALUE *argv,
VALUE exc)
1815 VALUE highlight = check_highlight_keyword(opt, 0);
1817 extern VALUE rb_decorate_message(
const VALUE eclass,
VALUE emesg,
int highlight);
1819 return rb_decorate_message(
CLASS_OF(exc), rb_get_message(exc),
RTEST(highlight));
1836exc_inspect(
VALUE exc)
1841 exc = rb_obj_as_string(exc);
1842 if (RSTRING_LEN(exc) == 0) {
1851 rb_str_catf(str,
":%+"PRIsVALUE, exc);
1897exc_backtrace(
VALUE exc)
1901 obj = rb_attr_get(exc, id_bt);
1903 if (rb_backtrace_p(obj)) {
1904 obj = rb_backtrace_to_str_ary(obj);
1914rb_get_backtrace(
VALUE exc)
1916 ID mid = id_backtrace;
1918 if (rb_method_basic_definition_p(
CLASS_OF(exc), id_backtrace)) {
1924 info = exc_backtrace(exc);
1928 info = rb_funcallv(exc, mid, 0, 0);
1931 return rb_check_backtrace(info);
1973exc_backtrace_locations(
VALUE exc)
1977 obj = rb_attr_get(exc, id_bt_locations);
1979 obj = rb_backtrace_to_location_ary(obj);
1985rb_check_backtrace(
VALUE bt)
1988 static const char err[] =
"backtrace must be an Array of String or an Array of Thread::Backtrace::Location";
1992 if (rb_backtrace_p(bt))
return bt;
2111 VALUE btobj = rb_location_ary_to_backtrace(bt);
2118 return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt));
2125 return exc_set_backtrace(exc, bt);
2163 return rb_attr_get(exc, id_cause);
2167try_convert_to_exception(
VALUE obj)
2184 VALUE mesg, backtrace;
2186 if (exc == obj)
return Qtrue;
2191 obj = rb_protect(try_convert_to_exception, obj, &state);
2192 if (state || UNDEF_P(obj)) {
2193 rb_set_errinfo(
Qnil);
2198 if (UNDEF_P(mesg))
return Qfalse;
2200 if (UNDEF_P(backtrace))
return Qfalse;
2203 mesg = rb_attr_get(obj, id_mesg);
2204 backtrace = exc_backtrace(obj);
2207 if (!
rb_equal(rb_attr_get(exc, id_mesg), mesg))
2209 return rb_equal(exc_backtrace(exc), backtrace);
2225exit_initialize(
int argc,
VALUE *argv,
VALUE exc)
2233 status =
INT2FIX(EXIT_SUCCESS);
2238 status =
INT2FIX(EXIT_FAILURE);
2244 if (
NIL_P(status)) {
2245 status =
INT2FIX(EXIT_SUCCESS);
2248#if EXIT_SUCCESS != 0
2250 status =
INT2FIX(EXIT_SUCCESS);
2259 status =
INT2FIX(EXIT_SUCCESS);
2275exit_status(
VALUE exc)
2277 return rb_attr_get(exc, id_status);
2289exit_success_p(
VALUE exc)
2291 VALUE status_val = rb_attr_get(exc, id_status);
2294 if (
NIL_P(status_val))
2297 return RBOOL(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
2303 if (!UNDEF_P(recv))
rb_ivar_set(exc, id_recv, recv);
2320frozen_err_initialize(
int argc,
VALUE *argv,
VALUE self)
2323 VALUE values[numberof(keywords)], options;
2326 keywords[0] = id_receiver;
2327 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2329 err_init_recv(self, values[0]);
2341#define frozen_err_receiver name_err_receiver
2349 va_start(args, fmt);
2364 va_start(args, fmt);
2378 cfp = rb_vm_get_ruby_level_next_cfp(ec, cfp);
2380 err_init_recv(exc, recv);
2381 if (cfp && VM_FRAME_TYPE(cfp) != VM_FRAME_MAGIC_DUMMY) {
2382 rb_ivar_set(exc, id_iseq, rb_iseqw_new(cfp->iseq));
2401name_err_initialize(
int argc,
VALUE *argv,
VALUE self)
2404 VALUE values[numberof(keywords)], name, options;
2407 keywords[0] = id_receiver;
2408 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2409 name = (argc > 1) ? argv[--argc] :
Qnil;
2411 name_err_init_attr(self, values[0], name);
2420 exc_init(exc, rb_name_err_mesg_new(mesg, recv, method));
2421 return name_err_init_attr(exc, recv, method);
2428 return name_err_init(exc, mesg, recv, method);
2439name_err_name(
VALUE self)
2441 return rb_attr_get(self, id_name);
2455name_err_local_variables(
VALUE self)
2457 VALUE vars = rb_attr_get(self, id_local_variables);
2460 VALUE iseqw = rb_attr_get(self, id_iseq);
2461 if (!
NIL_P(iseqw)) vars = rb_iseqw_local_variables(iseqw);
2462 if (
NIL_P(vars)) vars = rb_ary_new();
2469nometh_err_init_attr(
VALUE exc,
VALUE args,
int priv)
2493nometh_err_initialize(
int argc,
VALUE *argv,
VALUE self)
2496 VALUE args, options;
2498 priv = (argc > 3) && (--argc,
RTEST(argv[argc]));
2499 args = (argc > 2) ? argv[--argc] :
Qnil;
2500 if (!
NIL_P(options)) argv[argc++] = options;
2502 return nometh_err_init_attr(self, args, priv);
2509 name_err_init(exc, mesg, recv, method);
2510 return nometh_err_init_attr(exc, args, priv);
2520name_err_mesg_mark(
void *p)
2523 rb_gc_mark_movable(ptr->mesg);
2524 rb_gc_mark_movable(ptr->recv);
2525 rb_gc_mark_movable(ptr->name);
2529name_err_mesg_update(
void *p)
2532 ptr->mesg = rb_gc_location(ptr->mesg);
2533 ptr->recv = rb_gc_location(ptr->recv);
2534 ptr->name = rb_gc_location(ptr->name);
2543 name_err_mesg_update,
2545 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE
2569name_err_mesg_alloc(
VALUE klass)
2576name_err_mesg_init_copy(
VALUE obj1,
VALUE obj2)
2578 if (obj1 == obj2)
return obj1;
2595 if (obj1 == obj2)
return Qtrue;
2612name_err_mesg_receiver_name(
VALUE obj)
2623name_err_mesg_to_str(
VALUE obj)
2628 VALUE mesg = ptr->mesg;
2631 struct RString s_str, c_str, d_str;
2632 VALUE c, s, d = 0, args[4], c2;
2636#define FAKE_CSTR(v, str) rb_setup_fake_str((v), (str), rb_strlen_lit(str), usascii)
2637 c = s = FAKE_CSTR(&s_str,
"");
2641 c = d = FAKE_CSTR(&d_str,
"nil");
2644 c = d = FAKE_CSTR(&d_str,
"true");
2647 c = d = FAKE_CSTR(&d_str,
"false");
2650 if (strstr(RSTRING_PTR(mesg),
"%2$s")) {
2651 d = rb_protect(name_err_mesg_receiver_name, obj, &state);
2652 if (state || NIL_OR_UNDEF_P(d))
2655 rb_set_errinfo(
Qnil);
2666 s = FAKE_CSTR(&s_str,
"module ");
2670 s = FAKE_CSTR(&s_str,
"class ");
2682 s = FAKE_CSTR(&s_str,
"");
2683 if (obj == rb_vm_top_self()) {
2684 c = FAKE_CSTR(&c_str,
"main");
2692 s = FAKE_CSTR(&s_str,
"an instance of ");
2696 c2 = rb_protect(name_err_mesg_receiver_name, c, &state);
2697 if (state || NIL_OR_UNDEF_P(c2))
2700 rb_set_errinfo(
Qnil);
2709 args[0] = rb_obj_as_string(
ptr->name);
2722 return name_err_mesg_to_str(obj);
2740name_err_receiver(
VALUE self)
2742 VALUE recv = rb_ivar_lookup(self, id_recv,
Qundef);
2743 if (!UNDEF_P(recv))
return recv;
2745 VALUE mesg = rb_attr_get(self, id_mesg);
2764nometh_err_args(
VALUE self)
2766 return rb_attr_get(self, id_args);
2777nometh_err_private_call_p(
VALUE self)
2779 return rb_attr_get(self, id_private_call_p);
2798key_err_receiver(
VALUE self)
2802 recv = rb_ivar_lookup(self, id_receiver,
Qundef);
2803 if (!UNDEF_P(recv))
return recv;
2815key_err_key(
VALUE self)
2819 key = rb_ivar_lookup(self, id_key,
Qundef);
2820 if (!UNDEF_P(key))
return key;
2844key_err_initialize(
int argc,
VALUE *argv,
VALUE self)
2850 if (!
NIL_P(options)) {
2852 VALUE values[numberof(keywords)];
2854 keywords[0] = id_receiver;
2855 keywords[1] = id_key;
2856 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2857 for (i = 0; i < numberof(values); ++i) {
2858 if (!UNDEF_P(values[i])) {
2875no_matching_pattern_key_err_matchee(
VALUE self)
2879 matchee = rb_ivar_lookup(self, id_matchee,
Qundef);
2880 if (!UNDEF_P(matchee))
return matchee;
2892no_matching_pattern_key_err_key(
VALUE self)
2896 key = rb_ivar_lookup(self, id_key,
Qundef);
2897 if (!UNDEF_P(key))
return key;
2910no_matching_pattern_key_err_initialize(
int argc,
VALUE *argv,
VALUE self)
2916 if (!
NIL_P(options)) {
2918 VALUE values[numberof(keywords)];
2920 keywords[0] = id_matchee;
2921 keywords[1] = id_key;
2922 rb_get_kwargs(options, keywords, 0, numberof(values), values);
2923 for (i = 0; i < numberof(values); ++i) {
2924 if (!UNDEF_P(values[i])) {
2942syntax_error_initialize(
int argc,
VALUE *argv,
VALUE self)
2946 mesg = rb_fstring_lit(
"compile error");
2957 *mesg = rb_enc_str_new(0, 0, enc);
2962 VALUE old_path = rb_attr_get(exc, id_i_path);
2963 if (old_path != path) {
2965 rb_raise(
rb_eArgError,
"SyntaxError#path changed: %+"PRIsVALUE
" (%p->%p)",
2966 old_path, (
void *)old_path, (
void *)path);
2969 rb_raise(
rb_eArgError,
"SyntaxError#path changed: %+"PRIsVALUE
"(%s%s)->%+"PRIsVALUE
"(%s)",
2970 old_path, rb_enc_name(rb_enc_get(old_path)),
2971 (
FL_TEST(old_path, RSTRING_FSTR) ?
":FSTR" :
""),
2972 path, rb_enc_name(rb_enc_get(path)));
2975 VALUE s = *mesg = rb_attr_get(exc, idMesg);
2976 if (RSTRING_LEN(s) > 0 && *(
RSTRING_END(s)-1) !=
'\n')
3030rb_free_warning(
void)
3032 st_free_table(warning_categories.id2enum);
3033 st_free_table(warning_categories.enum2id);
3034 st_free_table(syserr_tbl);
3038setup_syserr(
int n,
const char *name)
3047#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
3052 rb_eEWOULDBLOCK = error;
3055 rb_eEINPROGRESS = error;
3059 rb_define_const(error,
"Errno",
INT2NUM(n));
3060 st_add_direct(syserr_tbl, n, (st_data_t)error);
3065set_syserr(
int n,
const char *name)
3069 if (!st_lookup(syserr_tbl, n, &error)) {
3070 return setup_syserr(n, name);
3074 rb_define_const(
rb_mErrno, name, errclass);
3084 if (!st_lookup(syserr_tbl, n, &error)) {
3087 snprintf(name,
sizeof(name),
"E%03d", n);
3088 return setup_syserr(n, name);
3090 return (
VALUE)error;
3104syserr_initialize(
int argc,
VALUE *argv,
VALUE self)
3107 VALUE mesg, error, func, errmsg;
3111 st_data_t data = (st_data_t)klass;
3114 error = mesg; mesg =
Qnil;
3116 if (!
NIL_P(error) && st_lookup(syserr_tbl,
NUM2LONG(error), &data)) {
3117 klass = (
VALUE)data;
3122 RBASIC_SET_CLASS(self, klass);
3130 else err =
"unknown error";
3136 if (!
NIL_P(func)) rb_str_catf(errmsg,
" @ %"PRIsVALUE, func);
3137 rb_str_catf(errmsg,
" - %"PRIsVALUE, str);
3154syserr_errno(
VALUE self)
3156 return rb_attr_get(self, id_errno);
3177 num = rb_attr_get(exc, id_errno);
3179 num = rb_funcallv(exc, id_errno, 0, 0);
3549exception_alloc(
VALUE klass)
3551 return rb_class_allocate_instance(klass);
3555exception_dumper(
VALUE exc)
3565ivar_copy_i(
ID key,
VALUE val, st_data_t exc)
3571void rb_exc_check_circular_cause(
VALUE exc);
3587 rb_exc_check_circular_cause(exc);
3589 if (rb_attr_get(exc, id_bt) == rb_attr_get(exc, id_bt_locations)) {
3684 syserr_tbl = st_init_numtable();
3724 id_iseq = rb_make_internal_id();
3725 id_recv = rb_make_internal_id();
3727 sym_category =
ID2SYM(id_category);
3730 warning_categories.id2enum = rb_init_identtable();
3736 warning_categories.enum2id = rb_init_identtable();
3750 va_start(args, fmt);
3758rb_vraise(
VALUE exc,
const char *fmt, va_list ap)
3764rb_raise(
VALUE exc_class,
const char *fmt, ...)
3767 va_start(args, fmt);
3773NORETURN(
static void raise_loaderror(
VALUE path,
VALUE mesg));
3789 va_start(args, fmt);
3792 raise_loaderror(
Qnil, mesg);
3801 va_start(args, fmt);
3804 raise_loaderror(path, mesg);
3811 "%"PRIsVALUE
"() function is unimplemented on this machine",
3812 rb_id2str(rb_frame_this_func()));
3816rb_fatal(
const char *fmt, ...)
3821 if (! ruby_thread_has_gvl_p()) {
3824 fprintf(stderr,
"[FATAL] rb_fatal() outside of GVL\n");
3825 rb_print_backtrace(stderr);
3829 va_start(args, fmt);
3816rb_fatal(
const char *fmt, ...) {
…}
3837make_errno_exc(
const char *mesg)
3843 rb_bug(
"rb_sys_fail(%s) - errno == 0", mesg ? mesg :
"");
3849make_errno_exc_str(
VALUE mesg)
3854 if (!mesg) mesg =
Qnil;
3856 const char *s = !
NIL_P(mesg) ? RSTRING_PTR(mesg) :
"";
3857 rb_bug(
"rb_sys_fail_str(%s) - errno == 0", s);
3890rb_sys_fail(
const char *mesg)
3892 rb_exc_raise(make_errno_exc(mesg));
3890rb_sys_fail(
const char *mesg) {
…}
3895#undef rb_sys_fail_str
3899 rb_exc_raise(make_errno_exc_str(mesg));
3902#ifdef RUBY_FUNCTION_NAME_STRING
3904rb_sys_fail_path_in(
const char *func_name,
VALUE path)
3909 rb_syserr_fail_path_in(func_name, n, path);
3913rb_syserr_fail_path_in(
const char *func_name,
int n,
VALUE path)
3915 rb_exc_raise(rb_syserr_new_path_in(func_name, n, path));
3919rb_syserr_new_path_in(
const char *func_name,
int n,
VALUE path)
3923 if (!path) path =
Qnil;
3925 const char *s = !
NIL_P(path) ? RSTRING_PTR(path) :
"";
3926 if (!func_name) func_name =
"(null)";
3927 rb_bug(
"rb_sys_fail_path_in(%s, %s) - errno == 0",
3936NORETURN(
static void rb_mod_exc_raise(
VALUE exc,
VALUE mod));
3948 VALUE exc = make_errno_exc(mesg);
3949 rb_mod_exc_raise(exc, mod);
3955 VALUE exc = make_errno_exc_str(mesg);
3956 rb_mod_exc_raise(exc, mod);
3963 rb_mod_exc_raise(exc, mod);
3970 rb_mod_exc_raise(exc, mod);
3974syserr_warning(
VALUE mesg,
int err)
3977 rb_str_catf(mesg,
": %s\n", strerror(err));
3978 rb_write_warning_str(mesg);
3983rb_sys_warn(
const char *fmt, ...)
3986 int errno_save =
errno;
3987 with_warning_string(mesg, 0, fmt) {
3988 syserr_warning(mesg, errno_save);
3995rb_syserr_warn(
int err,
const char *fmt, ...)
3998 with_warning_string(mesg, 0, fmt) {
3999 syserr_warning(mesg, err);
4005rb_sys_enc_warn(
rb_encoding *enc,
const char *fmt, ...)
4008 int errno_save =
errno;
4009 with_warning_string(mesg, enc, fmt) {
4010 syserr_warning(mesg, errno_save);
4017rb_syserr_enc_warn(
int err,
rb_encoding *enc,
const char *fmt, ...)
4020 with_warning_string(mesg, enc, fmt) {
4021 syserr_warning(mesg, err);
4031 int errno_save =
errno;
4032 with_warning_string(mesg, 0, fmt) {
4033 syserr_warning(mesg, errno_save);
4041rb_syserr_warning(
int err,
const char *fmt, ...)
4044 with_warning_string(mesg, 0, fmt) {
4045 syserr_warning(mesg, err);
4052rb_sys_enc_warning(
rb_encoding *enc,
const char *fmt, ...)
4055 int errno_save =
errno;
4056 with_warning_string(mesg, enc, fmt) {
4057 syserr_warning(mesg, errno_save);
4064rb_syserr_enc_warning(
int err,
rb_encoding *enc,
const char *fmt, ...)
4067 with_warning_string(mesg, enc, fmt) {
4068 syserr_warning(mesg, err);
4074rb_load_fail(
VALUE path,
const char *err)
4079 raise_loaderror(path, mesg);
4094 va_start(args, fmt);
4103inspect_frozen_obj(
VALUE obj,
VALUE mesg,
int recur)
4115get_created_info(
VALUE obj,
int *pline)
4117 VALUE info = rb_attr_get(obj, id_debug_created_info);
4121 VALUE path = rb_ary_entry(info, 0);
4122 VALUE line = rb_ary_entry(info, 1);
4131 rb_yjit_lazy_push_frame(GET_EC()->cfp->pc);
4133 VALUE mesg = rb_sprintf(
"can't modify frozen %"PRIsVALUE
": ",
4141 VALUE created_path = get_created_info(frozen_obj, &created_line);
4142 if (!
NIL_P(created_path)) {
4143 rb_str_catf(mesg,
", created at %"PRIsVALUE
":%d", created_path, created_line);
4149rb_warn_unchilled_literal(
VALUE obj)
4154 VALUE file = rb_source_location(&line);
4158 if (line) rb_str_catf(mesg,
":%d", line);
4161 rb_str_cat2(mesg,
"warning: literal string will be frozen in the future");
4164 if (STR_SHARED_P(str)) {
4165 str =
RSTRING(obj)->as.heap.aux.shared;
4167 VALUE created = get_created_info(str, &line);
4168 if (
NIL_P(created)) {
4169 rb_str_cat2(mesg,
" (run with --debug-frozen-string-literal for more information)\n");
4173 if (line) rb_str_catf(mesg,
":%d", line);
4174 rb_str_cat2(mesg,
": info: the string was created here\n");
4176 rb_warn_category(mesg, rb_warning_category_to_name(category));
4181rb_warn_unchilled_symbol_to_s(
VALUE obj)
4185 "string returned by :%s.to_s will be frozen in the future", RSTRING_PTR(obj)
4189#undef rb_check_frozen
4200 rb_check_frozen(obj);
4207 rb_eNOERROR = setup_syserr(0,
"NOERROR");
4210 rb_define_const(
rb_mErrno,
"NOERROR", rb_eNOERROR);
4212#define defined_error(name, num) set_syserr((num), (name));
4213#define undefined_error(name) rb_define_const(rb_mErrno, (name), rb_eNOERROR);
4214#include "known_errors.inc"
4216#undef undefined_error
4219#include "warning.rbinc"
#define RUBY_DEBUG
Define this macro when you want assertions.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
VALUE rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap)
Identical to rb_enc_sprintf(), except it takes a va_list instead of variadic arguments.
#define RUBY_EVENT_C_CALL
A method, written in C, is called.
#define RUBY_EVENT_C_RETURN
Return from a method, written in C.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_extend_object(VALUE obj, VALUE module)
Extend the object with the module.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
VALUE rb_define_module(const char *name)
Defines a top-level module.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define TYPE(_)
Old name of rb_type.
#define ISSPACE
Old name of rb_isspace.
#define T_STRING
Old name of RUBY_T_STRING.
#define T_MASK
Old name of RUBY_T_MASK.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define rb_str_cat2
Old name of rb_str_cat_cstr.
#define UNREACHABLE
Old name of RBIMPL_UNREACHABLE.
#define ID2SYM
Old name of RB_ID2SYM.
#define rb_str_buf_new2
Old name of rb_str_buf_new_cstr.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define T_DATA
Old name of RUBY_T_DATA.
#define CLASS_OF
Old name of rb_class_of.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define T_TRUE
Old name of RUBY_T_TRUE.
#define FL_ABLE
Old name of RB_FL_ABLE.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define T_FALSE
Old name of RUBY_T_FALSE.
#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 Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define T_OBJECT
Old name of RUBY_T_OBJECT.
#define NIL_P
Old name of RB_NIL_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define FL_TEST
Old name of RB_FL_TEST.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void rb_notimplement(void)
void rb_mod_sys_fail(VALUE mod, const char *mesg)
Identical to rb_sys_fail(), except it takes additional module to extend the exception object before r...
rb_warning_category_t
Warning categories.
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent)
Checks for the domestic relationship between the two.
void rb_category_warning(rb_warning_category_t category, const char *fmt,...)
Identical to rb_warning(), except it takes additional "category" parameter.
void rb_mod_syserr_fail(VALUE mod, int e, const char *mesg)
Identical to rb_mod_sys_fail(), except it does not depend on C global variable errno.
VALUE rb_eNotImpError
NotImplementedError exception.
VALUE rb_eScriptError
ScriptError exception.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
void rb_syserr_fail(int e, const char *mesg)
Raises appropriate exception that represents a C errno.
VALUE rb_eKeyError
KeyError exception.
VALUE rb_cNameErrorMesg
NameError::Message class.
VALUE rb_eSystemExit
SystemExit exception.
void rb_name_error(ID id, const char *fmt,...)
Raises an instance of rb_eNameError.
void rb_sys_warning(const char *fmt,...)
Identical to rb_sys_fail(), except it does not raise an exception to render a warning instead.
void rb_check_copyable(VALUE obj, VALUE orig)
Ensures that the passed object can be initialize_copy relationship.
VALUE rb_eStandardError
StandardError exception.
VALUE rb_mErrno
Errno module.
VALUE rb_syserr_new_str(int n, VALUE arg)
Identical to rb_syserr_new(), except it takes the message in Ruby's String instead of C's.
void rb_mod_syserr_fail_str(VALUE mod, int e, VALUE mesg)
Identical to rb_mod_syserr_fail(), except it takes the message in Ruby's String instead of C's.
void rb_error_frozen(const char *what)
Identical to rb_frozen_error_raise(), except its raising exception has a message like "can't modify f...
VALUE rb_eFrozenError
FrozenError exception.
VALUE rb_eNoMemError
NoMemoryError exception.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eLoadError
LoadError exception.
void rb_syserr_fail_str(int e, VALUE mesg)
Identical to rb_syserr_fail(), except it takes the message in Ruby's String instead of C's.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eNoMatchingPatternError
NoMatchingPatternError exception.
void rb_name_error_str(VALUE str, const char *fmt,...)
Identical to rb_name_error(), except it takes a VALUE instead of ID.
void rb_frozen_error_raise(VALUE frozen_obj, const char *fmt,...)
Raises an instance of rb_eFrozenError.
VALUE rb_eEncCompatError
Encoding::CompatibilityError exception.
void rb_category_compile_warn(rb_warning_category_t category, const char *file, int line, const char *fmt,...)
Identical to rb_compile_warn(), except it also accepts category.
VALUE rb_eFatal
fatal exception.
void rb_invalid_str(const char *str, const char *type)
Honestly I don't understand the name, but it raises an instance of rb_eArgError.
VALUE rb_eInterrupt
Interrupt exception.
VALUE rb_eNameError
NameError exception.
VALUE rb_eNoMethodError
NoMethodError exception.
void rb_exc_fatal(VALUE mesg)
Raises a fatal error in the current thread.
VALUE rb_eRuntimeError
RuntimeError exception.
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
Identical to rb_typeddata_is_kind_of(), except it raises exceptions instead of returning false.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_exc_new(VALUE etype, const char *ptr, long len)
Creates an instance of the passed exception class.
VALUE rb_eNoMatchingPatternKeyError
NoMatchingPatternKeyError exception.
void rb_error_frozen_object(VALUE frozen_obj)
Identical to rb_error_frozen(), except it takes arbitrary Ruby object instead of C's string.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_eArgError
ArgumentError exception.
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_enc_raise(rb_encoding *enc, VALUE exc, const char *fmt,...)
Identical to rb_raise(), except it additionally takes an encoding.
void rb_loaderror(const char *fmt,...)
Raises an instance of rb_eLoadError.
VALUE rb_eException
Mother of all exceptions.
VALUE rb_eIndexError
IndexError exception.
void rb_loaderror_with_path(VALUE path, const char *fmt,...)
Identical to rb_loaderror(), except it additionally takes which file is unable to load.
VALUE rb_eSyntaxError
SyntaxError exception.
VALUE rb_eEncodingError
EncodingError exception.
VALUE rb_syserr_new(int n, const char *mesg)
Creates an exception object that represents the given C errno.
VALUE rb_eSecurityError
SecurityError exception.
void rb_unexpected_type(VALUE x, int t)
Fails with the given object's type incompatibility to the type.
void rb_mod_sys_fail_str(VALUE mod, VALUE mesg)
Identical to rb_mod_sys_fail(), except it takes the message in Ruby's String instead of C's.
void rb_check_type(VALUE x, int t)
This was the old implementation of Check_Type(), but they diverged.
VALUE rb_eSystemCallError
SystemCallError exception.
void rb_warning(const char *fmt,...)
Issues a warning.
VALUE rb_eSignal
SignalException exception.
@ RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK
Warning is for checking unused block strictly.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
@ RB_WARN_CATEGORY_EXPERIMENTAL
Warning is for experimental features.
@ RB_WARN_CATEGORY_PERFORMANCE
Warning is for performance issues (not enabled by -w).
@ RB_WARN_CATEGORY_NONE
Category unspecified.
VALUE rb_check_to_int(VALUE val)
Identical to rb_check_to_integer(), except it uses #to_int for conversion.
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_obj_init_copy(VALUE src, VALUE dst)
Default implementation of #initialize_copy, #initialize_dup and #initialize_clone.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cEncoding
Encoding class.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_class_real(VALUE klass)
Finds a "real" class.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
VALUE rb_obj_clone(VALUE obj)
Produces a shallow copy of the given object.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
VALUE rb_String(VALUE val)
This is the logic behind Kernel#String.
VALUE rb_cString
String class.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
VALUE rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv(), except you can specify how to handle the last element of the given array.
VALUE rb_call_super_kw(int argc, const VALUE *argv, int kw_splat)
Identical to rb_call_super(), except you can specify how to handle the last element of the given arra...
VALUE rb_call_super(int argc, const VALUE *argv)
This resembles ruby's super.
Defines RBIMPL_HAS_BUILTIN.
static void rb_check_frozen_inline(VALUE obj)
Just another name of rb_check_frozen.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void ruby_default_signal(int sig)
Pretends as if there was no custom signal handler.
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_tmp_new(long len)
Allocates a "temporary" string.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_str_buf_cat
Just another name of rb_str_cat.
#define rb_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
#define rb_str_buf_new_cstr(str)
Identical to rb_str_new_cstr, except done differently.
VALUE rb_str_buf_append(VALUE dst, VALUE src)
Identical to rb_str_cat_cstr(), except it takes Ruby's string instead of C's.
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
void rb_str_set_len(VALUE str, long len)
Overwrites the length of the string.
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,...
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_exec_recursive(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
"Recursion" API entry point.
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
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_class_name(VALUE obj)
Queries the name of the given object's class.
int rb_respond_to(VALUE obj, ID mid)
Queries if the object responds to the method.
void rb_attr(VALUE klass, ID name, int need_reader, int need_writer, int honour_visibility)
This function resembles now-deprecated Module#attr.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
VALUE rb_check_funcall_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_check_funcall(), except you can specify how to handle the last element of the given a...
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
int len
Length of the buffer.
#define DECIMAL_SIZE_OF(expr)
An approximation of decimal representation size.
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Formats a string.
VALUE rb_vsprintf(const char *fmt, va_list ap)
Identical to rb_sprintf(), except it takes a va_list.
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
Marshal format compatibility layer.
#define ALLOCA_N(type, n)
VALUE type(ANYARGS)
ANYARGS-ed function type.
void rb_ivar_foreach(VALUE q, int_type *w, VALUE e)
Iteration over each instance variable of the object.
#define PRI_PIDT_PREFIX
A rb_sprintf() format prefix to be used for a pid_t parameter.
#define RARRAY_LEN
Just another name of rb_array_len.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define StringValue(v)
Ensures that the parameter object is a String.
static char * RSTRING_END(VALUE str)
Queries the end of the contents pointer of the string.
#define RSTRING(obj)
Convenient casting macro.
char * rb_string_value_ptr(volatile VALUE *ptr)
Identical to rb_str_to_str(), except it returns the converted string's backend memory region.
static bool RTYPEDDATA_P(VALUE obj)
Checks whether the passed object is RTypedData or RData.
#define RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
static const struct rb_data_type_struct * RTYPEDDATA_TYPE(VALUE obj)
Queries for the type of given object.
VALUE rb_argv0
The value of $0 at process bootup.
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
#define errno
Ractor-aware version of errno.
#define RB_PASS_KEYWORDS
Pass keywords, final argument should be a hash of keywords.
#define RB_PASS_CALLED_KEYWORDS
Pass keywords if current method is called with keywords, useful for argument delegation.
static bool RB_SPECIAL_CONST_P(VALUE obj)
Checks if the given object is of enum ruby_special_consts.
#define RTEST
This is an old name of RB_TEST.
char * ptr
Pointer to the contents of the string.
This is the struct that holds necessary info for a struct.
const rb_data_type_t * parent
Parent of this class.
const char * wrap_struct_name
Name of structs of this kind.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static enum ruby_value_type RB_BUILTIN_TYPE(VALUE obj)
Queries the type of the object.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.