12#include "ruby/internal/config.h"
23#include "internal/array.h"
24#include "internal/compar.h"
25#include "internal/enum.h"
26#include "internal/enumerator.h"
27#include "internal/error.h"
28#include "internal/numeric.h"
29#include "internal/range.h"
32static ID id_beg, id_end, id_excl;
41#define RANGE_SET_BEG(r, v) (RSTRUCT_SET(r, 0, v))
42#define RANGE_SET_END(r, v) (RSTRUCT_SET(r, 1, v))
43#define RANGE_SET_EXCL(r, v) (RSTRUCT_SET(r, 2, v))
45#define EXCL(r) RTEST(RANGE_EXCL(r))
56 rb_raise(rb_eArgError,
"bad value for range");
59 RANGE_SET_EXCL(range, exclude_end);
60 RANGE_SET_BEG(range, beg);
61 RANGE_SET_END(range, end);
73 range_init(range, beg, end, RBOOL(exclude_end));
78range_modify(
VALUE range)
80 rb_check_frozen(range);
82 if (RANGE_EXCL(range) !=
Qnil) {
83 rb_name_err_raise(
"'initialize' called twice", range,
ID2SYM(idInitialize));
103range_initialize(
int argc,
VALUE *argv,
VALUE range)
105 VALUE beg, end, flags;
109 range_init(range, beg, end, RBOOL(
RTEST(flags)));
118 rb_struct_init_copy(range, orig);
135range_exclude_end_p(
VALUE range)
137 return RBOOL(EXCL(range));
141recursive_equal(
VALUE range,
VALUE obj,
int recur)
143 if (recur)
return Qtrue;
144 if (!
rb_equal(RANGE_BEG(range), RANGE_BEG(obj)))
146 if (!
rb_equal(RANGE_END(range), RANGE_END(obj)))
149 return RBOOL(EXCL(range) == EXCL(obj));
207 return rb_cmpint(r, a, b);
211recursive_eql(
VALUE range,
VALUE obj,
int recur)
213 if (recur)
return Qtrue;
214 if (!
rb_eql(RANGE_BEG(range), RANGE_BEG(obj)))
216 if (!
rb_eql(RANGE_END(range), RANGE_END(obj)))
219 return RBOOL(EXCL(range) == EXCL(obj));
274range_hash(
VALUE range)
276 st_index_t hash = EXCL(range);
280 v = rb_hash(RANGE_BEG(range));
282 v = rb_hash(RANGE_END(range));
294 VALUE b = RANGE_BEG(range);
295 VALUE e = RANGE_END(range);
299 while (r_less(v, e) < 0) {
300 if ((*func)(v, arg))
break;
301 v = rb_funcallv(v, id_succ, 0, 0);
305 while ((c = r_less(v, e)) <= 0) {
306 if ((*func)(v, arg))
break;
308 v = rb_funcallv(v, id_succ, 0, 0);
317step_i_iter(
VALUE arg)
322 iter[0] -=
INT2FIX(1) & ~FIXNUM_FLAG;
327 if (iter[0] !=
INT2FIX(0))
return false;
335 if (step_i_iter(arg)) {
344 if (step_i_iter(arg)) {
351discrete_object_p(
VALUE obj)
357linear_object_p(
VALUE obj)
374check_step_domain(
VALUE step)
381 cmp = rb_cmpint(rb_funcallv(step, idCmp, 1, &zero), step, zero);
383 rb_raise(rb_eArgError,
"step can't be negative");
386 rb_raise(rb_eArgError,
"step can't be 0");
394 VALUE b = RANGE_BEG(range), e = RANGE_END(range);
401 return ruby_num_interval_step_size(b, e, step, EXCL(range));
490 b = RANGE_BEG(range);
491 e = RANGE_END(range);
505 if (b_num_p || !
NIL_P(str_b) || !
NIL_P(sym_b) || (
NIL_P(b) && e_num_p))
508 rb_raise(rb_eArgError,
"step is required for non-numeric ranges");
514 rb_raise(rb_eArgError,
"step can't be 0");
521 if (step_num_p && ((b_num_p && (
NIL_P(e) || e_num_p)) || (
NIL_P(b) && e_num_p))) {
522 return rb_arith_seq_new(range,
ID2SYM(rb_frame_this_func()), argc, argv,
523 range_step_size, b, e, step, EXCL(range));
528 rb_raise(rb_eArgError,
"#step for non-numeric beginless ranges is meaningless");
535 rb_raise(rb_eArgError,
"#step iteration for beginless ranges is meaningless");
548 for (;; b = rb_big_plus(b, step))
575 else if (b_num_p && step_num_p && ruby_float_step(b, e, step, EXCL(range), TRUE)) {
585 rb_str_upto_endless_each(str_b, step_i, (
VALUE)iter);
588 rb_str_upto_each(str_b, e, EXCL(range), step_i, (
VALUE)iter);
597 rb_str_upto_endless_each(sym_b, sym_step_i, (
VALUE)iter);
600 rb_str_upto_each(sym_b,
rb_sym2str(e), EXCL(range), sym_step_i, (
VALUE)iter);
608 else if (b_num_p && step_num_p && r_less(step,
INT2FIX(0)) < 0) {
611 for (; r_less(e, v) < 0; v =
rb_funcall(v, id_plus, 1, step))
615 for (; (c = r_less(e, v)) <= 0; v =
rb_funcall(v, id_plus, 1, step)) {
622 else if ((dir = r_less(b, e)) == 0) {
627 else if (dir == r_less(b,
rb_funcall(b, id_plus, 1, step))) {
635 for (; r_less(v, e) == dir; v =
rb_funcall(v, id_plus, 1, step))
639 for (; (c = r_less(v, e)) == dir || c == 0; v =
rb_funcall(v, id_plus, 1, step)) {
673 return range_step(1, &step, range);
676#if SIZEOF_DOUBLE == 8 && defined(HAVE_INT64_T)
683int64_as_double_to_num(int64_t i)
685 union int64_double convert;
697double_as_int64(
double d)
699 union int64_double convert;
701 return d < 0 ? -convert.i : convert.i;
716 return RTEST(is_int) && !UNDEF_P(is_int);
720bsearch_integer_range(
VALUE beg,
VALUE end,
int excl)
725#define BSEARCH_CHECK(expr) \
727 VALUE val = (expr); \
728 VALUE v = rb_yield(val); \
730 if (v == INT2FIX(0)) return val; \
731 smaller = (SIGNED_VALUE)v < 0; \
733 else if (v == Qtrue) { \
737 else if (!RTEST(v)) { \
740 else if (rb_obj_is_kind_of(v, rb_cNumeric)) { \
741 int cmp = rb_cmpint(rb_funcall(v, id_cmp, 1, INT2FIX(0)), v, INT2FIX(0)); \
742 if (!cmp) return val; \
746 rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE \
747 " (must be numeric, true, false or nil)", \
769 rb_cmpint(
rb_funcall(low, id_cmp, 1, mid), low, mid) < 0) {
792range_bsearch(
VALUE range)
817#define BSEARCH(conv, excl) \
819 RETURN_ENUMERATOR(range, 0, 0); \
820 if (!(excl)) high++; \
822 while (low + 1 < high) { \
823 mid = ((high < 0) == (low < 0)) ? low + ((high - low) / 2) \
824 : (low + high) / 2; \
825 BSEARCH_CHECK(conv(mid)); \
836#define BSEARCH_FIXNUM(beg, end, excl) \
838 long low = FIX2LONG(beg); \
839 long high = FIX2LONG(end); \
841 BSEARCH(INT2FIX, (excl)); \
844 beg = RANGE_BEG(range);
845 end = RANGE_END(range);
848 BSEARCH_FIXNUM(beg, end, EXCL(range));
850#if SIZEOF_DOUBLE == 8 && defined(HAVE_INT64_T)
855 BSEARCH(int64_as_double_to_num, EXCL(range));
858 else if (is_integer_p(beg) && is_integer_p(end)) {
860 return bsearch_integer_range(beg, end, EXCL(range));
862 else if (is_integer_p(beg) &&
NIL_P(end)) {
870 BSEARCH_FIXNUM(beg, mid,
false);
873 return bsearch_integer_range(beg, mid,
false);
880 else if (
NIL_P(beg) && is_integer_p(end)) {
888 BSEARCH_FIXNUM(mid, end,
false);
891 return bsearch_integer_range(mid, end,
false);
917#define CANT_ITERATE_FROM(x) \
918 rb_raise(rb_eTypeError, "can't iterate from %s", \
943range_size(
VALUE range)
945 VALUE b = RANGE_BEG(range), e = RANGE_END(range);
949 return ruby_num_interval_step_size(b, e,
INT2FIX(1), EXCL(range));
956 if (!discrete_object_p(b)) {
957 CANT_ITERATE_FROM(b);
964range_reverse_size(
VALUE range)
966 VALUE b = RANGE_BEG(range), e = RANGE_END(range);
969 CANT_ITERATE_FROM(e);
974 return ruby_num_interval_step_size(b, e,
INT2FIX(1), EXCL(range));
977 CANT_ITERATE_FROM(e);
986 CANT_ITERATE_FROM(e);
990 if (!discrete_object_p(b)) {
991 CANT_ITERATE_FROM(e);
997#undef CANT_ITERATE_FROM
1013range_to_a(
VALUE range)
1015 if (
NIL_P(RANGE_END(range))) {
1016 rb_raise(
rb_eRangeError,
"cannot convert endless range to an array");
1024 return range_size(range);
1030 return range_reverse_size(range);
1035range_each_bignum_endless(
VALUE beg)
1037 for (;; beg = rb_big_plus(beg,
INT2FIX(1))) {
1045range_each_fixnum_endless(
VALUE beg)
1058 long lim =
FIX2LONG(end) + !EXCL(range);
1059 for (
long i =
FIX2LONG(beg); i < lim; i++) {
1083range_each(
VALUE range)
1090 beg = RANGE_BEG(range);
1091 end = RANGE_END(range);
1094 range_each_fixnum_endless(beg);
1097 return range_each_fixnum_loop(beg, end, range);
1106 if (
NIL_P(end)) range_each_fixnum_endless(beg);
1107 if (
FIXNUM_P(end))
return range_each_fixnum_loop(beg, end, range);
1110 if (
NIL_P(end)) range_each_bignum_endless(beg);
1126 while (rb_big_cmp(beg, end) ==
INT2FIX(-1)) {
1128 beg = rb_big_plus(beg,
INT2FIX(1));
1133 while ((c = rb_big_cmp(beg, end)) !=
INT2FIX(1)) {
1136 beg = rb_big_plus(beg,
INT2FIX(1));
1144 rb_str_upto_endless_each(beg, sym_each_i, 0);
1147 rb_str_upto_each(beg,
rb_sym2str(end), EXCL(range), sym_each_i, 0);
1155 rb_str_upto_each(tmp, end, EXCL(range), each_i, 0);
1158 rb_str_upto_endless_each(tmp, each_i, 0);
1162 if (!discrete_object_p(beg)) {
1167 range_each_func(range, each_i, 0);
1169 for (;; beg = rb_funcallv(beg, id_succ, 0, 0))
1178range_reverse_each_bignum_beginless(
VALUE end)
1182 for (;; end = rb_big_minus(end,
INT2FIX(1))) {
1189range_reverse_each_bignum(
VALUE beg,
VALUE end)
1194 while ((c = rb_big_cmp(beg, end)) !=
INT2FIX(1)) {
1197 end = rb_big_minus(end,
INT2FIX(1));
1202range_reverse_each_positive_bignum_section(
VALUE beg,
VALUE end)
1212 range_reverse_each_bignum(beg, end);
1216range_reverse_each_fixnum_section(
VALUE beg,
VALUE end)
1234 for (
long i = e; i >= b; --i) {
1240range_reverse_each_negative_bignum_section(
VALUE beg,
VALUE end)
1249 range_reverse_each_bignum_beginless(end);
1254 range_reverse_each_bignum(beg, end);
1277range_reverse_each(
VALUE range)
1281 VALUE beg = RANGE_BEG(range);
1282 VALUE end = RANGE_END(range);
1283 int excl = EXCL(range);
1294 end = rb_int_minus(end,
INT2FIX(1));
1297 range_reverse_each_fixnum_section(beg, end);
1301 end = rb_int_minus(end,
INT2FIX(1));
1303 range_reverse_each_positive_bignum_section(beg, end);
1304 range_reverse_each_fixnum_section(beg, end);
1305 range_reverse_each_negative_bignum_section(beg, end);
1327range_begin(
VALUE range)
1329 return RANGE_BEG(range);
1348range_end(
VALUE range)
1350 return RANGE_END(range);
1392range_first(
int argc,
VALUE *argv,
VALUE range)
1396 if (
NIL_P(RANGE_BEG(range))) {
1397 rb_raise(
rb_eRangeError,
"cannot get the first element of beginless range");
1399 if (argc == 0)
return RANGE_BEG(range);
1410range_basic_each_p(
VALUE range)
1412 return rb_method_basic_definition_p(
CLASS_OF(range), idEach);
1416integer_end_optimizable(
VALUE range)
1418 VALUE b = RANGE_BEG(range);
1420 VALUE e = RANGE_END(range);
1422 if (RB_LIKELY(range_basic_each_p(range)))
return true;
1427rb_int_range_last(
int argc,
VALUE *argv,
VALUE range)
1437 b = RANGE_BEG(range);
1438 e = RANGE_END(range);
1445 len_1 = rb_int_minus(e, b);
1447 e = rb_int_minus(e, ONE);
1451 len = rb_int_plus(len_1, ONE);
1456 e = rb_int_minus(e, ONE);
1460 if (!
NIL_P(
len) && (FIXNUM_ZERO_P(
len) || rb_num_negative_p(
len))) {
1467 rb_raise(rb_eArgError,
"negative array size");
1477 b = rb_int_minus(e, nv);
1479 b = rb_int_plus(b, ONE);
1523range_last(
int argc,
VALUE *argv,
VALUE range)
1525 if (
NIL_P(RANGE_END(range))) {
1526 rb_raise(
rb_eRangeError,
"cannot get the last element of endless range");
1528 if (argc == 0)
return RANGE_END(range);
1529 if (integer_end_optimizable(range)) {
1530 return rb_int_range_last(argc, argv, range);
1532 return rb_ary_last(argc, argv,
rb_Array(range));
1620 if (
NIL_P(RANGE_BEG(range))) {
1621 rb_raise(
rb_eRangeError,
"cannot get the minimum of beginless range");
1625 if (
NIL_P(RANGE_END(range))) {
1626 rb_raise(
rb_eRangeError,
"cannot get the minimum of endless range with custom comparison method");
1630 else if (argc != 0) {
1631 return range_first(argc, argv, range);
1634 VALUE b = RANGE_BEG(range);
1635 VALUE e = RANGE_END(range);
1636 int c =
NIL_P(e) ? -1 : OPTIMIZED_CMP(b, e);
1638 if (c > 0 || (c == 0 && EXCL(range)))
1728 VALUE e = RANGE_END(range);
1731 if (
NIL_P(RANGE_END(range))) {
1732 rb_raise(
rb_eRangeError,
"cannot get the maximum of endless range");
1735 VALUE b = RANGE_BEG(range);
1739 rb_raise(
rb_eRangeError,
"cannot get the maximum of beginless range with custom comparison method");
1746 CONST_ID(reverse_each,
"reverse_each");
1752 if (integer_end_optimizable(range)) {
1753 return rb_int_range_last(argc, argv, range,
true);
1759 int c =
NIL_P(b) ? -1 : OPTIMIZED_CMP(b, e);
1765 rb_raise(
rb_eTypeError,
"cannot exclude non Integer end value");
1767 if (c == 0)
return Qnil;
1769 rb_raise(
rb_eTypeError,
"cannot exclude end value with non Integer begin value");
1774 return rb_int_minus(e,
INT2FIX(1));
1827range_minmax(
VALUE range)
1845 b = RANGE_BEG(range);
1846 e = RANGE_END(range);
1855 if (UNDEF_P(b))
return (
int)
Qfalse;
1857 if (UNDEF_P(e))
return (
int)
Qfalse;
1859 if (UNDEF_P(x))
return (
int)
Qfalse;
1891rb_range_component_beg_len(
VALUE b,
VALUE e,
int excl,
1892 long *begp,
long *lenp,
long len,
int err)
1898 if (
NIL_P(e)) excl = 0;
1908 if (err == 0 || err == 2) {
1935 VALUE res = rb_range_component_beg_len(b, e, excl, begp, lenp,
len, err);
1936 if (
NIL_P(res) && err) {
1965range_to_s(
VALUE range)
1979inspect_range(
VALUE range,
VALUE dummy,
int recur)
1984 return rb_str_new2(EXCL(range) ?
"(... ... ...)" :
"(... .. ...)");
1986 if (!
NIL_P(RANGE_BEG(range)) ||
NIL_P(RANGE_END(range))) {
1993 if (
NIL_P(RANGE_BEG(range)) || !
NIL_P(RANGE_END(range))) {
2024range_inspect(
VALUE range)
2074 return r_cover_p(range, RANGE_BEG(range), RANGE_END(range), val);
2110 VALUE ret = range_include_internal(range, val);
2111 if (!UNDEF_P(ret))
return ret;
2132 if (linear_object_p(val))
return Qtrue;
2136 rb_raise(
rb_eTypeError,
"cannot determine inclusion in beginless/endless ranges");
2143range_include_internal(
VALUE range,
VALUE val)
2145 VALUE beg = RANGE_BEG(range);
2146 VALUE end = RANGE_END(range);
2148 linear_object_p(beg) || linear_object_p(end);
2150 if (nv || range_integer_edge_p(beg, end)) {
2151 return r_cover_p(range, beg, end, val);
2153 else if (range_string_range_p(beg, end)) {
2154 return rb_str_include_range_p(beg, end, val, RANGE_EXCL(range));
2157 return range_include_fallback(beg, end, val);
2294 beg = RANGE_BEG(range);
2295 end = RANGE_END(range);
2298 return RBOOL(r_cover_range_p(range, beg, end, val));
2300 return r_cover_p(range, beg, end, val);
2306 return rb_funcallv(r, rb_intern(
"max"), 0, 0);
2312 VALUE val_beg, val_end, val_max;
2315 val_beg = RANGE_BEG(val);
2316 val_end = RANGE_END(val);
2318 if (!
NIL_P(end) &&
NIL_P(val_end))
return FALSE;
2319 if (!
NIL_P(beg) &&
NIL_P(val_beg))
return FALSE;
2320 if (!
NIL_P(val_beg) && !
NIL_P(val_end) && r_less(val_beg, val_end) > (EXCL(val) ? -1 : 0)) return FALSE;
2321 if (!
NIL_P(val_beg) && !r_cover_p(range, beg, end, val_beg))
return FALSE;
2326 if (
NIL_P(r_cmp_end))
return FALSE;
2327 cmp_end = rb_cmpint(r_cmp_end, end, val_end);
2330 cmp_end = r_less(end, val_end);
2334 if (EXCL(range) == EXCL(val)) {
2335 return cmp_end >= 0;
2337 else if (EXCL(range)) {
2340 else if (cmp_end >= 0) {
2345 if (
NIL_P(val_max))
return FALSE;
2347 return r_less(end, val_max) >= 0;
2353 if (
NIL_P(beg) || r_less(beg, val) <= 0) {
2354 int excl = EXCL(range);
2355 if (
NIL_P(end) || r_less(val, end) <= -excl)
2362range_dumper(
VALUE range)
2375 VALUE beg, end, excl;
2381 range_modify(range);
2386 range_init(range, beg, end, RBOOL(
RTEST(excl)));
2392range_alloc(
VALUE klass)
2431range_count(
int argc,
VALUE *argv,
VALUE range)
2444 VALUE beg = RANGE_BEG(range), end = RANGE_END(range);
2451 if (is_integer_p(beg)) {
2452 VALUE size = range_size(range);
2462empty_region_p(
VALUE beg,
VALUE end,
int excl)
2464 if (
NIL_P(beg))
return false;
2465 if (
NIL_P(end))
return false;
2466 int less = r_less(beg, end);
2468 if (less > 0)
return true;
2469 if (excl && less == 0)
return true;
2545 rb_raise(
rb_eTypeError,
"wrong argument type %"PRIsVALUE
" (expected Range)",
2549 VALUE self_beg = RANGE_BEG(range);
2550 VALUE self_end = RANGE_END(range);
2551 int self_excl = EXCL(range);
2552 VALUE other_beg = RANGE_BEG(other);
2553 VALUE other_end = RANGE_END(other);
2554 int other_excl = EXCL(other);
2556 if (empty_region_p(self_beg, other_end, other_excl))
return Qfalse;
2557 if (empty_region_p(other_beg, self_end, self_excl))
return Qfalse;
2563 if (rb_cmpint(cmp, self_beg, other_beg) == 0)
return Qtrue;
2567 return RBOOL(!
NIL_P(cmp));
2570 if (empty_region_p(self_beg, self_end, self_excl))
return Qfalse;
2571 if (empty_region_p(other_beg, other_end, other_excl))
return Qfalse;
2823 "Range", rb_cObject, range_alloc,
2824 "begin",
"end",
"excl", NULL);
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
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_block_given_p(void)
Determines if the current method is given a block.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
#define RFLOAT_VALUE
Old name of rb_float_value.
#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
Old name of RBIMPL_UNREACHABLE.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define CLASS_OF
Old name of rb_class_of.
#define FIXABLE
Old name of RB_FIXABLE.
#define LONG2FIX
Old name of RB_INT2FIX.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define FIXNUM_MIN
Old name of RUBY_FIXNUM_MIN.
#define FLONUM_P
Old name of RB_FLONUM_P.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define FIXNUM_MAX
Old name of RUBY_FIXNUM_MAX.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define T_OBJECT
Old name of RUBY_T_OBJECT.
#define NIL_P
Old name of RB_NIL_P.
#define POSFIXABLE
Old name of RB_POSFIXABLE.
#define DBL2NUM
Old name of rb_float_new.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void rb_iter_break(void)
Breaks from a block.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_cTime
Time class.
VALUE rb_Float(VALUE val)
This is the logic behind Kernel#Float.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_mEnumerable
Enumerable module.
int rb_eql(VALUE lhs, VALUE rhs)
Checks for equality of the passed objects, in terms of Object#eql?.
VALUE rb_cNumeric
Numeric class.
VALUE rb_Array(VALUE val)
This is the logic behind Kernel#Array.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_cRange
Range class.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
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_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
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_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
#define RUBY_FIXNUM_MAX
Maximum possible value that a fixnum can represent.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_call_super(int argc, const VALUE *argv)
This resembles ruby's super.
VALUE rb_ary_reverse(VALUE ary)
Destructively reverses the passed array in-place.
VALUE rb_ary_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
This roughly resembles return enum_for(__callee__) unless block_given?.
#define RETURN_ENUMERATOR(obj, argc, argv)
Identical to RETURN_SIZED_ENUMERATOR(), except its size is unknown.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
Deconstructs a range into its components.
VALUE rb_range_new(VALUE beg, VALUE end, int excl)
Creates a new Range.
VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
Deconstructs a numerical range.
#define rb_hash_uint(h, i)
Just another name of st_hash_uint.
#define rb_hash_end(h)
Just another name of st_hash_end.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
VALUE rb_struct_define_without_accessor(const char *name, VALUE super, rb_alloc_func_t func,...)
Identical to rb_struct_define(), except it does not define accessor methods.
VALUE rb_struct_alloc_noinit(VALUE klass)
Allocates an instance of the given class.
VALUE rb_exec_recursive(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
"Recursion" API entry point.
VALUE rb_exec_recursive_paired(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE p, VALUE h)
Identical to rb_exec_recursive(), except it checks for the recursion on the ordered pair of { g,...
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.
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.
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.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
int len
Length of the buffer.
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Shim for block function parameters.
VALUE rb_yield(VALUE val)
Yields the block.
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
Marshal format compatibility layer.
VALUE rb_block_call(VALUE q, ID w, int e, const VALUE *r, type *t, VALUE y)
Call a method with a block.
VALUE rb_rescue2(type *q, VALUE w, type *e, VALUE r,...)
An equivalent of rescue clause.
#define RBIMPL_ATTR_NORETURN()
Wraps (or simulates) [[noreturn]]
#define RARRAY_AREF(a, i)
#define RBASIC(obj)
Convenient casting macro.
#define RBIGNUM_SIGN
Just another name of rb_big_sign.
static bool RBIGNUM_NEGATIVE_P(VALUE b)
Checks if the bignum is negative.
static bool RBIGNUM_POSITIVE_P(VALUE b)
Checks if the bignum is positive.
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
#define RTEST
This is an old name of RB_TEST.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
static bool rb_integer_type_p(VALUE obj)
Queries if the object is an instance of rb_cInteger.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.