34#define ENC_ASSERT(expr) RUBY_ASSERT_WHEN(ENC_DEBUG, expr)
35#define MUST_STRING(str) (ENC_ASSERT(RB_TYPE_P(str, T_STRING)), str)
37#undef rb_ascii8bit_encindex
38#undef rb_utf8_encindex
39#undef rb_usascii_encindex
43#if defined __GNUC__ && __GNUC__ >= 4
44#pragma GCC visibility push(default)
53#pragma GCC visibility pop
59#define DEFAULT_ENCODING_LIST_CAPA 128
60static VALUE rb_default_encoding_list;
61static VALUE rb_additional_encoding_list;
69static struct enc_table {
80#define GLOBAL_ENC_TABLE_ENTER(enc_table) struct enc_table *enc_table = &global_enc_table; RB_VM_LOCK_ENTER()
81#define GLOBAL_ENC_TABLE_LEAVE() RB_VM_LOCK_LEAVE()
82#define GLOBAL_ENC_TABLE_EVAL(enc_table, expr) do { \
83 GLOBAL_ENC_TABLE_ENTER(enc_table); \
87 GLOBAL_ENC_TABLE_LEAVE(); \
91#define ENC_DUMMY_FLAG (1<<24)
92#define ENC_INDEX_MASK (~(~0U<<24))
94#define ENC_TO_ENCINDEX(enc) (int)((enc)->ruby_encoding_index & ENC_INDEX_MASK)
95#define ENC_DUMMY_P(enc) ((enc)->ruby_encoding_index & ENC_DUMMY_FLAG)
96#define ENC_SET_DUMMY(enc) ((enc)->ruby_encoding_index |= ENC_DUMMY_FLAG)
98#define ENCODING_COUNT ENCINDEX_BUILTIN_MAX
99#define UNSPECIFIED_ENCODING INT_MAX
101#define ENCODING_NAMELEN_MAX 63
102#define valid_encoding_name_p(name) ((name) && strlen(name) <= ENCODING_NAMELEN_MAX)
110#define is_data_encoding(obj) (RTYPEDDATA_P(obj) && RTYPEDDATA_TYPE(obj) == &encoding_data_type)
111#define is_obj_encoding(obj) (RB_TYPE_P((obj), T_DATA) && is_data_encoding(obj))
132 VALUE list = rb_default_encoding_list;
141 VALUE list = rb_additional_encoding_list;
152enc_list_lookup(
int idx)
157 if (!(list = rb_default_encoding_list)) {
158 rb_bug(
"rb_enc_from_encoding_index(%d): no rb_default_encoding_list", idx);
165 if (!(list = rb_additional_encoding_list)) {
166 rb_bug(
"rb_enc_from_encoding_index(%d): no rb_additional_encoding_list", idx);
174 rb_bug(
"rb_enc_from_encoding_index(%d): not created yet", idx);
182rb_enc_from_encoding_index(
int idx)
184 return enc_list_lookup(idx);
191 if (!encoding)
return Qnil;
193 return rb_enc_from_encoding_index(idx);
221enc_check_encoding(
VALUE obj)
226 return check_encoding(
RDATA(obj)->data);
240 int index = enc_check_encoding(
enc);
248must_encindex(
int index)
272 idx = enc_check_encoding(
enc);
289name_for_encoding(
volatile VALUE *
enc)
315 int idx = str_find_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;
346enc_table_expand(
struct enc_table *enc_table,
int newsize)
351 if (enc_table->size >= newsize)
return newsize;
352 newsize = (newsize + 7) / 8 * 8;
354 memset(ent + enc_table->size, 0,
sizeof(*ent)*(newsize - enc_table->size));
355 enc_table->list = ent;
356 enc_table->size = newsize;
361enc_register_at(
struct enc_table *enc_table,
int index,
const char *
name,
rb_encoding *base_encoding)
378 *encoding = *base_encoding;
381 memset(encoding, 0,
sizeof(*ent->
enc));
388 enc_list_update(index, encoding);
393enc_register(
struct enc_table *enc_table,
const char *
name,
rb_encoding *encoding)
395 int index = enc_table->count;
397 enc_table->count = enc_table_expand(enc_table, index + 1);
398 return enc_register_at(enc_table, index,
name, encoding);
401static void set_encoding_const(
const char *,
rb_encoding *);
402static int enc_registered(
struct enc_table *enc_table,
const char *
name);
405enc_from_index(
struct enc_table *enc_table,
int index)
410 return enc_table->list[index].enc;
424 enc = enc_from_index(enc_table, index));
436 index = enc_registered(enc_table,
name);
439 rb_encoding *oldenc = enc_from_index(enc_table, index);
441 index = enc_register(enc_table,
name, encoding);
444 enc_register_at(enc_table, index,
name, encoding);
451 index = enc_register(enc_table,
name, encoding);
460enc_registered(
struct enc_table *enc_table,
const char *
name)
464 if (!
name)
return -1;
465 if (!enc_table->list)
return -1;
477 int idx = enc_registered(enc_table,
name);
479 idx = enc_register(enc_table,
name, 0);
487enc_check_duplication(
struct enc_table *enc_table,
const char *
name)
489 if (enc_registered(enc_table,
name) >= 0) {
495set_base_encoding(
struct enc_table *enc_table,
int index,
rb_encoding *
base)
499 enc_table->list[index].base =
base;
513 int idx = enc_registered(enc_table,
name);
514 int origidx = enc_registered(enc_table, orig);
529 enc = enc_table->list[index].enc);
536enc_replicate(
struct enc_table *enc_table,
const char *
name,
rb_encoding *encoding)
540 enc_check_duplication(enc_table,
name);
541 idx = enc_register(enc_table,
name, encoding);
543 set_base_encoding(enc_table, idx, encoding);
554 r = enc_replicate(enc_table,
name, encoding));
573 return rb_enc_from_encoding_index(idx);
577enc_replicate_with_index(
struct enc_table *enc_table,
const char *
name,
rb_encoding *origenc,
int idx)
580 idx = enc_register(enc_table,
name, origenc);
583 idx = enc_register_at(enc_table, idx,
name, origenc);
586 set_base_encoding(enc_table, idx, origenc);
602 int origidx = enc_registered(enc_table, orig);
603 int idx = enc_registered(enc_table,
name);
606 origidx = enc_register(enc_table, orig, 0);
638 index = enc_replicate_with_index(enc_table,
name,
640 enc_registered(enc_table,
name));
704enc_alias_internal(
struct enc_table *enc_table,
const char *
alias,
int idx)
711enc_alias(
struct enc_table *enc_table,
const char *
alias,
int idx)
714 if (!enc_alias_internal(enc_table,
alias, idx))
715 set_encoding_const(
alias, enc_from_index(enc_table, idx));
726 enc_check_duplication(enc_table,
alias);
731 r = enc_alias(enc_table,
alias, idx);
746 int idx = enc_registered(enc_table, orig);
749 idx = enc_register(enc_table, orig, 0);
751 r = enc_alias(enc_table,
alias, idx);
765rb_enc_init(
struct enc_table *enc_table)
768 if (!enc_table->names) {
771#define ENC_REGISTER(enc) enc_register_at(enc_table, ENCINDEX_##enc, rb_enc_name(&OnigEncoding##enc), &OnigEncoding##enc)
779#define ENCDB_REGISTER(name, enc) enc_register_at(enc_table, ENCINDEX_##enc, name, NULL)
797 return must_encindex(index);
801load_encoding(
const char *
name)
807 char *s =
RSTRING_PTR(enclib) + 4, *e = RSTRING_END(enclib) - 3;
827 if (loaded < 0 || 1 < loaded) {
830 else if ((idx = enc_registered(enc_table,
name)) < 0) {
850 if (i >= enc_table->count)
return -1;
851 }
while (enc_table->list[i].enc !=
base && (++i, 1));
887 i = load_encoding(
name);
896 rb_warn(
"failed to load encoding (%s); use ASCII-8BIT instead",
919 if (idx < 0) idx = 0;
924enc_capable(
VALUE obj)
943 return enc_capable(obj);
990 i = enc_get_index_str(obj);
998 i = enc_check_encoding(tmp);
1003 i = enc_check_encoding(obj);
1013enc_set_index(
VALUE obj,
int idx)
1015 if (!enc_capable(obj)) {
1032 enc_set_index(obj, idx);
1039 int oldidx, oldtermlen, termlen;
1049 enc = must_encindex(idx);
1056 if (oldtermlen != termlen && RB_TYPE_P(obj,
T_STRING)) {
1059 enc_set_index(obj, idx);
1100enc_compatible_latter(
VALUE str1,
VALUE str2,
int idx1,
int idx2)
1106 isstr2 = RB_TYPE_P(str2,
T_STRING);
1109 isstr1 = RB_TYPE_P(str1,
T_STRING);
1157 int idx1 = enc_get_index_str(str1);
1158 int idx2 = enc_get_index_str(str2);
1160 if (idx1 < 0 || idx2 < 0)
1167 return enc_compatible_latter(str1, str2, idx1, idx2);
1177 if (idx1 < 0 || idx2 < 0)
1184 return enc_compatible_latter(str1, str2, idx1, idx2);
1225 return min <= e-p ? min : (
int)(e-p);
1249 c = (
unsigned char)*p;
1279#undef rb_enc_codepoint
1296#undef rb_enc_code_to_mbclen
1325enc_inspect(
VALUE self)
1362 if ((
int)idx == (
int)arg[0]) {
1378enc_names(
VALUE self)
1410enc_list(
VALUE klass)
1452 idx = str_to_encindex(
enc);
1454 return rb_enc_from_encoding_index(idx);
1486 if (!enc_capable(str1))
return Qnil;
1487 if (!enc_capable(str2))
return Qnil;
1496enc_s_alloc(
VALUE klass)
1507 return enc_name(self);
1521 return enc_find(klass,
str);
1527 return global_enc_ascii;
1539 return global_enc_utf_8;
1551 return global_enc_us_ascii;
1570 if (enc_registered(enc_table,
"locale") < 0) {
1575 enc_alias_internal(enc_table,
"locale", idx);
1594 idx = enc_registered(enc_table,
"filesystem"));
1617 int overridden =
FALSE;
1619 if (
def->index != -2)
1625 if (
NIL_P(encoding)) {
1634 enc_alias_internal(enc_table,
name,
def->index);
1637 if (
def == &default_external) {
1649 if (default_external.
enc)
return default_external.
enc;
1651 if (default_external.
index >= 0) {
1653 return default_external.
enc;
1695get_default_external(
VALUE klass)
1703 if (
NIL_P(encoding)) {
1706 enc_set_default_encoding(&default_external, encoding,
1724set_default_external(
VALUE klass,
VALUE encoding)
1726 rb_warning(
"setting Encoding.default_external");
1736 if (!default_internal.
enc && default_internal.
index >= 0) {
1739 return default_internal.
enc;
1778get_default_internal(
VALUE klass)
1786 enc_set_default_encoding(&default_internal, encoding,
1804set_default_internal(
VALUE klass,
VALUE encoding)
1806 rb_warning(
"setting Encoding.default_internal");
1815 char *s = (
char *)
name;
1816 int haslower = 0, hasupper = 0, valid = 0;
1821 while (*++s && (
ISALNUM(*s) || *s ==
'_')) {
1822 if (
ISLOWER(*s)) haslower = 1;
1830 if (!valid || haslower) {
1833 if (!haslower || !hasupper) {
1835 if (
ISLOWER(*s)) haslower = 1;
1836 if (
ISUPPER(*s)) hasupper = 1;
1837 }
while (*++s && (!haslower || !hasupper));
1854 for (s = (
char *)
name; *s; ++s) {
1886rb_enc_name_list(
VALUE klass)
1904 VALUE aliases = p[0], ary = p[1];
1905 int idx = (
int)orig;
1936rb_enc_aliases(
VALUE klass)
2180 struct enc_table *enc_table = &global_enc_table;
2182 if (DEFAULT_ENCODING_LIST_CAPA < enc_table->
count)
rb_bug(
"DEFAULT_ENCODING_LIST_CAPA is too small");
2184 list = rb_additional_encoding_list =
rb_ary_new();
2185 RBASIC_CLEAR_CLASS(list);
2189 RBASIC_CLEAR_CLASS(list);
2192 for (i = 0; i < enc_table->count; ++i) {
2193 rb_ary_push(list, enc_new(enc_table->list[i].enc));
2202 rb_enc_init(&global_enc_table);
void rb_ary_store(VALUE ary, long idx, VALUE val)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_ary_replace(VALUE copy, VALUE orig)
VALUE rb_ary_concat(VALUE x, VALUE y)
VALUE rb_ary_entry(VALUE ary, long offset)
#define UNREACHABLE_RETURN
Our own, locale independent, character handling routines.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
Internal header for Encoding.
#define ENCINDEX_BUILTIN_MAX
#define ENCINDEX_US_ASCII
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
int rb_enc_autoload(rb_encoding *enc)
#define DEFAULT_ENCODING_LIST_CAPA
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)
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)
#define GLOBAL_ENC_TABLE_ENTER(enc_table)
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)
#define GLOBAL_ENC_TABLE_EVAL(enc_table, expr)
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)
rb_encoding * rb_locale_encoding(void)
#define GLOBAL_ENC_TABLE_LEAVE()
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_codelen(int c, rb_encoding *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)
char str[HTML_ESCAPE_MAX_LEN+1]
#define RSTRING_LEN(string)
#define RSTRING_PTR(string)
void rb_gc_register_mark_object(VALUE obj)
Inform the garbage collector that object is a live Ruby object that should not be moved.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_undef_method(VALUE klass, const char *name)
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.
void rb_warning(const char *fmt,...)
VALUE rb_cObject
Object class.
void rb_undefined_alloc(VALUE klass)
VALUE rb_obj_class(VALUE)
VALUE rb_obj_freeze(VALUE)
Make the object unmodifiable.
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
#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 rb_enc_codepoint(p, e, enc)
VALUE rb_enc_sprintf(rb_encoding *, const char *,...)
#define ENCODING_INLINE_MAX
int rb_enc_str_asciionly_p(VALUE)
#define rb_enc_code_to_mbclen(c, enc)
#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)
Thin wrapper to ruby/config.h.
VALUE rb_check_string_type(VALUE)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_attr_get(VALUE, ID)
VALUE rb_ivar_set(VALUE, ID, VALUE)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
ID rb_intern(const char *)
void rb_define_const(VALUE, const char *, VALUE)
Internal header aggregating init functions.
int Init_enc_set_filesystem_encoding(void)
Internal header for Encoding.
#define rb_enc_autoload_p(enc)
Internal header for require.
int rb_require_internal(VALUE fname)
Internal header for Object.
Internal header for String.
void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen)
char * rb_str_to_cstr(VALUE str)
Internal header for RubyVM.
#define rb_fstring_cstr(...)
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
#define MEMCPY(p1, p2, type, n)
#define ALLOCA_N(type, n)
#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)
#define TypedData_Wrap_Struct(klass, data_type, sval)
@ RUBY_TYPED_FREE_IMMEDIATELY
VALUE rb_sprintf(const char *,...)
#define st_init_strcasetable
size_t strlen(const char *)
#define RB_VM_LOCK_ENTER()
#define RB_VM_LOCK_LEAVE()
void Init_w32_codepage(void)
if((ID)(DISPID) nameid !=nameid)
int def(FILE *source, FILE *dest, int level)