summaryrefslogtreecommitdiff
path: root/transcode.c
diff options
context:
space:
mode:
Diffstat (limited to 'transcode.c')
-rw-r--r--transcode.c613
1 files changed, 390 insertions, 223 deletions
diff --git a/transcode.c b/transcode.c
index 4c3a273e7a..e494747823 100644
--- a/transcode.c
+++ b/transcode.c
@@ -9,22 +9,40 @@
**********************************************************************/
-#include "ruby/ruby.h"
-#include "ruby/encoding.h"
+#include "ruby/internal/config.h"
+
+#include <ctype.h>
+
#include "internal.h"
+#include "internal/array.h"
+#include "internal/inits.h"
+#include "internal/object.h"
+#include "internal/string.h"
+#include "internal/transcode.h"
+#include "ruby/encoding.h"
+
#include "transcode_data.h"
-#include <ctype.h>
+#include "id.h"
#define ENABLE_ECONV_NEWLINE_OPTION 1
/* VALUE rb_cEncoding = rb_define_class("Encoding", rb_cObject); */
-VALUE rb_eUndefinedConversionError;
-VALUE rb_eInvalidByteSequenceError;
-VALUE rb_eConverterNotFoundError;
+static VALUE rb_eUndefinedConversionError;
+static VALUE rb_eInvalidByteSequenceError;
+static VALUE rb_eConverterNotFoundError;
VALUE rb_cEncodingConverter;
-static VALUE sym_invalid, sym_undef, sym_replace, sym_fallback, sym_aref;
+static ID id_destination_encoding;
+static ID id_destination_encoding_name;
+static ID id_error_bytes;
+static ID id_error_char;
+static ID id_incomplete_input;
+static ID id_readagain_bytes;
+static ID id_source_encoding;
+static ID id_source_encoding_name;
+
+static VALUE sym_invalid, sym_undef, sym_replace, sym_fallback;
static VALUE sym_xml, sym_text, sym_attr;
static VALUE sym_universal_newline;
static VALUE sym_crlf_newline;
@@ -110,21 +128,21 @@ typedef struct {
struct rb_econv_t {
int flags;
+ int started; /* bool */
+
const char *source_encoding_name;
const char *destination_encoding_name;
- int started;
-
const unsigned char *replacement_str;
size_t replacement_len;
const char *replacement_enc;
- int replacement_allocated;
unsigned char *in_buf_start;
unsigned char *in_data_start;
unsigned char *in_data_end;
unsigned char *in_buf_end;
rb_econv_elem_t *elems;
+ int replacement_allocated; /* bool */
int num_allocated;
int num_trans;
int num_finished;
@@ -156,7 +174,7 @@ struct rb_econv_t {
typedef struct {
const char *sname;
const char *dname;
- const char *lib; /* null means means no need to load a library */
+ const char *lib; /* null means no need to load a library */
const rb_transcoder *transcoder;
} transcoder_entry_t;
@@ -227,15 +245,13 @@ declare_transcoder(const char *sname, const char *dname, const char *lib)
entry->lib = lib;
}
-#define MAX_TRANSCODER_LIBNAME_LEN 64
static const char transcoder_lib_prefix[] = "enc/trans/";
void
rb_declare_transcoder(const char *enc1, const char *enc2, const char *lib)
{
- if (!lib || strlen(lib) > MAX_TRANSCODER_LIBNAME_LEN) {
- rb_raise(rb_eArgError, "invalid library name - %s",
- lib ? lib : "(null)");
+ if (!lib) {
+ rb_raise(rb_eArgError, "invalid library name - (null)");
}
declare_transcoder(enc1, enc2, lib);
}
@@ -360,6 +376,8 @@ transcode_search_path(const char *sname, const char *dname,
return pathlen; /* is -1 if not found */
}
+int rb_require_internal_silent(VALUE fname);
+
static const rb_transcoder *
load_transcoder_entry(transcoder_entry_t *entry)
{
@@ -367,23 +385,17 @@ load_transcoder_entry(transcoder_entry_t *entry)
return entry->transcoder;
if (entry->lib) {
- const char *lib = entry->lib;
- size_t len = strlen(lib);
- char path[sizeof(transcoder_lib_prefix) + MAX_TRANSCODER_LIBNAME_LEN];
- VALUE fn;
- const int safe = rb_safe_level();
-
- entry->lib = NULL;
+ const char *const lib = entry->lib;
+ const size_t len = strlen(lib);
+ const size_t total_len = sizeof(transcoder_lib_prefix) - 1 + len;
+ const VALUE fn = rb_str_new(0, total_len);
+ char *const path = RSTRING_PTR(fn);
- if (len > MAX_TRANSCODER_LIBNAME_LEN)
- return NULL;
memcpy(path, transcoder_lib_prefix, sizeof(transcoder_lib_prefix) - 1);
- memcpy(path + sizeof(transcoder_lib_prefix) - 1, lib, len + 1);
- fn = rb_str_new2(path);
- FL_UNSET(fn, FL_TAINT|FL_UNTRUSTED);
+ memcpy(path + sizeof(transcoder_lib_prefix) - 1, lib, len);
+ rb_str_set_len(fn, total_len);
OBJ_FREEZE(fn);
- if (!rb_require_safe(fn, safe > 3 ? 3 : safe))
- return NULL;
+ rb_require_internal_silent(fn);
}
if (entry->transcoder)
@@ -982,28 +994,15 @@ rb_econv_open0(const char *sname, const char *dname, int ecflags)
int num_trans;
rb_econv_t *ec;
- rb_encoding *senc, *denc;
- int sidx, didx;
-
- senc = NULL;
- if (*sname) {
- sidx = rb_enc_find_index(sname);
- if (0 <= sidx) {
- senc = rb_enc_from_index(sidx);
- }
- }
-
- denc = NULL;
- if (*dname) {
- didx = rb_enc_find_index(dname);
- if (0 <= didx) {
- denc = rb_enc_from_index(didx);
- }
- }
+ /* Just check if sname and dname are defined */
+ /* (This check is needed?) */
+ if (*sname) rb_enc_find_index(sname);
+ if (*dname) rb_enc_find_index(dname);
if (*sname == '\0' && *dname == '\0') {
num_trans = 0;
entries = NULL;
+ sname = dname = "";
}
else {
struct trans_open_t toarg;
@@ -1204,7 +1203,6 @@ rb_trans_conv(rb_econv_t *ec,
if (ec->elems[0].last_result == econv_after_output)
ec->elems[0].last_result = econv_source_buffer_empty;
- needreport_index = -1;
for (i = ec->num_trans-1; 0 <= i; i--) {
switch (ec->elems[i].last_result) {
case econv_invalid_byte_sequence:
@@ -1213,7 +1211,6 @@ rb_trans_conv(rb_econv_t *ec,
case econv_after_output:
case econv_finished:
sweep_start = i+1;
- needreport_index = i;
goto found_needreport;
case econv_destination_buffer_full:
@@ -1815,18 +1812,32 @@ rb_econv_asciicompat_encoding(const char *ascii_incompat_name)
return data.ascii_compat_name;
}
+/*
+ * Append `len` bytes pointed by `ss` to `dst` with converting with `ec`.
+ *
+ * If the result of the conversion is not compatible with the encoding of
+ * `dst`, `dst` may not be valid encoding.
+ */
VALUE
-rb_econv_substr_append(rb_econv_t *ec, VALUE src, long off, long len, VALUE dst, int flags)
+rb_econv_append(rb_econv_t *ec, const char *ss, long len, VALUE dst, int flags)
{
- unsigned const char *ss, *sp, *se;
+ unsigned const char *sp, *se;
unsigned char *ds, *dp, *de;
rb_econv_result_t res;
int max_output;
+ enum ruby_coderange_type coderange;
+ rb_encoding *dst_enc = ec->destination_encoding;
if (NIL_P(dst)) {
dst = rb_str_buf_new(len);
- if (ec->destination_encoding)
- rb_enc_associate(dst, ec->destination_encoding);
+ if (dst_enc) {
+ rb_enc_associate(dst, dst_enc);
+ }
+ coderange = ENC_CODERANGE_7BIT; // scan from the start
+ }
+ else {
+ dst_enc = rb_enc_get(dst);
+ coderange = rb_enc_str_coderange(dst);
}
if (ec->last_tc)
@@ -1834,32 +1845,52 @@ rb_econv_substr_append(rb_econv_t *ec, VALUE src, long off, long len, VALUE dst,
else
max_output = 1;
- res = econv_destination_buffer_full;
- while (res == econv_destination_buffer_full) {
+ do {
+ int cr;
long dlen = RSTRING_LEN(dst);
if (rb_str_capacity(dst) - dlen < (size_t)len + max_output) {
unsigned long new_capa = (unsigned long)dlen + len + max_output;
if (LONG_MAX < new_capa)
rb_raise(rb_eArgError, "too long string");
- rb_str_resize(dst, new_capa);
- rb_str_set_len(dst, dlen);
+ rb_str_modify_expand(dst, new_capa - dlen);
}
- ss = sp = (const unsigned char *)RSTRING_PTR(src) + off;
- se = ss + len;
+ sp = (const unsigned char *)ss;
+ se = sp + len;
ds = (unsigned char *)RSTRING_PTR(dst);
de = ds + rb_str_capacity(dst);
dp = ds += dlen;
res = rb_econv_convert(ec, &sp, se, &dp, de, flags);
- off += sp - ss;
- len -= sp - ss;
+ switch (coderange) {
+ case ENC_CODERANGE_7BIT:
+ case ENC_CODERANGE_VALID:
+ cr = (int)coderange;
+ rb_str_coderange_scan_restartable((char *)ds, (char *)dp, dst_enc, &cr);
+ coderange = cr;
+ ENC_CODERANGE_SET(dst, coderange);
+ break;
+ case ENC_CODERANGE_UNKNOWN:
+ case ENC_CODERANGE_BROKEN:
+ break;
+ }
+ len -= (const char *)sp - ss;
+ ss = (const char *)sp;
rb_str_set_len(dst, dlen + (dp - ds));
rb_econv_check_error(ec);
- }
+ } while (res == econv_destination_buffer_full);
return dst;
}
VALUE
+rb_econv_substr_append(rb_econv_t *ec, VALUE src, long off, long len, VALUE dst, int flags)
+{
+ src = rb_str_new_frozen(src);
+ dst = rb_econv_append(ec, RSTRING_PTR(src) + off, len, dst, flags);
+ RB_GC_GUARD(src);
+ return dst;
+}
+
+VALUE
rb_econv_str_append(rb_econv_t *ec, VALUE src, VALUE dst, int flags)
{
return rb_econv_substr_append(ec, src, 0, RSTRING_LEN(src), dst, flags);
@@ -1939,48 +1970,37 @@ rb_econv_decorate_at_last(rb_econv_t *ec, const char *decorator_name)
void
rb_econv_binmode(rb_econv_t *ec)
{
- const rb_transcoder *trs[3];
- int n, i, j;
- transcoder_entry_t *entry;
- int num_trans;
+ const char *dname = 0;
- n = 0;
- if (ec->flags & ECONV_UNIVERSAL_NEWLINE_DECORATOR) {
- entry = get_transcoder_entry("", "universal_newline");
- if (entry->transcoder)
- trs[n++] = entry->transcoder;
- }
- if (ec->flags & ECONV_CRLF_NEWLINE_DECORATOR) {
- entry = get_transcoder_entry("", "crlf_newline");
- if (entry->transcoder)
- trs[n++] = entry->transcoder;
- }
- if (ec->flags & ECONV_CR_NEWLINE_DECORATOR) {
- entry = get_transcoder_entry("", "cr_newline");
- if (entry->transcoder)
- trs[n++] = entry->transcoder;
- }
-
- num_trans = ec->num_trans;
- j = 0;
- for (i = 0; i < num_trans; i++) {
- int k;
- for (k = 0; k < n; k++)
- if (trs[k] == ec->elems[i].tc->transcoder)
- break;
- if (k == n) {
- ec->elems[j] = ec->elems[i];
- j++;
- }
- else {
- rb_transcoding_close(ec->elems[i].tc);
- xfree(ec->elems[i].out_buf_start);
- ec->num_trans--;
- }
+ switch (ec->flags & ECONV_NEWLINE_DECORATOR_MASK) {
+ case ECONV_UNIVERSAL_NEWLINE_DECORATOR:
+ dname = "universal_newline";
+ break;
+ case ECONV_CRLF_NEWLINE_DECORATOR:
+ dname = "crlf_newline";
+ break;
+ case ECONV_CR_NEWLINE_DECORATOR:
+ dname = "cr_newline";
+ break;
}
- ec->flags &= ~ECONV_NEWLINE_DECORATOR_MASK;
+ if (dname) {
+ const rb_transcoder *transcoder = get_transcoder_entry("", dname)->transcoder;
+ int num_trans = ec->num_trans;
+ int i, j = 0;
+
+ for (i=0; i < num_trans; i++) {
+ if (transcoder == ec->elems[i].tc->transcoder) {
+ rb_transcoding_close(ec->elems[i].tc);
+ xfree(ec->elems[i].out_buf_start);
+ ec->num_trans--;
+ }
+ else
+ ec->elems[j++] = ec->elems[i];
+ }
+ }
+ ec->flags &= ~ECONV_NEWLINE_DECORATOR_MASK;
}
static VALUE
@@ -2065,7 +2085,6 @@ make_econv_exception(rb_econv_t *ec)
size_t readagain_len = ec->last_error.readagain_len;
VALUE bytes2 = Qnil;
VALUE dumped2;
- int idx;
if (ec->last_error.result == econv_incomplete_input) {
mesg = rb_sprintf("incomplete %s on %s",
StringValueCStr(dumped),
@@ -2086,20 +2105,10 @@ make_econv_exception(rb_econv_t *ec)
}
exc = rb_exc_new3(rb_eInvalidByteSequenceError, mesg);
- rb_ivar_set(exc, rb_intern("error_bytes"), bytes);
- rb_ivar_set(exc, rb_intern("readagain_bytes"), bytes2);
- rb_ivar_set(exc, rb_intern("incomplete_input"), ec->last_error.result == econv_incomplete_input ? Qtrue : Qfalse);
-
- set_encs:
- rb_ivar_set(exc, rb_intern("source_encoding_name"), rb_str_new2(ec->last_error.source_encoding));
- rb_ivar_set(exc, rb_intern("destination_encoding_name"), rb_str_new2(ec->last_error.destination_encoding));
- idx = rb_enc_find_index(ec->last_error.source_encoding);
- if (0 <= idx)
- rb_ivar_set(exc, rb_intern("source_encoding"), rb_enc_from_encoding(rb_enc_from_index(idx)));
- idx = rb_enc_find_index(ec->last_error.destination_encoding);
- if (0 <= idx)
- rb_ivar_set(exc, rb_intern("destination_encoding"), rb_enc_from_encoding(rb_enc_from_index(idx)));
- return exc;
+ rb_ivar_set(exc, id_error_bytes, bytes);
+ rb_ivar_set(exc, id_readagain_bytes, bytes2);
+ rb_ivar_set(exc, id_incomplete_input, RBOOL(ec->last_error.result == econv_incomplete_input));
+ goto set_encs;
}
if (ec->last_error.result == econv_undefined_conversion) {
VALUE bytes = rb_str_new((const char *)ec->last_error.error_bytes_start,
@@ -2119,7 +2128,7 @@ make_econv_exception(rb_econv_t *ec)
dumped = rb_sprintf("U+%04X", cc);
}
}
- if (dumped == Qnil)
+ if (NIL_P(dumped))
dumped = rb_str_dump(bytes);
if (strcmp(ec->last_error.source_encoding,
ec->source_encoding_name) == 0 &&
@@ -2147,10 +2156,21 @@ make_econv_exception(rb_econv_t *ec)
idx = rb_enc_find_index(ec->last_error.source_encoding);
if (0 <= idx)
rb_enc_associate_index(bytes, idx);
- rb_ivar_set(exc, rb_intern("error_char"), bytes);
+ rb_ivar_set(exc, id_error_char, bytes);
goto set_encs;
}
return Qnil;
+
+ set_encs:
+ rb_ivar_set(exc, id_source_encoding_name, rb_str_new2(ec->last_error.source_encoding));
+ rb_ivar_set(exc, id_destination_encoding_name, rb_str_new2(ec->last_error.destination_encoding));
+ int idx = rb_enc_find_index(ec->last_error.source_encoding);
+ if (0 <= idx)
+ rb_ivar_set(exc, id_source_encoding, rb_enc_from_encoding(rb_enc_from_index(idx)));
+ idx = rb_enc_find_index(ec->last_error.destination_encoding);
+ if (0 <= idx)
+ rb_ivar_set(exc, id_destination_encoding, rb_enc_from_encoding(rb_enc_from_index(idx)));
+ return exc;
}
static void
@@ -2174,7 +2194,6 @@ make_replacement(rb_econv_t *ec)
{
rb_transcoding *tc;
const rb_transcoder *tr;
- rb_encoding *enc;
const unsigned char *replacement;
const char *repl_enc;
const char *ins_enc;
@@ -2188,7 +2207,7 @@ make_replacement(rb_econv_t *ec)
tc = ec->last_tc;
if (*ins_enc) {
tr = tc->transcoder;
- enc = rb_enc_find(tr->dst_encoding);
+ rb_enc_find(tr->dst_encoding);
replacement = (const unsigned char *)get_replacement_character(ins_enc, &len, &repl_enc);
}
else {
@@ -2214,7 +2233,7 @@ rb_econv_set_replacement(rb_econv_t *ec,
encname2 = rb_econv_encoding_to_insert_output(ec);
- if (encoding_equal(encname, encname2)) {
+ if (!*encname2 || encoding_equal(encname, encname2)) {
str2 = xmalloc(len);
MEMCPY(str2, str, unsigned char, len); /* xxx: str may be invalid */
len2 = len;
@@ -2269,7 +2288,7 @@ method_fallback(VALUE fallback, VALUE c)
static VALUE
aref_fallback(VALUE fallback, VALUE c)
{
- return rb_funcall3(fallback, sym_aref, 1, &c);
+ return rb_funcallv_public(fallback, idAREF, 1, &c);
}
static void
@@ -2295,7 +2314,7 @@ transcode_loop(const unsigned char **in_pos, unsigned char **out_pos,
if (!ec)
rb_exc_raise(rb_econv_open_exc(src_encoding, dst_encoding, ecflags));
- if (!NIL_P(ecopts) && TYPE(ecopts) == T_HASH) {
+ if (!NIL_P(ecopts) && RB_TYPE_P(ecopts, T_HASH)) {
fallback = rb_hash_aref(ecopts, sym_fallback);
if (RB_TYPE_P(fallback, T_HASH)) {
fallback_func = hash_fallback;
@@ -2438,6 +2457,7 @@ static int
econv_opts(VALUE opt, int ecflags)
{
VALUE v;
+ int newlineflag = 0;
v = rb_hash_aref(opt, sym_invalid);
if (NIL_P(v)) {
@@ -2472,8 +2492,8 @@ econv_opts(VALUE opt, int ecflags)
else if (v==sym_attr) {
ecflags |= ECONV_XML_ATTR_CONTENT_DECORATOR|ECONV_XML_ATTR_QUOTE_DECORATOR|ECONV_UNDEF_HEX_CHARREF;
}
- else if (TYPE(v) == T_SYMBOL) {
- rb_raise(rb_eArgError, "unexpected value for xml option: %s", rb_id2name(SYM2ID(v)));
+ else if (SYMBOL_P(v)) {
+ rb_raise(rb_eArgError, "unexpected value for xml option: %"PRIsVALUE, rb_sym2str(v));
}
else {
rb_raise(rb_eArgError, "unexpected value for xml option");
@@ -2483,6 +2503,7 @@ econv_opts(VALUE opt, int ecflags)
#ifdef ENABLE_ECONV_NEWLINE_OPTION
v = rb_hash_aref(opt, sym_newline);
if (!NIL_P(v)) {
+ newlineflag = 2;
ecflags &= ~ECONV_NEWLINE_DECORATOR_MASK;
if (v == sym_universal) {
ecflags |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;
@@ -2497,17 +2518,16 @@ econv_opts(VALUE opt, int ecflags)
/* ecflags |= ECONV_LF_NEWLINE_DECORATOR; */
}
else if (SYMBOL_P(v)) {
- rb_raise(rb_eArgError, "unexpected value for newline option: %s",
- rb_id2name(SYM2ID(v)));
+ rb_raise(rb_eArgError, "unexpected value for newline option: %"PRIsVALUE,
+ rb_sym2str(v));
}
else {
rb_raise(rb_eArgError, "unexpected value for newline option");
}
}
- else
#endif
{
- int setflags = 0, newlineflag = 0;
+ int setflags = 0;
v = rb_hash_aref(opt, sym_universal_newline);
if (RTEST(v))
@@ -2524,9 +2544,15 @@ econv_opts(VALUE opt, int ecflags)
setflags |= ECONV_CR_NEWLINE_DECORATOR;
newlineflag |= !NIL_P(v);
- if (newlineflag) {
+ switch (newlineflag) {
+ case 1:
ecflags &= ~ECONV_NEWLINE_DECORATOR_MASK;
ecflags |= setflags;
+ break;
+
+ case 3:
+ rb_warning(":newline option precedes other newline options");
+ break;
}
}
@@ -2563,7 +2589,7 @@ rb_econv_prepare_options(VALUE opthash, VALUE *opts, int ecflags)
if (!NIL_P(v)) {
VALUE h = rb_check_hash_type(v);
if (NIL_P(h)
- ? (rb_obj_is_proc(v) || rb_obj_is_method(v) || rb_respond_to(v, sym_aref))
+ ? (rb_obj_is_proc(v) || rb_obj_is_method(v) || rb_respond_to(v, idAREF))
: (v = h, 1)) {
if (NIL_P(newhash))
newhash = rb_hash_new();
@@ -2594,7 +2620,7 @@ rb_econv_open_opts(const char *source_encoding, const char *destination_encoding
replacement = Qnil;
}
else {
- if (TYPE(opthash) != T_HASH || !OBJ_FROZEN(opthash))
+ if (!RB_TYPE_P(opthash, T_HASH) || !OBJ_FROZEN(opthash))
rb_bug("rb_econv_open_opts called with invalid opthash");
replacement = rb_hash_aref(opthash, sym_replace);
}
@@ -2620,7 +2646,7 @@ rb_econv_open_opts(const char *source_encoding, const char *destination_encoding
}
static int
-enc_arg(volatile VALUE *arg, const char **name_p, rb_encoding **enc_p)
+enc_arg(VALUE *arg, const char **name_p, rb_encoding **enc_p)
{
rb_encoding *enc;
const char *n;
@@ -2644,7 +2670,7 @@ enc_arg(volatile VALUE *arg, const char **name_p, rb_encoding **enc_p)
}
static int
-str_transcode_enc_args(VALUE str, volatile VALUE *arg1, volatile VALUE *arg2,
+str_transcode_enc_args(VALUE str, VALUE *arg1, VALUE *arg2,
const char **sname_p, rb_encoding **senc_p,
const char **dname_p, rb_encoding **denc_p)
{
@@ -2675,17 +2701,16 @@ str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
{
VALUE dest;
VALUE str = *self;
- volatile VALUE arg1, arg2;
+ VALUE arg1, arg2;
long blen, slen;
unsigned char *buf, *bp, *sp;
const unsigned char *fromp;
rb_encoding *senc, *denc;
const char *sname, *dname;
int dencidx;
+ int explicitly_invalid_replace = TRUE;
- if (argc <0 || argc > 2) {
- rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
- }
+ rb_check_arity(argc, 0, 2);
if (argc == 0) {
arg1 = rb_enc_default_internal();
@@ -2693,6 +2718,9 @@ str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
if (!ecflags) return -1;
arg1 = rb_obj_encoding(str);
}
+ if (!(ecflags & ECONV_INVALID_MASK)) {
+ explicitly_invalid_replace = FALSE;
+ }
ecflags |= ECONV_INVALID_REPLACE | ECONV_UNDEF_REPLACE;
}
else {
@@ -2706,6 +2734,16 @@ str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
ECONV_XML_ATTR_CONTENT_DECORATOR|
ECONV_XML_ATTR_QUOTE_DECORATOR)) == 0) {
if (senc && senc == denc) {
+ if ((ecflags & ECONV_INVALID_MASK) && explicitly_invalid_replace) {
+ VALUE rep = Qnil;
+ if (!NIL_P(ecopts)) {
+ rep = rb_hash_aref(ecopts, sym_replace);
+ }
+ dest = rb_enc_str_scrub(senc, str, rep);
+ if (NIL_P(dest)) dest = str;
+ *self = dest;
+ return dencidx;
+ }
return NIL_P(arg2) ? -1 : dencidx;
}
if (senc && denc && rb_enc_asciicompat(senc) && rb_enc_asciicompat(denc)) {
@@ -2718,6 +2756,12 @@ str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
}
}
else {
+ if (senc && denc && !rb_enc_asciicompat(senc) && !rb_enc_asciicompat(denc)) {
+ rb_encoding *utf8 = rb_utf8_encoding();
+ str = rb_str_conv_enc(str, senc, utf8);
+ senc = utf8;
+ sname = "UTF-8";
+ }
if (encoding_equal(sname, dname)) {
sname = "";
dname = "";
@@ -2741,6 +2785,8 @@ str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
/* set encoding */
if (!denc) {
dencidx = rb_define_dummy_encoding(dname);
+ RB_GC_GUARD(arg1);
+ RB_GC_GUARD(arg2);
}
*self = dest;
@@ -2781,14 +2827,14 @@ str_encode_associate(VALUE str, int encidx)
/*
* call-seq:
- * str.encode!(encoding [, options] ) -> str
- * str.encode!(dst_encoding, src_encoding [, options] ) -> str
+ * str.encode!(encoding, **options) -> str
+ * str.encode!(dst_encoding, src_encoding, **options) -> str
*
* The first form transcodes the contents of <i>str</i> from
* str.encoding to +encoding+.
* The second form transcodes the contents of <i>str</i> from
* src_encoding to dst_encoding.
- * The options Hash gives details for conversion. See String#encode
+ * The +options+ keyword arguments give details for conversion. See String#encode
* for details.
* Returns the string even if no changes were made.
*/
@@ -2805,6 +2851,10 @@ str_encode_bang(int argc, VALUE *argv, VALUE str)
encidx = str_transcode(argc, argv, &newstr);
if (encidx < 0) return str;
+ if (newstr == str) {
+ rb_enc_associate_index(str, encidx);
+ return str;
+ }
rb_str_shared_replace(str, newstr);
return str_encode_associate(str, encidx);
}
@@ -2813,9 +2863,9 @@ static VALUE encoded_dup(VALUE newstr, VALUE str, int encidx);
/*
* call-seq:
- * str.encode(encoding [, options] ) -> str
- * str.encode(dst_encoding, src_encoding [, options] ) -> str
- * str.encode([options]) -> str
+ * str.encode(encoding, **options) -> str
+ * str.encode(dst_encoding, src_encoding, **options) -> str
+ * str.encode(**options) -> str
*
* The first form returns a copy of +str+ transcoded
* to encoding +encoding+.
@@ -2831,8 +2881,8 @@ static VALUE encoded_dup(VALUE newstr, VALUE str, int encidx);
* in the source encoding. The last form by default does not raise
* exceptions but uses replacement strings.
*
- * The +options+ Hash gives details for conversion and can have the following
- * keys:
+ * The +options+ keyword arguments give details for conversion.
+ * The arguments are:
*
* :invalid ::
* If the value is +:replace+, #encode replaces invalid byte sequences in
@@ -2891,13 +2941,20 @@ encoded_dup(VALUE newstr, VALUE str, int encidx)
if (encidx < 0) return rb_str_dup(str);
if (newstr == str) {
newstr = rb_str_dup(str);
+ rb_enc_associate_index(newstr, encidx);
+ return newstr;
}
else {
- RBASIC(newstr)->klass = rb_obj_class(str);
+ RBASIC_SET_CLASS(newstr, rb_obj_class(str));
}
return str_encode_associate(newstr, encidx);
}
+/*
+ * Document-class: Encoding::Converter
+ *
+ * Encoding conversion class.
+ */
static void
econv_free(void *ptr)
{
@@ -2908,12 +2965,13 @@ econv_free(void *ptr)
static size_t
econv_memsize(const void *ptr)
{
- return ptr ? sizeof(rb_econv_t) : 0;
+ return sizeof(rb_econv_t);
}
static const rb_data_type_t econv_data_type = {
"econv",
- {NULL, econv_free, econv_memsize,},
+ {0, econv_free, econv_memsize,},
+ 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
};
static VALUE
@@ -2957,7 +3015,7 @@ make_encobj(const char *name)
*
* Returns nil if the argument is an ASCII compatible encoding.
*
- * "corresponding ASCII compatible encoding" is a ASCII compatible encoding which
+ * "corresponding ASCII compatible encoding" is an ASCII compatible encoding which
* can represents exactly the same characters as the given ASCII incompatible encoding.
* So, no conversion undefined error occurs when converting between the two encodings.
*
@@ -2986,7 +3044,7 @@ econv_s_asciicompat_encoding(VALUE klass, VALUE arg)
static void
econv_args(int argc, VALUE *argv,
- volatile VALUE *snamev_p, volatile VALUE *dnamev_p,
+ VALUE *snamev_p, VALUE *dnamev_p,
const char **sname_p, const char **dname_p,
rb_encoding **senc_p, rb_encoding **denc_p,
int *ecflags_p,
@@ -3002,8 +3060,7 @@ econv_args(int argc, VALUE *argv,
if (!NIL_P(flags_v)) {
if (!NIL_P(opt)) {
- rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)",
- argc + 1);
+ rb_error_arity(argc + 1, 2, 3);
}
ecflags = NUM2INT(rb_to_int(flags_v));
ecopts = Qnil;
@@ -3059,10 +3116,10 @@ decorate_convpath(VALUE convpath, int ecflags)
len = n = RARRAY_LENINT(convpath);
if (n != 0) {
- VALUE pair = RARRAY_PTR(convpath)[n-1];
- if (TYPE(pair) == T_ARRAY) {
- const char *sname = rb_enc_name(rb_to_encoding(RARRAY_PTR(pair)[0]));
- const char *dname = rb_enc_name(rb_to_encoding(RARRAY_PTR(pair)[1]));
+ VALUE pair = RARRAY_AREF(convpath, n-1);
+ if (RB_TYPE_P(pair, T_ARRAY)) {
+ const char *sname = rb_enc_name(rb_to_encoding(RARRAY_AREF(pair, 0)));
+ const char *dname = rb_enc_name(rb_to_encoding(RARRAY_AREF(pair, 1)));
transcoder_entry_t *entry = get_transcoder_entry(sname, dname);
const rb_transcoder *tr = load_transcoder_entry(entry);
if (!tr)
@@ -3090,7 +3147,7 @@ search_convpath_i(const char *sname, const char *dname, int depth, void *arg)
VALUE *ary_p = arg;
VALUE v;
- if (*ary_p == Qnil) {
+ if (NIL_P(*ary_p)) {
*ary_p = rb_ary_new();
}
@@ -3131,7 +3188,7 @@ search_convpath_i(const char *sname, const char *dname, int depth, void *arg)
static VALUE
econv_s_search_convpath(int argc, VALUE *argv, VALUE klass)
{
- volatile VALUE snamev, dnamev;
+ VALUE snamev, dnamev;
const char *sname, *dname;
rb_encoding *senc, *denc;
int ecflags;
@@ -3143,11 +3200,19 @@ econv_s_search_convpath(int argc, VALUE *argv, VALUE klass)
convpath = Qnil;
transcode_search_path(sname, dname, search_convpath_i, &convpath);
- if (NIL_P(convpath))
- rb_exc_raise(rb_econv_open_exc(sname, dname, ecflags));
+ if (NIL_P(convpath)) {
+ VALUE exc = rb_econv_open_exc(sname, dname, ecflags);
+ RB_GC_GUARD(snamev);
+ RB_GC_GUARD(dnamev);
+ rb_exc_raise(exc);
+ }
- if (decorate_convpath(convpath, ecflags) == -1)
- rb_exc_raise(rb_econv_open_exc(sname, dname, ecflags));
+ if (decorate_convpath(convpath, ecflags) == -1) {
+ VALUE exc = rb_econv_open_exc(sname, dname, ecflags);
+ RB_GC_GUARD(snamev);
+ RB_GC_GUARD(dnamev);
+ rb_exc_raise(exc);
+ }
return convpath;
}
@@ -3203,7 +3268,7 @@ rb_econv_init_by_convpath(VALUE self, VALUE convpath,
DATA_PTR(self) = ec;
for (i = 0; i < RARRAY_LEN(convpath); i++) {
- volatile VALUE snamev, dnamev;
+ VALUE snamev, dnamev;
VALUE pair;
elt = rb_ary_entry(convpath, i);
if (!NIL_P(pair = rb_check_array_type(elt))) {
@@ -3220,8 +3285,12 @@ rb_econv_init_by_convpath(VALUE self, VALUE convpath,
}
if (DECORATOR_P(sname, dname)) {
ret = rb_econv_add_converter(ec, sname, dname, ec->num_trans);
- if (ret == -1)
- rb_raise(rb_eArgError, "decoration failed: %s", dname);
+ if (ret == -1) {
+ VALUE msg = rb_sprintf("decoration failed: %s", dname);
+ RB_GC_GUARD(snamev);
+ RB_GC_GUARD(dnamev);
+ rb_exc_raise(rb_exc_new_str(rb_eArgError, msg));
+ }
}
else {
int j = ec->num_trans;
@@ -3230,8 +3299,12 @@ rb_econv_init_by_convpath(VALUE self, VALUE convpath,
arg.index = ec->num_trans;
arg.ret = 0;
ret = transcode_search_path(sname, dname, rb_econv_init_by_convpath_i, &arg);
- if (ret == -1 || arg.ret == -1)
- rb_raise(rb_eArgError, "adding conversion failed: %s to %s", sname, dname);
+ if (ret == -1 || arg.ret == -1) {
+ VALUE msg = rb_sprintf("adding conversion failed: %s to %s", sname, dname);
+ RB_GC_GUARD(snamev);
+ RB_GC_GUARD(dnamev);
+ rb_exc_raise(rb_exc_new_str(rb_eArgError, msg));
+ }
if (first) {
first = 0;
*senc_p = senc;
@@ -3243,10 +3316,10 @@ rb_econv_init_by_convpath(VALUE self, VALUE convpath,
}
if (first) {
- *senc_p = NULL;
- *denc_p = NULL;
- *sname_p = "";
- *dname_p = "";
+ *senc_p = NULL;
+ *denc_p = NULL;
+ *sname_p = "";
+ *dname_p = "";
}
ec->source_encoding_name = *sname_p;
@@ -3325,7 +3398,7 @@ rb_econv_init_by_convpath(VALUE self, VALUE convpath,
* Convert LF to CR.
* [:xml => :text]
* Escape as XML CharData.
- * This form can be used as a HTML 4.0 #PCDATA.
+ * This form can be used as an HTML 4.0 #PCDATA.
* - '&' -> '&amp;'
* - '<' -> '&lt;'
* - '>' -> '&gt;'
@@ -3333,7 +3406,7 @@ rb_econv_init_by_convpath(VALUE self, VALUE convpath,
* [:xml => :attr]
* Escape as XML AttValue.
* The converted result is quoted as "...".
- * This form can be used as a HTML 4.0 attribute value.
+ * This form can be used as an HTML 4.0 attribute value.
* - '&' -> '&amp;'
* - '<' -> '&lt;'
* - '>' -> '&gt;'
@@ -3365,7 +3438,7 @@ static VALUE
econv_init(int argc, VALUE *argv, VALUE self)
{
VALUE ecopts;
- volatile VALUE snamev, dnamev;
+ VALUE snamev, dnamev;
const char *sname, *dname;
rb_encoding *senc, *denc;
rb_econv_t *ec;
@@ -3387,7 +3460,10 @@ econv_init(int argc, VALUE *argv, VALUE self)
}
if (!ec) {
- rb_exc_raise(rb_econv_open_exc(sname, dname, ecflags));
+ VALUE exc = rb_econv_open_exc(sname, dname, ecflags);
+ RB_GC_GUARD(snamev);
+ RB_GC_GUARD(dnamev);
+ rb_exc_raise(exc);
}
if (!DECORATOR_P(sname, dname)) {
@@ -3395,6 +3471,8 @@ econv_init(int argc, VALUE *argv, VALUE self)
senc = make_dummy_encoding(sname);
if (!denc)
denc = make_dummy_encoding(dname);
+ RB_GC_GUARD(snamev);
+ RB_GC_GUARD(dnamev);
}
ec->source_encoding = senc;
@@ -3600,7 +3678,7 @@ econv_result_to_symbol(rb_econv_result_t res)
* primitive_convert converts source_buffer into destination_buffer.
*
* source_buffer should be a string or nil.
- * nil means a empty string.
+ * nil means an empty string.
*
* destination_buffer should be a string.
*
@@ -3637,9 +3715,12 @@ econv_result_to_symbol(rb_econv_result_t res)
*
* primitive_convert stops conversion when one of following condition met.
* - invalid byte sequence found in source buffer (:invalid_byte_sequence)
+ * +primitive_errinfo+ and +last_error+ methods returns the detail of the error.
* - unexpected end of source buffer (:incomplete_input)
* this occur only when :partial_input is not specified.
+ * +primitive_errinfo+ and +last_error+ methods returns the detail of the error.
* - character not representable in output encoding (:undefined_conversion)
+ * +primitive_errinfo+ and +last_error+ methods returns the detail of the error.
* - after some output is generated, before input is done (:after_output)
* this occur only when :after_output is specified.
* - destination buffer is full (:destination_buffer_full)
@@ -3690,8 +3771,7 @@ econv_primitive_convert(int argc, VALUE *argv, VALUE self)
if (!NIL_P(flags_v)) {
if (!NIL_P(opt)) {
- rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..5)",
- argc + 1);
+ rb_error_arity(argc + 1, 2, 5);
}
flags = NUM2INT(rb_to_int(flags_v));
}
@@ -3715,7 +3795,11 @@ econv_primitive_convert(int argc, VALUE *argv, VALUE self)
rb_str_modify(output);
if (NIL_P(output_bytesize_v)) {
+#if USE_RVARGC
+ output_bytesize = rb_str_capacity(output);
+#else
output_bytesize = RSTRING_EMBED_LEN_MAX;
+#endif
if (!NIL_P(input) && output_bytesize < RSTRING_LEN(input))
output_bytesize = RSTRING_LEN(input);
}
@@ -3757,8 +3841,9 @@ econv_primitive_convert(int argc, VALUE *argv, VALUE self)
res = rb_econv_convert(ec, &ip, is, &op, os, flags);
rb_str_set_len(output, op-(unsigned char *)RSTRING_PTR(output));
- if (!NIL_P(input))
+ if (!NIL_P(input)) {
rb_str_drop_bytes(input, ip - (unsigned char *)RSTRING_PTR(input));
+ }
if (NIL_P(output_bytesize_v) && res == econv_destination_buffer_full) {
if (LONG_MAX / 2 < output_bytesize)
@@ -3873,7 +3958,7 @@ econv_finish(VALUE self)
av[1] = dst;
av[2] = Qnil;
av[3] = Qnil;
- av[4] = INT2NUM(0);
+ av[4] = INT2FIX(0);
ac = 5;
ret = econv_primitive_convert(ac, av, self);
@@ -3921,7 +4006,7 @@ econv_finish(VALUE self)
* ec = Encoding::Converter.new("EUC-JP", "Shift_JIS")
* ec.primitive_convert(src="\xff", dst="", nil, 10)
* p ec.primitive_errinfo
- * #=> [:invalid_byte_sequence, "EUC-JP", "UTF-8", "\xFF", ""]
+ * #=> [:invalid_byte_sequence, "EUC-JP", "Shift_JIS", "\xFF", ""]
*
* # HIRAGANA LETTER A (\xa4\xa2 in EUC-JP) is not representable in ISO-8859-1.
* # Since this error is occur in UTF-8 to ISO-8859-1 conversion,
@@ -4047,7 +4132,7 @@ econv_insert_output(VALUE self, VALUE string)
}
/*
- * call-seq
+ * call-seq:
* ec.putback -> string
* ec.putback(max_numbytes) -> string
*
@@ -4078,10 +4163,9 @@ econv_putback(int argc, VALUE *argv, VALUE self)
int putbackable;
VALUE str, max;
- rb_scan_args(argc, argv, "01", &max);
-
- if (NIL_P(max))
+ if (!rb_check_arity(argc, 0, 1) || NIL_P(max = argv[0])) {
n = rb_econv_putbackable(ec);
+ }
else {
n = NUM2INT(max);
putbackable = rb_econv_putbackable(ec);
@@ -4219,7 +4303,7 @@ rb_econv_check_error(rb_econv_t *ec)
static VALUE
ecerr_source_encoding_name(VALUE self)
{
- return rb_attr_get(self, rb_intern("source_encoding_name"));
+ return rb_attr_get(self, id_source_encoding_name);
}
/*
@@ -4245,7 +4329,7 @@ ecerr_source_encoding_name(VALUE self)
static VALUE
ecerr_source_encoding(VALUE self)
{
- return rb_attr_get(self, rb_intern("source_encoding"));
+ return rb_attr_get(self, id_source_encoding);
}
/*
@@ -4257,7 +4341,7 @@ ecerr_source_encoding(VALUE self)
static VALUE
ecerr_destination_encoding_name(VALUE self)
{
- return rb_attr_get(self, rb_intern("destination_encoding_name"));
+ return rb_attr_get(self, id_destination_encoding_name);
}
/*
@@ -4269,7 +4353,7 @@ ecerr_destination_encoding_name(VALUE self)
static VALUE
ecerr_destination_encoding(VALUE self)
{
- return rb_attr_get(self, rb_intern("destination_encoding"));
+ return rb_attr_get(self, id_destination_encoding);
}
/*
@@ -4290,7 +4374,7 @@ ecerr_destination_encoding(VALUE self)
static VALUE
ecerr_error_char(VALUE self)
{
- return rb_attr_get(self, rb_intern("error_char"));
+ return rb_attr_get(self, id_error_char);
}
/*
@@ -4311,7 +4395,7 @@ ecerr_error_char(VALUE self)
static VALUE
ecerr_error_bytes(VALUE self)
{
- return rb_attr_get(self, rb_intern("error_bytes"));
+ return rb_attr_get(self, id_error_bytes);
}
/*
@@ -4323,7 +4407,7 @@ ecerr_error_bytes(VALUE self)
static VALUE
ecerr_readagain_bytes(VALUE self)
{
- return rb_attr_get(self, rb_intern("readagain_bytes"));
+ return rb_attr_get(self, id_readagain_bytes);
}
/*
@@ -4353,7 +4437,7 @@ ecerr_readagain_bytes(VALUE self)
static VALUE
ecerr_incomplete_input(VALUE self)
{
- return rb_attr_get(self, rb_intern("incomplete_input"));
+ return rb_attr_get(self, id_incomplete_input);
}
/*
@@ -4381,45 +4465,59 @@ ecerr_incomplete_input(VALUE self)
void
Init_transcode(void)
{
- rb_eUndefinedConversionError = rb_define_class_under(rb_cEncoding, "UndefinedConversionError", rb_eEncodingError);
- rb_eInvalidByteSequenceError = rb_define_class_under(rb_cEncoding, "InvalidByteSequenceError", rb_eEncodingError);
- rb_eConverterNotFoundError = rb_define_class_under(rb_cEncoding, "ConverterNotFoundError", rb_eEncodingError);
-
transcoder_table = st_init_strcasetable();
- sym_invalid = ID2SYM(rb_intern("invalid"));
- sym_undef = ID2SYM(rb_intern("undef"));
- sym_replace = ID2SYM(rb_intern("replace"));
- sym_fallback = ID2SYM(rb_intern("fallback"));
- sym_aref = ID2SYM(rb_intern("[]"));
- sym_xml = ID2SYM(rb_intern("xml"));
- sym_text = ID2SYM(rb_intern("text"));
- sym_attr = ID2SYM(rb_intern("attr"));
-
- sym_invalid_byte_sequence = ID2SYM(rb_intern("invalid_byte_sequence"));
- sym_undefined_conversion = ID2SYM(rb_intern("undefined_conversion"));
- sym_destination_buffer_full = ID2SYM(rb_intern("destination_buffer_full"));
- sym_source_buffer_empty = ID2SYM(rb_intern("source_buffer_empty"));
- sym_finished = ID2SYM(rb_intern("finished"));
- sym_after_output = ID2SYM(rb_intern("after_output"));
- sym_incomplete_input = ID2SYM(rb_intern("incomplete_input"));
- sym_universal_newline = ID2SYM(rb_intern("universal_newline"));
- sym_crlf_newline = ID2SYM(rb_intern("crlf_newline"));
- sym_cr_newline = ID2SYM(rb_intern("cr_newline"));
- sym_partial_input = ID2SYM(rb_intern("partial_input"));
+ id_destination_encoding = rb_intern_const("destination_encoding");
+ id_destination_encoding_name = rb_intern_const("destination_encoding_name");
+ id_error_bytes = rb_intern_const("error_bytes");
+ id_error_char = rb_intern_const("error_char");
+ id_incomplete_input = rb_intern_const("incomplete_input");
+ id_readagain_bytes = rb_intern_const("readagain_bytes");
+ id_source_encoding = rb_intern_const("source_encoding");
+ id_source_encoding_name = rb_intern_const("source_encoding_name");
+
+ sym_invalid = ID2SYM(rb_intern_const("invalid"));
+ sym_undef = ID2SYM(rb_intern_const("undef"));
+ sym_replace = ID2SYM(rb_intern_const("replace"));
+ sym_fallback = ID2SYM(rb_intern_const("fallback"));
+ sym_xml = ID2SYM(rb_intern_const("xml"));
+ sym_text = ID2SYM(rb_intern_const("text"));
+ sym_attr = ID2SYM(rb_intern_const("attr"));
+
+ sym_invalid_byte_sequence = ID2SYM(rb_intern_const("invalid_byte_sequence"));
+ sym_undefined_conversion = ID2SYM(rb_intern_const("undefined_conversion"));
+ sym_destination_buffer_full = ID2SYM(rb_intern_const("destination_buffer_full"));
+ sym_source_buffer_empty = ID2SYM(rb_intern_const("source_buffer_empty"));
+ sym_finished = ID2SYM(rb_intern_const("finished"));
+ sym_after_output = ID2SYM(rb_intern_const("after_output"));
+ sym_incomplete_input = ID2SYM(rb_intern_const("incomplete_input"));
+ sym_universal_newline = ID2SYM(rb_intern_const("universal_newline"));
+ sym_crlf_newline = ID2SYM(rb_intern_const("crlf_newline"));
+ sym_cr_newline = ID2SYM(rb_intern_const("cr_newline"));
+ sym_partial_input = ID2SYM(rb_intern_const("partial_input"));
#ifdef ENABLE_ECONV_NEWLINE_OPTION
- sym_newline = ID2SYM(rb_intern("newline"));
- sym_universal = ID2SYM(rb_intern("universal"));
- sym_crlf = ID2SYM(rb_intern("crlf"));
- sym_cr = ID2SYM(rb_intern("cr"));
- sym_lf = ID2SYM(rb_intern("lf"));
+ sym_newline = ID2SYM(rb_intern_const("newline"));
+ sym_universal = ID2SYM(rb_intern_const("universal"));
+ sym_crlf = ID2SYM(rb_intern_const("crlf"));
+ sym_cr = ID2SYM(rb_intern_const("cr"));
+ sym_lf = ID2SYM(rb_intern_const("lf"));
#endif
+ InitVM(transcode);
+}
+
+void
+InitVM_transcode(void)
+{
+ rb_eUndefinedConversionError = rb_define_class_under(rb_cEncoding, "UndefinedConversionError", rb_eEncodingError);
+ rb_eInvalidByteSequenceError = rb_define_class_under(rb_cEncoding, "InvalidByteSequenceError", rb_eEncodingError);
+ rb_eConverterNotFoundError = rb_define_class_under(rb_cEncoding, "ConverterNotFoundError", rb_eEncodingError);
+
rb_define_method(rb_cString, "encode", str_encode, -1);
rb_define_method(rb_cString, "encode!", str_encode_bang, -1);
- rb_cEncodingConverter = rb_define_class_under(rb_cEncoding, "Converter", rb_cData);
+ rb_cEncodingConverter = rb_define_class_under(rb_cEncoding, "Converter", rb_cObject);
rb_define_alloc_func(rb_cEncodingConverter, econv_s_allocate);
rb_define_singleton_method(rb_cEncodingConverter, "asciicompat_encoding", econv_s_asciicompat_encoding, 1);
rb_define_singleton_method(rb_cEncodingConverter, "search_convpath", econv_s_search_convpath, -1);
@@ -4439,18 +4537,87 @@ Init_transcode(void)
rb_define_method(rb_cEncodingConverter, "replacement=", econv_set_replacement, 1);
rb_define_method(rb_cEncodingConverter, "==", econv_equal, 1);
+ /* Document-const: INVALID_MASK
+ *
+ * Mask for invalid byte sequences
+ */
rb_define_const(rb_cEncodingConverter, "INVALID_MASK", INT2FIX(ECONV_INVALID_MASK));
+
+ /* Document-const: INVALID_REPLACE
+ *
+ * Replace invalid byte sequences
+ */
rb_define_const(rb_cEncodingConverter, "INVALID_REPLACE", INT2FIX(ECONV_INVALID_REPLACE));
+
+ /* Document-const: UNDEF_MASK
+ *
+ * Mask for a valid character in the source encoding but no related
+ * character(s) in destination encoding.
+ */
rb_define_const(rb_cEncodingConverter, "UNDEF_MASK", INT2FIX(ECONV_UNDEF_MASK));
+
+ /* Document-const: UNDEF_REPLACE
+ *
+ * Replace byte sequences that are undefined in the destination encoding.
+ */
rb_define_const(rb_cEncodingConverter, "UNDEF_REPLACE", INT2FIX(ECONV_UNDEF_REPLACE));
+
+ /* Document-const: UNDEF_HEX_CHARREF
+ *
+ * Replace byte sequences that are undefined in the destination encoding
+ * with an XML hexadecimal character reference. This is valid for XML
+ * conversion.
+ */
rb_define_const(rb_cEncodingConverter, "UNDEF_HEX_CHARREF", INT2FIX(ECONV_UNDEF_HEX_CHARREF));
+
+ /* Document-const: PARTIAL_INPUT
+ *
+ * Indicates the source may be part of a larger string. See
+ * primitive_convert for an example.
+ */
rb_define_const(rb_cEncodingConverter, "PARTIAL_INPUT", INT2FIX(ECONV_PARTIAL_INPUT));
+
+ /* Document-const: AFTER_OUTPUT
+ *
+ * Stop converting after some output is complete but before all of the
+ * input was consumed. See primitive_convert for an example.
+ */
rb_define_const(rb_cEncodingConverter, "AFTER_OUTPUT", INT2FIX(ECONV_AFTER_OUTPUT));
+
+ /* Document-const: UNIVERSAL_NEWLINE_DECORATOR
+ *
+ * Decorator for converting CRLF and CR to LF
+ */
rb_define_const(rb_cEncodingConverter, "UNIVERSAL_NEWLINE_DECORATOR", INT2FIX(ECONV_UNIVERSAL_NEWLINE_DECORATOR));
+
+ /* Document-const: CRLF_NEWLINE_DECORATOR
+ *
+ * Decorator for converting LF to CRLF
+ */
rb_define_const(rb_cEncodingConverter, "CRLF_NEWLINE_DECORATOR", INT2FIX(ECONV_CRLF_NEWLINE_DECORATOR));
+
+ /* Document-const: CR_NEWLINE_DECORATOR
+ *
+ * Decorator for converting LF to CR
+ */
rb_define_const(rb_cEncodingConverter, "CR_NEWLINE_DECORATOR", INT2FIX(ECONV_CR_NEWLINE_DECORATOR));
+
+ /* Document-const: XML_TEXT_DECORATOR
+ *
+ * Escape as XML CharData
+ */
rb_define_const(rb_cEncodingConverter, "XML_TEXT_DECORATOR", INT2FIX(ECONV_XML_TEXT_DECORATOR));
+
+ /* Document-const: XML_ATTR_CONTENT_DECORATOR
+ *
+ * Escape as XML AttValue
+ */
rb_define_const(rb_cEncodingConverter, "XML_ATTR_CONTENT_DECORATOR", INT2FIX(ECONV_XML_ATTR_CONTENT_DECORATOR));
+
+ /* Document-const: XML_ATTR_QUOTE_DECORATOR
+ *
+ * Escape as XML AttValue
+ */
rb_define_const(rb_cEncodingConverter, "XML_ATTR_QUOTE_DECORATOR", INT2FIX(ECONV_XML_ATTR_QUOTE_DECORATOR));
rb_define_method(rb_eUndefinedConversionError, "source_encoding_name", ecerr_source_encoding_name, 0);
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 11:12:47 +0000