14#include "internal/class.h"
15#include "internal/error.h"
16#include "internal/hash.h"
17#include "internal/object.h"
18#include "internal/proc.h"
19#include "internal/struct.h"
20#include "internal/symbol.h"
27 AREF_HASH_THRESHOLD = 10
35static ID id_members, id_back_members, id_keyword_init;
43 VALUE ivar = rb_attr_get(c,
id);
53 ivar = rb_attr_get(c,
id);
62rb_struct_s_keyword_init(
VALUE klass)
64 return struct_ivar_get(klass, id_keyword_init);
70 VALUE members = struct_ivar_get(klass, id_members);
87 rb_raise(
rb_eTypeError,
"struct size differs (%ld required %ld given)",
94struct_member_pos_ideal(
VALUE name,
long mask)
97 return (
SYM2ID(name) >> (ID_SCOPE_SHIFT - 1)) & mask;
101struct_member_pos_probe(
long prev,
long mask)
104 return (prev * AREF_HASH_UNIT + 2) & mask;
111 const long members_length =
RARRAY_LEN(members);
113 if (members_length <= AREF_HASH_THRESHOLD) {
117 long i, j, mask = 64;
120 while (mask < members_length * AREF_HASH_UNIT) mask *= 2;
126 for (i=0; i < members_length; i++) {
129 j = struct_member_pos_ideal(name, mask);
137 j = struct_member_pos_probe(j, mask);
154 if (UNLIKELY(
NIL_P(back))) {
163 if (mask <= AREF_HASH_THRESHOLD) {
164 if (UNLIKELY(RSTRUCT_LEN(s) != mask)) {
166 "struct size differs (%ld required %ld given)",
167 mask, RSTRUCT_LEN(s));
169 for (j = 0; j < mask; j++) {
177 rb_raise(
rb_eTypeError,
"struct size differs (%d required %ld given)",
182 j = struct_member_pos_ideal(name, mask);
191 j = struct_member_pos_probe(j, mask);
207rb_struct_s_members_m(
VALUE klass)
227rb_struct_members_m(
VALUE obj)
236 int i = struct_member_pos(obj, slot);
238 return RSTRUCT_GET(obj, i);
240 rb_name_err_raise(
"'%1$s' is not a struct member", obj,
ID2SYM(
id));
246rb_struct_modify(
VALUE s)
252anonymous_struct(
VALUE klass)
257 rb_make_metaclass(nstr,
RBASIC(klass)->klass);
268 if (!rb_is_const_name(name)) {
269 rb_name_err_raise(
"identifier %1$s needs to be constant",
274 rb_warn(
"redefining constant %"PRIsVALUE
"::%"PRIsVALUE, super, name);
277 return rb_define_class_id_under_no_pin(super,
id, super);
280NORETURN(
static void invalid_struct_pos(
VALUE s,
VALUE idx));
285 rb_add_method_optimized(nstr,
SYM2ID(name), OPTIMIZED_METHOD_TYPE_STRUCT_AREF,
FIX2UINT(
off), METHOD_VISI_PUBLIC);
291 rb_add_method_optimized(nstr,
SYM2ID(name), OPTIMIZED_METHOD_TYPE_STRUCT_ASET,
FIX2UINT(
off), METHOD_VISI_PUBLIC);
295rb_struct_s_inspect(
VALUE klass)
298 if (
RTEST(rb_struct_s_keyword_init(klass))) {
305rb_data_s_new(
int argc,
const VALUE *argv,
VALUE klass)
309 rb_error_arity(argc, 0, 0);
314 VALUE members = struct_ivar_get(klass, id_members);
318 VALUE arg_hash = rb_hash_new_with_size(argc);
319 for (
long i=0; i<argc; i++) {
321 rb_hash_aset(arg_hash, k, v);
345rb_struct_s_keyword_init_p(
VALUE obj)
350#define rb_struct_s_keyword_init_p rb_struct_s_keyword_init
357 members = struct_set_members(nstr, members);
367 for (i=0; i<
len; i++) {
372 define_aref_method(nstr, sym,
off);
373 define_aset_method(nstr,
ID2SYM(rb_id_attrset(
id)),
off);
384 members = struct_set_members(subclass, members);
395 for (i=0; i<
len; i++) {
399 define_aref_method(subclass, sym,
off);
408 return struct_alloc(klass);
412struct_make_members_list(va_list ar)
415 VALUE ary, list = rb_ident_hash_new();
416 RBASIC_CLEAR_CLASS(list);
417 while ((mem = va_arg(ar,
char*)) != 0) {
418 VALUE sym = rb_sym_intern_ascii_cstr(mem);
419 if (
RTEST(rb_hash_has_key(list, sym))) {
420 rb_raise(rb_eArgError,
"duplicate member: %s", mem);
422 rb_hash_aset(list, sym,
Qtrue);
424 ary = rb_hash_keys(list);
425 RBASIC_CLEAR_CLASS(ary);
444 klass = anonymous_struct(super);
447 struct_set_members(klass, members);
466 members = struct_make_members_list(ar);
469 return struct_define_without_accessor(outer, class_name, super, alloc, members);
479 members = struct_make_members_list(ar);
482 return struct_define_without_accessor(0, class_name, super, alloc, members);
492 ary = struct_make_members_list(ar);
500 rb_vm_register_global_object(st);
502 return setup_struct(st, ary);
512 ary = struct_make_members_list(ar);
643rb_struct_s_def(
int argc,
VALUE *argv,
VALUE klass)
651 if (argc >= 1 && !
SYMBOL_P(argv[0])) {
658 static ID keyword_ids[1];
660 if (!keyword_ids[0]) {
661 keyword_ids[0] = rb_intern(
"keyword_init");
664 if (UNDEF_P(keyword_init)) {
667 else if (
RTEST(keyword_init)) {
668 keyword_init =
Qtrue;
672 rest = rb_ident_hash_new();
673 RBASIC_CLEAR_CLASS(rest);
674 for (i=0; i<argc; i++) {
676 if (rb_is_attrset_sym(mem)) {
677 rb_raise(rb_eArgError,
"invalid struct member: %"PRIsVALUE, mem);
679 if (
RTEST(rb_hash_has_key(rest, mem))) {
680 rb_raise(rb_eArgError,
"duplicate member: %"PRIsVALUE, mem);
682 rb_hash_aset(rest, mem,
Qtrue);
684 rest = rb_hash_keys(rest);
685 RBASIC_CLEAR_CLASS(rest);
688 st = anonymous_struct(klass);
691 st = new_struct(name, klass);
693 setup_struct(st, rest);
703num_members(
VALUE klass)
706 members = struct_ivar_get(klass, id_members);
718 VALUE unknown_keywords;
721static int rb_struct_pos(
VALUE s,
VALUE *name);
727 int i = rb_struct_pos(args->self, &key);
729 if (
NIL_P(args->unknown_keywords)) {
735 rb_struct_modify(args->self);
736 RSTRUCT_SET(args->self, i, val);
742rb_struct_initialize_m(
int argc,
const VALUE *argv,
VALUE self)
745 rb_struct_modify(self);
746 long n = num_members(klass);
752 bool keyword_init =
false;
753 switch (rb_struct_s_keyword_init(klass)) {
756 rb_error_arity(argc, 0, 0);
773 arg.unknown_keywords =
Qnil;
775 if (arg.unknown_keywords !=
Qnil) {
776 rb_raise(rb_eArgError,
"unknown keywords: %s",
782 rb_raise(rb_eArgError,
"struct size differs");
784 for (
long i=0; i<argc; i++) {
785 RSTRUCT_SET(self, i, argv[i]);
804struct_heap_alloc(
VALUE st,
size_t len)
810struct_alloc(
VALUE klass)
812 long n = num_members(klass);
813 size_t embedded_size = offsetof(
struct RStruct, as.ary) + (
sizeof(
VALUE) * n);
816 if (n > 0 && rb_gc_size_allocatable_p(embedded_size)) {
817 flags |= n << RSTRUCT_EMBED_LEN_SHIFT;
819 NEWOBJ_OF(st,
struct RStruct, klass, flags, embedded_size, 0);
826 NEWOBJ_OF(st,
struct RStruct, klass, flags,
sizeof(
struct RStruct), 0);
828 st->as.heap.ptr = struct_heap_alloc((
VALUE)st, n);
845 VALUE tmpargs[16], *mem = tmpargs;
850 if (size > numberof(tmpargs)) {
854 va_start(args, klass);
855 for (i=0; i<size; i++) {
856 mem[i] = va_arg(args,
VALUE);
892rb_struct_each(
VALUE s)
897 for (i=0; i<RSTRUCT_LEN(s); i++) {
927rb_struct_each_pair(
VALUE s)
934 if (rb_block_pair_yield_optimizable()) {
935 for (i=0; i<RSTRUCT_LEN(s); i++) {
937 VALUE value = RSTRUCT_GET(s, i);
942 for (i=0; i<RSTRUCT_LEN(s); i++) {
944 VALUE value = RSTRUCT_GET(s, i);
952inspect_struct(
VALUE s,
VALUE prefix,
int recur)
958 char first = RSTRING_PTR(cname)[0];
960 if (recur || first !=
'#') {
968 len = RSTRUCT_LEN(s);
970 for (i=0; i<
len; i++) {
977 else if (first !=
'#') {
1009rb_struct_inspect(
VALUE s)
1028rb_struct_to_a(
VALUE s)
1030 return rb_ary_new4(RSTRUCT_LEN(s), RSTRUCT_CONST_PTR(s));
1057rb_struct_to_h(
VALUE s)
1059 VALUE h = rb_hash_new_with_size(RSTRUCT_LEN(s));
1064 for (i=0; i<RSTRUCT_LEN(s); i++) {
1069 rb_hash_aset(h, k, v);
1092rb_struct_deconstruct_keys(
VALUE s,
VALUE keys)
1098 return rb_struct_to_h(s);
1102 "wrong argument type %"PRIsVALUE
" (expected Array or nil)",
1107 return rb_hash_new_with_size(0);
1112 int i = rb_struct_pos(s, &key);
1116 rb_hash_aset(h, key, RSTRUCT_GET(s, i));
1128 if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
1132 for (i=0,
len=RSTRUCT_LEN(copy); i<
len; i++) {
1133 RSTRUCT_SET(copy, i, RSTRUCT_GET(s, i));
1146 return struct_member_pos(s, idx);
1150 if (
NIL_P(idx))
return -1;
1151 return struct_member_pos(s, idx);
1156 len = RSTRUCT_LEN(s);
1164 else if (
len <= i) {
1178 rb_raise(
rb_eIndexError,
"offset %ld too small for struct(size:%ld)",
1182 rb_raise(
rb_eIndexError,
"offset %ld too large for struct(size:%ld)",
1187 rb_name_err_raise(
"no member '%1$s' in struct", s, idx);
1220 int i = rb_struct_pos(s, &idx);
1221 if (i < 0) invalid_struct_pos(s, idx);
1222 return RSTRUCT_GET(s, i);
1258 int i = rb_struct_pos(s, &idx);
1259 if (i < 0) invalid_struct_pos(s, idx);
1260 rb_struct_modify(s);
1261 RSTRUCT_SET(s, i, val);
1271 return rb_struct_lookup_default(s, idx,
Qnil);
1277 int i = rb_struct_pos(s, &idx);
1278 if (i < 0)
return notfound;
1279 return RSTRUCT_GET(s, i);
1283struct_entry(
VALUE s,
long n)
1324rb_struct_values_at(
int argc,
VALUE *argv,
VALUE s)
1348rb_struct_select(
int argc,
VALUE *argv,
VALUE s)
1356 for (i = 0; i < RSTRUCT_LEN(s); i++) {
1370 if (recur)
return Qtrue;
1371 len = RSTRUCT_LEN(s);
1372 for (i=0; i<
len; i++) {
1373 if (!
rb_equal(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i)))
return Qfalse;
1402 if (s == s2)
return Qtrue;
1405 if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1406 rb_bug(
"inconsistent struct");
1432rb_struct_hash(
VALUE s)
1439 len = RSTRUCT_LEN(s);
1440 for (i = 0; i <
len; i++) {
1441 n = rb_hash(RSTRUCT_GET(s, i));
1453 if (recur)
return Qtrue;
1454 len = RSTRUCT_LEN(s);
1455 for (i=0; i<
len; i++) {
1456 if (!
rb_eql(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i)))
return Qfalse;
1483 if (s == s2)
return Qtrue;
1486 if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1487 rb_bug(
"inconsistent struct");
1544rb_struct_dig(
int argc,
VALUE *argv,
VALUE self)
1547 self = rb_struct_lookup(self, *argv);
1548 if (!--argc)
return self;
1550 return rb_obj_dig(argc, argv, self,
Qnil);
1669rb_data_s_def(
int argc,
VALUE *argv,
VALUE klass)
1675 rest = rb_ident_hash_new();
1676 RBASIC_CLEAR_CLASS(rest);
1677 for (i=0; i<argc; i++) {
1679 if (rb_is_attrset_sym(mem)) {
1680 rb_raise(rb_eArgError,
"invalid data member: %"PRIsVALUE, mem);
1682 if (
RTEST(rb_hash_has_key(rest, mem))) {
1683 rb_raise(rb_eArgError,
"duplicate member: %"PRIsVALUE, mem);
1685 rb_hash_aset(rest, mem,
Qtrue);
1687 rest = rb_hash_keys(rest);
1688 RBASIC_CLEAR_CLASS(rest);
1690 data_class = anonymous_struct(klass);
1691 setup_data(data_class, rest);
1704 va_start(ar, super);
1705 ary = struct_make_members_list(ar);
1707 if (!super) super = rb_cData;
1708 VALUE klass = setup_data(anonymous_struct(super), ary);
1709 rb_vm_register_global_object(klass);
1724#define rb_data_s_members_m rb_struct_s_members_m
1778rb_data_initialize_m(
int argc,
const VALUE *argv,
VALUE self)
1781 rb_struct_modify(self);
1782 VALUE members = struct_ivar_get(klass, id_members);
1786 if (num_members > 0) {
1787 rb_exc_raise(rb_keyword_error_new(
"missing", members));
1792 rb_error_arity(argc, 0, 0);
1796 VALUE missing = rb_ary_diff(members, rb_hash_keys(argv[0]));
1797 rb_exc_raise(rb_keyword_error_new(
"missing", missing));
1803 arg.unknown_keywords =
Qnil;
1808 if (arg.unknown_keywords !=
Qnil) {
1809 rb_exc_raise(rb_keyword_error_new(
"unknown", arg.unknown_keywords));
1818 copy = rb_struct_init_copy(copy, s);
1854rb_data_with(
int argc,
const VALUE *argv,
VALUE self)
1858 if (
NIL_P(kwargs)) {
1862 VALUE h = rb_struct_to_h(self);
1863 rb_hash_update_by(h, kwargs, 0);
1887rb_data_inspect(
VALUE s)
1913#define rb_data_equal rb_struct_equal
1933#define rb_data_eql rb_struct_eql
1957#define rb_data_hash rb_struct_hash
1987#define rb_data_to_h rb_struct_to_h
2002#define rb_data_members_m rb_struct_members_m
2033#define rb_data_deconstruct rb_struct_to_a
2065#define rb_data_deconstruct_keys rb_struct_deconstruct_keys
2239 rb_define_method(rb_cData,
"deconstruct_keys", rb_data_deconstruct_keys, 1);
2248 id_members = rb_intern(
"__members__");
2249 id_back_members = rb_intern(
"__members_back__");
2250 id_keyword_init = rb_intern(
"__keyword_init__");
#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.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define RB_OBJ_FREEZE
Just another name of rb_obj_freeze_inline.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_class_new(VALUE super)
Creates a new, anonymous class.
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_class_id_under(VALUE outer, ID id, VALUE super)
Identical to rb_define_class_under(), except it takes the name in ID instead of C's string.
VALUE rb_class_inherited(VALUE super, VALUE klass)
Calls Class::inherited.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
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_keyword_given_p(void)
Determines if the current method is given a keyword argument.
int rb_block_given_p(void)
Determines if the current method is given a block.
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 OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define T_STRING
Old name of RUBY_T_STRING.
#define INT2FIX
Old name of RB_INT2FIX.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#define rb_str_cat2
Old name of rb_str_cat_cstr.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define SYM2ID
Old name of RB_SYM2ID.
#define FIX2UINT
Old name of RB_FIX2UINT.
#define CLASS_OF
Old name of rb_class_of.
#define rb_ary_new4
Old name of rb_ary_new_from_values.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FIX2INT
Old name of RB_FIX2INT.
#define T_HASH
Old name of RUBY_T_HASH.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define T_CLASS
Old name of RUBY_T_CLASS.
#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_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eTypeError
TypeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eIndexError
IndexError exception.
VALUE rb_class_superclass(VALUE klass)
Queries the parent 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_class_new_instance_kw(int argc, const VALUE *argv, VALUE klass, int kw_splat)
Identical to rb_class_new_instance(), except you can specify how to handle the last element of the gi...
VALUE rb_mEnumerable
Enumerable module.
VALUE rb_cStruct
Struct class.
VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass)
Identical to rb_class_new_instance(), except it passes the passed keywords if any to the #initialize ...
int rb_eql(VALUE lhs, VALUE rhs)
Checks for equality of the passed objects, in terms of Object#eql?.
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_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.
#define RGENGC_WB_PROTECTED_STRUCT
This is a compile-time flag to enable/disable write barrier for struct RStruct.
Defines RBIMPL_HAS_BUILTIN.
VALUE rb_ary_dup(VALUE ary)
Duplicates an array.
VALUE rb_get_values_at(VALUE obj, long olen, int argc, const VALUE *argv, VALUE(*func)(VALUE obj, long oidx))
This was a generalisation of Array#values_at, Struct#values_at, and MatchData#values_at.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_hidden_new(long capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
void rb_mem_clear(VALUE *buf, long len)
Fills the memory region with a series of RUBY_Qnil.
VALUE rb_ary_join(VALUE ary, VALUE sep)
Recursively stringises the elements of the passed array, flattens that result, then joins the sequenc...
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
This roughly resembles return enum_for(__callee__) unless block_given?.
#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.
int rb_is_const_id(ID id)
Classifies the given ID, then sees if it is a constant.
int rb_is_local_id(ID id)
Classifies the given ID, then sees if it is a local variable.
#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.
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
#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.
VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc,...)
Identical to rb_struct_define_without_accessor(), except it defines the class under the specified nam...
VALUE rb_struct_define_under(VALUE space, const char *name,...)
Identical to rb_struct_define(), except it defines the class under the specified namespace instead of...
VALUE rb_struct_new(VALUE klass,...)
Creates an instance of the given struct.
VALUE rb_struct_initialize(VALUE self, VALUE values)
Mass-assigns a struct's fields.
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_define(const char *name,...)
Defines a struct class.
VALUE rb_struct_alloc(VALUE klass, VALUE values)
Identical to rb_struct_new(), except it takes the field values as a Ruby array.
VALUE rb_data_define(VALUE super,...)
Defines an anonymous data class.
VALUE rb_struct_alloc_noinit(VALUE klass)
Allocates an instance of the given class.
VALUE rb_struct_s_members(VALUE klass)
Queries the list of the names of the fields of the given struct class.
VALUE rb_struct_members(VALUE self)
Queries the list of the names of the fields of the class of the given struct object.
VALUE rb_struct_getmember(VALUE self, ID key)
Identical to rb_struct_aref(), except it takes ID instead of VALUE.
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_mod_remove_const(VALUE space, VALUE name)
Resembles Module#remove_const.
VALUE rb_class_name(VALUE obj)
Queries the name of the given object's class.
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
VALUE(* rb_alloc_func_t)(VALUE klass)
This is the type of functions that ruby calls when trying to allocate an object.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
VALUE rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
Identical to rb_obj_instance_eval(), except it evaluates within the context of module.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
VALUE rb_check_symbol(volatile VALUE *namep)
Identical to rb_check_id(), except it returns an instance of rb_cSymbol instead.
VALUE rb_to_symbol(VALUE name)
Identical to rb_intern_str(), except it generates a dynamic symbol if necessary.
int off
Offset inside of ptr.
int len
Length of the buffer.
VALUE rb_yield_values(int n,...)
Identical to rb_yield(), except it takes variadic number of parameters and pass them to the block.
VALUE rb_yield(VALUE val)
Yields the block.
#define rb_long2int
Just another name of rb_long2int_inline.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
void rb_hash_foreach(VALUE q, int_type *w, VALUE e)
Iteration over the given hash.
#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.
static VALUE * RARRAY_PTR(VALUE ary)
Wild use of a C pointer.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define RBASIC(obj)
Convenient casting macro.
#define RHASH_SIZE(h)
Queries the size of the hash.
VALUE rb_str_to_str(VALUE obj)
Identical to rb_check_string_type(), except it raises exceptions in case of conversion failures.
VALUE rb_struct_aset(VALUE st, VALUE k, VALUE v)
Resembles Struct#[]=.
VALUE rb_struct_size(VALUE st)
Returns the number of struct members.
VALUE rb_struct_aref(VALUE st, VALUE k)
Resembles Struct#[].
#define InitVM(ext)
This macro is for internal use.
#define RB_PASS_KEYWORDS
Pass keywords, final argument should be a hash of keywords.
#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_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.