18 #define ENABLE_ECONV_NEWLINE_OPTION 1
32 #ifdef ENABLE_ECONV_NEWLINE_OPTION
45 static unsigned char *
47 const unsigned char *str,
size_t len,
48 unsigned char *caller_dst_buf,
size_t caller_dst_bufsize,
80 char ary[
sizeof(double) >
sizeof(
void*) ?
sizeof(double) :
sizeof(
void*)];
84 #define TRANSCODING_READBUF(tc) \
85 ((tc)->transcoder->max_input <= (int)sizeof((tc)->readbuf.ary) ? \
88 #define TRANSCODING_WRITEBUF(tc) \
89 ((tc)->transcoder->max_output <= (int)sizeof((tc)->writebuf.ary) ? \
90 (tc)->writebuf.ary : \
92 #define TRANSCODING_WRITEBUF_SIZE(tc) \
93 ((tc)->transcoder->max_output <= (int)sizeof((tc)->writebuf.ary) ? \
94 sizeof((tc)->writebuf.ary) : \
95 (size_t)(tc)->transcoder->max_output)
96 #define TRANSCODING_STATE_EMBED_MAX ((int)sizeof(union rb_transcoding_state_t))
97 #define TRANSCODING_STATE(tc) \
98 ((tc)->transcoder->state_size <= (int)sizeof((tc)->state) ? \
154 #define DECORATOR_P(sname, dname) (*(sname) == '\0')
178 entry->
sname = sname;
179 entry->
dname = dname;
230 #define MAX_TRANSCODER_LIBNAME_LEN 64
238 lib ? lib :
"(null)");
243 #define encoding_equal(enc1, enc2) (STRCASECMP((enc1), (enc2)) == 0)
260 const char *dname = (
const char *)key;
280 void (*
callback)(
const char *sname,
const char *dname,
int depth,
void *
arg),
337 const char *enc = dname;
345 enc = (
const char *)val;
353 callback((
const char *)val, enc, --depth, arg);
354 enc = (
const char *)val;
370 const char *lib = entry->
lib;
380 memcpy(path, transcoder_lib_prefix,
sizeof(transcoder_lib_prefix) - 1);
381 memcpy(path +
sizeof(transcoder_lib_prefix) - 1, lib, len + 1);
400 *repl_encname_ptr =
"UTF-8";
401 return "\xEF\xBF\xBD";
405 *repl_encname_ptr =
"US-ASCII";
414 static const unsigned char *
416 const unsigned char *in_start,
417 const unsigned char *inchar_start,
418 const unsigned char *in_p,
419 size_t *char_len_ptr)
421 const unsigned char *ptr;
422 if (inchar_start - in_start < tc->recognized_len) {
424 inchar_start,
unsigned char, in_p - inchar_start);
436 const unsigned char *in_stop,
unsigned char *out_stop,
442 ssize_t readagain_len = 0;
444 const unsigned char *inchar_start;
445 const unsigned char *in_p;
447 unsigned char *out_p;
449 in_p = inchar_start = *in_pos;
453 #define SUSPEND(ret, num) \
455 tc->resume_position = (num); \
456 if (0 < in_p - inchar_start) \
457 MEMMOVE(TRANSCODING_READBUF(tc)+tc->recognized_len, \
458 inchar_start, unsigned char, in_p - inchar_start); \
461 tc->recognized_len += in_p - inchar_start; \
462 if (readagain_len) { \
463 tc->recognized_len -= readagain_len; \
464 tc->readagain_len = readagain_len; \
467 resume_label ## num:; \
469 #define SUSPEND_OBUF(num) \
471 while (out_stop - out_p < 1) { SUSPEND(econv_destination_buffer_full, num); } \
474 #define SUSPEND_AFTER_OUTPUT(num) \
475 if ((opt & ECONV_AFTER_OUTPUT) && *out_pos != out_p) { \
476 SUSPEND(econv_after_output, num); \
479 #define next_table (tc->next_table)
480 #define next_info (tc->next_info)
481 #define next_byte (tc->next_byte)
482 #define writebuf_len (tc->writebuf_len)
483 #define writebuf_off (tc->writebuf_off)
487 case 1:
goto resume_label1;
488 case 2:
goto resume_label2;
489 case 3:
goto resume_label3;
490 case 4:
goto resume_label4;
491 case 5:
goto resume_label5;
492 case 6:
goto resume_label6;
493 case 7:
goto resume_label7;
494 case 8:
goto resume_label8;
495 case 9:
goto resume_label9;
496 case 10:
goto resume_label10;
497 case 11:
goto resume_label11;
498 case 12:
goto resume_label12;
499 case 13:
goto resume_label13;
500 case 14:
goto resume_label14;
501 case 15:
goto resume_label15;
502 case 16:
goto resume_label16;
503 case 17:
goto resume_label17;
504 case 18:
goto resume_label18;
505 case 19:
goto resume_label19;
506 case 20:
goto resume_label20;
507 case 21:
goto resume_label21;
508 case 22:
goto resume_label22;
509 case 23:
goto resume_label23;
510 case 24:
goto resume_label24;
511 case 25:
goto resume_label25;
512 case 26:
goto resume_label26;
513 case 27:
goto resume_label27;
514 case 28:
goto resume_label28;
515 case 29:
goto resume_label29;
516 case 30:
goto resume_label30;
517 case 31:
goto resume_label31;
518 case 32:
goto resume_label32;
519 case 33:
goto resume_label33;
520 case 34:
goto resume_label34;
530 if (in_stop <= in_p) {
537 #define BYTE_ADDR(index) (tr->byte_array + (index))
538 #define WORD_ADDR(index) (tr->word_array + INFO2WORDINDEX(index))
539 #define BL_BASE BYTE_ADDR(BYTE_LOOKUP_BASE(WORD_ADDR(next_table)))
540 #define BL_INFO WORD_ADDR(BYTE_LOOKUP_INFO(WORD_ADDR(next_table)))
541 #define BL_MIN_BYTE (BL_BASE[0])
542 #define BL_MAX_BYTE (BL_BASE[1])
543 #define BL_OFFSET(byte) (BL_BASE[2+(byte)-BL_MIN_BYTE])
544 #define BL_ACTION(byte) (BL_INFO[BL_OFFSET((byte))])
557 const unsigned char *
p = inchar_start;
570 case 0x00:
case 0x04:
case 0x08:
case 0x0C:
571 case 0x10:
case 0x14:
case 0x18:
case 0x1C:
573 while (in_p >= in_stop) {
619 const unsigned char *char_start;
643 const unsigned char *char_start;
649 char_start, (
size_t)char_len,
650 out_p, out_stop - out_p);
655 char_start, (
size_t)char_len,
667 const unsigned char *char_start;
674 out_p, out_stop - out_p);
708 discard_len = ((invalid_len - 1) / unitlen) * unitlen;
709 readagain_len = invalid_len - discard_len;
737 out_p, out_stop - out_p);
761 const unsigned char *in_stop,
unsigned char *out_stop,
767 const unsigned char *readagain_pos = readagain_buf;
768 const unsigned char *readagain_stop = readagain_buf + tc->
readagain_len;
777 readagain_pos,
unsigned char, readagain_stop - readagain_pos);
793 if (TRANSCODING_STATE_EMBED_MAX < tr->state_size)
814 const unsigned char **input_ptr,
const unsigned char *input_stop,
815 unsigned char **output_ptr,
unsigned char *output_stop,
819 input_ptr, output_ptr,
820 input_stop, output_stop,
831 if (TRANSCODING_STATE_EMBED_MAX < tr->state_size)
846 if (TRANSCODING_STATE_EMBED_MAX < tr->state_size) {
941 for (i = 0; i < n; i++) {
950 for (i = 0; i < n; i++) {
1004 if (*sname ==
'\0' && *dname ==
'\0') {
1014 if (num_trans < 0) {
1025 ec->
flags = ecflags;
1032 #define MAX_ECFLAGS_DECORATORS 32
1055 if (ecflags & ECONV_XML_TEXT_DECORATOR)
1056 decorators_ret[num_decorators++] =
"xml_text_escape";
1057 if (ecflags & ECONV_XML_ATTR_CONTENT_DECORATOR)
1058 decorators_ret[num_decorators++] =
"xml_attr_content_escape";
1060 decorators_ret[num_decorators++] =
"xml_attr_quote";
1063 decorators_ret[num_decorators++] =
"crlf_newline";
1065 decorators_ret[num_decorators++] =
"cr_newline";
1067 decorators_ret[num_decorators++] =
"universal_newline";
1069 return num_decorators;
1081 if (num_decorators == -1)
1088 for (i = 0; i < num_decorators; i++)
1094 ec->
flags |= ecflags & ~ECONV_ERROR_HANDLER_MASK;
1101 const unsigned char **input_ptr,
const unsigned char *input_stop,
1102 unsigned char **output_ptr,
unsigned char *output_stop,
1109 const unsigned char **ipp, *is, *iold;
1110 unsigned char **opp, *os, *oold;
1116 for (i = start; i < ec->
num_trans; i++) {
1150 flags &= ~ECONV_AFTER_OUTPUT;
1153 f &= ~ECONV_AFTER_OUTPUT;
1157 if (iold != *ipp || oold != *opp)
1182 const unsigned char **input_ptr,
const unsigned char *input_stop,
1183 unsigned char **output_ptr,
unsigned char *output_stop,
1185 int *result_position_ptr)
1188 int needreport_index;
1191 unsigned char empty_buf;
1192 unsigned char *empty_ptr = &empty_buf;
1195 input_ptr = (
const unsigned char **)&empty_ptr;
1196 input_stop = empty_ptr;
1200 output_ptr = &empty_ptr;
1201 output_stop = empty_ptr;
1207 needreport_index = -1;
1208 for (i = ec->
num_trans-1; 0 <= i; i--) {
1216 needreport_index =
i;
1217 goto found_needreport;
1224 rb_bug(
"unexpected transcode last result");
1236 result_position_ptr);
1248 needreport_index =
trans_sweep(ec, input_ptr, input_stop, output_ptr, output_stop, flags, sweep_start);
1249 sweep_start = needreport_index + 1;
1250 }
while (needreport_index != -1 && needreport_index != ec->
num_trans-1);
1252 for (i = ec->
num_trans-1; 0 <= i; i--) {
1261 if (result_position_ptr)
1262 *result_position_ptr =
i;
1266 if (result_position_ptr)
1267 *result_position_ptr = -1;
1273 const unsigned char **input_ptr,
const unsigned char *input_stop,
1274 unsigned char **output_ptr,
unsigned char *output_stop,
1278 int result_position;
1286 if (output_stop - *output_ptr < ec->in_data_end - ec->
in_data_start) {
1287 len = output_stop - *output_ptr;
1289 *output_ptr = output_stop;
1303 if (output_stop - *output_ptr < input_stop - *input_ptr) {
1304 len = output_stop - *output_ptr;
1307 len = input_stop - *input_ptr;
1310 *(*output_ptr)++ = *(*input_ptr)++;
1314 memcpy(*output_ptr, *input_ptr, len);
1317 if (*input_ptr != input_stop)
1329 if (data_start != data_end) {
1331 if (output_stop - *output_ptr < data_end - data_start) {
1332 len = output_stop - *output_ptr;
1333 memcpy(*output_ptr, data_start, len);
1334 *output_ptr = output_stop;
1339 len = data_end - data_start;
1340 memcpy(*output_ptr, data_start, len);
1359 *input_ptr != input_stop) {
1360 input_stop = *input_ptr;
1361 res =
rb_trans_conv(ec, input_ptr, input_stop, output_ptr, output_stop, flags, &result_position);
1365 else if ((flags & ECONV_AFTER_OUTPUT) ||
1367 res =
rb_trans_conv(ec, input_ptr, input_stop, output_ptr, output_stop, flags, &result_position);
1372 res =
rb_trans_conv(ec, input_ptr, input_stop, output_ptr, output_stop, flags, &result_position);
1399 unsigned char utfbuf[1024];
1400 const unsigned char *utf;
1402 int utf_allocated = 0;
1403 char charef_buf[16];
1404 const unsigned char *
p;
1413 utfbuf,
sizeof(utfbuf),
1421 if (utf_len % 4 != 0)
1425 while (4 <= utf_len) {
1431 snprintf(charef_buf,
sizeof(charef_buf),
"&#x%X;", u);
1453 const unsigned char **input_ptr,
const unsigned char *input_stop,
1454 unsigned char **output_ptr,
unsigned char *output_stop,
1459 unsigned char empty_buf;
1460 unsigned char *empty_ptr = &empty_buf;
1465 input_ptr = (
const unsigned char **)&empty_ptr;
1466 input_stop = empty_ptr;
1470 output_ptr = &empty_ptr;
1471 output_stop = empty_ptr;
1475 ret =
rb_econv_convert0(ec, input_ptr, input_stop, output_ptr, output_stop, flags);
1524 static unsigned char *
1526 const unsigned char *str,
size_t len,
1527 unsigned char *caller_dst_buf,
size_t caller_dst_bufsize,
1528 size_t *dst_len_ptr)
1530 unsigned char *dst_str;
1537 const unsigned char *sp;
1541 dst_bufsize = caller_dst_bufsize;
1551 dst_str = caller_dst_buf;
1553 dst_str =
xmalloc(dst_bufsize);
1556 dp = dst_str+dst_len;
1558 dst_len = dp - dst_str;
1564 if (dst_str == caller_dst_buf) {
1567 memcpy(tmp, dst_str, dst_bufsize/2);
1571 dst_str =
xrealloc(dst_str, dst_bufsize);
1573 dp = dst_str+dst_len;
1575 dst_len = dp - dst_str;
1581 *dst_len_ptr = dst_len;
1585 if (dst_str != caller_dst_buf)
1594 const unsigned char *str,
size_t len,
const char *str_encoding)
1597 unsigned char insert_buf[4096];
1598 const unsigned char *insert_str =
NULL;
1601 int last_trans_index;
1604 unsigned char **buf_start_p;
1605 unsigned char **data_start_p;
1606 unsigned char **data_end_p;
1607 unsigned char **buf_end_p;
1622 str, len, insert_buf,
sizeof(insert_buf), &insert_len);
1623 if (insert_str ==
NULL)
1638 tc = ec->
elems[last_trans_index].
tc;
1640 if (need < insert_len)
1642 if (last_trans_index == 0) {
1662 tc = ec->
elems[last_trans_index].
tc;
1665 if (*buf_start_p ==
NULL) {
1668 *data_start_p =
buf;
1670 *buf_end_p = buf+need;
1672 else if ((
size_t)(*buf_end_p - *data_end_p) < need) {
1673 MEMMOVE(*buf_start_p, *data_start_p,
unsigned char, *data_end_p - *data_start_p);
1674 *data_end_p = *buf_start_p + (*data_end_p - *data_start_p);
1675 *data_start_p = *buf_start_p;
1676 if ((
size_t)(*buf_end_p - *data_end_p) < need) {
1678 size_t s = (*data_end_p - *buf_start_p) + need;
1682 *data_start_p =
buf;
1683 *data_end_p = buf + (*data_end_p - *buf_start_p);
1685 *buf_end_p = buf + s;
1689 memcpy(*data_end_p, insert_str, insert_len);
1690 *data_end_p += insert_len;
1697 if (insert_str != str && insert_str != insert_buf)
1698 xfree((
void*)insert_str);
1702 if (insert_str != str && insert_str != insert_buf)
1703 xfree((
void*)insert_str);
1752 #if SIZEOF_SIZE_T > SIZEOF_INT
1815 return data.ascii_compat_name;
1821 unsigned const char *ss, *sp, *se;
1822 unsigned char *ds, *
dp, *de;
1841 unsigned long new_capa = (
unsigned long)dlen + len + max_output;
1847 ss = sp = (
const unsigned char *)
RSTRING_PTR(src) + off;
1966 for (i = 0; i < num_trans; i++) {
1968 for (k = 0; k < n; k++)
1989 int has_description = 0;
1994 if (*sname !=
'\0' || *dname !=
'\0') {
1997 else if (*dname ==
'\0')
2001 has_description = 1;
2008 const char *pre =
"";
2009 if (has_description)
2035 has_description = 1;
2037 if (!has_description) {
2074 else if (readagain_len) {
2075 bytes2 =
rb_str_new(err+error_len, readagain_len);
2111 const char *start, *end;
2135 mesg =
rb_sprintf(
"%s to %s in conversion from %s",
2159 unsigned char *(*resize_destination)(
VALUE,
size_t,
size_t),
2161 unsigned char **out_start_ptr,
2162 unsigned char **out_pos,
2163 unsigned char **out_stop_ptr)
2165 size_t len = (*out_pos - *out_start_ptr);
2166 size_t new_len = (len + max_output) * 2;
2167 *out_start_ptr = resize_destination(destination, len, new_len);
2168 *out_pos = *out_start_ptr +
len;
2169 *out_stop_ptr = *out_start_ptr + new_len;
2178 const unsigned char *replacement;
2179 const char *repl_enc;
2180 const char *ins_enc;
2195 replacement = (
unsigned char *)
"?";
2209 const unsigned char *str,
size_t len,
const char *encname)
2211 unsigned char *str2;
2213 const char *encname2;
2219 MEMCPY(str2, str,
unsigned char, len);
2255 #define hash_fallback rb_hash_aref
2277 const unsigned char *in_stop,
unsigned char *out_stop,
2279 unsigned char *(*resize_destination)(
VALUE,
size_t,
size_t),
2280 const char *src_encoding,
2281 const char *dst_encoding,
2288 unsigned char *out_start = *out_pos;
2324 rep = (*fallback_func)(fallback, rep);
2329 if ((
int)ret == -1) {
2345 more_output_buffer(destination, resize_destination, max_output, &out_start, out_pos, &out_stop);
2355 transcode_loop(
const unsigned char **in_pos,
unsigned char **out_pos,
2356 const unsigned char *in_stop,
unsigned char *out_stop,
2358 unsigned char *(*resize_destination)(
VALUE,
size_t,
size_t),
2359 const char *src_encoding,
2360 const char *dst_encoding,
2367 unsigned char *out_start = *out_pos;
2368 const unsigned char *ptr;
2382 unsigned char input_byte;
2383 const unsigned char *
p = &input_byte;
2386 if (ptr < in_stop) {
2397 if (&input_byte != p)
2398 ptr += p - &input_byte;
2409 more_output_buffer(destination, resize_destination, max_output, &out_start, out_pos, &out_stop);
2430 static unsigned char *
2483 #ifdef ENABLE_ECONV_NEWLINE_OPTION
2510 int setflags = 0, newlineflag = 0;
2515 newlineflag |= !
NIL_P(v);
2520 newlineflag |= !
NIL_P(v);
2525 newlineflag |= !
NIL_P(v);
2529 ecflags |= setflags;
2542 if (
NIL_P(opthash)) {
2574 if (!
NIL_P(newhash))
2593 if (
NIL_P(opthash)) {
2598 rb_bug(
"rb_econv_open_opts called with invalid opthash");
2602 ec =
rb_econv_open(source_encoding, destination_encoding, ecflags);
2606 if (!
NIL_P(replacement)) {
2652 const char *sname, *dname;
2653 int sencidx, dencidx;
2655 dencidx =
enc_arg(arg1, &dname, &denc);
2663 sencidx =
enc_arg(arg2, &sname, &senc);
2678 volatile VALUE arg1, arg2;
2680 unsigned char *
buf, *
bp, *sp;
2681 const unsigned char *fromp;
2683 const char *sname, *dname;
2686 if (argc <0 || argc > 2) {
2693 if (!ecflags)
return -1;
2701 arg2 = argc<=1 ?
Qnil : argv[1];
2708 if (senc && senc == denc) {
2709 return NIL_P(arg2) ? -1 : dencidx;
2717 return NIL_P(arg2) ? -1 : dencidx;
2734 if (fromp != sp+slen) {
2807 if (encidx < 0)
return str;
2808 if (newstr == str) {
2892 int encidx =
str_transcode0(argc, argv, &newstr, ecflags, ecopts);
2900 if (newstr == str) {
2982 const char *arg_name, *result_name;
2985 enc_arg(&arg, &arg_name, &arg_enc);
2989 if (result_name ==
NULL)
2999 volatile VALUE *snamev_p,
volatile VALUE *dnamev_p,
3000 const char **sname_p,
const char **dname_p,
3005 VALUE opt, flags_v, ecopts;
3007 const char *sname, *dname;
3011 argc =
rb_scan_args(argc, argv,
"21:", snamev_p, dnamev_p, &flags_v, &opt);
3013 if (!
NIL_P(flags_v)) {
3021 else if (!
NIL_P(opt)) {
3054 *ecflags_p = ecflags;
3067 if (num_decorators == -1)
3083 rb_ary_store(convpath, len + num_decorators - 1, pair);
3087 rb_ary_store(convpath, len + num_decorators - 1, pair);
3091 for (i = 0; i < num_decorators; i++)
3103 if (*ary_p ==
Qnil) {
3144 volatile VALUE snamev, dnamev;
3145 const char *sname, *dname;
3151 econv_args(argc, argv, &snamev, &dnamev, &sname, &dname, &senc, &denc, &ecflags, &ecopts);
3156 if (
NIL_P(convpath))
3176 return RTEST(convpath);
3202 const char **sname_p,
const char **dname_p,
3210 const char *sname, *dname;
3216 volatile VALUE snamev, dnamev;
3223 enc_arg(&snamev, &sname, &senc);
3225 enc_arg(&dnamev, &dname, &denc);
3243 if (ret == -1 || arg.
ret == -1)
3378 volatile VALUE snamev, dnamev;
3379 const char *sname, *dname;
3395 econv_args(argc, argv, &snamev, &dnamev, &sname, &dname, &senc, &denc, &ecflags, &ecopts);
3436 return rb_sprintf(
"#<%s: uninitialized>", cname);
3683 const unsigned char *ip, *is;
3684 unsigned char *op, *os;
3685 long output_byteoffset, output_bytesize;
3686 unsigned long output_byteend;
3689 argc =
rb_scan_args(argc, argv,
"23:", &input, &output, &output_byteoffset_v, &output_bytesize_v, &flags_v, &opt);
3691 if (
NIL_P(output_byteoffset_v))
3692 output_byteoffset = 0;
3694 output_byteoffset =
NUM2LONG(output_byteoffset_v);
3696 if (
NIL_P(output_bytesize_v))
3697 output_bytesize = 0;
3699 output_bytesize =
NUM2LONG(output_bytesize_v);
3701 if (!
NIL_P(flags_v)) {
3708 else if (!
NIL_P(opt)) {
3727 if (
NIL_P(output_bytesize_v)) {
3735 if (
NIL_P(output_byteoffset_v))
3738 if (output_byteoffset < 0)
3744 if (output_bytesize < 0)
3747 output_byteend = (
unsigned long)output_byteoffset +
3748 (
unsigned long)output_bytesize;
3750 if (output_byteend < (
unsigned long)output_byteoffset ||
3765 op = (
unsigned char *)
RSTRING_PTR(output) + output_byteoffset;
3766 os = op + output_bytesize;
3774 if (
LONG_MAX / 2 < output_bytesize)
3776 output_bytesize *= 2;
3777 output_byteoffset_v =
Qnil;
3855 rb_bug(
"unexpected result of econv_primitive_convert");
3899 rb_bug(
"unexpected result of econv_primitive_convert");
4041 const char *insert_enc;
4098 if (putbackable < n)
4421 #ifdef ENABLE_ECONV_NEWLINE_OPTION
RUBY_EXTERN VALUE rb_cString
const char * ascii_incompat_name
#define RSTRING_LEN(string)
static long NUM2LONG(VALUE x)
int rb_econv_prepare_opts(VALUE opthash, VALUE *opts)
#define ECONV_XML_TEXT_DECORATOR
VALUE(* func_si)(void *, const unsigned char *, size_t)
search_path_queue_t * queue
int rb_enc_get_index(VALUE obj)
void rb_econv_check_error(rb_econv_t *ec)
RUBY_EXTERN VALUE rb_cData
static VALUE econv_destination_encoding(VALUE self)
#define MBCLEN_CHARFOUND_P(ret)
static VALUE sym_undefined_conversion
VALUE rb_eConverterNotFoundError
VALUE rb_ary_new4(long n, const VALUE *elts)
int(* state_fini_func)(void *)
VALUE rb_ary_entry(VALUE ary, long offset)
#define MBCLEN_CHARFOUND_LEN(ret)
unsigned char * in_buf_end
const unsigned char * error_bytes_start
void rb_bug(const char *fmt,...)
rb_econv_result_t last_result
#define rb_enc_mbc_to_codepoint(p, e, enc)
VALUE rb_econv_make_exception(rb_econv_t *ec)
const char * dst_encoding
long rb_str_coderange_scan_restartable(const char *, const char *, rb_encoding *, int *)
static VALUE sym_invalid_byte_sequence
size_t strlen(const char *)
struct search_path_queue_tag search_path_queue_t
#define DECORATOR_P(sname, dname)
rb_econv_result_t rb_econv_convert(rb_econv_t *ec, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags)
VALUE rb_econv_open_exc(const char *sname, const char *dname, int ecflags)
static int max(int a, int b)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static void transcode_loop(const unsigned char **in_pos, unsigned char **out_pos, const unsigned char *in_stop, unsigned char *out_stop, VALUE destination, unsigned char *(*resize_destination)(VALUE, size_t, size_t), const char *src_encoding, const char *dst_encoding, int ecflags, VALUE ecopts)
VALUE rb_eInvalidByteSequenceError
#define ECONV_XML_ATTR_CONTENT_DECORATOR
static void econv_args(int argc, VALUE *argv, volatile VALUE *snamev_p, volatile VALUE *dnamev_p, const char **sname_p, const char **dname_p, rb_encoding **senc_p, rb_encoding **denc_p, int *ecflags_p, VALUE *ecopts_p)
int(* state_init_func)(void *)
void rb_econv_binmode(rb_econv_t *ec)
static void rb_transcoding_close(rb_transcoding *tc)
rb_encoding * source_encoding
unsigned char * out_data_start
static int decorate_convpath(VALUE convpath, int ecflags)
static int enc_arg(volatile VALUE *arg, const char **name_p, rb_encoding **enc_p)
static VALUE sym_crlf_newline
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define MAX_ECFLAGS_DECORATORS
static size_t rb_transcoding_memsize(rb_transcoding *tc)
#define ENC_CODERANGE_SET(obj, cr)
#define TypedData_Get_Struct(obj, type, data_type, sval)
int rb_econv_prepare_options(VALUE opthash, VALUE *opts, int ecflags)
unsigned char * in_data_start
#define ECONV_ERROR_HANDLER_MASK
int rb_econv_decorate_at_last(rb_econv_t *ec, const char *decorator_name)
static int str_transcode_enc_args(VALUE str, volatile VALUE *arg1, volatile VALUE *arg2, const char **sname_p, rb_encoding **senc_p, const char **dname_p, rb_encoding **denc_p)
VALUE rb_method_call(int, VALUE *, VALUE)
rb_encoding * rb_to_encoding(VALUE enc)
rb_encoding * destination_encoding
#define ECONV_XML_ATTR_QUOTE_DECORATOR
struct rb_transcoding * tc
#define SUSPEND(ret, num)
VALUE rb_enc_from_encoding(rb_encoding *encoding)
static VALUE sym_cr_newline
static rb_encoding * to_encoding(VALUE enc)
static int str_transcode(int argc, VALUE *argv, VALUE *self)
VALUE rb_econv_substr_append(rb_econv_t *ec, VALUE src, long off, long len, VALUE dst, int flags)
VALUE rb_ary_push(VALUE ary, VALUE item)
static VALUE econv_last_error(VALUE self)
VALUE rb_obj_is_method(VALUE)
static VALUE INT2NUM(int v)
struct rb_transcoding * error_tc
static rb_econv_t * rb_econv_alloc(int n_hint)
#define RSTRING_PTR(string)
int rb_enc_str_coderange(VALUE)
static rb_econv_t * rb_econv_open_by_transcoder_entries(int n, transcoder_entry_t **entries)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
unsigned int conv_tree_start
static void rb_econv_init_by_convpath_i(const char *sname, const char *dname, int depth, void *arg)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
#define RARRAY_LEN(ARRAY)
rb_econv_t * rb_econv_open_opts(const char *source_encoding, const char *destination_encoding, int ecflags, VALUE opthash)
union rb_transcoding::@72 writebuf
const rb_transcoder * transcoder
static int output_replacement_character(rb_econv_t *ec)
static rb_econv_result_t rb_trans_conv(rb_econv_t *ec, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags, int *result_position_ptr)
void callback(ffi_cif *cif, void *resp, void **args, void *ctx)
static rb_econv_result_t transcode_restartable(const unsigned char **in_pos, unsigned char **out_pos, const unsigned char *in_stop, unsigned char *out_stop, rb_transcoding *tc, const int opt)
static VALUE econv_finish(VALUE self)
rb_encoding * rb_utf8_encoding(void)
static VALUE econv_description(const char *sname, const char *dname, int ecflags, VALUE mesg)
static transcoder_entry_t * make_transcoder_entry(const char *sname, const char *dname)
static const rb_transcoder * load_transcoder_entry(transcoder_entry_t *entry)
VALUE rb_str_tmp_new(long)
static int transcode_search_path(const char *sname, const char *dname, void(*callback)(const char *sname, const char *dname, int depth, void *arg), void *arg)
unsigned char * in_buf_start
static rb_econv_t * rb_econv_open0(const char *sname, const char *dname, int ecflags)
static void econv_free(void *ptr)
static VALUE sym_source_buffer_empty
void rb_econv_putback(rb_econv_t *ec, unsigned char *p, int n)
ssize_t(* func_so)(void *, const unsigned char *, size_t, unsigned char *, size_t)
#define ENC_CODERANGE_7BIT
const char * rb_obj_classname(VALUE)
static VALUE econv_convert(VALUE self, VALUE source_string)
static VALUE sym_partial_input
static const char transcoder_lib_prefix[]
static rb_econv_t * rb_econv_init_by_convpath(VALUE self, VALUE convpath, const char **sname_p, const char **dname_p, rb_encoding **senc_p, rb_encoding **denc_p)
void rb_exc_raise(VALUE mesg)
static unsigned char * output
static const char * get_replacement_character(const char *encname, size_t *len_ret, const char **repl_encname_ptr)
static VALUE str_encode_associate(VALUE str, int encidx)
st_table * st_init_strcasetable(void)
#define RB_TYPE_P(obj, type)
static VALUE ecerr_incomplete_input(VALUE self)
int rb_econv_has_convpath_p(const char *from_encoding, const char *to_encoding)
static unsigned char * str_transcoding_resize(VALUE destination, size_t len, size_t new_len)
double dummy_for_alignment
int rb_to_encoding_index(VALUE enc)
static VALUE econv_primitive_errinfo(VALUE self)
ssize_t(* finish_func)(void *, unsigned char *, size_t)
unsigned int output_index
#define TRANSCODING_READBUF(tc)
static size_t econv_memsize(const void *ptr)
void Init_transcode(void)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
unsigned char * in_data_end
static VALUE str_encode_bang(int argc, VALUE *argv, VALUE str)
static VALUE str_encode(int argc, VALUE *argv, VALUE str)
const char * destination_encoding
static int rb_econv_decorate_at(rb_econv_t *ec, const char *decorator_name, int n)
#define MAX_TRANSCODER_LIBNAME_LEN
#define ECONV_INVALID_MASK
struct rb_econv_t rb_econv_t
#define SUSPEND_AFTER_OUTPUT(num)
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
VALUE rb_str_cat2(VALUE, const char *)
#define ECONV_INVALID_REPLACE
void rb_econv_close(rb_econv_t *ec)
static VALUE econv_get_replacement(VALUE self)
#define ECONV_PARTIAL_INPUT
#define ECONV_AFTER_OUTPUT
static void more_output_buffer(VALUE destination, unsigned char *(*resize_destination)(VALUE, size_t, size_t), int max_output, unsigned char **out_start_ptr, unsigned char **out_pos, unsigned char **out_stop_ptr)
void rb_define_const(VALUE, const char *, VALUE)
void rb_ary_store(VALUE ary, long idx, VALUE val)
static VALUE econv_s_search_convpath(int argc, VALUE *argv, VALUE klass)
VALUE rb_econv_str_append(rb_econv_t *ec, VALUE src, VALUE dst, int flags)
static st_table * transcoder_table
int rb_econv_insert_output(rb_econv_t *ec, const unsigned char *str, size_t len, const char *str_encoding)
static VALUE make_econv_exception(rb_econv_t *ec)
VALUE rb_cEncodingConverter
VALUE rb_require_safe(VALUE, int)
static const rb_data_type_t econv_data_type
ssize_t(* func_sio)(void *, const unsigned char *, size_t, VALUE, unsigned char *, size_t)
#define ALLOCA_N(type, n)
static VALUE econv_set_replacement(VALUE self, VALUE arg)
#define TRANSCODING_STATE(tc)
#define MEMCPY(p1, p2, type, n)
#define ENC_CODERANGE_BROKEN
static VALUE sym_fallback
char ary[sizeof(double) > sizeof(void *)?sizeof(double):sizeof(void *)]
VALUE rb_enc_associate_index(VALUE obj, int idx)
static VALUE method_fallback(VALUE fallback, VALUE c)
rb_transcoder_asciicompat_type_t asciicompat_type
void rb_declare_transcoder(const char *enc1, const char *enc2, const char *lib)
static VALUE econv_equal(VALUE self, VALUE other)
int rb_econv_decorate_at_first(rb_econv_t *ec, const char *decorator_name)
#define ENC_CODERANGE_VALID
#define SUSPEND_OBUF(num)
VALUE rb_str_resize(VALUE, long)
static int str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
void rb_register_transcoder(const rb_transcoder *tr)
size_t rb_str_capacity(VALUE)
unsigned char * out_buf_start
static int transcode_search_path_i(st_data_t key, st_data_t val, st_data_t arg)
static VALUE econv_putback(int argc, VALUE *argv, VALUE self)
static void search_convpath_i(const char *sname, const char *dname, int depth, void *arg)
static rb_econv_t * check_econv(VALUE self)
#define REALLOC_N(var, type, n)
VALUE rb_obj_is_proc(VALUE)
static VALUE econv_s_allocate(VALUE klass)
search_path_queue_t ** queue_last_ptr
VALUE rb_sprintf(const char *format,...)
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
static VALUE econv_insert_output(VALUE self, VALUE string)
static VALUE ecerr_destination_encoding(VALUE self)
int rb_econv_putbackable(rb_econv_t *ec)
#define RSTRING_EMBED_LEN_MAX
unsigned char * out_buf_end
static int decorator_names(int ecflags, const char **decorators_ret)
int rb_econv_set_replacement(rb_econv_t *ec, const unsigned char *str, size_t len, const char *encname)
struct rb_transcoding * last_tc
#define MEMMOVE(p1, p2, type, n)
#define STR1_BYTEINDEX(w)
static VALUE aref_fallback(VALUE fallback, VALUE c)
static VALUE make_encobj(const char *name)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
VALUE rb_ivar_set(VALUE, ID, VALUE)
VALUE rb_check_hash_type(VALUE hash)
unsigned char buf[MIME_BUF_SIZE]
VALUE rb_assoc_new(VALUE car, VALUE cdr)
#define ECONV_CRLF_NEWLINE_DECORATOR
const char * source_encoding
int rb_define_dummy_encoding(const char *name)
VALUE rb_econv_substr_convert(rb_econv_t *ec, VALUE src, long byteoff, long bytesize, int flags)
static VALUE econv_init(int argc, VALUE *argv, VALUE self)
union rb_transcoding::@71 readbuf
static VALUE sym_universal_newline
union rb_transcoding::rb_transcoding_state_t state
#define ECONV_NEWLINE_DECORATOR_MASK
const char * src_encoding
VALUE rb_obj_encoding(VALUE obj)
register unsigned int len
#define RARRAY_PTR(ARRAY)
#define ECONV_UNDEF_HEX_CHARREF
static void trans_open_i(const char *sname, const char *dname, int depth, void *arg)
#define rb_enc_asciicompat(enc)
static VALUE sym_universal
VALUE rb_str_new_cstr(const char *)
int memcmp(const void *s1, const void *s2, size_t len)
static VALUE ecerr_error_char(VALUE self)
VALUE rb_proc_call(VALUE, VALUE)
const char * ascii_compat_name
static rb_encoding * make_encoding(const char *name)
#define ECONV_CR_NEWLINE_DECORATOR
#define RARRAY_LENINT(ary)
static VALUE econv_source_encoding(VALUE self)
static VALUE proc_fallback(VALUE fallback, VALUE c)
static VALUE sym_finished
VALUE rb_funcall3(VALUE, ID, int, const VALUE *)
Calls a method.
VALUE rb_hash_freeze(VALUE hash)
int rb_respond_to(VALUE, ID)
#define StringValueCStr(v)
static int make_replacement(rb_econv_t *ec)
static rb_econv_result_t transcode_restartable0(const unsigned char **in_pos, unsigned char **out_pos, const unsigned char *in_stop, unsigned char *out_stop, rb_transcoding *tc, const int opt)
#define ECONV_UNDEF_REPLACE
void rb_str_modify(VALUE)
rb_encoding * rb_enc_get(VALUE obj)
static VALUE sym_after_output
static VALUE econv_inspect(VALUE self)
static rb_transcoding * rb_transcoding_open_by_transcoder(const rb_transcoder *tr, int flags)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
VALUE rb_exc_new3(VALUE etype, VALUE str)
unsigned char * out_data_end
static rb_econv_result_t rb_econv_convert0(rb_econv_t *ec, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags)
static int asciicompat_encoding_i(st_data_t key, st_data_t val, st_data_t arg)
size_t rb_econv_memsize(rb_econv_t *ec)
rb_econv_t * rb_econv_open(const char *sname, const char *dname, int ecflags)
#define TRANSCODING_WRITEBUF(tc)
static const unsigned char * transcode_char_start(rb_transcoding *tc, const unsigned char *in_start, const unsigned char *inchar_start, const unsigned char *in_p, size_t *char_len_ptr)
VALUE rb_check_array_type(VALUE ary)
VALUE rb_hash_aref(VALUE hash, VALUE key)
static VALUE ecerr_error_bytes(VALUE self)
static rb_econv_result_t rb_transcoding_convert(rb_transcoding *tc, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags)
VALUE rb_str_catf(VALUE str, const char *format,...)
void rb_str_shared_replace(VALUE, VALUE)
#define rb_str_set_len(str, length)
static void declare_transcoder(const char *sname, const char *dname, const char *lib)
static int rb_econv_add_converter(rb_econv_t *ec, const char *sname, const char *dname, int n)
static int rb_econv_add_transcoder_at(rb_econv_t *ec, const rb_transcoder *tr, int i)
static VALUE econv_s_asciicompat_encoding(VALUE klass, VALUE arg)
const char * destination_encoding_name
static VALUE econv_convpath(VALUE self)
static int trans_sweep(rb_econv_t *ec, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags, int start)
struct rb_econv_t::@73 last_error
VALUE rb_enc_default_internal(void)
VALUE rb_ary_new2(long capa)
const char * rb_econv_asciicompat_encoding(const char *ascii_incompat_name)
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
const char * rb_econv_encoding_to_insert_output(rb_econv_t *ec)
static VALUE ecerr_source_encoding(VALUE self)
static int output_hex_charref(rb_econv_t *ec)
VALUE rb_econv_str_convert(rb_econv_t *ec, VALUE src, int flags)
static VALUE ecerr_readagain_bytes(VALUE self)
VALUE rb_eUndefinedConversionError
const char * rb_id2name(ID id)
const char * replacement_enc
VALUE rb_str_new_frozen(VALUE)
VALUE rb_str_drop_bytes(VALUE, long)
const char * source_encoding_name
int replacement_allocated
struct search_path_queue_tag * next
int rb_enc_find_index(const char *name)
static VALUE encoded_dup(VALUE newstr, VALUE str, int encidx)
static int econv_opts(VALUE opt, int ecflags)
#define rb_check_frozen(obj)
static VALUE sym_destination_buffer_full
static unsigned char * allocate_converted_string(const char *sname, const char *dname, const unsigned char *str, size_t len, unsigned char *caller_dst_buf, size_t caller_dst_bufsize, size_t *dst_len_ptr)
const rb_transcoder * transcoder
static transcoder_entry_t * get_transcoder_entry(const char *sname, const char *dname)
VALUE rb_str_buf_new(long)
struct rb_transcoding rb_transcoding
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
const unsigned char * replacement_str
VALUE rb_str_new2(const char *)
#define STR1_LENGTH(byte_addr)
VALUE(* func_ii)(void *, VALUE)
#define encoding_equal(enc1, enc2)
#define TRANSCODING_WRITEBUF_SIZE(tc)
static rb_encoding * make_dummy_encoding(const char *name)
#define ECONV_UNIVERSAL_NEWLINE_DECORATOR
rb_encoding * rb_enc_find(const char *name)
transcoder_entry_t ** entries
static VALUE econv_result_to_symbol(rb_econv_result_t res)
VALUE rb_attr_get(VALUE, ID)
static VALUE ecerr_source_encoding_name(VALUE self)
rb_encoding * rb_enc_from_index(int index)
static VALUE econv_primitive_convert(int argc, VALUE *argv, VALUE self)
ssize_t(* func_io)(void *, VALUE, const unsigned char *, size_t)
VALUE rb_obj_class(VALUE)
VALUE rb_str_new(const char *, long)
static VALUE ecerr_destination_encoding_name(VALUE self)
static VALUE sym_incomplete_input