iconv 0.1 → 1.0.0

data/ext/iconv/iconv.c

@@ -4,7 +4,6 @@
   iconv.c -
 
   $Author$
-  $Date$
   created at: Wed Dec  1 20:28:09 JST 1999
 
   All the files in this distribution are covered under the Ruby's
@@ -14,12 +13,12 @@
 
 **********************************************************************/
 
-#include "ruby.h"
+#include "ruby/ruby.h"
 #include <errno.h>
 #include <iconv.h>
 #include <assert.h>
-#include "st.h"
-#include "intern.h"
+#include "ruby/st.h"
+#include "ruby/encoding.h"
 
 /*
  * Document-class: Iconv
@@ -27,20 +26,20 @@
  * == Summary
  *
  * Ruby extension for charset conversion.
- * 
+ *
  * == Abstract
  *
  * Iconv is a wrapper class for the UNIX 95 <tt>iconv()</tt> function family,
  * which translates string between various encoding systems.
- * 
+ *
  * See Open Group's on-line documents for more details.
  * * <tt>iconv.h</tt>:       http://www.opengroup.org/onlinepubs/007908799/xsh/iconv.h.html
  * * <tt>iconv_open()</tt>:  http://www.opengroup.org/onlinepubs/007908799/xsh/iconv_open.html
  * * <tt>iconv()</tt>:       http://www.opengroup.org/onlinepubs/007908799/xsh/iconv.html
  * * <tt>iconv_close()</tt>: http://www.opengroup.org/onlinepubs/007908799/xsh/iconv_close.html
- * 
+ *
  * Which coding systems are available is platform-dependent.
- * 
+ *
  * == Examples
  *
  * 1. Simple conversion between two charsets.
@@ -67,6 +66,12 @@
  * 4. Shorthand for (3).
  *
  *      Iconv.iconv(to, from, *input.to_a)
+ *
+ * == Attentions
+ *
+ * Even if some extentions of implementation dependent are useful,
+ * DON'T USE those extentions in libraries and scripts to widely distribute.
+ * If you want to use those feature, use String#encode.
  */
 
 /* Invalid value for iconv_t is -1 but 0 for VALUE, I hope VALUE is
@@ -80,9 +85,18 @@ struct iconv_env_t
     int argc;
     VALUE *argv;
     VALUE ret;
+    int toidx;
     VALUE (*append)_((VALUE, VALUE));
 };
 
+struct rb_iconv_opt_t
+{
+    VALUE transliterate;
+    VALUE discard_ilseq;
+};
+
+static ID id_transliterate, id_discard_ilseq;
+
 static VALUE rb_eIconvInvalidEncoding;
 static VALUE rb_eIconvFailure;
 static VALUE rb_eIconvIllegalSeq;
@@ -91,26 +105,28 @@ static VALUE rb_eIconvOutOfRange;
 static VALUE rb_eIconvBrokenLibrary;
 
 static ID rb_success, rb_failed;
-static VALUE iconv_fail _((VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, const char *mesg));
-static VALUE iconv_fail_retry _((VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, const char *mesg));
+static VALUE iconv_fail _((VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, VALUE mesg));
+static VALUE iconv_fail_retry _((VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, VALUE mesg));
 static VALUE iconv_failure_initialize _((VALUE error, VALUE mesg, VALUE success, VALUE failed));
 static VALUE iconv_failure_success _((VALUE self));
 static VALUE iconv_failure_failed _((VALUE self));
 
-static iconv_t iconv_create _((VALUE to, VALUE from));
+static iconv_t iconv_create _((VALUE to, VALUE from, struct rb_iconv_opt_t *opt, int *idx));
 static void iconv_dfree _((void *cd));
 static VALUE iconv_free _((VALUE cd));
 static VALUE iconv_try _((iconv_t cd, const char **inptr, size_t *inlen, char **outptr, size_t *outlen));
-static VALUE rb_str_derive _((VALUE str, const char* ptr, int len));
-static VALUE iconv_convert _((iconv_t cd, VALUE str, long start, long length, struct iconv_env_t* env));
+static VALUE rb_str_derive _((VALUE str, const char* ptr, long len));
+static VALUE iconv_convert _((iconv_t cd, VALUE str, long start, long length, int toidx,
+			      struct iconv_env_t* env));
 static VALUE iconv_s_allocate _((VALUE klass));
-static VALUE iconv_initialize _((VALUE self, VALUE to, VALUE from));
-static VALUE iconv_s_open _((VALUE self, VALUE to, VALUE from));
+static VALUE iconv_initialize _((int argc, VALUE *argv, VALUE self));
+static VALUE iconv_s_open _((int argc, VALUE *argv, VALUE self));
 static VALUE iconv_s_convert _((struct iconv_env_t* env));
 static VALUE iconv_s_iconv _((int argc, VALUE *argv, VALUE self));
 static VALUE iconv_init_state _((VALUE cd));
 static VALUE iconv_finish _((VALUE self));
 static VALUE iconv_iconv _((int argc, VALUE *argv, VALUE self));
+static VALUE iconv_conv _((int argc, VALUE *argv, VALUE self));
 
 static VALUE charset_map;
 
@@ -120,94 +136,162 @@ static VALUE charset_map;
  *
  * Returns the map from canonical name to system dependent name.
  */
-static VALUE charset_map_get _((void))
+static VALUE
+charset_map_get(void)
 {
     return charset_map;
 }
 
+static VALUE
+strip_glibc_option(VALUE *code)
+{
+    VALUE val = StringValue(*code);
+    const char *ptr = RSTRING_PTR(val), *pend = RSTRING_END(val);
+    const char *slash = memchr(ptr, '/', pend - ptr);
+
+    if (slash && slash < pend - 1 && slash[1] ==  '/') {
+	VALUE opt = rb_str_subseq(val, slash - ptr, pend - slash);
+	val = rb_str_subseq(val, 0, slash - ptr);
+	*code = val;
+	return opt;
+    }
+    return 0;
+}
+
 static char *
