13#include "internal/concurrent_set.h"
14#include "internal/error.h"
15#include "internal/gc.h"
16#include "internal/hash.h"
17#include "internal/object.h"
18#include "internal/symbol.h"
19#include "internal/vm.h"
28#if defined(USE_SYMBOL_GC) && !(USE_SYMBOL_GC+0)
30# define USE_SYMBOL_GC 0
33# define USE_SYMBOL_GC 1
35#if defined(SYMBOL_DEBUG) && (SYMBOL_DEBUG+0)
37# define SYMBOL_DEBUG 1
40# define SYMBOL_DEBUG 0
42#ifndef CHECK_ID_SERIAL
43# define CHECK_ID_SERIAL SYMBOL_DEBUG
46#define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
47#define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
49#define SYMBOL_PINNED_P(sym) (RSYMBOL(sym)->id&~ID_SCOPE_MASK)
51#define STATIC_SYM2ID(sym) RSHIFT((VALUE)(sym), RUBY_SPECIAL_SHIFT)
54#define REGISTER_SYMID(id, name) register_static_symid((id), (name), strlen(name), enc)
57#define is_identchar(p,e,enc) (ISALNUM((unsigned char)*(p)) || (*(p)) == '_' || !ISASCII(*(p)))
59#define op_tbl_count numberof(op_tbl)
60STATIC_ASSERT(op_tbl_name_size,
sizeof(op_tbl[0].name) == 3);
61#define op_tbl_len(i) (!op_tbl[i].name[1] ? 1 : !op_tbl[i].name[2] ? 2 : 3)
64#define GLOBAL_SYMBOLS_LOCKING(symbols) \
65 for (rb_symbols_t *symbols = &ruby_global_symbols, **locking = &symbols; \
76 for (i =
'!'; i <=
'~'; ++i) {
79 register_static_symid(i, &c, 1, enc);
82 for (i = 0; i < op_tbl_count; ++i) {
83 register_static_symid(op_tbl[i].token, op_tbl[i].name, op_tbl_len(i), enc);
87static const int ID_ENTRY_UNIT = 512;
109#define SYM_SET_SYM_STATIC_TAG 1
112sym_set_sym_static_p(
VALUE sym)
114 return sym & SYM_SET_SYM_STATIC_TAG;
120 VALUE value = (
VALUE)sym | SYM_SET_SYM_STATIC_TAG;
128sym_set_static_sym_untag(
VALUE sym)
136sym_set_sym_get_str(
VALUE sym)
139 if (sym_set_sym_static_p(sym)) {
140 str = sym_set_static_sym_untag(sym)->str;
144 str = RSYMBOL(sym)->fstr;
153sym_set_hash(
VALUE sym)
155 if (sym_set_sym_static_p(sym)) {
159 return (
VALUE)RSYMBOL(sym)->hashval;
166 return rb_str_hash_cmp(sym_set_sym_get_str(a), sym_set_sym_get_str(b)) ==
false;
171sym_check_asciionly(
VALUE str,
bool fake_str)
173 if (!rb_enc_asciicompat(rb_enc_get(str)))
return FALSE;
177 str = rb_enc_str_new(RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str));
180 rb_enc_name(rb_enc_get(str)), str);
188dup_string_for_create(
VALUE str)
192 str = rb_enc_str_new(RSTRING_PTR(str), RSTRING_LEN(str), enc);
195 if (enc != ascii && sym_check_asciionly(str,
false)) {
196 rb_enc_associate(str, ascii);
200 str = rb_fstring(str);
206rb_str_symname_type(
VALUE name,
unsigned int allowed_attrset)
209 long len = RSTRING_LEN(name);
210 int type = rb_enc_symname_type(ptr,
len, rb_enc_get(name), allowed_attrset);
220 return (
ID)serial << ID_SCOPE_SHIFT;
230 size_t idx = num / ID_ENTRY_UNIT;
232 VALUE ary, ids = symbols->ids;
237 idx = (num % ID_ENTRY_UNIT) * ID_ENTRY_SIZE;
243sym_set_create(
VALUE sym,
void *data)
245 bool create_dynamic_symbol = (bool)data;
249 VALUE str = dup_string_for_create(static_sym_entry->str);
251 if (create_dynamic_symbol) {
255 rb_enc_set_index((
VALUE)obj, rb_enc_to_index(enc));
259 int id = rb_str_symname_type(str, IDSET_ATTRSET_FOR_INTERN);
260 if (
id < 0)
id = ID_INTERNAL;
264 RUBY_DTRACE_CREATE_HOOK(SYMBOL, RSTRING_PTR(obj->fstr));
270 new_static_sym_entry->str = str;
272 VALUE static_sym = static_sym_entry->sym;
273 if (static_sym == 0) {
274 ID id = rb_str_symname_type(str, IDSET_ATTRSET_FOR_INTERN);
275 if (
id == (
ID)-1)
id = ID_INTERNAL;
277 id |= next_id_base();
280 static_sym = STATIC_ID2SYM(
id);
282 new_static_sym_entry->sym = static_sym;
285 set_id_entry(&ruby_global_symbols, rb_id_to_serial(STATIC_SYM2ID(static_sym)), str, static_sym);
288 return sym_set_static_sym_tag(new_static_sym_entry);
293sym_set_free(
VALUE sym)
295 if (sym_set_sym_static_p(sym)) {
296 xfree(sym_set_static_sym_untag(sym));
301 .hash = sym_set_hash,
303 .create = sym_set_create,
304 .free = sym_set_free,
308sym_set_entry_to_sym(
VALUE entry)
310 if (sym_set_sym_static_p(entry)) {
313 if (!
STATIC_SYM_P(sym_set_static_sym_untag(entry)->sym)) rb_bug(
"not sym");
315 return sym_set_static_sym_untag(entry)->sym;
331 return sym_set_entry_to_sym(
332 rb_concurrent_set_find_or_insert(&symbols->sym_set, sym_set_static_sym_tag(&static_sym), (
void *)
true)
342 return sym_set_entry_to_sym(
343 rb_concurrent_set_find_or_insert(&symbols->sym_set, sym_set_static_sym_tag(&static_sym), (
void *)
false)
351 .sym = STATIC_ID2SYM(
id),
354 return sym_set_entry_to_sym(
355 rb_concurrent_set_find_or_insert(&symbols->sym_set, sym_set_static_sym_tag(&static_sym), (
void *)
false)
364 symbols->sym_set = rb_concurrent_set_new(&sym_set_funcs, 1024);
372rb_sym_global_symbols_mark(
void)
376 rb_gc_mark_movable(symbols->sym_set);
377 rb_gc_mark_movable(symbols->ids);
381rb_sym_global_symbols_update_references(
void)
385 symbols->sym_set = rb_gc_location(symbols->sym_set);
386 symbols->ids = rb_gc_location(symbols->ids);
390rb_free_global_symbol_table_i(
VALUE *sym_ptr,
void *data)
392 sym_set_free(*sym_ptr);
398rb_free_global_symbol_table(
void)
400 rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_free_global_symbol_table_i, NULL);
403WARN_UNUSED_RESULT(
static ID lookup_str_id(
VALUE str));
404WARN_UNUSED_RESULT(
static VALUE lookup_id_str(
ID id));
411 if (!is_notop_id(
id)) {
413 case tAREF:
case tASET:
416 rb_name_error(
id,
"cannot make operator ID :%"PRIsVALUE
" attrset",
422 case ID_LOCAL:
case ID_INSTANCE:
case ID_GLOBAL:
423 case ID_CONST:
case ID_CLASS:
case ID_INTERNAL:
429 VALUE str = lookup_id_str(
id);
431 rb_name_error(
id,
"cannot make unknown type ID %d:%"PRIsVALUE
" attrset",
444 VALUE str = lookup_id_str(
id);
448 if (sym_check_asciionly(str,
false)) {
449 rb_enc_associate(str, rb_usascii_encoding());
452 VALUE sym = sym_find_or_insert_static_symbol(&ruby_global_symbols, str);
460 RBIMPL_ATTR_NONSTRING_ARRAY()
static const char id_types[][8] = {
470 rb_name_error(
id,
"cannot make anonymous %.*s ID %"PRIxVALUE
" attrset",
471 (
int)
sizeof(id_types[0]), id_types[scope], (
VALUE)
id);
478is_special_global_name(
const char *m,
const char *e,
rb_encoding *enc)
482 if (m >= e)
return 0;
483 if (is_global_name_punct(*m)) {
486 else if (*m ==
'-') {
487 if (++m >= e)
return 0;
488 if (is_identchar(m, e, enc)) {
490 m += rb_enc_mbclen(m, e, enc);
498 }
while (m < e &&
ISDIGIT(*m));
500 return m == e ? mb + 1 : 0;
516rb_sym_constant_char_p(
const char *name,
long nlen,
rb_encoding *enc)
519 const char *end = name + nlen;
521 if (nlen < 1)
return FALSE;
523 c = rb_enc_precise_mbclen(name, end, enc);
526 c = rb_enc_mbc_to_codepoint(name, end, enc);
529 if (ONIGENC_IS_UNICODE(enc)) {
530 static int ctype_titlecase = 0;
531 if (!ctype_titlecase) {
532 static const UChar cname[] =
"titlecaseletter";
533 static const UChar *
const end = cname +
sizeof(cname) - 1;
534 ctype_titlecase = ONIGENC_PROPERTY_NAME_TO_CTYPE(enc, cname, end);
540 OnigUChar fold[ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM];
541 const OnigUChar *beg = (
const OnigUChar *)name;
542 int r = enc->mbc_case_fold(ONIGENC_CASE_FOLD,
543 &beg, (
const OnigUChar *)end,
545 if (r > 0 && (r !=
len || memcmp(fold, name, r)))
552 const enum { invalid, stophere, needmore, } kind;
553 const enum ruby_id_types
type;
557#define t struct enc_synmane_type_leading_chars_tag
560enc_synmane_type_leading_chars(const char *name,
long len,
rb_encoding *enc,
int allowed_attrset)
562 const char *m = name;
563 const char *e = m +
len;
565 if (! rb_enc_asciicompat(enc)) {
566 return (t) { invalid, 0, 0, };
569 return (t) { invalid, 0, 0, };
571 else if (
len <= 0 ) {
572 return (t) { invalid, 0, 0, };
576 return (t) { invalid, 0, 0, };
579 if (is_special_global_name(++m, e, enc)) {
580 return (t) { stophere, ID_GLOBAL,
len, };
583 return (t) { needmore, ID_GLOBAL, 1, };
588 default:
return (t) { needmore, ID_INSTANCE, 1, };
589 case '@':
return (t) { needmore, ID_CLASS, 2, };
594 default:
return (t) { stophere, ID_INTERNAL, 1, };
595 case '<':
return (t) { stophere, ID_INTERNAL, 2, };
598 default:
return (t) { stophere, ID_INTERNAL, 2, };
599 case '>':
return (t) { stophere, ID_INTERNAL, 3, };
605 default:
return (t) { stophere, ID_INTERNAL, 1, };
606 case '>':
case '=':
return (t) { stophere, ID_INTERNAL, 2, };
611 default:
return (t) { invalid, 0, 1, };
612 case '~':
return (t) { stophere, ID_INTERNAL, 2, };
615 default:
return (t) { stophere, ID_INTERNAL, 2, };
616 case '=':
return (t) { stophere, ID_INTERNAL, 3, };
622 default:
return (t) { stophere, ID_INTERNAL, 1, };
623 case '*':
return (t) { stophere, ID_INTERNAL, 2, };
628 default:
return (t) { stophere, ID_INTERNAL, 1, };
629 case '@':
return (t) { stophere, ID_INTERNAL, 2, };
632 case '|':
case '^':
case '&':
case '/':
case '%':
case '~':
case '`':
633 return (t) { stophere, ID_INTERNAL, 1, };
637 default:
return (t) { needmore, ID_INTERNAL, 0, };
640 default:
return (t) { stophere, ID_INTERNAL, 2, };
641 case '=':
return (t) { stophere, ID_INTERNAL, 3, };
647 case '=':
case '~':
return (t) { stophere, ID_INTERNAL, 2, };
649 if (allowed_attrset & (1U << ID_INTERNAL)) {
650 return (t) { needmore, ID_INTERNAL, 1, };
653 return (t) { stophere, ID_INTERNAL, 1, };
658 if (rb_sym_constant_char_p(name,
len, enc)) {
659 return (t) { needmore, ID_CONST, 0, };
662 return (t) { needmore, ID_LOCAL, 0, };
669rb_enc_symname_type(
const char *name,
long len,
rb_encoding *enc,
unsigned int allowed_attrset)
672 enc_synmane_type_leading_chars(name,
len, enc, allowed_attrset);
673 const char *m = name + f.nread;
674 const char *e = name +
len;
675 int type = (int)f.type;
678 case invalid:
return -1;
679 case stophere:
break;
683 if (
len > 1 && *(e-1) ==
'=') {
684 type = rb_enc_symname_type(name,
len-1, enc, allowed_attrset);
685 if (allowed_attrset & (1U <<
type))
return ID_ATTRSET;
689 while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
693 if (
type == ID_GLOBAL ||
type == ID_CLASS ||
type == ID_INSTANCE)
return -1;
696 if (m + 1 < e || *m !=
'=')
break;
699 if (!(allowed_attrset & (1U <<
type)))
return -1;
706 return m == e ?
type : -1;
712 return rb_enc_symname_type(name,
len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
716get_id_serial_entry(rb_id_serial_t num,
ID id,
const enum id_entry_type t)
720 GLOBAL_SYMBOLS_LOCKING(symbols) {
722 size_t idx = num / ID_ENTRY_UNIT;
723 VALUE ids = symbols->ids;
726 long pos = (long)(num % ID_ENTRY_UNIT) * ID_ENTRY_SIZE;
732 else if (CHECK_ID_SERIAL) {
735 if (t != ID_ENTRY_SYM)
738 if (STATIC_SYM2ID(sym) !=
id) result = 0;
741 if (RSYMBOL(sym)->
id !=
id) result = 0;
766get_id_entry(
ID id,
const enum id_entry_type t)
768 return get_id_serial_entry(rb_id_to_serial(
id),
id, t);
772rb_static_id_valid_p(
ID id)
774 return STATIC_ID2SYM(
id) == get_id_entry(
id, ID_ENTRY_SYM);
778rb_id_serial_to_id(rb_id_serial_t num)
780 if (is_notop_id((
ID)num)) {
781 VALUE sym = get_id_serial_entry(num, 0, ID_ENTRY_SYM);
782 if (sym)
return SYM2ID(sym);
783 return ((
ID)num << ID_SCOPE_SHIFT) | ID_INTERNAL | ID_STATIC_SYM;
793 VALUE str = rb_enc_str_new(name,
len, enc);
795 str = rb_fstring(str);
797 RUBY_DTRACE_CREATE_HOOK(SYMBOL, RSTRING_PTR(str));
799 sym_find_or_insert_static_symbol_id(&ruby_global_symbols, str,
id);
812 sym = rb_concurrent_set_find(&ruby_global_symbols.sym_set, sym_set_static_sym_tag(&static_sym));
815 return sym_set_entry_to_sym(sym);
823lookup_str_id(
VALUE str)
825 VALUE sym = sym_find(str);
832 return STATIC_SYM2ID(sym);
835 ID id = RSYMBOL(sym)->id;
836 if (
id & ~ID_SCOPE_MASK)
return id;
839 rb_bug(
"non-symbol object %s:%"PRIxVALUE
" for %"PRIsVALUE
" in symbol table",
840 rb_builtin_class_name(sym), sym, str);
849 return get_id_entry(
id, ID_ENTRY_STR);
856 VALUE str = rb_setup_fake_str(&fake_str, name,
len, enc);
859 VALUE sym = sym_find_or_insert_static_symbol(&ruby_global_symbols, str);
864rb_intern2(
const char *name,
long len)
866 return rb_intern3(name,
len, rb_usascii_encoding());
871rb_intern(
const char *name)
873 return rb_intern2(name, strlen(name));
879 VALUE sym = sym_find_or_insert_static_symbol(&ruby_global_symbols, str);
884rb_obj_is_symbol_table(
VALUE obj)
886 return obj == ruby_global_symbols.sym_set;
890 int (*callback)(
VALUE *key,
void *data);
895rb_sym_global_symbol_table_foreach_weak_reference_i(
VALUE *key,
void *d)
900 if (sym_set_sym_static_p(sym)) {
903 return data->callback(&static_sym->str, data->data);
906 return data->callback(key, data->data);
911rb_sym_global_symbol_table_foreach_weak_reference(
int (*callback)(
VALUE *key,
void *data),
void *data)
913 if (!ruby_global_symbols.sym_set)
return;
916 .callback = callback,
920 rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_sym_global_symbol_table_foreach_weak_reference_i, &foreach_data);
924rb_gc_free_dsymbol(
VALUE sym)
926 VALUE str = RSYMBOL(sym)->fstr;
929 rb_concurrent_set_delete_by_identity(ruby_global_symbols.sym_set, sym);
931 RSYMBOL(sym)->fstr = 0;
958 return sym_find_or_insert_dynamic_symbol(&ruby_global_symbols, str);
966 id = STATIC_SYM2ID(sym);
969 GLOBAL_SYMBOLS_LOCKING(symbols) {
971 id = RSYMBOL(sym)->id;
973 if (UNLIKELY(!(
id & ~ID_SCOPE_MASK))) {
974 VALUE fstr = RSYMBOL(sym)->fstr;
975 ID num = next_id_base();
977 RSYMBOL(sym)->id =
id |= num;
980 set_id_entry(symbols, rb_id_to_serial(num), fstr, sym);
985 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Symbol)",
986 rb_builtin_class_name(sym));
995 if (!DYNAMIC_ID_P(x))
return STATIC_ID2SYM(x);
996 return get_id_entry(x, ID_ENTRY_SYM);
1016 str = RSYMBOL(sym)->fstr;
1020 str = rb_id2str(STATIC_SYM2ID(sym));
1030 return lookup_id_str(
id);
1036 VALUE str = rb_id2str(
id);
1039 return RSTRING_PTR(str);
1043rb_make_internal_id(
void)
1045 return next_id_base() | ID_INTERNAL | ID_STATIC_SYM;
1049rb_make_temporary_id(
size_t n)
1051 const ID max_id = RB_ID_SERIAL_MAX & ~0xffff;
1052 const ID id = max_id - (
ID)n;
1056 return (
id << ID_SCOPE_SHIFT) | ID_STATIC_SYM | ID_INTERNAL;
1060symbols_i(
VALUE *key,
void *data)
1065 if (sym_set_sym_static_p(sym)) {
1066 rb_ary_push(ary, sym_set_static_sym_untag(sym)->sym);
1068 else if (rb_objspace_garbage_object_p(sym)) {
1083 GLOBAL_SYMBOLS_LOCKING(symbols) {
1084 ary =
rb_ary_new2(rb_concurrent_set_size(symbols->sym_set));
1085 rb_concurrent_set_foreach_with_replace(symbols->sym_set, symbols_i, (
void *)ary);
1092rb_sym_immortal_count(
void)
1100 return is_const_id(
id);
1106 return is_class_id(
id);
1112 return is_global_id(
id);
1118 return is_instance_id(
id);
1124 return is_attrset_id(
id);
1130 return is_local_id(
id);
1136 return is_internal_id(
id);
1140rb_is_const_sym(
VALUE sym)
1142 return is_const_sym(sym);
1146rb_is_attrset_sym(
VALUE sym)
1148 return is_attrset_sym(sym);
1155 VALUE name = *namep;
1158 return STATIC_SYM2ID(name);
1161 if (SYMBOL_PINNED_P(name)) {
1162 return RSYMBOL(name)->id;
1165 *namep = RSYMBOL(name)->fstr;
1172 rb_raise(
rb_eTypeError,
"%+"PRIsVALUE
" is not a symbol nor a string",
1179 sym_check_asciionly(name,
false);
1181 return lookup_str_id(name);
1186rb_get_symbol_id(
VALUE name)
1189 return STATIC_SYM2ID(name);
1192 if (SYMBOL_PINNED_P(name)) {
1193 return RSYMBOL(name)->id;
1200 return lookup_str_id(name);
1213 VALUE name = *namep;
1225 rb_raise(
rb_eTypeError,
"%+"PRIsVALUE
" is not a symbol nor a string",
1232 sym_check_asciionly(name,
false);
1234 if ((sym = sym_find(name)) != 0) {
1245 const VALUE name = rb_setup_fake_str(&fake_str,
ptr,
len, enc);
1247 sym_check_asciionly(name,
true);
1249 return lookup_str_id(name);
1257 const VALUE name = rb_setup_fake_str(&fake_str,
ptr,
len, enc);
1259 sym_check_asciionly(name,
true);
1261 if ((sym = sym_find(name)) != 0) {
1268#undef rb_sym_intern_ascii_cstr
1273FUNC_MINIMIZED(
VALUE rb_sym_intern_ascii(
const char *
ptr,
long len));
1274FUNC_MINIMIZED(
VALUE rb_sym_intern_ascii_cstr(
const char *
ptr));
1281 const VALUE name = rb_setup_fake_str(&fake_str,
ptr,
len, enc);
1286rb_sym_intern_ascii(
const char *
ptr,
long len)
1288 return rb_sym_intern(
ptr,
len, rb_usascii_encoding());
1292rb_sym_intern_ascii_cstr(
const char *
ptr)
1294 return rb_sym_intern_ascii(
ptr, strlen(
ptr));
1298rb_to_symbol_type(
VALUE obj)
1300 return rb_convert_type_with_id(obj,
T_SYMBOL,
"Symbol", idTo_sym);
1304rb_is_const_name(
VALUE name)
1306 return rb_str_symname_type(name, 0) == ID_CONST;
1310rb_is_class_name(
VALUE name)
1312 return rb_str_symname_type(name, 0) == ID_CLASS;
1316rb_is_instance_name(
VALUE name)
1318 return rb_str_symname_type(name, 0) == ID_INSTANCE;
1322rb_is_local_name(
VALUE name)
1324 return rb_str_symname_type(name, 0) == ID_LOCAL;
1327#include "id_table.c"
1328#include "symbol.rbinc"
#define RUBY_ASSERT_BUILTIN_TYPE(obj, type)
A variant of RUBY_ASSERT that asserts when either RUBY_DEBUG or built-in type of obj is type.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define RUBY_ATOMIC_FETCH_ADD(var, val)
Atomically replaces the value pointed by var with the result of addition of val to the old value of v...
#define RUBY_ATOMIC_LOAD(var)
Atomic load.
static bool rb_enc_isupper(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isupper(), except it additionally takes an encoding.
static bool rb_enc_isctype(OnigCodePoint c, OnigCtype t, rb_encoding *enc)
Queries if the passed code point is of passed character type in the passed encoding.
static bool rb_enc_islower(OnigCodePoint c, rb_encoding *enc)
Identical to rb_islower(), except it additionally takes an encoding.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define T_STRING
Old name of RUBY_T_STRING.
#define xfree
Old name of ruby_xfree.
#define ISUPPER
Old name of rb_isupper.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define SYM2ID
Old name of RB_SYM2ID.
#define xmalloc
Old name of ruby_xmalloc.
#define ISDIGIT
Old name of rb_isdigit.
#define STATIC_SYM_P
Old name of RB_STATIC_SYM_P.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define ISALPHA
Old name of rb_isalpha.
#define ISASCII
Old name of rb_isascii.
#define DYNAMIC_SYM_P
Old name of RB_DYNAMIC_SYM_P.
#define Qnil
Old name of RUBY_Qnil.
#define ENC_CODERANGE_BROKEN
Old name of RUBY_ENC_CODERANGE_BROKEN.
#define NIL_P
Old name of RB_NIL_P.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define IMMEDIATE_P
Old name of RB_IMMEDIATE_P.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define ISALNUM
Old name of rb_isalnum.
void rb_name_error(ID id, const char *fmt,...)
Raises an instance of rb_eNameError.
VALUE rb_eTypeError
TypeError exception.
void rb_name_error_str(VALUE str, const char *fmt,...)
Identical to rb_name_error(), except it takes a VALUE instead of ID.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_eEncodingError
EncodingError exception.
VALUE rb_cSymbol
Symbol class.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
int rb_enc_symname_p(const char *str, rb_encoding *enc)
Identical to rb_symname_p(), except it additionally takes an encoding.
VALUE rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc)
Identical to rb_check_id_cstr(), except for the return type.
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Identical to rb_enc_symname_p(), except it additionally takes the passed string's length.
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Identical to rb_check_id(), except it takes a pointer to a memory region instead of Ruby's string.
Defines RBIMPL_HAS_BUILTIN.
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.
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
VALUE rb_sym_all_symbols(void)
Collects every single bits of symbols that have ever interned in the entire history of the current pr...
int rb_is_global_id(ID id)
Classifies the given ID, then sees if it is a global variable.
int rb_is_instance_id(ID id)
Classifies the given ID, then sees if it is an instance variable.
int rb_is_const_id(ID id)
Classifies the given ID, then sees if it is a constant.
int rb_is_junk_id(ID)
Classifies the given ID, then sees if it is a junk ID.
int rb_symname_p(const char *str)
Sees if the passed C string constructs a valid syntactic symbol.
int rb_is_class_id(ID id)
Classifies the given ID, then sees if it is a class variable.
int rb_is_attrset_id(ID id)
Classifies the given ID, then sees if it is an attribute writer.
int rb_is_local_id(ID id)
Classifies the given ID, then sees if it is a local variable.
int rb_str_hash_cmp(VALUE str1, VALUE str2)
Compares two strings.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
st_index_t rb_str_hash(VALUE str)
Calculates a hash value of a string.
VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
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_check_symbol(volatile VALUE *namep)
Identical to rb_check_id(), except it returns an instance of rb_cSymbol instead.
VALUE rb_id2sym(ID id)
Allocates an instance of rb_cSymbol that has the given id.
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
ID rb_sym2id(VALUE obj)
Converts an instance of rb_cSymbol into an ID.
int len
Length of the buffer.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE type(ANYARGS)
ANYARGS-ed function type.
Defines RBIMPL_ATTR_NONSTRING.
#define RARRAY_LEN
Just another name of rb_array_len.
#define StringValuePtr(v)
Identical to StringValue, except it returns a char*.
char * ptr
Pointer to the contents of the string.
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.