12#include "ruby/internal/config.h"
18#include "internal/enc.h"
19#include "internal/encoding.h"
20#include "internal/error.h"
21#include "internal/inits.h"
22#include "internal/load.h"
23#include "internal/object.h"
24#include "internal/string.h"
25#include "internal/vm.h"
30#include "ruby_assert.h"
32#include "ruby_atomic.h"
37#define ENC_ASSERT(expr) RUBY_ASSERT_WHEN(ENC_DEBUG, expr)
38#define MUST_STRING(str) (ENC_ASSERT(RB_TYPE_P(str, T_STRING)), str)
40#undef rb_ascii8bit_encindex
41#undef rb_utf8_encindex
42#undef rb_usascii_encindex
46#if defined __GNUC__ && __GNUC__ >= 4
47#pragma GCC visibility push(default)
48int rb_enc_register(
const char *name,
rb_encoding *encoding);
49void rb_enc_set_base(
const char *name,
const char *orig);
50int rb_enc_set_dummy(
int index);
51void rb_encdb_declare(
const char *name);
52int rb_encdb_replicate(
const char *name,
const char *orig);
53int rb_encdb_dummy(
const char *name);
54int rb_encdb_alias(
const char *alias,
const char *orig);
55#pragma GCC visibility pop
61#define ENCODING_LIST_CAPA 256
62static VALUE rb_encoding_list;
78enc_names_free_i(st_data_t name, st_data_t idx, st_data_t args)
80 ruby_xfree((
void *)name);
85rb_free_global_enc_table(
void)
87 for (
size_t i = 0; i < ENCODING_LIST_CAPA; i++) {
88 xfree((
void *)global_enc_table.list[i].enc);
91 st_foreach(global_enc_table.names, enc_names_free_i, (st_data_t)0);
92 st_free_table(global_enc_table.names);
99#define GLOBAL_ENC_TABLE_LOCKING(tbl) \
100 for (struct enc_table *tbl = &global_enc_table, **locking = &tbl; \
106#define ENC_DUMMY_FLAG (1<<24)
107#define ENC_INDEX_MASK (~(~0U<<24))
109#define ENC_TO_ENCINDEX(enc) (int)((enc)->ruby_encoding_index & ENC_INDEX_MASK)
110#define ENC_DUMMY_P(enc) ((enc)->ruby_encoding_index & ENC_DUMMY_FLAG)
111#define ENC_SET_DUMMY(enc) ((enc)->ruby_encoding_index |= ENC_DUMMY_FLAG)
113#define ENCODING_COUNT ENCINDEX_BUILTIN_MAX
114#define UNSPECIFIED_ENCODING INT_MAX
116#define ENCODING_NAMELEN_MAX 63
117#define valid_encoding_name_p(name) ((name) && strlen(name) <= ENCODING_NAMELEN_MAX)
122 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
125#define is_data_encoding(obj) (RTYPEDDATA_P(obj) && RTYPEDDATA_TYPE(obj) == &encoding_data_type)
126#define is_obj_encoding(obj) (RB_TYPE_P((obj), T_DATA) && is_data_encoding(obj))
129rb_data_is_encoding(
VALUE obj)
131 return is_data_encoding(obj);
148 VALUE list = RUBY_ATOMIC_VALUE_LOAD(rb_encoding_list);
152 RBASIC_CLEAR_CLASS(new_list);
162enc_list_lookup(
int idx)
166 if (idx < ENCODING_LIST_CAPA) {
167 list = RUBY_ATOMIC_VALUE_LOAD(rb_encoding_list);
173 rb_bug(
"rb_enc_from_encoding_index(%d): not created yet", idx);
181rb_enc_from_encoding_index(
int idx)
183 return enc_list_lookup(idx);
190 if (!encoding)
return Qnil;
191 idx = ENC_TO_ENCINDEX(encoding);
192 return rb_enc_from_encoding_index(idx);
198 return enc ? ENC_TO_ENCINDEX(enc) : 0;
204 return ENC_DUMMY_P(enc) != 0;
210 int index = rb_enc_to_index(enc);
211 if (rb_enc_from_index(index) != enc)
213 if (rb_enc_autoload_p(enc)) {
214 index = rb_enc_autoload(enc);
220enc_check_encoding(
VALUE obj)
222 if (!is_obj_encoding(obj)) {
225 return check_encoding(
RDATA(obj)->data);
228NORETURN(
static void not_encoding(
VALUE enc));
230not_encoding(
VALUE enc)
232 rb_raise(
rb_eTypeError,
"wrong argument type %"PRIsVALUE
" (expected Encoding)",
237must_encoding(
VALUE enc)
239 int index = enc_check_encoding(enc);
247must_encindex(
int index)
254 if (rb_enc_autoload_p(enc) && rb_enc_autoload(enc) == -1) {
258 if (ENC_TO_ENCINDEX(enc) != (
int)(index & ENC_INDEX_MASK)) {
260 index, rb_enc_name(enc), ENC_TO_ENCINDEX(enc));
268 ASSERT_vm_unlocking();
272 idx = enc_check_encoding(enc);
279 if (!rb_enc_asciicompat(rb_enc_get(enc))) {
282 if (!(name = rb_str_to_cstr(enc))) {
285 return rb_enc_find_index(name);
289name_for_encoding(
volatile VALUE *enc)
294 if (!rb_enc_asciicompat(rb_enc_get(name))) {
295 rb_raise(rb_eArgError,
"invalid encoding name (non ASCII)");
297 if (!(n = rb_str_to_cstr(name))) {
298 rb_raise(rb_eArgError,
"invalid encoding name (NUL byte)");
305str_find_encindex(
VALUE enc)
307 int idx = rb_enc_find_index(name_for_encoding(&enc));
313str_to_encindex(
VALUE enc)
315 int idx = str_find_encindex(enc);
317 rb_raise(rb_eArgError,
"unknown encoding name - %"PRIsVALUE, enc);
323str_to_encoding(
VALUE enc)
325 return rb_enc_from_index(str_to_encindex(enc));
331 if (enc_check_encoding(enc) >= 0)
return RDATA(enc)->data;
332 return str_to_encoding(enc);
339 if (enc_check_encoding(enc) >= 0)
return RDATA(enc)->data;
340 idx = str_find_encindex(enc);
341 if (idx < 0)
return NULL;
342 return rb_enc_from_index(idx);
348 if (newsize > ENCODING_LIST_CAPA) {
376 tmp_encoding.name = encoding->name;
377 tmp_encoding.ruby_encoding_index = encoding->ruby_encoding_index;
378 *encoding = tmp_encoding;
398 ent->name = name =
strdup(name);
401 encoding->name = name;
402 encoding->ruby_encoding_index = index;
405 if (st_insert(
enc_table->names, (st_data_t)name, (st_data_t)index)) {
406 rb_bug(
"encoding name was somehow registered twice");
409 enc_list_update(index, encoding);
412 enc_load_from_base(
enc_table, index, base_encoding);
427 if (!valid_encoding_name_p(name))
return -1;
432 return enc_register_at(
enc_table, index, name, encoding);
435static void set_encoding_const(
const char *,
rb_encoding *);
441 if (UNLIKELY(index < 0 || enc_table->count <= (index &= ENC_INDEX_MASK))) {
450rb_enc_from_index(
int index)
452 return enc_from_index(&global_enc_table, index);
456rb_enc_register(
const char *name,
rb_encoding *encoding)
466 index = enc_register(
enc_table, name, encoding);
468 else if (rb_enc_autoload_p(oldenc) || !ENC_DUMMY_P(oldenc)) {
469 enc_load_from_base(
enc_table, index, encoding);
472 rb_raise(rb_eArgError,
"encoding %s is already registered", name);
476 index = enc_register(
enc_table, name, encoding);
477 set_encoding_const(name, rb_enc_from_index(index));
489 if (!name)
return -1;
491 if (st_lookup(
enc_table->names, (st_data_t)name, &idx)) {
498rb_enc_registered(
const char *name)
508rb_encdb_declare(
const char *name)
511 int idx = enc_registered(
enc_table, name);
515 set_encoding_const(name, rb_enc_from_index(idx));
522 if (enc_registered(
enc_table, name) >= 0) {
523 rb_raise(rb_eArgError,
"encoding %s is already registered", name);
525 else if (!valid_encoding_name_p(name)) {
526 rb_raise(rb_eArgError,
"invalid encoding name: %s", name);
546rb_enc_set_base(
const char *name,
const char *orig)
549 int idx = enc_registered(
enc_table, name);
550 int origidx = enc_registered(
enc_table, orig);
551 set_base_encoding(
enc_table, idx, rb_enc_from_index(origidx));
559rb_enc_set_dummy(
int index)
561 rb_encoding *enc = global_enc_table.list[index].enc;
572 idx = enc_register(
enc_table, name, encoding);
573 if (idx < 0) rb_raise(rb_eArgError,
"invalid encoding name: %s", name);
574 set_base_encoding(
enc_table, idx, encoding);
575 set_encoding_const(name, rb_enc_from_index(idx));
583 idx = enc_register(
enc_table, name, origenc);
586 enc_load_from_base(
enc_table, idx, origenc);
589 set_base_encoding(
enc_table, idx, origenc);
590 set_encoding_const(name, rb_enc_from_index(idx));
593 rb_raise(rb_eArgError,
"failed to replicate encoding");
599rb_encdb_replicate(
const char *name,
const char *orig)
604 int origidx = enc_registered(
enc_table, orig);
605 int idx = enc_registered(
enc_table, name);
608 origidx = enc_register(
enc_table, orig, 0);
610 r = enc_replicate_with_index(
enc_table, name, rb_enc_from_index(origidx), idx);
617rb_define_dummy_encoding(
const char *name)
622 index = enc_replicate(
enc_table, name, rb_ascii8bit_encoding());
631rb_encdb_dummy(
const char *name)
636 index = enc_replicate_with_index(
enc_table, name,
637 rb_ascii8bit_encoding(),
660enc_dummy_p(
VALUE enc)
662 return RBOOL(ENC_DUMMY_P(must_encoding(enc)));
676enc_ascii_compatible_p(
VALUE enc)
678 return RBOOL(rb_enc_asciicompat(must_encoding(enc)));
687 return ONIGENC_IS_UNICODE(enc);
691enc_dup_name(st_data_t name)
693 return (st_data_t)
strdup((
const char *)name);
704 return st_insert2(
enc_table->names, (st_data_t)alias, (st_data_t)idx,
711 if (!valid_encoding_name_p(alias))
return -1;
712 if (!enc_alias_internal(
enc_table, alias, idx))
713 set_encoding_const(alias, enc_from_index(
enc_table, idx));
718rb_enc_alias(
const char *alias,
const char *orig)
725 idx = rb_enc_find_index(orig);
726 if (idx < 0)
return -1;
736rb_encdb_alias(
const char *alias,
const char *orig)
741 int idx = enc_registered(
enc_table, orig);
756 enc_table_expand(
enc_table, ENCODING_COUNT + 1);
758 enc_table->names = st_init_strcasetable_with_size(ENCODING_LIST_CAPA);
760#define OnigEncodingASCII_8BIT OnigEncodingASCII
761#define ENC_REGISTER(enc) enc_register_at(enc_table, ENCINDEX_##enc, rb_enc_name(&OnigEncoding##enc), &OnigEncoding##enc)
762 ENC_REGISTER(ASCII_8BIT);
764 ENC_REGISTER(US_ASCII);
765 global_enc_ascii =
enc_table->list[ENCINDEX_ASCII_8BIT].enc;
766 global_enc_utf_8 =
enc_table->list[ENCINDEX_UTF_8].enc;
767 global_enc_us_ascii =
enc_table->list[ENCINDEX_US_ASCII].enc;
769#undef OnigEncodingASCII_8BIT
770#define ENCDB_REGISTER(name, enc) enc_register_at(enc_table, ENCINDEX_##enc, name, NULL)
771 ENCDB_REGISTER(
"UTF-16BE", UTF_16BE);
772 ENCDB_REGISTER(
"UTF-16LE", UTF_16LE);
773 ENCDB_REGISTER(
"UTF-32BE", UTF_32BE);
774 ENCDB_REGISTER(
"UTF-32LE", UTF_32LE);
775 ENCDB_REGISTER(
"UTF-16", UTF_16);
776 ENCDB_REGISTER(
"UTF-32", UTF_32);
777 ENCDB_REGISTER(
"UTF8-MAC", UTF8_MAC);
779 ENCDB_REGISTER(
"EUC-JP", EUC_JP);
780 ENCDB_REGISTER(
"Windows-31J", Windows_31J);
786rb_enc_get_from_index(
int index)
788 return must_encindex(index);
791int rb_require_internal_silent(
VALUE fname);
794load_encoding(
const char *name)
796 ASSERT_vm_unlocking();
797 VALUE enclib = rb_sprintf(
"enc/%s.so", name);
800 char *s = RSTRING_PTR(enclib) + 4, *e =
RSTRING_END(enclib) - 3;
809 enclib = rb_fstring(enclib);
811 errinfo = rb_errinfo();
812 loaded = rb_require_internal_silent(enclib);
814 rb_set_errinfo(errinfo);
817 if (loaded < 0 || 1 < loaded) {
820 else if ((idx = enc_registered(
enc_table, name)) < 0) {
823 else if (rb_enc_autoload_p(
enc_table->list[idx].enc)) {
836 ASSERT_vm_unlocking();
839 base =
enc_table->list[ENC_TO_ENCINDEX(enc)].base;
843 bool do_register =
true;
844 if (rb_enc_autoload_p(base)) {
845 if (rb_enc_autoload(base) < 0) {
853 i = ENC_TO_ENCINDEX(enc);
869 ASSERT_vm_unlocking();
870 int i = enc_autoload_body(enc);
872 i = load_encoding(rb_enc_name(enc));
880 int idx = ENC_TO_ENCINDEX(enc);
887rb_enc_find_index(
const char *name)
890 ASSERT_vm_unlocking();
897 i = load_encoding(name);
899 else if (!(enc = rb_enc_from_index(i))) {
900 if (i != UNSPECIFIED_ENCODING) {
901 rb_raise(rb_eArgError,
"encoding %s is not registered", name);
904 else if (rb_enc_autoload_p(enc)) {
905 if (rb_enc_autoload(enc) < 0) {
906 rb_warn(
"failed to load encoding (%s); use ASCII-8BIT instead",
915rb_enc_find_index2(
const char *name,
long len)
917 char buf[ENCODING_NAMELEN_MAX+1];
919 if (
len > ENCODING_NAMELEN_MAX)
return -1;
920 memcpy(buf, name,
len);
922 return rb_enc_find_index(buf);
926rb_enc_find(
const char *name)
928 int idx = rb_enc_find_index(name);
929 if (idx < 0) idx = 0;
930 return rb_enc_from_index(idx);
934enc_capable(
VALUE obj)
944 if (is_data_encoding(obj))
return TRUE;
953 return enc_capable(obj);
964enc_get_index_str(
VALUE str)
979 iv = rb_attr_get(str, rb_id_encoding());
1000 i = enc_get_index_str(obj);
1003 tmp = rb_funcallv(obj, rb_intern(
"internal_encoding"), 0, 0);
1005 tmp = rb_funcallv(obj, rb_intern(
"external_encoding"), 0, 0);
1007 if (is_obj_encoding(tmp)) {
1008 i = enc_check_encoding(tmp);
1012 if (is_data_encoding(obj)) {
1013 i = enc_check_encoding(obj);
1023enc_set_index(
VALUE obj,
int idx)
1025 if (!enc_capable(obj)) {
1026 rb_raise(rb_eArgError,
"cannot set encoding on non-encoding capable object");
1042 int idx = enc ? ENC_TO_ENCINDEX(enc) : 0;
1055 rb_check_frozen(obj);
1057 enc_set_index(obj, idx);
1061rb_enc_associate_index(
VALUE obj,
int idx)
1064 int oldidx, oldtermlen, termlen;
1066 rb_check_frozen(obj);
1067 oldidx = rb_enc_get_index(obj);
1071 rb_raise(rb_eArgError,
"cannot set encoding");
1073 enc = must_encindex(idx);
1075 !rb_enc_asciicompat(enc)) {
1078 termlen = rb_enc_mbminlen(enc);
1079 oldtermlen = rb_enc_mbminlen(rb_enc_from_index(oldidx));
1081 rb_str_change_terminator_length(obj, oldtermlen, termlen);
1083 enc_set_index(obj, idx);
1090 return rb_enc_associate_index(obj, rb_enc_to_index(enc));
1096 return rb_enc_from_index(rb_enc_get_index(obj));
1102 if (enc == global_enc_ascii) {
1103 return "BINARY (ASCII-8BIT)";
1113 rb_enc_inspect_name(rb_enc_get(str1)),
1114 rb_enc_inspect_name(rb_enc_get(str2)));
1123 rb_encoding *enc = enc_compatible_str(MUST_STRING(str1), MUST_STRING(str2));
1124 return rb_encoding_check(enc, str1, str2);
1131 return rb_encoding_check(enc, str1, str2);
1135enc_compatible_latter(
VALUE str1,
VALUE str2,
int idx1,
int idx2)
1137 if (idx1 < 0 || idx2 < 0)
1141 return rb_enc_from_index(idx1);
1149 if (isstr2 && RSTRING_LEN(str2) == 0)
1152 if (isstr1 && isstr2 && RSTRING_LEN(str1) == 0)
1154 if (!rb_enc_asciicompat(enc1) || !rb_enc_asciicompat(enc2)) {
1159 if (!isstr2 && idx2 == ENCINDEX_US_ASCII)
1161 if (!isstr1 && idx1 == ENCINDEX_US_ASCII)
1199 int idx1 = enc_get_index_str(str1);
1200 int idx2 = enc_get_index_str(str2);
1202 return enc_compatible_latter(str1, str2, idx1, idx2);
1208 int idx1 = rb_enc_get_index(str1);
1209 int idx2 = rb_enc_get_index(str2);
1211 return enc_compatible_latter(str1, str2, idx1, idx2);
1217 rb_enc_associate_index(obj1, rb_enc_get_index(obj2));
1234 int idx = rb_enc_get_index(obj);
1238 return rb_enc_from_encoding_index(idx & ENC_INDEX_MASK);
1244 return ONIGENC_MBC_ENC_LEN(enc, (UChar*)p, (UChar*)e);
1250 int n = ONIGENC_PRECISE_MBC_ENC_LEN(enc, (UChar*)p, (UChar*)e);
1254 int min = rb_enc_mbminlen(enc);
1255 return min <= e-p ? min : (int)(e-p);
1264 return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(1);
1265 n = ONIGENC_PRECISE_MBC_ENC_LEN(enc, (UChar*)p, (UChar*)e);
1267 return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(n-(
int)(e-p));
1278 if (rb_enc_asciicompat(enc)) {
1279 c = (
unsigned char)*p;
1285 l = rb_enc_precise_mbclen(p, e, enc);
1288 c = rb_enc_mbc_to_codepoint(p, e, enc);
1289 if (!rb_enc_isascii(c, enc))
1296rb_enc_codepoint_len(
const char *p,
const char *e,
int *len_p,
rb_encoding *enc)
1300 rb_raise(rb_eArgError,
"empty string");
1301 r = rb_enc_precise_mbclen(p, e, enc);
1303 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(enc));
1306 return rb_enc_mbc_to_codepoint(p, e, enc);
1312 int n = ONIGENC_CODE_TO_MBCLEN(enc,c);
1314 rb_raise(rb_eArgError,
"invalid codepoint 0x%x in %s", c, rb_enc_name(enc));
1322 return (ONIGENC_IS_ASCII_CODE(c)?ONIGENC_ASCII_CODE_TO_UPPER_CASE(c):(c));
1328 return (ONIGENC_IS_ASCII_CODE(c)?ONIGENC_ASCII_CODE_TO_LOWER_CASE(c):(c));
1341enc_inspect(
VALUE self)
1345 if (!is_data_encoding(self)) {
1348 if (!(enc =
DATA_PTR(self)) || rb_enc_from_index(rb_enc_to_index(enc)) != enc) {
1354 rb_enc_inspect_name(enc),
1355 (ENC_DUMMY_P(enc) ?
" (dummy)" :
""),
1356 rb_enc_autoload_p(enc) ?
" (autoload)" :
"");
1375enc_names_i(st_data_t name, st_data_t idx, st_data_t args)
1379 if ((
int)idx == (int)arg[0]) {
1395enc_names(
VALUE self)
1399 args[0] = (
VALUE)rb_to_encoding_index(self);
1403 st_foreach(
enc_table->names, enc_names_i, (st_data_t)args);
1427enc_list(
VALUE klass)
1429 VALUE list = RUBY_ATOMIC_VALUE_LOAD(rb_encoding_list);
1459 if (is_obj_encoding(enc))
1461 idx = str_to_encindex(enc);
1462 if (idx == UNSPECIFIED_ENCODING)
return Qnil;
1463 return rb_enc_from_encoding_index(idx);
1495 if (!enc_capable(str1))
return Qnil;
1496 if (!enc_capable(str2))
return Qnil;
1497 enc = rb_enc_compatible(str1, str2);
1498 if (!enc)
return Qnil;
1499 return rb_enc_from_encoding(enc);
1502NORETURN(
static VALUE enc_s_alloc(
VALUE klass));
1505enc_s_alloc(
VALUE klass)
1507 rb_undefined_alloc(klass);
1516 return enc_name(self);
1530 return enc_find(klass, str);
1534rb_ascii8bit_encoding(
void)
1536 return global_enc_ascii;
1540rb_ascii8bit_encindex(
void)
1542 return ENCINDEX_ASCII_8BIT;
1546rb_utf8_encoding(
void)
1548 return global_enc_utf_8;
1552rb_utf8_encindex(
void)
1554 return ENCINDEX_UTF_8;
1558rb_usascii_encoding(
void)
1560 return global_enc_us_ascii;
1564rb_usascii_encindex(
void)
1566 return ENCINDEX_US_ASCII;
1569int rb_locale_charmap_index(
void);
1572rb_locale_encindex(
void)
1576 ASSERT_vm_unlocking();
1577 int idx = rb_locale_charmap_index();
1579 if (idx < 0) idx = ENCINDEX_UTF_8;
1582 if (enc_registered(
enc_table,
"locale") < 0) {
1584 void Init_w32_codepage(
void);
1585 Init_w32_codepage();
1588 enc_alias_internal(
enc_table,
"locale", idx);
1597rb_locale_encoding(
void)
1599 return rb_enc_from_index(rb_locale_encindex());
1603rb_filesystem_encindex(
void)
1607 idx = enc_registered(
enc_table,
"filesystem");
1609 if (idx < 0) idx = ENCINDEX_ASCII_8BIT;
1614rb_filesystem_encoding(
void)
1616 return rb_enc_from_index(rb_filesystem_encindex());
1629 int overridden = FALSE;
1631 if (def->index != -2)
1636 if (!
NIL_P(encoding)) {
1637 enc_check_encoding(encoding);
1638 index = rb_enc_to_index(rb_to_encoding(encoding));
1642 if (
NIL_P(encoding)) {
1645 char *name_dup =
strdup(name);
1647 st_data_t existing_name = (st_data_t)name_dup;
1648 if (st_delete(
enc_table->names, &existing_name, NULL)) {
1649 xfree((
void *)existing_name);
1652 st_insert(
enc_table->names, (st_data_t)name_dup,
1653 (st_data_t)UNSPECIFIED_ENCODING);
1658 enc_alias_internal(
enc_table, name, def->index);
1661 if (def == &default_external) {
1662 enc_alias_internal(
enc_table,
"filesystem", Init_enc_set_filesystem_encoding());
1670rb_default_external_encoding(
void)
1672 if (default_external.enc)
return default_external.enc;
1674 if (default_external.index >= 0) {
1675 default_external.enc = rb_enc_from_index(default_external.index);
1676 return default_external.enc;
1679 return rb_locale_encoding();
1684rb_enc_default_external(
void)
1686 return rb_enc_from_encoding(rb_default_external_encoding());
1718get_default_external(
VALUE klass)
1720 return rb_enc_default_external();
1724rb_enc_set_default_external(
VALUE encoding)
1726 if (
NIL_P(encoding)) {
1727 rb_raise(rb_eArgError,
"default external can not be nil");
1729 enc_set_default_encoding(&default_external, encoding,
1747set_default_external(
VALUE klass,
VALUE encoding)
1749 rb_warning(
"setting Encoding.default_external");
1750 rb_enc_set_default_external(encoding);
1757rb_default_internal_encoding(
void)
1759 if (!default_internal.enc && default_internal.index >= 0) {
1760 default_internal.enc = rb_enc_from_index(default_internal.index);
1762 return default_internal.enc;
1766rb_enc_default_internal(
void)
1769 return rb_enc_from_encoding(rb_default_internal_encoding());
1801get_default_internal(
VALUE klass)
1803 return rb_enc_default_internal();
1807rb_enc_set_default_internal(
VALUE encoding)
1809 enc_set_default_encoding(&default_internal, encoding,
1827set_default_internal(
VALUE klass,
VALUE encoding)
1829 rb_warning(
"setting Encoding.default_internal");
1830 rb_enc_set_default_internal(encoding);
1835set_encoding_const(
const char *name,
rb_encoding *enc)
1837 VALUE encoding = rb_enc_from_encoding(enc);
1838 char *s = (
char *)name;
1839 int haslower = 0, hasupper = 0, valid = 0;
1844 while (*++s && (
ISALNUM(*s) || *s ==
'_')) {
1845 if (
ISLOWER(*s)) haslower = 1;
1849 if (s - name > ENCODING_NAMELEN_MAX)
return;
1853 if (!valid || haslower) {
1854 size_t len = s - name;
1855 if (
len > ENCODING_NAMELEN_MAX)
return;
1856 if (!haslower || !hasupper) {
1858 if (
ISLOWER(*s)) haslower = 1;
1859 if (
ISUPPER(*s)) hasupper = 1;
1860 }
while (*++s && (!haslower || !hasupper));
1864 if (
len++ > ENCODING_NAMELEN_MAX)
return;
1868 if (
ISLOWER(*s)) *s = ONIGENC_ASCII_CODE_TO_UPPER_CASE((
int)*s);
1877 for (s = (
char *)name; *s; ++s) {
1878 if (
ISLOWER(*s)) *s = ONIGENC_ASCII_CODE_TO_UPPER_CASE((
int)*s);
1886rb_enc_name_list_i(st_data_t name, st_data_t idx, st_data_t arg)
1909rb_enc_name_list(
VALUE klass)
1914 st_foreach(
enc_table->names, rb_enc_name_list_i, (st_data_t)ary);
1920rb_enc_aliases_enc_i(st_data_t name, st_data_t orig, st_data_t arg)
1923 VALUE aliases = p[0], ary = p[1];
1924 int idx = (int)orig;
1930 if (!enc)
return ST_CONTINUE;
1931 if (
STRCASECMP((
char*)name, rb_enc_name(enc)) == 0) {
1934 str = rb_fstring_cstr(rb_enc_name(enc));
1938 rb_hash_aset(aliases, key, str);
1955rb_enc_aliases(
VALUE klass)
1958 aliases[0] = rb_hash_new();
1962 st_foreach(
enc_table->names, rb_enc_aliases_enc_i, (st_data_t)aliases);
2031 rb_gc_register_address(&rb_encoding_list);
2032 list = rb_encoding_list =
rb_ary_new2(ENCODING_LIST_CAPA);
2033 RBASIC_CLEAR_CLASS(list);
2035 for (i = 0; i <
enc_table->count; ++i) {
2043Init_unicode_version(
void)
2045 extern const char onigenc_unicode_version_string[];
2048 strlen(onigenc_unicode_version_string));
2057 rb_enc_init(&global_enc_table);
2063rb_enc_foreach_name(
int (*func)(st_data_t name, st_data_t idx, st_data_t arg), st_data_t arg)
2066 st_foreach(
enc_table->names, func, arg);
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define RUBY_ATOMIC_VALUE_SET(var, val)
Identical to RUBY_ATOMIC_SET, except it expects its arguments are VALUE.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define RUBY_ATOMIC_LOAD(var)
Atomic load.
#define RUBY_ATOMIC_SET(var, val)
Identical to RUBY_ATOMIC_EXCHANGE, except for the return type.
#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_sprintf(rb_encoding *enc, const char *fmt,...)
Identical to rb_sprintf(), except it additionally takes an encoding.
@ RUBY_FL_SHAREABLE
This flag has something to do with Ractor.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
#define ENCODING_SET_INLINED(obj, i)
Old name of RB_ENCODING_SET_INLINED.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define T_FILE
Old name of RUBY_T_FILE.
#define T_STRING
Old name of RUBY_T_STRING.
#define xfree
Old name of ruby_xfree.
#define ISUPPER
Old name of rb_isupper.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define T_DATA
Old name of RUBY_T_DATA.
#define ZALLOC
Old name of RB_ZALLOC.
#define CLASS_OF
Old name of rb_class_of.
#define ISDIGIT
Old name of rb_isdigit.
#define ISLOWER
Old name of rb_islower.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define ENCODING_INLINE_MAX
Old name of RUBY_ENCODING_INLINE_MAX.
#define STRCASECMP
Old name of st_locale_insensitive_strcasecmp.
#define ISASCII
Old name of rb_isascii.
#define TOLOWER
Old name of rb_tolower.
#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 NIL_P
Old name of RB_NIL_P.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define ENC_CODERANGE_ASCIIONLY(obj)
Old name of RB_ENC_CODERANGE_ASCIIONLY.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define ENCODING_GET_INLINED(obj)
Old name of RB_ENCODING_GET_INLINED.
#define ENC_CODERANGE_CLEAR(obj)
Old name of RB_ENC_CODERANGE_CLEAR.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define ISALNUM
Old name of rb_isalnum.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eEncCompatError
Encoding::CompatibilityError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
void rb_loaderror(const char *fmt,...)
Raises an instance of rb_eLoadError.
VALUE rb_eEncodingError
EncodingError exception.
void rb_warning(const char *fmt,...)
Issues a warning.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cEncoding
Encoding class.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
VALUE rb_locale_charmap(VALUE klass)
Returns a platform-depended "charmap" of the current locale.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
int rb_enc_str_asciionly_p(VALUE str)
Queries if the passed string is "ASCII only".
VALUE rb_ary_dup(VALUE ary)
Duplicates an array.
VALUE rb_ary_new(void)
Allocates a new, 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_freeze(VALUE obj)
Freeze an array, preventing further modifications.
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.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
VALUE rb_interned_str_cstr(const char *ptr)
Identical to rb_interned_str(), except it assumes the passed pointer is a pointer to a C's string.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_usascii_str_new_static(const char *ptr, long len)
Identical to rb_str_new_static(), except it generates a string of "US ASCII" encoding instead of "bin...
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.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
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 strdup(s)
Just another name of ruby_strdup.
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
Marshal format compatibility layer.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define DATA_PTR(obj)
Convenient getter macro.
#define RDATA(obj)
Convenient casting macro.
#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 TypedData_Wrap_Struct(klass, data_type, sval)
Converts sval, a pointer to your struct, into a Ruby object.
This is the struct that holds necessary info for a struct.
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.