-map_charset
-#ifdef HAVE_PROTOTYPES
-    (VALUE *code)
-#else /* HAVE_PROTOTYPES */
-    (code)
-    VALUE *code;
-#endif /* HAVE_PROTOTYPES */
+map_charset(VALUE *code)
 {
-    VALUE val = *code;
+    VALUE val = StringValue(*code);
 
-    if (RHASH(charset_map)->tbl && RHASH(charset_map)->tbl->num_entries) {
+    if (RHASH_SIZE(charset_map)) {
+	st_data_t data;
 	VALUE key = rb_funcall2(val, rb_intern("downcase"), 0, 0);
 	StringValuePtr(key);
-	if (st_lookup(RHASH(charset_map)->tbl, key, &val)) {
-	    *code = val;
+	if (st_lookup(RHASH_TBL(charset_map), key, &data)) {
+	    *code = (VALUE)data;
 	}
     }
     return StringValuePtr(*code);
 }
 
-NORETURN(static void rb_iconv_sys_fail(const char *s));
+NORETURN(static void rb_iconv_sys_fail_str(VALUE msg));
 static void
-rb_iconv_sys_fail(const char *s)
+rb_iconv_sys_fail_str(VALUE msg)
 {
     if (errno == 0) {
-	rb_exc_raise(iconv_fail(rb_eIconvBrokenLibrary, Qnil, Qnil, NULL, s));
+	rb_exc_raise(iconv_fail(rb_eIconvBrokenLibrary, Qnil, Qnil, NULL, msg));
     }
-    rb_sys_fail(s);
+    rb_sys_fail_str(msg);
+}
+
+#define rb_sys_fail_str(s) rb_iconv_sys_fail_str(s)
+
+NORETURN(static void rb_iconv_sys_fail(const char *s));
+static void
+rb_iconv_sys_fail(const char *s)
+{
+    rb_iconv_sys_fail_str(rb_str_new_cstr(s));
 }
 
 #define rb_sys_fail(s) rb_iconv_sys_fail(s)
 
 static iconv_t
-iconv_create
-#ifdef HAVE_PROTOTYPES
-    (VALUE to, VALUE from)
-#else /* HAVE_PROTOTYPES */
-    (to, from)
-    VALUE to;
-    VALUE from;
-#endif /* HAVE_PROTOTYPES */
+iconv_create(VALUE to, VALUE from, struct rb_iconv_opt_t *opt, int *idx)
 {
+    VALUE toopt = strip_glibc_option(&to);
+    VALUE fromopt = strip_glibc_option(&from);
+    VALUE toenc = 0, fromenc = 0;
     const char* tocode = map_charset(&to);
     const char* fromcode = map_charset(&from);
+    iconv_t cd;
+    int retry = 0;
 
-    iconv_t cd = iconv_open(tocode, fromcode);
+    *idx = rb_enc_find_index(tocode);
 
-    if (cd == (iconv_t)-1) {
+    if (toopt) {
+	toenc = rb_str_plus(to, toopt);
+	tocode = RSTRING_PTR(toenc);
+    }
+    if (fromopt) {
+	fromenc = rb_str_plus(from, fromopt);
+	fromcode = RSTRING_PTR(fromenc);
+    }
+    while ((cd = iconv_open(tocode, fromcode)) == (iconv_t)-1) {
+	int inval = 0;
 	switch (errno) {
 	  case EMFILE:
 	  case ENFILE:
 	  case ENOMEM:
-	    rb_gc();
-	    cd = iconv_open(tocode, fromcode);
+	    if (!retry++) {
+		rb_gc();
+		continue;
+	    }
+	    break;
+	  case EINVAL:
+	    retry = 0;
+	    inval = 1;
+	    if (toenc) {
+		tocode = RSTRING_PTR(to);
+		rb_str_resize(toenc, 0);
+		toenc = 0;
+		continue;
+	    }
+	    if (fromenc) {
+		fromcode = RSTRING_PTR(from);
+		rb_str_resize(fromenc, 0);
+		fromenc = 0;
+		continue;
+	    }
+	    break;
 	}
-	if (cd == (iconv_t)-1) {
-	    int inval = errno == EINVAL;
+	{
 	    const char *s = inval ? "invalid encoding " : "iconv";
-	    volatile VALUE msg = rb_str_new(0, strlen(s) + RSTRING(to)->len +
-					    RSTRING(from)->len + 8);
-
-	    sprintf(RSTRING(msg)->ptr, "%s(\"%s\", \"%s\")",
-		    s, RSTRING(to)->ptr, RSTRING(from)->ptr);
-	    s = RSTRING(msg)->ptr;
-	    RSTRING(msg)->len = strlen(s);
-	    if (!inval) rb_sys_fail(s);
+	    VALUE msg = rb_sprintf("%s(\"%s\", \"%s\")",
+				   s, RSTRING_PTR(to), RSTRING_PTR(from));
+	    if (!inval) rb_sys_fail_str(msg);
 	    rb_exc_raise(iconv_fail(rb_eIconvInvalidEncoding, Qnil,
-				    rb_ary_new3(2, to, from), NULL, s));
+				    rb_ary_new3(2, to, from), NULL, msg));
+	}
+    }
+
+    if (toopt || fromopt) {
+	if (toopt && fromopt && RTEST(rb_str_equal(toopt, fromopt))) {
+	    fromopt = 0;
+	}
+	if (toopt && fromopt) {
+	    rb_warning("encoding option isn't portable: %s, %s",
+		       RSTRING_PTR(toopt) + 2, RSTRING_PTR(fromopt) + 2);
+	}
+	else {
+	    rb_warning("encoding option isn't portable: %s",
+		       (toopt ? RSTRING_PTR(toopt) : RSTRING_PTR(fromopt)) + 2);
+	}
+    }
+
+    if (opt) {
+#ifdef ICONV_SET_TRANSLITERATE
+	if (opt->transliterate != Qundef) {
+	    int flag = RTEST(opt->transliterate);
+	    rb_warning("encoding option isn't portable: transliterate");
+	    if (iconvctl(cd, ICONV_SET_TRANSLITERATE, (void *)&flag))
+		rb_sys_fail("ICONV_SET_TRANSLITERATE");
 	}
+#endif
+#ifdef ICONV_SET_DISCARD_ILSEQ
+	if (opt->discard_ilseq != Qundef) {
+	    int flag = RTEST(opt->discard_ilseq);
+	    rb_warning("encoding option isn't portable: discard_ilseq");
+	    if (iconvctl(cd, ICONV_SET_DISCARD_ILSEQ, (void *)&flag))
+		rb_sys_fail("ICONV_SET_DISCARD_ILSEQ");
+	}
+#endif
     }
 
     return cd;
 }
 
 static void
-iconv_dfree
-#ifdef HAVE_PROTOTYPES
-    (void *cd)
-#else /* HAVE_PROTOTYPES */
-    (cd)
-    void *cd;
-#endif /* HAVE_PROTOTYPES */
+iconv_dfree(void *cd)
 {
     iconv_close(VALUE2ICONV(cd));
 }
@@ -215,13 +299,7 @@ iconv_dfree
 #define ICONV_FREE iconv_dfree
 
 static VALUE
-iconv_free
-#ifdef HAVE_PROTOTYPES
-    (VALUE cd)
-#else /* HAVE_PROTOTYPES */
-    (cd)
-    VALUE cd;
-#endif /* HAVE_PROTOTYPES */
+iconv_free(VALUE cd)
 {
     if (cd && iconv_close(VALUE2ICONV(cd)) == -1)
 	rb_sys_fail("iconv_close");
@@ -229,13 +307,7 @@ iconv_free
 }
 
 static VALUE
-check_iconv
-#ifdef HAVE_PROTOTYPES
-    (VALUE obj)
-#else /* HAVE_PROTOTYPES */
-    (obj)
-    VALUE obj;
-#endif /* HAVE_PROTOTYPES */
+check_iconv(VALUE obj)
 {
     Check_Type(obj, T_DATA);
     if (RDATA(obj)->dfree != ICONV_FREE) {
@@ -245,17 +317,7 @@ check_iconv
 }
 
 static VALUE
-iconv_try
-#ifdef HAVE_PROTOTYPES
-    (iconv_t cd, const char **inptr, size_t *inlen, char **outptr, size_t *outlen)
-#else /* HAVE_PROTOTYPES */
-    (cd, inptr, inlen, outptr, outlen)
-    iconv_t cd;
-    const char **inptr;
-    size_t *inlen;
-    char **outptr;
-    size_t *outlen;
-#endif /* HAVE_PROTOTYPES */
+iconv_try(iconv_t cd, const char **inptr, size_t *inlen, char **outptr, size_t *outlen)
 {
 #ifdef ICONV_INPTR_CONST
 #define ICONV_INPTR_CAST
@@ -295,13 +357,8 @@ iconv_try
 
 #define FAILED_MAXLEN 16
 
-static VALUE iconv_failure_initialize
-#ifdef HAVE_PROTOTYPES
-    (VALUE error, VALUE mesg, VALUE success, VALUE failed)
-#else /* HAVE_PROTOTYPES */
-    (error, mesg, success, failed)
-    VALUE error, mesg, success, failed;
-#endif /* HAVE_PROTOTYPES */
+static VALUE
+iconv_failure_initialize(VALUE error, VALUE mesg, VALUE success, VALUE failed)
 {
     rb_call_super(1, &mesg);
     rb_ivar_set(error, rb_success, success);
@@ -310,22 +367,14 @@ static VALUE iconv_failure_initialize
 }
 
 static VALUE
-iconv_fail
-#ifdef HAVE_PROTOTYPES
-    (VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, const char *mesg)
-#else /* HAVE_PROTOTYPES */
-    (error, success, failed, env, mesg)
-    VALUE error, success, failed;
-    struct iconv_env_t *env;
-    const char *mesg;
-#endif /* HAVE_PROTOTYPES */
+iconv_fail(VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, VALUE mesg)
 {
     VALUE args[3];
 
-    if (mesg && *mesg) {
-	args[0] = rb_str_new2(mesg);
+    if (!NIL_P(mesg)) {
+	args[0] = mesg;
     }
-    else if (TYPE(failed) != T_STRING || RSTRING(failed)->len < FAILED_MAXLEN) {
+    else if (TYPE(failed) != T_STRING || RSTRING_LEN(failed) < FAILED_MAXLEN) {
 	args[0] = rb_inspect(failed);
     }
     else {
@@ -345,33 +394,23 @@ iconv_fail
 }
 
 static VALUE
-iconv_fail_retry(VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, const char *mesg)
+iconv_fail_retry(VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, VALUE mesg)
 {
     error = iconv_fail(error, success, failed, env, mesg);
     if (!rb_block_given_p()) rb_exc_raise(error);
-    ruby_errinfo = error;
+    rb_set_errinfo(error);
     return rb_yield(failed);
 }
 
 static VALUE
-rb_str_derive
-#ifdef HAVE_PROTOTYPES
-    (VALUE str, const char* ptr, int len)
-#else /* HAVE_PROTOTYPES */
-    (str, ptr, len)
-    VALUE str;
-    const char *ptr;
-    int len;
-#endif /* HAVE_PROTOTYPES */
+rb_str_derive(VALUE str, const char* ptr, long len)
 {
     VALUE ret;
 
     if (NIL_P(str))
 	return rb_str_new(ptr, len);
-    if (RSTRING(str)->ptr == ptr && RSTRING(str)->len == len)
-	return str;
-    if (RSTRING(str)->ptr + RSTRING(str)->len == ptr + len)
-	ret = rb_str_substr(str, ptr - RSTRING(str)->ptr, len);
+    if (RSTRING_PTR(str) + RSTRING_LEN(str) == ptr + len)
+	ret = rb_str_subseq(str, ptr - RSTRING_PTR(str), len);
     else
 	ret = rb_str_new(ptr, len);
     OBJ_INFECT(ret, str);
@@ -379,17 +418,7 @@ rb_str_derive
 }
 
 static VALUE
-iconv_convert
-#ifdef HAVE_PROTOTYPES
-    (iconv_t cd, VALUE str, long start, long length, struct iconv_env_t* env)
-#else /* HAVE_PROTOTYPES */
-    (cd, str, start, length, env)
-    iconv_t cd;
-    VALUE str;
-    long start;
-    long length;
-    struct iconv_env_t *env;
-#endif /* HAVE_PROTOTYPES */
+iconv_convert(iconv_t cd, VALUE str, long start, long length, int toidx, struct iconv_env_t* env)
 {
     VALUE ret = Qfalse;
     VALUE error = Qfalse;
@@ -413,9 +442,9 @@ iconv_convert
 	error = iconv_try(cd, &inptr, &inlen, &outptr, &outlen);
 	if (RTEST(error)) {
 	    unsigned int i;
-	    rescue = iconv_fail_retry(error, Qnil, Qnil, env, 0);
+	    rescue = iconv_fail_retry(error, Qnil, Qnil, env, Qnil);
 	    if (TYPE(rescue) == T_ARRAY) {
-		str = RARRAY(rescue)->len > 0 ? RARRAY(rescue)->ptr[0] : Qnil;
+		str = RARRAY_LEN(rescue) > 0 ? RARRAY_PTR(rescue)[0] : Qnil;
 	    }
 	    if (FIXNUM_P(str) && (i = FIX2INT(str)) <= 0xff) {
 		char c = i;
@@ -430,11 +459,11 @@ iconv_convert
 	length = 0;
     }
     else {
-	int slen;
+	long slen;
 
 	StringValue(str);
-	slen = RSTRING(str)->len;
-	inptr = RSTRING(str)->ptr;
+	slen = RSTRING_LEN(str);
+	inptr = RSTRING_PTR(str);
 
 	inptr += start;
 	if (length < 0 || length > start + slen)
@@ -444,23 +473,27 @@ iconv_convert
     inlen = length;
 
     do {
-	char errmsg[50];
+	VALUE errmsg = Qnil;
 	const char *tmpstart = inptr;
 	outptr = buffer;
 	outlen = sizeof(buffer);
 
-	errmsg[0] = 0;
 	error = iconv_try(cd, &inptr, &inlen, &outptr, &outlen);
 
-	if (0 <= outlen && outlen <= sizeof(buffer)) {
+	if (
+#if SIGNEDNESS_OF_SIZE_T < 0
+	    0 <= outlen &&
+#endif
+	    outlen <= sizeof(buffer)) {
 	    outlen = sizeof(buffer) - outlen;
 	    if (NIL_P(error) ||	/* something converted */
-		outlen > inptr - tmpstart || /* input can't contain output */
-		(outlen < inptr - tmpstart && inlen > 0) || /* something skipped */
+		outlen > (size_t)(inptr - tmpstart) || /* input can't contain output */
+		(outlen < (size_t)(inptr - tmpstart) && inlen > 0) || /* something skipped */
 		memcmp(buffer, tmpstart, outlen)) /* something differs */
 	    {
 		if (NIL_P(str)) {
 		    ret = rb_str_new(buffer, outlen);
+		    if (toidx >= 0) rb_enc_associate_index(ret, toidx);
 		}
 		else {
 		    if (ret) {
@@ -468,6 +501,7 @@ iconv_convert
 		    }
 		    else {
 			ret = rb_str_new(instart, tmpstart - instart);
+			if (toidx >= 0) rb_enc_associate_index(ret, toidx);
 			OBJ_INFECT(ret, str);
 		    }
 		    ret = rb_str_buf_cat(ret, buffer, outlen);
@@ -480,26 +514,29 @@ iconv_convert
 	}
 	else {
 	    /* Some iconv() have a bug, return *outlen out of range */
-	    sprintf(errmsg, "bug?(output length = %ld)", (long)(sizeof(buffer) - outlen));
+	    errmsg = rb_sprintf("bug?(output length = %ld)", (long)(sizeof(buffer) - outlen));
 	    error = rb_eIconvOutOfRange;
 	}
 
 	if (RTEST(error)) {
 	    long len = 0;
 
-	    if (!ret)
+	    if (!ret) {
 		ret = rb_str_derive(str, instart, inptr - instart);
-	    else if (inptr > instart)
+		if (toidx >= 0) rb_enc_associate_index(ret, toidx);
+	    }
+	    else if (inptr > instart) {
 		rb_str_cat(ret, instart, inptr - instart);
+	    }
 	    str = rb_str_derive(str, inptr, inlen);
 	    rescue = iconv_fail_retry(error, ret, str, env, errmsg);
 	    if (TYPE(rescue) == T_ARRAY) {
-		if ((len = RARRAY(rescue)->len) > 0)
-		    rb_str_concat(ret, RARRAY(rescue)->ptr[0]);
-		if (len > 1 && !NIL_P(str = RARRAY(rescue)->ptr[1])) {
+		if ((len = RARRAY_LEN(rescue)) > 0)
+		    rb_str_concat(ret, RARRAY_PTR(rescue)[0]);
+		if (len > 1 && !NIL_P(str = RARRAY_PTR(rescue)[1])) {
 		    StringValue(str);
-		    inlen = length = RSTRING(str)->len;
-		    instart = inptr = RSTRING(str)->ptr;
+		    inlen = length = RSTRING_LEN(str);
+		    instart = inptr = RSTRING_PTR(str);
 		    continue;
 		}
 	    }
@@ -510,36 +547,107 @@ iconv_convert
 	}
     } while (inlen > 0);
 
-    if (!ret)
+    if (!ret) {
 	ret = rb_str_derive(str, instart, inptr - instart);
-    else if (inptr > instart)
+	if (toidx >= 0) rb_enc_associate_index(ret, toidx);
+    }
+    else if (inptr > instart) {
 	rb_str_cat(ret, instart, inptr - instart);
+    }
     return ret;
 }
 
 static VALUE
-iconv_s_allocate
-#ifdef HAVE_PROTOTYPES
-    (VALUE klass)
-#else /* HAVE_PROTOTYPES */
-    (klass)
-    VALUE klass;
-#endif /* HAVE_PROTOTYPES */
+iconv_s_allocate(VALUE klass)
 {
     return Data_Wrap_Struct(klass, 0, ICONV_FREE, 0);
 }
 
+static VALUE
+get_iconv_opt_i(VALUE i, VALUE arg)
+{
+    VALUE name;
+#if defined ICONV_SET_TRANSLITERATE || defined ICONV_SET_DISCARD_ILSEQ
+    VALUE val;
+    struct rb_iconv_opt_t *opt = (struct rb_iconv_opt_t *)arg;
+#endif
+
+    i = rb_Array(i);
+    name = rb_ary_entry(i, 0);
+#if defined ICONV_SET_TRANSLITERATE || defined ICONV_SET_DISCARD_ILSEQ
+    val = rb_ary_entry(i, 1);
+#endif
+    do {
+	if (SYMBOL_P(name)) {
+	    ID id = SYM2ID(name);
+	    if (id == id_transliterate) {
+#ifdef ICONV_SET_TRANSLITERATE
+		opt->transliterate = val;
+#else
+		rb_notimplement();
+#endif
+		break;
+	    }
+	    if (id == id_discard_ilseq) {
+#ifdef ICONV_SET_DISCARD_ILSEQ
+		opt->discard_ilseq = val;
+#else
+		rb_notimplement();
+#endif
+		break;
+	    }
+	}
+	else {
+	    const char *s = StringValueCStr(name);
+	    if (strcmp(s, "transliterate") == 0) {
+#ifdef ICONV_SET_TRANSLITERATE
+		opt->transliterate = val;
+#else
+		rb_notimplement();
+#endif
+		break;
+	    }
+	    if (strcmp(s, "discard_ilseq") == 0) {
+#ifdef ICONV_SET_DISCARD_ILSEQ
+		opt->discard_ilseq = val;
+#else
+		rb_notimplement();
+#endif
+		break;
+	    }
+	}
+	name = rb_inspect(name);
+	rb_raise(rb_eArgError, "unknown option - %s", StringValueCStr(name));
+    } while (0);
+    return Qnil;
+}
+
+static void
+get_iconv_opt(struct rb_iconv_opt_t *opt, VALUE options)
+{
+    opt->transliterate = Qundef;
+    opt->discard_ilseq = Qundef;
+    if (!NIL_P(options)) {
+	rb_block_call(options, rb_intern("each"), 0, 0, get_iconv_opt_i, (VALUE)opt);
+    }
+}
+
+#define iconv_ctl(self, func, val) (\
+	iconvctl(VALUE2ICONV(check_iconv(self)), func, (void *)&(val)) ? \
+	rb_sys_fail(#func) : (void)0)
+
 /*
  * Document-method: new
- * call-seq: Iconv.new(to, from)
+ * call-seq: Iconv.new(to, from, [options])
  *
  * Creates new code converter from a coding-system designated with +from+
  * to another one designated with +to+.
- * 
+ *
  * === Parameters
  *
  * +to+::   encoding name for destination
  * +from+:: encoding name for source
+ * +options+:: options for converter
  *
  * === Exceptions
  *
@@ -548,19 +656,18 @@ iconv_s_allocate
  * SystemCallError:: if <tt>iconv_open(3)</tt> fails
  */
 static VALUE
-iconv_initialize
-#ifdef HAVE_PROTOTYPES
-    (VALUE self, VALUE to, VALUE from)
-#else /* HAVE_PROTOTYPES */
-    (self, to, from)
-    VALUE self;
-    VALUE to;
-    VALUE from;
-#endif /* HAVE_PROTOTYPES */
+iconv_initialize(int argc, VALUE *argv, VALUE self)
 {
+    VALUE to, from, options;
+    struct rb_iconv_opt_t opt;
+    int idx;
+
+    rb_scan_args(argc, argv, "21", &to, &from, &options);
+    get_iconv_opt(&opt, options);
     iconv_free(check_iconv(self));
     DATA_PTR(self) = NULL;
-    DATA_PTR(self) = (void *)ICONV2VALUE(iconv_create(to, from));
+    DATA_PTR(self) = (void *)ICONV2VALUE(iconv_create(to, from, &opt, &idx));
+    if (idx >= 0) ENCODING_SET(self, idx);
     return self;
 }
 
@@ -573,19 +680,19 @@ iconv_initialize
  * returned from the block.
  */
 static VALUE
-iconv_s_open
-#ifdef HAVE_PROTOTYPES
-    (VALUE self, VALUE to, VALUE from)
-#else /* HAVE_PROTOTYPES */
-    (self, to, from)
-    VALUE self;
-    VALUE to;
-    VALUE from;
-#endif /* HAVE_PROTOTYPES */
+iconv_s_open(int argc, VALUE *argv, VALUE self)
 {
-    VALUE cd = ICONV2VALUE(iconv_create(to, from));
+    VALUE to, from, options, cd;
+    struct rb_iconv_opt_t opt;
+    int idx;
+
+    rb_scan_args(argc, argv, "21", &to, &from, &options);
+    get_iconv_opt(&opt, options);
+    cd = ICONV2VALUE(iconv_create(to, from, &opt, &idx));
 
     self = Data_Wrap_Struct(self, NULL, ICONV_FREE, (void *)cd);
+    if (idx >= 0) ENCODING_SET(self, idx);
+
     if (rb_block_given_p()) {
 	return rb_ensure(rb_yield, self, (VALUE(*)())iconv_finish, self);
     }
@@ -595,24 +702,19 @@ iconv_s_open
 }
 
 static VALUE
-iconv_s_convert
-#ifdef HAVE_PROTOTYPES
-    (struct iconv_env_t* env)
-#else /* HAVE_PROTOTYPES */
-    (env)
-    struct iconv_env_t *env;
-#endif /* HAVE_PROTOTYPES */
+iconv_s_convert(struct iconv_env_t* env)
 {
     VALUE last = 0;
 
     for (; env->argc > 0; --env->argc, ++env->argv) {
-	VALUE s = iconv_convert(env->cd, last = *(env->argv), 0, -1, env);
+	VALUE s = iconv_convert(env->cd, last = *(env->argv),
+				0, -1, env->toidx, env);
 	env->append(env->ret, s);
     }
 
     if (!NIL_P(last)) {
-	VALUE s = iconv_convert(env->cd, Qnil, 0, 0, env);
-	if (RSTRING(s)->len)
+	VALUE s = iconv_convert(env->cd, Qnil, 0, 0, env->toidx, env);
+	if (RSTRING_LEN(s))
 	    env->append(env->ret, s);
     }
 
@@ -638,15 +740,7 @@ iconv_s_convert
  * Exceptions thrown by Iconv.new, Iconv.open and Iconv#iconv.
  */
 static VALUE
-iconv_s_iconv
-#ifdef HAVE_PROTOTYPES
-    (int argc, VALUE *argv, VALUE self)
-#else /* HAVE_PROTOTYPES */
-    (argc, argv, self)
-    int argc;
-    VALUE *argv;
-    VALUE self;
-#endif /* HAVE_PROTOTYPES */
+iconv_s_iconv(int argc, VALUE *argv, VALUE self)
 {
     struct iconv_env_t arg;
 
@@ -657,7 +751,7 @@ iconv_s_iconv
     arg.argv = argv + 2;
     arg.append = rb_ary_push;
     arg.ret = rb_ary_new2(argc);
-    arg.cd = iconv_create(argv[0], argv[1]);
+    arg.cd = iconv_create(argv[0], argv[1], NULL, &arg.toidx);
     return rb_ensure(iconv_s_convert, (VALUE)&arg, iconv_free, ICONV2VALUE(arg.cd));
 }
 
@@ -670,13 +764,7 @@ iconv_s_iconv
  * See Iconv.iconv.
  */
 static VALUE
-iconv_s_conv
-#ifdef HAVE_PROTOTYPES
-    (VALUE self, VALUE to, VALUE from, VALUE str)
-#else /* HAVE_PROTOTYPES */
-    (self, to, from, str)
-    VALUE self, to, from, str;
-#endif /* HAVE_PROTOTYPES */
+iconv_s_conv(VALUE self, VALUE to, VALUE from, VALUE str)
 {
     struct iconv_env_t arg;
 
@@ -684,10 +772,94 @@ iconv_s_conv
     arg.argv = &str;
     arg.append = rb_str_append;
     arg.ret = rb_str_new(0, 0);
-    arg.cd = iconv_create(to, from);
+    arg.cd = iconv_create(to, from, NULL, &arg.toidx);
     return rb_ensure(iconv_s_convert, (VALUE)&arg, iconv_free, ICONV2VALUE(arg.cd));
 }
 
+/*
+ * Document-method: list
+ * call-seq: Iconv.list {|*aliases| ... }
+ *
+ * Iterates each alias sets.
+ */
+
+#ifdef HAVE_ICONVLIST
+struct iconv_name_list
+{
+    unsigned int namescount;
+    const char *const *names;
+    VALUE array;
+};
+
+static VALUE
+list_iconv_i(VALUE ptr)
+{
+    struct iconv_name_list *p = (struct iconv_name_list *)ptr;
+    unsigned int i, namescount = p->namescount;
+    const char *const *names = p->names;
+    VALUE ary = rb_ary_new2(namescount);
+
+    for (i = 0; i < namescount; i++) {
+	rb_ary_push(ary, rb_str_new2(names[i]));
+    }
+    if (p->array) {
+	return rb_ary_push(p->array, ary);
+    }
+    return rb_yield(ary);
+}
+
+static int
+list_iconv(unsigned int namescount, const char *const *names, void *data)
+{
+    int *state = data;
+    struct iconv_name_list list;
+
+    list.namescount = namescount;
+    list.names = names;
+    list.array = ((VALUE *)data)[1];
+    rb_protect(list_iconv_i, (VALUE)&list, state);
+    return *state;
+}
+#endif
+
+#if defined(HAVE_ICONVLIST) || defined(HAVE___ICONV_FREE_LIST)
+static VALUE
+iconv_s_list(void)
+{
+#ifdef HAVE_ICONVLIST
+    int state;
+    VALUE args[2];
+
+    args[1] = rb_block_given_p() ? 0 : rb_ary_new();
+    iconvlist(list_iconv, args);
+    state = *(int *)args;
+    if (state) rb_jump_tag(state);
+    if (args[1]) return args[1];
+#elif defined(HAVE___ICONV_FREE_LIST)
+    char **list;
+    size_t sz, i;
+    VALUE ary;
+
+    if (__iconv_get_list(&list, &sz)) return Qnil;
+
+    ary = rb_ary_new2(sz);
+    for (i = 0; i < sz; i++) {
+	rb_ary_push(ary, rb_str_new2(list[i]));
+    }
+    __iconv_free_list(list, sz);
+
+    if (!rb_block_given_p())
+	return ary;
+    for (i = 0; i < RARRAY_LEN(ary); i++) {
+	rb_yield(RARRAY_PTR(ary)[i]);
+    }
+#endif
+    return Qnil;
+}
+#else
+#define iconv_s_list rb_f_notimplement
+#endif
+
 /*
  * Document-method: close
  *
@@ -700,32 +872,20 @@ iconv_s_conv
  * its initial shift state.
  */
 static VALUE
-iconv_init_state
-#ifdef HAVE_PROTOTYPES
-    (VALUE cd)
-#else /* HAVE_PROTOTYPES */
-    (cd)
-    VALUE cd;
-#endif /* HAVE_PROTOTYPES */
+iconv_init_state(VALUE self)
 {
-    return iconv_convert(VALUE2ICONV(cd), Qnil, 0, 0, NULL);
+    iconv_t cd = VALUE2ICONV((VALUE)DATA_PTR(self));
+    DATA_PTR(self) = NULL;
+    return iconv_convert(cd, Qnil, 0, 0, ENCODING_GET(self), NULL);
 }
 
 static VALUE
-iconv_finish
-#ifdef HAVE_PROTOTYPES
-    (VALUE self)
-#else /* HAVE_PROTOTYPES */
-    (self)
-    VALUE self;
-#endif /* HAVE_PROTOTYPES */
+iconv_finish(VALUE self)
 {
     VALUE cd = check_iconv(self);
 
     if (!cd) return Qnil;
-    DATA_PTR(self) = NULL;
-
-    return rb_ensure(iconv_init_state, cd, iconv_free, cd);
+    return rb_ensure(iconv_init_state, self, iconv_free, cd);
 }
 
 /*
@@ -756,34 +916,186 @@ iconv_finish
  * See the Iconv documentation.
  */
 static VALUE
-iconv_iconv
-#ifdef HAVE_PROTOTYPES
-    (int argc, VALUE *argv, VALUE self)
-#else /* HAVE_PROTOTYPES */
-    (argc, argv, self)
-    int argc;
-    VALUE *argv;
-    VALUE self;
-#endif /* HAVE_PROTOTYPES */
+iconv_iconv(int argc, VALUE *argv, VALUE self)
 {
     VALUE str, n1, n2;
     VALUE cd = check_iconv(self);
     long start = 0, length = 0, slen = 0;
 
     rb_scan_args(argc, argv, "12", &str, &n1, &n2);
-    if (!NIL_P(str)) slen = RSTRING_LEN(StringValue(str));
+    if (!NIL_P(str)) {
+	VALUE n = rb_str_length(StringValue(str));
+	slen = NUM2LONG(n);
+    }
     if (argc != 2 || !RTEST(rb_range_beg_len(n1, &start, &length, slen, 0))) {
 	if (NIL_P(n1) || ((start = NUM2LONG(n1)) < 0 ? (start += slen) >= 0 : start < slen)) {
-	    if (NIL_P(n2)) {
-		length = -1;
-	    }
-	    else if ((length = NUM2LONG(n2)) >= slen - start) {
-		length = slen - start;
-	    }
+	    length = NIL_P(n2) ? -1 : NUM2LONG(n2);
+	}
+    }
+    if (start > 0 || length > 0) {
+	rb_encoding *enc = rb_enc_get(str);
+	const char *s = RSTRING_PTR(str), *e = s + RSTRING_LEN(str);
+	const char *ps = s;
+	if (start > 0) {
+	    start = (ps = rb_enc_nth(s, e, start, enc)) - s;
+	}
+	if (length > 0) {
+	    length = rb_enc_nth(ps, e, length, enc) - ps;
 	}
     }
 
-    return iconv_convert(VALUE2ICONV(cd), str, start, length, NULL);
+    return iconv_convert(VALUE2ICONV(cd), str, start, length, ENCODING_GET(self), NULL);
+}
+
+/*
+ * Document-method: conv
+ * call-seq: conv(str...)
+ *
+ * Equivalent to
+ *
+ *   iconv(nil, str..., nil).join
+ */
+static VALUE
+iconv_conv(int argc, VALUE *argv, VALUE self)
+{
+    iconv_t cd = VALUE2ICONV(check_iconv(self));
+    VALUE str, s;
+    int toidx = ENCODING_GET(self);
+
+    str = iconv_convert(cd, Qnil, 0, 0, toidx, NULL);
+    if (argc > 0) {
+	do {
+	    s = iconv_convert(cd, *argv++, 0, -1, toidx, NULL);
+	    if (RSTRING_LEN(s))
+		rb_str_buf_append(str, s);
+	} while (--argc);
+	s = iconv_convert(cd, Qnil, 0, 0, toidx, NULL);
+	if (RSTRING_LEN(s))
+	    rb_str_buf_append(str, s);
+    }
+
+    return str;
+}
+
+#ifdef ICONV_TRIVIALP
+/*
+ * Document-method: trivial?
+ * call-seq: trivial?
+ *
+ * Returns trivial flag.
+ */
+static VALUE
+iconv_trivialp(VALUE self)
+{
+    int trivial = 0;
+    iconv_ctl(self, ICONV_TRIVIALP, trivial);
+    if (trivial) return Qtrue;
+    return Qfalse;
+}
+#else
+#define iconv_trivialp rb_f_notimplement
+#endif
+
+#ifdef ICONV_GET_TRANSLITERATE
+/*
+ * Document-method: transliterate?
+ * call-seq: transliterate?
+ *
+ * Returns transliterate flag.
+ */
+static VALUE
+iconv_get_transliterate(VALUE self)
+{
+    int trans = 0;
+    iconv_ctl(self, ICONV_GET_TRANSLITERATE, trans);
+    if (trans) return Qtrue;
+    return Qfalse;
+}
+#else
+#define iconv_get_transliterate rb_f_notimplement
+#endif
+
+#ifdef ICONV_SET_TRANSLITERATE
+/*
+ * Document-method: transliterate=
+ * call-seq: cd.transliterate = flag
+ *
+ * Sets transliterate flag.
+ */
+static VALUE
+iconv_set_transliterate(VALUE self, VALUE transliterate)
+{
+    int trans = RTEST(transliterate);
+    iconv_ctl(self, ICONV_SET_TRANSLITERATE, trans);
+    return self;
+}
+#else
+#define iconv_set_transliterate rb_f_notimplement
+#endif
+
+#ifdef ICONV_GET_DISCARD_ILSEQ
+/*
+ * Document-method: discard_ilseq?
+ * call-seq: discard_ilseq?
+ *
+ * Returns discard_ilseq flag.
+ */
+static VALUE
+iconv_get_discard_ilseq(VALUE self)
+{
+    int dis = 0;
+    iconv_ctl(self, ICONV_GET_DISCARD_ILSEQ, dis);
+    if (dis) return Qtrue;
+    return Qfalse;
+}
+#else
+#define iconv_get_discard_ilseq rb_f_notimplement
+#endif
+
+#ifdef ICONV_SET_DISCARD_ILSEQ
+/*
+ * Document-method: discard_ilseq=
+ * call-seq: cd.discard_ilseq = flag
+ *
+ * Sets discard_ilseq flag.
+ */
+static VALUE
+iconv_set_discard_ilseq(VALUE self, VALUE discard_ilseq)
+{
+    int dis = RTEST(discard_ilseq);
+    iconv_ctl(self, ICONV_SET_DISCARD_ILSEQ, dis);
+    return self;
+}
+#else
+#define iconv_set_discard_ilseq rb_f_notimplement
+#endif
+
+/*
+ * Document-method: ctlmethods
+ * call-seq: Iconv.ctlmethods => array
+ *
+ * Returns available iconvctl() method list.
+ */
+static VALUE
+iconv_s_ctlmethods(VALUE klass)
+{
+    VALUE ary = rb_ary_new();
+#ifdef ICONV_TRIVIALP
+    rb_ary_push(ary, ID2SYM(rb_intern("trivial?")));
+#endif
+#ifdef ICONV_GET_TRANSLITERATE
+    rb_ary_push(ary, ID2SYM(rb_intern("transliterate?")));
+#endif
+#ifdef ICONV_SET_TRANSLITERATE
+    rb_ary_push(ary, ID2SYM(rb_intern("transliterate=")));
+#endif
+#ifdef ICONV_GET_DISCARD_ILSEQ
+    rb_ary_push(ary, ID2SYM(rb_intern("discard_ilseq?")));
+#endif
+#ifdef ICONV_SET_DISCARD_ILSEQ
+    rb_ary_push(ary, ID2SYM(rb_intern("discard_ilseq=")));
+#endif
+    return ary;
 }
 
 /*
@@ -802,13 +1114,7 @@ iconv_iconv
  *   failure and the last element is string on the way.
  */
 static VALUE
-iconv_failure_success
-#ifdef HAVE_PROTOTYPES
-(VALUE self)
-#else /* HAVE_PROTOTYPES */
-    (self)
-    VALUE self;
-#endif /* HAVE_PROTOTYPES */
+iconv_failure_success(VALUE self)
 {
     return rb_attr_get(self, rb_success);
 }
@@ -818,16 +1124,10 @@ iconv_failure_success
  * call-seq: failed
  *
  * Returns substring of the original string passed to Iconv that starts at the
- * character caused the exception. 
+ * character caused the exception.
  */
 static VALUE
-iconv_failure_failed
-#ifdef HAVE_PROTOTYPES
-(VALUE self)
-#else /* HAVE_PROTOTYPES */
-    (self)
-    VALUE self;
-#endif /* HAVE_PROTOTYPES */
+iconv_failure_failed(VALUE self)
 {
     return rb_attr_get(self, rb_failed);
 }
@@ -839,13 +1139,7 @@ iconv_failure_failed
  * Returns inspected string like as: #<_class_: _success_, _failed_>
  */
 static VALUE
-iconv_failure_inspect
-#ifdef HAVE_PROTOTYPES
-    (VALUE self)
-#else /* HAVE_PROTOTYPES */
-    (self)
-    VALUE self;
-#endif /* HAVE_PROTOTYPES */
+iconv_failure_inspect(VALUE self)
 {
     const char *cname = rb_class2name(CLASS_OF(self));
     VALUE success = rb_attr_get(self, rb_success);
@@ -860,13 +1154,13 @@ iconv_failure_inspect
 
 /*
  * Document-class: Iconv::InvalidEncoding
- * 
+ *
  * Requested coding-system is not available on this system.
  */
 
 /*
  * Document-class: Iconv::IllegalSequence
- * 
+ *
  * Input conversion stopped due to an input byte that does not belong to
  * the input codeset, or the output codeset does not contain the
  * character.
@@ -874,36 +1168,44 @@ iconv_failure_inspect
 
 /*
  * Document-class: Iconv::InvalidCharacter
- * 
+ *
  * Input conversion stopped due to an incomplete character or shift
  * sequence at the end of the input buffer.
  */
 
 /*
  * Document-class: Iconv::OutOfRange
- * 
+ *
  * Iconv library internal error.  Must not occur.
  */
 
 /*
  * Document-class: Iconv::BrokenLibrary
- * 
+ *
  * Detected a bug of underlying iconv(3) libray.
  * * returns an error without setting errno properly
  */
 
 void
-Init_iconv _((void))
+Init_iconv(void)
 {
     VALUE rb_cIconv = rb_define_class("Iconv", rb_cData);
 
     rb_define_alloc_func(rb_cIconv, iconv_s_allocate);
-    rb_define_singleton_method(rb_cIconv, "open", iconv_s_open, 2);
+    rb_define_singleton_method(rb_cIconv, "open", iconv_s_open, -1);
     rb_define_singleton_method(rb_cIconv, "iconv", iconv_s_iconv, -1);
     rb_define_singleton_method(rb_cIconv, "conv", iconv_s_conv, 3);
-    rb_define_method(rb_cIconv, "initialize", iconv_initialize, 2);
+    rb_define_singleton_method(rb_cIconv, "list", iconv_s_list, 0);
+    rb_define_singleton_method(rb_cIconv, "ctlmethods", iconv_s_ctlmethods, 0);
+    rb_define_method(rb_cIconv, "initialize", iconv_initialize, -1);
     rb_define_method(rb_cIconv, "close", iconv_finish, 0);
     rb_define_method(rb_cIconv, "iconv", iconv_iconv, -1);
+    rb_define_method(rb_cIconv, "conv", iconv_conv, -1);
+    rb_define_method(rb_cIconv, "trivial?", iconv_trivialp, 0);
+    rb_define_method(rb_cIconv, "transliterate?", iconv_get_transliterate, 0);
+    rb_define_method(rb_cIconv, "transliterate=", iconv_set_transliterate, 1);
+    rb_define_method(rb_cIconv, "discard_ilseq?", iconv_get_discard_ilseq, 0);
+    rb_define_method(rb_cIconv, "discard_ilseq=", iconv_set_discard_ilseq, 1);
 
     rb_eIconvFailure = rb_define_module_under(rb_cIconv, "Failure");
     rb_define_method(rb_eIconvFailure, "initialize", iconv_failure_initialize, 3);
@@ -924,8 +1226,11 @@ Init_iconv _((void))
 
     rb_success = rb_intern("success");
     rb_failed = rb_intern("failed");
+    id_transliterate = rb_intern("transliterate");
+    id_discard_ilseq = rb_intern("discard_ilseq");
 
     rb_gc_register_address(&charset_map);
     charset_map = rb_hash_new();
     rb_define_singleton_method(rb_cIconv, "charset_map", charset_map_get, 0);
 }
+