23#define ENC_ASSERT(expr) RUBY_ASSERT_WHEN(ENC_DEBUG, expr)
24#define MUST_STRING(str) (ENC_ASSERT(RB_TYPE_P(str, T_STRING)), str)
26#undef rb_ascii8bit_encindex
27#undef rb_utf8_encindex
28#undef rb_usascii_encindex
32#if defined __GNUC__ && __GNUC__ >= 4
33#pragma GCC visibility push(default)
42#pragma GCC visibility pop
47static VALUE rb_encoding_list;
62#define ENC_DUMMY_FLAG (1<<24)
63#define ENC_INDEX_MASK (~(~0U<<24))
65#define ENC_TO_ENCINDEX(enc) (int)((enc)->ruby_encoding_index & ENC_INDEX_MASK)
66#define ENC_DUMMY_P(enc) ((enc)->ruby_encoding_index & ENC_DUMMY_FLAG)
67#define ENC_SET_DUMMY(enc) ((enc)->ruby_encoding_index |= ENC_DUMMY_FLAG)
69#define ENCODING_COUNT ENCINDEX_BUILTIN_MAX
70#define UNSPECIFIED_ENCODING INT_MAX
72#define ENCODING_NAMELEN_MAX 63
73#define valid_encoding_name_p(name) ((name) && strlen(name) <= ENCODING_NAMELEN_MAX)
75#define enc_autoload_p(enc) (!rb_enc_mbmaxlen(enc))
77static int load_encoding(
const char *
name);
85#define is_data_encoding(obj) (RTYPEDDATA_P(obj) && RTYPEDDATA_TYPE(obj) == &encoding_data_type)
86#define is_obj_encoding(obj) (RB_TYPE_P((obj), T_DATA) && is_data_encoding(obj))
101rb_enc_from_encoding_index(
int idx)
105 if (!(
list = rb_encoding_list)) {
106 rb_bug(
"rb_enc_from_encoding_index(%d): no rb_encoding_list", idx);
110 rb_bug(
"rb_enc_from_encoding_index(%d): not created yet", idx);
119 if (!encoding)
return Qnil;
121 return rb_enc_from_encoding_index(idx);
156 return check_encoding(
RDATA(
obj)->data);
170 int index = enc_check_encoding(
enc);
178must_encindex(
int index)
201 idx = enc_check_encoding(
enc);
231 int idx = str_find_encindex(
enc);
247 if (enc_check_encoding(
enc) >= 0)
return RDATA(
enc)->data;
248 return str_to_encoding(
enc);
255 if (enc_check_encoding(
enc) >= 0)
return RDATA(
enc)->data;
256 idx = str_find_encindex(
enc);
257 if (idx < 0)
return NULL;
262enc_table_expand(
int newsize)
267 if (enc_table.size >= newsize)
return newsize;
268 newsize = (newsize + 7) / 8 * 8;
270 memset(ent + enc_table.size, 0,
sizeof(*ent)*(newsize - enc_table.size));
271 enc_table.list = ent;
272 enc_table.size = newsize;
295 *encoding = *base_encoding;
304 list = rb_encoding_list;
315 int index = enc_table.count;
317 if ((
index = enc_table_expand(
index + 1)) < 0)
return -1;
318 enc_table.count =
index;
319 return enc_register_at(
index - 1,
name, encoding);
322static void set_encoding_const(
const char *,
rb_encoding *);
354 idx = enc_register(
name, 0);
360enc_check_duplication(
const char *
name)
406 enc_check_duplication(
name);
407 idx = enc_register(
name, encoding);
408 set_base_encoding(idx, encoding);
425 return rb_enc_from_encoding_index(
431enc_replicate_with_index(
const char *
name,
rb_encoding *origenc,
int idx)
434 idx = enc_register(
name, origenc);
437 idx = enc_register_at(idx,
name, origenc);
440 set_base_encoding(idx, origenc);
456 origidx = enc_register(orig, 0);
537enc_alias_internal(
const char *
alias,
int idx)
544enc_alias(
const char *
alias,
int idx)
547 if (!enc_alias_internal(
alias, idx))
557 enc_check_duplication(
alias);
561 return enc_alias(
alias, idx);
570 idx = enc_register(orig, 0);
572 return enc_alias(
alias, idx);
585 if (!enc_table.names) {
588#define ENC_REGISTER(enc) enc_register_at(ENCINDEX_##enc, rb_enc_name(&OnigEncoding##enc), &OnigEncoding##enc)
593#define ENCDB_REGISTER(name, enc) enc_register_at(ENCINDEX_##enc, name, NULL)
614 return enc_table.list[
index].enc;
620 return must_encindex(
index);
628 if (!
name)
return -1;
629 if (!enc_table.list)
return -1;
637load_encoding(
const char *
name)
660 if (loaded < 0 || 1 < loaded)
return -1;
675 if (
i >= enc_table.count)
return -1;
676 }
while (enc_table.list[
i].enc !=
base && (++
i, 1));
678 if (enc_autoload(
base) < 0)
return -1;
699 i = load_encoding(
name);
707 if (enc_autoload(
enc) < 0) {
708 rb_warn(
"failed to load encoding (%s); use ASCII-8BIT instead",
731 if (idx < 0) idx = 0;
755 return enc_capable(
obj);
792 i = enc_get_index_str(
obj);
800 i = enc_check_encoding(tmp);
805 i = enc_check_encoding(
obj);
817 if (!enc_capable(
obj)) {
834 enc_set_index(
obj, idx);
841 int oldidx, oldtermlen, termlen;
851 enc = must_encindex(idx);
861 enc_set_index(
obj, idx);
902enc_compatible_latter(
VALUE str1,
VALUE str2,
int idx1,
int idx2)
959 int idx1 = enc_get_index_str(str1);
960 int idx2 = enc_get_index_str(str2);
962 if (idx1 < 0 || idx2 < 0)
969 return enc_compatible_latter(str1, str2, idx1, idx2);
979 if (idx1 < 0 || idx2 < 0)
986 return enc_compatible_latter(str1, str2, idx1, idx2);
1027 return min <= e-p ? min : (
int)(e-p);
1051 c = (
unsigned char)*p;
1081#undef rb_enc_codepoint
1098#undef rb_enc_code_to_mbclen
1127enc_inspect(
VALUE self)
1164 if ((
int)idx == (
int)
arg[0]) {
1180enc_names(
VALUE self)
1244 idx = str_to_encindex(
enc);
1246 return rb_enc_from_encoding_index(idx);
1278 if (!enc_capable(str1))
return Qnil;
1279 if (!enc_capable(str2))
return Qnil;
1289 rb_undefined_alloc(
klass);
1298 return enc_name(
self);
1365 enc_alias_internal(
"locale", idx);
1402 int overridden =
FALSE;
1404 if (def->
index != -2)
1408 if (
NIL_P(encoding)) {
1420 if (def == &default_external)
1429 if (default_external.
enc)
return default_external.
enc;
1431 if (default_external.
index >= 0) {
1433 return default_external.
enc;
1481 if (
NIL_P(encoding)) {
1484 enc_set_default_encoding(&default_external, encoding,
1504 rb_warning(
"setting Encoding.default_external");
1514 if (!default_internal.
enc && default_internal.
index >= 0) {
1517 return default_internal.
enc;
1565 enc_set_default_encoding(&default_internal, encoding,
1585 rb_warning(
"setting Encoding.default_internal");
1594 char *s = (
char *)
name;
1595 int haslower = 0, hasupper = 0, valid = 0;
1600 while (*++s && (
ISALNUM(*s) || *s ==
'_')) {
1601 if (
ISLOWER(*s)) haslower = 1;
1609 if (!valid || haslower) {
1612 if (!haslower || !hasupper) {
1614 if (
ISLOWER(*s)) haslower = 1;
1615 if (
ISUPPER(*s)) hasupper = 1;
1616 }
while (*++s && (!haslower || !hasupper));
1633 for (s = (
char *)
name; *s; ++s) {
1676 VALUE aliases = p[0], ary = p[1];
1677 int idx = (
int)orig;
1922#define rb_intern(str) rb_intern_const(str)
1953 rb_encoding_list =
list;
1956 for (
i = 0;
i < enc_table.count; ++
i) {
#define ENCINDEX_BUILTIN_MAX
#define ENCINDEX_US_ASCII
struct rb_encoding_entry * list
rb_encoding * rb_find_encoding(VALUE enc)
#define is_data_encoding(obj)
int rb_enc_dummy_p(rb_encoding *enc)
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
int rb_enc_get_index(VALUE obj)
int rb_filesystem_encindex(void)
int rb_enc_replicate(const char *name, rb_encoding *encoding)
int rb_to_encoding_index(VALUE enc)
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
#define ENC_TO_ENCINDEX(enc)
void rb_encdb_declare(const char *name)
rb_encoding * rb_utf8_encoding(void)
rb_encoding * rb_enc_check_str(VALUE str1, VALUE str2)
rb_encoding * rb_ascii8bit_encoding(void)
unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len_p, rb_encoding *enc)
rb_encoding * rb_enc_from_index(int index)
rb_encoding * rb_filesystem_encoding(void)
#define UNSPECIFIED_ENCODING
rb_encoding * rb_default_internal_encoding(void)
int rb_enc_register(const char *name, rb_encoding *encoding)
int rb_utf8_encindex(void)
int rb_enc_fast_mbclen(const char *p, const char *e, rb_encoding *enc)
int rb_enc_set_dummy(int index)
rb_encoding * rb_enc_get(VALUE obj)
int rb_ascii8bit_encindex(void)
int rb_enc_code_to_mbclen(int code, rb_encoding *enc)
rb_encoding * rb_enc_get_from_index(int index)
void rb_enc_set_base(const char *name, const char *orig)
int rb_enc_unicode_p(rb_encoding *enc)
void rb_enc_copy(VALUE obj1, VALUE obj2)
#define ENCDB_REGISTER(name, enc)
int rb_enc_to_index(rb_encoding *enc)
void Init_encodings(void)
int rb_data_is_encoding(VALUE obj)
void rb_enc_set_default_internal(VALUE encoding)
void rb_encdb_set_unicode(int index)
VALUE rb_enc_default_external(void)
#define ENCODING_NAMELEN_MAX
void rb_enc_set_index(VALUE obj, int idx)
rb_encoding * rb_enc_find(const char *name)
int rb_define_dummy_encoding(const char *name)
int rb_enc_tolower(int c, rb_encoding *enc)
int rb_encdb_replicate(const char *name, const char *orig)
int rb_enc_find_index2(const char *name, long len)
rb_encoding * rb_default_external_encoding(void)
int rb_locale_encindex(void)
NORETURN(static void not_encoding(VALUE enc))
rb_encoding * rb_enc_check(VALUE str1, VALUE str2)
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
int rb_enc_capable(VALUE obj)
#define valid_encoding_name_p(name)
VALUE rb_enc_default_internal(void)
int rb_encdb_dummy(const char *name)
#define ENC_REGISTER(enc)
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc)
rb_encoding * rb_locale_encoding(void)
VALUE rb_obj_encoding(VALUE obj)
rb_encoding * rb_to_encoding(VALUE enc)
int rb_enc_toupper(int c, rb_encoding *enc)
rb_encoding * rb_usascii_encoding(void)
OnigEncodingType rb_raw_encoding
VALUE rb_enc_from_encoding(rb_encoding *encoding)
void rb_enc_set_default_external(VALUE encoding)
VALUE rb_enc_associate_index(VALUE obj, int idx)
int rb_locale_charmap_index(void)
int rb_enc_find_index(const char *name)
int rb_enc_alias(const char *alias, const char *orig)
int rb_enc_registered(const char *name)
int rb_enc_codelen(int c, rb_encoding *enc)
#define enc_autoload_p(enc)
int rb_encdb_alias(const char *alias, const char *orig)
#define ENC_SET_DUMMY(enc)
#define is_obj_encoding(obj)
void rb_enc_foreach_name(int(*func)(st_data_t name, st_data_t idx, st_data_t arg), st_data_t arg)
int rb_enc_ascget(const char *p, const char *e, int *len, rb_encoding *enc)
int rb_usascii_encindex(void)
#define ENCODING_SET_INLINED(obj, i)
#define ENC_CODERANGE_7BIT
int rb_enc_str_coderange(VALUE)
#define rb_enc_isascii(c, enc)
VALUE rb_locale_charmap(VALUE klass)
#define rb_enc_mbc_to_codepoint(p, e, enc)
#define MBCLEN_CHARFOUND_LEN(ret)
#define rb_enc_asciicompat(enc)
#define ENCODING_INLINE_MAX
int rb_enc_str_asciionly_p(VALUE)
#define rb_enc_mbminlen(enc)
#define MBCLEN_CHARFOUND_P(ret)
#define ENC_CODERANGE_ASCIIONLY(obj)
#define ENCODING_GET_INLINED(obj)
#define ENC_CODERANGE_CLEAR(obj)
char str[HTML_ESCAPE_MAX_LEN+1]
VALUE rb_define_class(const char *, VALUE)
Defines a top-level class.
void rb_undef_method(VALUE, const char *)
VALUE rb_cObject
Object class.
void rb_raise(VALUE exc, const char *fmt,...)
void rb_bug(const char *fmt,...)
void rb_set_errinfo(VALUE err)
Sets the current exception ($!) to the given value.
void rb_warn(const char *fmt,...)
void rb_loaderror(const char *fmt,...)
VALUE rb_errinfo(void)
The current exception in the current thread.
VALUE rb_obj_class(VALUE)
Equivalent to Object#class in Ruby.
verbose(int level, const char *format,...)
unsigned char buf[MIME_BUF_SIZE]
#define ONIGENC_MBC_ENC_LEN(enc, p, e)
#define ONIGENC_IS_UNICODE(enc)
#define ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(n)
#define ONIGENC_PRECISE_MBC_ENC_LEN(enc, p, e)
#define ONIGENC_FLAG_UNICODE
#define ONIGENC_CODE_TO_MBCLEN(enc, code)
#define ONIGENC_ASCII_CODE_TO_LOWER_CASE(c)
#define ONIGENC_ASCII_CODE_TO_UPPER_CASE(c)
#define ONIGENC_IS_ASCII_CODE(code)
VALUE rb_enc_sprintf(rb_encoding *enc, const char *format,...)
int st_insert2(st_table *tab, st_data_t key, st_data_t value, st_data_t(*func)(st_data_t))
int st_insert(st_table *tab, st_data_t key, st_data_t value)
int st_lookup(st_table *tab, st_data_t key, st_data_t *value)
int st_foreach(st_table *tab, st_foreach_callback_func *func, st_data_t arg)
st_table * st_init_strcasetable(void)
void Init_w32_codepage(void)