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"
21#include "transient_heap.h"
28 AREF_HASH_THRESHOLD = 10
36static ID id_members, id_back_members, id_keyword_init;
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);
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;
122 back = rb_ary_hidden_new(mask + 1);
123 rb_ary_store(back, mask,
INT2FIX(members_length));
126 for (i=0; i < members_length; i++) {
129 j = struct_member_pos_ideal(name, mask);
133 rb_ary_store(back, j, name);
134 rb_ary_store(back, j + 1,
INT2FIX(i));
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++) {
182 j = struct_member_pos_ideal(name, mask);
191 j = struct_member_pos_probe(j, mask);
207rb_struct_s_members_m(
VALUE klass)
211 return rb_ary_dup(members);
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++) {
320 VALUE k = rb_ary_entry(members, i), v = argv[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);
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 st_table *tbl = RHASH_TBL_RAW(list);
418 RBASIC_CLEAR_CLASS(list);
420 while ((mem = va_arg(ar,
char*)) != 0) {
421 VALUE sym = rb_sym_intern_ascii_cstr(mem);
422 if (st_insert(tbl, sym,
Qtrue)) {
426 ary = rb_hash_keys(list);
428 RBASIC_CLEAR_CLASS(ary);
447 klass = anonymous_struct(super);
450 struct_set_members(klass, members);
469 members = struct_make_members_list(ar);
472 return struct_define_without_accessor(outer, class_name, super, alloc, members);
482 members = struct_make_members_list(ar);
485 return struct_define_without_accessor(0, class_name, super, alloc, members);
495 ary = struct_make_members_list(ar);
503 rb_vm_add_root_module(st);
505 return setup_struct(st, ary);
515 ary = struct_make_members_list(ar);
648rb_struct_s_def(
int argc,
VALUE *argv,
VALUE klass)
656 argc =
rb_scan_args(argc, argv,
"1*:", NULL, NULL, &opt);
667 static ID keyword_ids[1];
669 if (!keyword_ids[0]) {
670 keyword_ids[0] =
rb_intern(
"keyword_init");
673 if (UNDEF_P(keyword_init)) {
676 else if (
RTEST(keyword_init)) {
677 keyword_init =
Qtrue;
681 rest = rb_ident_hash_new();
682 RBASIC_CLEAR_CLASS(rest);
684 tbl = RHASH_TBL_RAW(rest);
685 for (i=0; i<argc; i++) {
687 if (rb_is_attrset_sym(mem)) {
690 if (st_insert(tbl, mem,
Qtrue)) {
694 rest = rb_hash_keys(rest);
696 RBASIC_CLEAR_CLASS(rest);
699 st = anonymous_struct(klass);
702 st = new_struct(name, klass);
704 setup_struct(st, rest);
714num_members(
VALUE klass)
717 members = struct_ivar_get(klass, id_members);
729 VALUE unknown_keywords;
732static int rb_struct_pos(
VALUE s,
VALUE *name);
738 int i = rb_struct_pos(args->self, &key);
740 if (
NIL_P(args->unknown_keywords)) {
741 args->unknown_keywords = rb_ary_new();
743 rb_ary_push(args->unknown_keywords, key);
746 rb_struct_modify(args->self);
747 RSTRUCT_SET(args->self, i, val);
753rb_struct_initialize_m(
int argc,
const VALUE *argv,
VALUE self)
756 rb_struct_modify(self);
757 long n = num_members(klass);
759 rb_mem_clear((
VALUE *)RSTRUCT_CONST_PTR(self), n);
763 bool keyword_init =
false;
764 switch (rb_struct_s_keyword_init(klass)) {
767 rb_error_arity(argc, 0, 0);
782 rb_mem_clear((
VALUE *)RSTRUCT_CONST_PTR(self), n);
784 arg.unknown_keywords =
Qnil;
786 if (arg.unknown_keywords !=
Qnil) {
795 for (
long i=0; i<argc; i++) {
796 RSTRUCT_SET(self, i, argv[i]);
799 rb_mem_clear((
VALUE *)RSTRUCT_CONST_PTR(self)+argc, n-argc);
815struct_heap_alloc(
VALUE st,
size_t len)
820 RSTRUCT_TRANSIENT_SET(st);
824 RSTRUCT_TRANSIENT_UNSET(st);
829#if USE_TRANSIENT_HEAP
831rb_struct_transient_heap_evacuate(
VALUE obj,
int promote)
833 if (RSTRUCT_TRANSIENT_P(obj)) {
834 const VALUE *old_ptr = rb_struct_const_heap_ptr(obj);
836 long len = RSTRUCT_LEN(obj);
843 new_ptr = struct_heap_alloc(obj, len);
846 RSTRUCT(obj)->as.heap.ptr = new_ptr;
852struct_alloc(
VALUE klass)
857 n = num_members(klass);
859 if (0 < n && n <= RSTRUCT_EMBED_LEN_MAX) {
860 RBASIC(st)->flags &= ~RSTRUCT_EMBED_LEN_MASK;
861 RBASIC(st)->flags |= n << RSTRUCT_EMBED_LEN_SHIFT;
862 rb_mem_clear((
VALUE *)st->as.ary, n);
865 st->as.heap.ptr = struct_heap_alloc((
VALUE)st, n);
866 rb_mem_clear((
VALUE *)st->as.heap.ptr, n);
882 VALUE tmpargs[16], *mem = tmpargs;
887 if (size > numberof(tmpargs)) {
888 tmpargs[0] = rb_ary_hidden_new(size);
891 va_start(args, klass);
892 for (i=0; i<size; i++) {
893 mem[i] = va_arg(args,
VALUE);
929rb_struct_each(
VALUE s)
934 for (i=0; i<RSTRUCT_LEN(s); i++) {
964rb_struct_each_pair(
VALUE s)
971 if (rb_block_pair_yield_optimizable()) {
972 for (i=0; i<RSTRUCT_LEN(s); i++) {
973 VALUE key = rb_ary_entry(members, i);
974 VALUE value = RSTRUCT_GET(s, i);
979 for (i=0; i<RSTRUCT_LEN(s); i++) {
980 VALUE key = rb_ary_entry(members, i);
981 VALUE value = RSTRUCT_GET(s, i);
989inspect_struct(
VALUE s,
VALUE prefix,
int recur)
997 if (recur || first !=
'#') {
1005 len = RSTRUCT_LEN(s);
1007 for (i=0; i<len; i++) {
1014 else if (first !=
'#') {
1048rb_struct_inspect(
VALUE s)
1069rb_struct_to_a(
VALUE s)
1071 return rb_ary_new4(RSTRUCT_LEN(s), RSTRUCT_CONST_PTR(s));
1098rb_struct_to_h(
VALUE s)
1100 VALUE h = rb_hash_new_with_size(RSTRUCT_LEN(s));
1105 for (i=0; i<RSTRUCT_LEN(s); i++) {
1106 VALUE k = rb_ary_entry(members, i), v = RSTRUCT_GET(s, i);
1110 rb_hash_aset(h, k, v);
1133rb_struct_deconstruct_keys(
VALUE s,
VALUE keys)
1139 return rb_struct_to_h(s);
1143 "wrong argument type %"PRIsVALUE
" (expected Array or nil)",
1148 return rb_hash_new_with_size(0);
1153 int i = rb_struct_pos(s, &key);
1157 rb_hash_aset(h, key, RSTRUCT_GET(s, i));
1169 if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
1173 for (i=0, len=RSTRUCT_LEN(copy); i<len; i++) {
1174 RSTRUCT_SET(copy, i, RSTRUCT_GET(s, i));
1187 return struct_member_pos(s, idx);
1191 if (
NIL_P(idx))
return -1;
1192 return struct_member_pos(s, idx);
1197 len = RSTRUCT_LEN(s);
1205 else if (len <= i) {
1217 long i =
FIX2INT(idx), len = RSTRUCT_LEN(s);
1228 rb_name_err_raise(
"no member '%1$s' in struct", s, idx);
1261 int i = rb_struct_pos(s, &idx);
1262 if (i < 0) invalid_struct_pos(s, idx);
1263 return RSTRUCT_GET(s, i);
1299 int i = rb_struct_pos(s, &idx);
1300 if (i < 0) invalid_struct_pos(s, idx);
1301 rb_struct_modify(s);
1302 RSTRUCT_SET(s, i, val);
1312 return rb_struct_lookup_default(s, idx,
Qnil);
1318 int i = rb_struct_pos(s, &idx);
1319 if (i < 0)
return notfound;
1320 return RSTRUCT_GET(s, i);
1324struct_entry(
VALUE s,
long n)
1365rb_struct_values_at(
int argc,
VALUE *argv,
VALUE s)
1367 return rb_get_values_at(s, RSTRUCT_LEN(s), argc, argv, struct_entry);
1391rb_struct_select(
int argc,
VALUE *argv,
VALUE s)
1398 result = rb_ary_new();
1399 for (i = 0; i < RSTRUCT_LEN(s); i++) {
1401 rb_ary_push(result, RSTRUCT_GET(s, i));
1413 if (recur)
return Qtrue;
1414 len = RSTRUCT_LEN(s);
1415 for (i=0; i<len; i++) {
1416 if (!
rb_equal(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i)))
return Qfalse;
1445 if (s == s2)
return Qtrue;
1448 if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1449 rb_bug(
"inconsistent struct");
1475rb_struct_hash(
VALUE s)
1482 len = RSTRUCT_LEN(s);
1483 for (i = 0; i < len; i++) {
1484 n = rb_hash(RSTRUCT_GET(s, i));
1496 if (recur)
return Qtrue;
1497 len = RSTRUCT_LEN(s);
1498 for (i=0; i<len; i++) {
1499 if (!
rb_eql(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i)))
return Qfalse;
1526 if (s == s2)
return Qtrue;
1529 if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1530 rb_bug(
"inconsistent struct");
1588rb_struct_dig(
int argc,
VALUE *argv,
VALUE self)
1591 self = rb_struct_lookup(self, *argv);
1592 if (!--argc)
return self;
1594 return rb_obj_dig(argc, argv, self,
Qnil);
1713rb_data_s_def(
int argc,
VALUE *argv,
VALUE klass)
1720 rest = rb_ident_hash_new();
1721 RBASIC_CLEAR_CLASS(rest);
1723 tbl = RHASH_TBL_RAW(rest);
1724 for (i=0; i<argc; i++) {
1726 if (rb_is_attrset_sym(mem)) {
1729 if (st_insert(tbl, mem,
Qtrue)) {
1733 rest = rb_hash_keys(rest);
1735 RBASIC_CLEAR_CLASS(rest);
1737 data_class = anonymous_struct(klass);
1738 setup_data(data_class, rest);
1757#define rb_data_s_members_m rb_struct_s_members_m
1810rb_data_initialize_m(
int argc,
const VALUE *argv,
VALUE self)
1813 rb_struct_modify(self);
1814 VALUE members = struct_ivar_get(klass, id_members);
1818 if (num_members > 0) {
1819 rb_exc_raise(rb_keyword_error_new(
"missing", members));
1824 rb_error_arity(argc, 0, 0);
1828 VALUE missing = rb_ary_diff(members, rb_hash_keys(argv[0]));
1829 rb_exc_raise(rb_keyword_error_new(
"missing", missing));
1833 rb_mem_clear((
VALUE *)RSTRUCT_CONST_PTR(self), num_members);
1835 arg.unknown_keywords =
Qnil;
1837 if (arg.unknown_keywords !=
Qnil) {
1838 rb_exc_raise(rb_keyword_error_new(
"unknown", arg.unknown_keywords));
1848 copy = rb_struct_init_copy(copy, s);
1884rb_data_with(
int argc,
const VALUE *argv,
VALUE self)
1888 if (
NIL_P(kwargs)) {
1893 rb_struct_init_copy(copy, self);
1897 arg.unknown_keywords =
Qnil;
1903 if (arg.unknown_keywords !=
Qnil) {
1904 rb_exc_raise(rb_keyword_error_new(
"unknown", arg.unknown_keywords));
1930rb_data_inspect(
VALUE s)
1956#define rb_data_equal rb_struct_equal
1976#define rb_data_eql rb_struct_eql
2000#define rb_data_hash rb_struct_hash
2030#define rb_data_to_h rb_struct_to_h
2045#define rb_data_members_m rb_struct_members_m
2076#define rb_data_deconstruct rb_struct_to_a
2108#define rb_data_deconstruct_keys rb_struct_deconstruct_keys
2282 rb_define_method(rb_cData,
"deconstruct_keys", rb_data_deconstruct_keys, 1);
2292 id_back_members =
rb_intern(
"__members_back__");
2293 id_keyword_init =
rb_intern(
"__keyword_init__");
#define RUBY_ASSERT(expr)
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.
static void RB_OBJ_FREEZE_RAW(VALUE obj)
This is an implenentation detail of RB_OBJ_FREEZE().
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 NEWOBJ_OF
Old name of RB_NEWOBJ_OF.
#define FL_UNSET_RAW
Old name of RB_FL_UNSET_RAW.
#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 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_RAW
Old name of RB_OBJ_FREEZE_RAW.
#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 OBJ_WB_UNPROTECT
Old name of RB_OBJ_WB_UNPROTECT.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void rb_raise(VALUE exc, const char *fmt,...)
Exception entry point.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_bug(const char *fmt,...)
Interpreter panic switch.
VALUE rb_eTypeError
TypeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports always regardless of runtime -W flag.
VALUE rb_eArgError
ArgumentError exception.
VALUE rb_eIndexError
IndexError exception.
VALUE rb_class_superclass(VALUE klass)
Queries the parent of the given class.
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_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 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().
#define rb_check_frozen
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.
int rb_is_const_id(ID id)
Classifies the given ID, then sees if it is a constant.
ID rb_id_attrset(ID id)
Calculates an ID of attribute writer.
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_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_attr_get(VALUE obj, ID name)
Identical to rb_ivar_get()
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.
ID rb_intern(const char *name)
Finds or creates a symbol of the given name.
VALUE rb_to_symbol(VALUE name)
Identical to rb_intern_str(), except it generates a dynamic symbol if necessary.
ID rb_to_id(VALUE str)
Identical to rb_intern(), except it takes an instance of rb_cString.
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 MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#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 RGENGC_WB_PROTECTED_STRUCT
This is a compile-time flag to enable/disable write barrier for struct RStruct.
#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.
static char * RSTRING_PTR(VALUE str)
Queries the contents pointer of the string.
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.