iconv 0.1

data/ext/iconv/charset_alias.rb

@@ -0,0 +1,104 @@
+#! /usr/bin/ruby
+# :stopdoc:
+require 'rbconfig'
+require 'optparse'
+
+# http://www.ctan.org/get/macros/texinfo/texinfo/gnulib/lib/config.charset
+# Tue, 25 Dec 2007 00:00:00 GMT
+
+OS = RbConfig::CONFIG["target_os"]
+SHELL = RbConfig::CONFIG['SHELL']
+
+class Hash::Ordered < Hash
+  def [](key)
+    val = super and val.last
+  end
+  def []=(key, val)
+    ary = fetch(key) {return super(key, [self.size, key, val])} and
+      ary << val
+  end
+  def sort
+    values.sort.collect {|i, *rest| rest}
+  end
+  def each(&block)
+    sort.each(&block)
+  end
+end
+
+def charset_alias(config_charset, mapfile, target = OS)
+  map = Hash::Ordered.new
+  comments = []
+  open(config_charset) do |input|
+    input.find {|line| /^case "\$os" in/ =~ line} or break
+    input.find {|line|
+      /^\s*([-\w\*]+(?:\s*\|\s*[-\w\*]+)*)(?=\))/ =~ line and
+      $&.split('|').any? {|pattern| File.fnmatch?(pattern.strip, target)}
+    } or break
+    input.find do |line|
+      case line
+      when /^\s*echo "(?:\$\w+\.)?([-\w*]+)\s+([-\w]+)"/
+        sys, can = $1, $2
+        can.downcase!
+        map[can] = sys
+        false
+      when /^\s*;;/
+        true
+      else
+        false
+      end
+    end
+  end
+  case target
+  when /linux|-gnu/
+    # map.delete('ascii')
+  when /cygwin|os2-emx/
+    # get rid of tilde/yen problem.
+    map['shift_jis'] = 'cp932'
+  end
+  st = Hash.new(0)
+  map = map.sort.collect do |can, *sys|
+    if sys.grep(/^en_us(?=.|$)/i) {break true} == true
+      noen = %r"^(?!en_us)\w+_\w+#{Regexp.new($')}$"i #"
+      sys.reject! {|s| noen =~ s}
+    end
+    sys = sys.first
+    st[sys] += 1
+    [can, sys]
+  end
+  st.delete_if {|sys, i| i == 1}.empty?
+  st.keys.each {|sys| st[sys] = nil}
+  st.default = nil
+  writer = proc do |f|
+    f.puts("require 'iconv.so'")
+    f.puts
+    f.puts(comments)
+    f.puts("class Iconv")
+    i = 0
+    map.each do |can, sys|
+      if s = st[sys]
+        sys = s
+      elsif st.key?(sys)
+        sys = (st[sys] = "sys#{i+=1}") + " = '#{sys}'.freeze"
+      else
+        sys = "'#{sys}'.freeze"
+      end
+      f.puts("  charset_map['#{can}'] = #{sys}")
+    end
+    f.puts("end")
+  end
+  if mapfile
+    open(mapfile, "w", &writer)
+  else
+    writer[STDOUT]
+  end
+end
+
+target = OS
+opt = nil
+ARGV.options do |opt2|
+  opt = opt2
+  opt.banner << " config.status map.rb"
+  opt.on("--target OS") {|t| target = t}
+  opt.parse! and (1..2) === ARGV.size
+end or abort opt.to_s
+charset_alias(ARGV[0], ARGV[1], target)

data/ext/iconv/extconf.rb

@@ -0,0 +1,51 @@
+require 'mkmf'
+
+dir_config("iconv")
+
+conf = File.exist?(File.join($srcdir, "config.charset"))
+conf = with_config("config-charset", enable_config("config-charset", conf))
+
+if have_func("iconv", "iconv.h") or
+    have_library("iconv", "iconv", "iconv.h")
+  if checking_for("const of iconv() 2nd argument") do
+      create_tmpsrc(cpp_include("iconv.h") + "---> iconv(cd,0,0,0,0) <---")
+      src = xpopen(cpp_command("")) {|f|f.read}
+      if !(func = src[/^--->\s*(\w+).*\s*<---/, 1])
+        Logging::message "iconv function name not found"
+        false
+      elsif !(second = src[%r"\b#{func}\s*\(.*?,(.*?),.*?\)\s*;"m, 1])
+        Logging::message "prototype for #{func}() not found"
+        false
+      else
+        Logging::message $&+"\n"
+        /\bconst\b/ =~ second
+      end
+    end
+    $defs.push('-DICONV_INPTR_CONST')
+  end
+  if conf
+    prefix = '$(srcdir)'
+    prefix =  $nmake ? "{#{prefix}}" : "#{prefix}/"
+    if $extout
+      wrapper = "$(RUBYARCHDIR)/iconv.rb"
+    else
+      wrapper = "./iconv.rb"
+      $INSTALLFILES = [[wrapper, "$(RUBYARCHDIR)"]]
+    end
+    if String === conf
+      require 'uri'
+      scheme = URI.parse(conf).scheme
+    else
+      conf = "$(srcdir)/config.charset"
+    end
+    $cleanfiles << wrapper
+  end
+  create_makefile("iconv")
+  if conf
+    open("Makefile", "a") do |mf|
+      mf.print("\nall: #{wrapper}\n\n#{wrapper}: #{prefix}charset_alias.rb")
+      mf.print(" ", conf) unless scheme
+      mf.print("\n\t$(RUBY) $(srcdir)/charset_alias.rb #{conf} $@\n")
+    end
+  end
+end

data/ext/iconv/iconv.c

@@ -0,0 +1,931 @@
+/* -*- mode:c; c-file-style:"ruby" -*- */
+/**********************************************************************
+
+  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
+  license (see the file COPYING).
+
+  Documentation by Yukihiro Matsumoto and Gavin Sinclair.
+
+**********************************************************************/
+
+#include "ruby.h"
+#include <errno.h>
+#include <iconv.h>
+#include <assert.h>
+#include "st.h"
+#include "intern.h"
+
+/*
+ * Document-class: Iconv
+ *
+ * == 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.
+ *
+ *      converted_text = Iconv.conv('iso-8859-15', 'utf-8', text)
+ *
+ * 2. Instantiate a new Iconv and use method Iconv#iconv.
+ *
+ *      cd = Iconv.new(to, from)
+ *      begin
+ *        input.each { |s| output << cd.iconv(s) }
+ *        output << cd.iconv(nil)                   # Don't forget this!
+ *      ensure
+ *        cd.close
+ *      end
+ *
+ * 3. Invoke Iconv.open with a block.
+ *
+ *      Iconv.open(to, from) do |cd|
+ *        input.each { |s| output << cd.iconv(s) }
+ *        output << cd.iconv(nil)
+ *      end
+ *
+ * 4. Shorthand for (3).
+ *
+ *      Iconv.iconv(to, from, *input.to_a)
+ */
+
+/* Invalid value for iconv_t is -1 but 0 for VALUE, I hope VALUE is
+   big enough to keep iconv_t */
+#define VALUE2ICONV(v) ((iconv_t)((VALUE)(v) ^ -1))
+#define ICONV2VALUE(c) ((VALUE)(c) ^ -1)
+
+struct iconv_env_t
+{
+    iconv_t cd;
+    int argc;
+    VALUE *argv;
+    VALUE ret;
+    VALUE (*append)_((VALUE, VALUE));
+};
+
+static VALUE rb_eIconvInvalidEncoding;
+static VALUE rb_eIconvFailure;
+static VALUE rb_eIconvIllegalSeq;
+static VALUE rb_eIconvInvalidChar;
+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_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 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 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_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 charset_map;
+
+/*
+ * Document-method: charset_map
+ * call-seq: Iconv.charset_map
+ *
+ * Returns the map from canonical name to system dependent name.
+ */
+static VALUE charset_map_get _((void))
+{
+    return charset_map;
+}
+
+static char *
+map_charset
+#ifdef HAVE_PROTOTYPES
+    (VALUE *code)
+#else /* HAVE_PROTOTYPES */
+    (code)
+    VALUE *code;
+#endif /* HAVE_PROTOTYPES */
+{
+    VALUE val = *code;
+
+    if (RHASH(charset_map)->tbl && RHASH(charset_map)->tbl->num_entries) {
+	VALUE key = rb_funcall2(val, rb_intern("downcase"), 0, 0);
+	StringValuePtr(key);
+	if (st_lookup(RHASH(charset_map)->tbl, key, &val)) {
+	    *code = val;
+	}
+    }
+    return StringValuePtr(*code);
+}
+
+NORETURN(static void rb_iconv_sys_fail(const char *s));
+static void
+rb_iconv_sys_fail(const char *s)
+{
+    if (errno == 0) {
+	rb_exc_raise(iconv_fail(rb_eIconvBrokenLibrary, Qnil, Qnil, NULL, s));
+    }
+    rb_sys_fail(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 */
+{
+    const char* tocode = map_charset(&to);
+    const char* fromcode = map_charset(&from);
+
+    iconv_t cd = iconv_open(tocode, fromcode);
+
+    if (cd == (iconv_t)-1) {
+	switch (errno) {
+	  case EMFILE:
+	  case ENFILE:
+	  case ENOMEM:
+	    rb_gc();
+	    cd = iconv_open(tocode, fromcode);
+	}
+	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);
+	    rb_exc_raise(iconv_fail(rb_eIconvInvalidEncoding, Qnil,
+				    rb_ary_new3(2, to, from), NULL, s));
+	}
+    }
+
+    return cd;
+}
+
+static void
+iconv_dfree
+#ifdef HAVE_PROTOTYPES
+    (void *cd)
+#else /* HAVE_PROTOTYPES */
+    (cd)
+    void *cd;
+#endif /* HAVE_PROTOTYPES */
+{
+    iconv_close(VALUE2ICONV(cd));
+}
+
+#define ICONV_FREE iconv_dfree
+
+static VALUE
+iconv_free
+#ifdef HAVE_PROTOTYPES
+    (VALUE cd)
+#else /* HAVE_PROTOTYPES */
+    (cd)
+    VALUE cd;
+#endif /* HAVE_PROTOTYPES */
+{
+    if (cd && iconv_close(VALUE2ICONV(cd)) == -1)
+	rb_sys_fail("iconv_close");
+    return Qnil;
+}
+
+static VALUE
+check_iconv
+#ifdef HAVE_PROTOTYPES
+    (VALUE obj)
+#else /* HAVE_PROTOTYPES */
+    (obj)
+    VALUE obj;
+#endif /* HAVE_PROTOTYPES */
+{
+    Check_Type(obj, T_DATA);
+    if (RDATA(obj)->dfree != ICONV_FREE) {
+	rb_raise(rb_eArgError, "Iconv expected (%s)", rb_class2name(CLASS_OF(obj)));
+    }
+    return (VALUE)DATA_PTR(obj);
+}
+
+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 */
+{
+#ifdef ICONV_INPTR_CONST
+#define ICONV_INPTR_CAST
+#else
+#define ICONV_INPTR_CAST (char **)
+#endif
+    size_t ret;
+
+    errno = 0;
+    ret = iconv(cd, ICONV_INPTR_CAST inptr, inlen, outptr, outlen);
+    if (ret == (size_t)-1) {
+	if (!*inlen)
+	    return Qfalse;
+	switch (errno) {
+	  case E2BIG:
+	    /* try the left in next loop */
+	    break;
+	  case EILSEQ:
+	    return rb_eIconvIllegalSeq;
+	  case EINVAL:
+	    return rb_eIconvInvalidChar;
+	  case 0:
+	    return rb_eIconvBrokenLibrary;
+	  default:
+	    rb_sys_fail("iconv");
+	}
+    }
+    else if (*inlen > 0) {
+	/* something goes wrong */
+	return rb_eIconvIllegalSeq;
+    }
+    else if (ret) {
+	return Qnil;		/* conversion */
+    }
+    return Qfalse;
+}
+
+#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 */
+{
+    rb_call_super(1, &mesg);
+    rb_ivar_set(error, rb_success, success);
+    rb_ivar_set(error, rb_failed, failed);
+    return error;
+}
+
+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 */
+{
+    VALUE args[3];
+
+    if (mesg && *mesg) {
+	args[0] = rb_str_new2(mesg);
+    }
+    else if (TYPE(failed) != T_STRING || RSTRING(failed)->len < FAILED_MAXLEN) {
+	args[0] = rb_inspect(failed);
+    }
+    else {
+	args[0] = rb_inspect(rb_str_substr(failed, 0, FAILED_MAXLEN));
+	rb_str_cat2(args[0], "...");
+    }
+    args[1] = success;
+    args[2] = failed;
+    if (env) {
+	args[1] = env->append(rb_obj_dup(env->ret), success);
+	if (env->argc > 0) {
+	    *(env->argv) = failed;
+	    args[2] = rb_ary_new4(env->argc, env->argv);
+	}
+    }
+    return rb_class_new_instance(3, args, error);
+}
+
+static VALUE
+iconv_fail_retry(VALUE error, VALUE success, VALUE failed, struct iconv_env_t* env, const char *mesg)
+{
+    error = iconv_fail(error, success, failed, env, mesg);
+    if (!rb_block_given_p()) rb_exc_raise(error);
+    ruby_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 */
+{
+    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);
+    else
+	ret = rb_str_new(ptr, len);
+    OBJ_INFECT(ret, str);
+    return ret;
+}
+
+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 */
+{
+    VALUE ret = Qfalse;
+    VALUE error = Qfalse;
+    VALUE rescue;
+    const char *inptr, *instart;
+    size_t inlen;
+    /* I believe ONE CHARACTER never exceed this. */
+    char buffer[BUFSIZ];
+    char *outptr;
+    size_t outlen;
+
+    if (cd == (iconv_t)-1)
+	rb_raise(rb_eArgError, "closed iconv");
+
+    if (NIL_P(str)) {
+	/* Reset output pointer or something. */
+	inptr = "";
+	inlen = 0;
+	outptr = buffer;
+	outlen = sizeof(buffer);
+	error = iconv_try(cd, &inptr, &inlen, &outptr, &outlen);
+	if (RTEST(error)) {
+	    unsigned int i;
+	    rescue = iconv_fail_retry(error, Qnil, Qnil, env, 0);
+	    if (TYPE(rescue) == T_ARRAY) {
+		str = RARRAY(rescue)->len > 0 ? RARRAY(rescue)->ptr[0] : Qnil;
+	    }
+	    if (FIXNUM_P(str) && (i = FIX2INT(str)) <= 0xff) {
+		char c = i;
+		str = rb_str_new(&c, 1);
+	    }
+	    else if (!NIL_P(str)) {
+		StringValue(str);
+	    }
+	}
+
+	inptr = NULL;
+	length = 0;
+    }
+    else {
+	int slen;
+
+	StringValue(str);
+	slen = RSTRING(str)->len;
+	inptr = RSTRING(str)->ptr;
+
+	inptr += start;
+	if (length < 0 || length > start + slen)
+	    length = slen - start;
+    }
+    instart = inptr;
+    inlen = length;
+
+    do {
+	char errmsg[50];
+	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)) {
+	    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 */
+		memcmp(buffer, tmpstart, outlen)) /* something differs */
+	    {
+		if (NIL_P(str)) {
+		    ret = rb_str_new(buffer, outlen);
+		}
+		else {
+		    if (ret) {
+			ret = rb_str_buf_cat(ret, instart, tmpstart - instart);
+		    }
+		    else {
+			ret = rb_str_new(instart, tmpstart - instart);
+			OBJ_INFECT(ret, str);
+		    }
+		    ret = rb_str_buf_cat(ret, buffer, outlen);
+		    instart = inptr;
+		}
+	    }
+	    else if (!inlen) {
+		inptr = tmpstart + outlen;
+	    }
+	}
+	else {
+	    /* Some iconv() have a bug, return *outlen out of range */
+	    sprintf(errmsg, "bug?(output length = %ld)", (long)(sizeof(buffer) - outlen));
+	    error = rb_eIconvOutOfRange;
+	}
+
+	if (RTEST(error)) {
+	    long len = 0;
+
+	    if (!ret)
+		ret = rb_str_derive(str, instart, inptr - instart);
+	    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])) {
+		    StringValue(str);
+		    inlen = length = RSTRING(str)->len;
+		    instart = inptr = RSTRING(str)->ptr;
+		    continue;
+		}
+	    }
+	    else if (!NIL_P(rescue)) {
+		rb_str_concat(ret, rescue);
+	    }
+	    break;
+	}
+    } while (inlen > 0);
+
+    if (!ret)
+	ret = rb_str_derive(str, instart, inptr - instart);
+    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 */
+{
+    return Data_Wrap_Struct(klass, 0, ICONV_FREE, 0);
+}
+
+/*
+ * Document-method: new
+ * call-seq: Iconv.new(to, from)
+ *
+ * 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
+ *
+ * === Exceptions
+ *
+ * TypeError::       if +to+ or +from+ aren't String
+ * InvalidEncoding:: if designated converter couldn't find out
+ * 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_free(check_iconv(self));
+    DATA_PTR(self) = NULL;
+    DATA_PTR(self) = (void *)ICONV2VALUE(iconv_create(to, from));
+    return self;
+}
+
+/*
+ * Document-method: open
+ * call-seq: Iconv.open(to, from) { |iconv| ... }
+ *
+ * Equivalent to Iconv.new except that when it is called with a block, it
+ * yields with the new instance and closes it, and returns the result which
+ * 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 */
+{
+    VALUE cd = ICONV2VALUE(iconv_create(to, from));
+
+    self = Data_Wrap_Struct(self, NULL, ICONV_FREE, (void *)cd);
+    if (rb_block_given_p()) {
+	return rb_ensure(rb_yield, self, (VALUE(*)())iconv_finish, self);
+    }
+    else {
+	return self;
+    }
+}
+
+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 */
+{
+    VALUE last = 0;
+
+    for (; env->argc > 0; --env->argc, ++env->argv) {
+	VALUE s = iconv_convert(env->cd, last = *(env->argv), 0, -1, env);
+	env->append(env->ret, s);
+    }
+
+    if (!NIL_P(last)) {
+	VALUE s = iconv_convert(env->cd, Qnil, 0, 0, env);
+	if (RSTRING(s)->len)
+	    env->append(env->ret, s);
+    }
+
+    return env->ret;
+}
+
+/*
+ * Document-method: Iconv::iconv
+ * call-seq: Iconv.iconv(to, from, *strs)
+ *
+ * Shorthand for
+ *   Iconv.open(to, from) { |cd|
+ *     (strs + [nil]).collect { |s| cd.iconv(s) }
+ *   }
+ *
+ * === Parameters
+ *
+ * <tt>to, from</tt>:: see Iconv.new
+ * <tt>strs</tt>:: strings to be converted
+ *
+ * === Exceptions
+ *
+ * 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 */
+{
+    struct iconv_env_t arg;
+
+    if (argc < 2)		/* needs `to' and `from' arguments at least */
+	rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, 2);
+
+    arg.argc = argc -= 2;
+    arg.argv = argv + 2;
+    arg.append = rb_ary_push;
+    arg.ret = rb_ary_new2(argc);
+    arg.cd = iconv_create(argv[0], argv[1]);
+    return rb_ensure(iconv_s_convert, (VALUE)&arg, iconv_free, ICONV2VALUE(arg.cd));
+}
+
+/*
+ * Document-method: Iconv::conv
+ * call-seq: Iconv.conv(to, from, str)
+ *
+ * Shorthand for
+ *   Iconv.iconv(to, from, str).join
+ * 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 */
+{
+    struct iconv_env_t arg;
+
+    arg.argc = 1;
+    arg.argv = &str;
+    arg.append = rb_str_append;
+    arg.ret = rb_str_new(0, 0);
+    arg.cd = iconv_create(to, from);
+    return rb_ensure(iconv_s_convert, (VALUE)&arg, iconv_free, ICONV2VALUE(arg.cd));
+}
+
+/*
+ * Document-method: close
+ *
+ * Finishes conversion.
+ *
+ * After calling this, calling Iconv#iconv will cause an exception, but
+ * multiple calls of #close are guaranteed to end successfully.
+ *
+ * Returns a string containing the byte sequence to change the output buffer to
+ * its initial shift state.
+ */
+static VALUE
+iconv_init_state
+#ifdef HAVE_PROTOTYPES
+    (VALUE cd)
+#else /* HAVE_PROTOTYPES */
+    (cd)
+    VALUE cd;
+#endif /* HAVE_PROTOTYPES */
+{
+    return iconv_convert(VALUE2ICONV(cd), Qnil, 0, 0, NULL);
+}
+
+static VALUE
+iconv_finish
+#ifdef HAVE_PROTOTYPES
+    (VALUE self)
+#else /* HAVE_PROTOTYPES */
+    (self)
+    VALUE self;
+#endif /* HAVE_PROTOTYPES */
+{
+    VALUE cd = check_iconv(self);
+
+    if (!cd) return Qnil;
+    DATA_PTR(self) = NULL;
+
+    return rb_ensure(iconv_init_state, cd, iconv_free, cd);
+}
+
+/*
+ * Document-method: Iconv#iconv
+ * call-seq: iconv(str, start=0, length=-1)
+ *
+ * Converts string and returns the result.
+ * * If +str+ is a String, converts <tt>str[start, length]</tt> and returns the converted string.
+ * * If +str+ is +nil+, places converter itself into initial shift state and
+ *   just returns a string containing the byte sequence to change the output
+ *   buffer to its initial shift state.
+ * * Otherwise, raises an exception.
+ *
+ * === Parameters
+ *
+ * str::    string to be converted, or nil
+ * start::  starting offset
+ * length:: conversion length; nil or -1 means whole the string from start
+ *
+ * === Exceptions
+ *
+ * * IconvIllegalSequence
+ * * IconvInvalidCharacter
+ * * IconvOutOfRange
+ *
+ * === Examples
+ *
+ * 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 */
+{
+    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 (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;
+	    }
+	}
+    }
+
+    return iconv_convert(VALUE2ICONV(cd), str, start, length, NULL);
+}
+
+/*
+ * Document-class: Iconv::Failure
+ *
+ * Base attributes for Iconv exceptions.
+ */
+
+/*
+ * Document-method: success
+ * call-seq: success
+ *
+ * Returns string(s) translated successfully until the exception occurred.
+ * * In the case of failure occurred within Iconv.iconv, returned
+ *   value is an array of strings translated successfully preceding
+ *   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 */
+{
+    return rb_attr_get(self, rb_success);
+}
+
+/*
+ * Document-method: failed
+ * call-seq: failed
+ *
+ * Returns substring of the original string passed to Iconv that starts at the
+ * character caused the exception. 
+ */
+static VALUE
+iconv_failure_failed
+#ifdef HAVE_PROTOTYPES
+(VALUE self)
+#else /* HAVE_PROTOTYPES */
+    (self)
+    VALUE self;
+#endif /* HAVE_PROTOTYPES */
+{
+    return rb_attr_get(self, rb_failed);
+}
+
+/*
+ * Document-method: inspect
+ * call-seq: inspect
+ *
+ * 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 */
+{
+    const char *cname = rb_class2name(CLASS_OF(self));
+    VALUE success = rb_attr_get(self, rb_success);
+    VALUE failed = rb_attr_get(self, rb_failed);
+    VALUE str = rb_str_buf_cat2(rb_str_new2("#<"), cname);
+    str = rb_str_buf_cat(str, ": ", 2);
+    str = rb_str_buf_append(str, rb_inspect(success));
+    str = rb_str_buf_cat(str, ", ", 2);
+    str = rb_str_buf_append(str, rb_inspect(failed));
+    return rb_str_buf_cat(str, ">", 1);
+}
+
+/*
+ * 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.
+ */
+
+/*
+ * 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))
+{
+    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, "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_method(rb_cIconv, "close", iconv_finish, 0);
+    rb_define_method(rb_cIconv, "iconv", iconv_iconv, -1);
+
+    rb_eIconvFailure = rb_define_module_under(rb_cIconv, "Failure");
+    rb_define_method(rb_eIconvFailure, "initialize", iconv_failure_initialize, 3);
+    rb_define_method(rb_eIconvFailure, "success", iconv_failure_success, 0);
+    rb_define_method(rb_eIconvFailure, "failed", iconv_failure_failed, 0);
+    rb_define_method(rb_eIconvFailure, "inspect", iconv_failure_inspect, 0);
+
+    rb_eIconvInvalidEncoding = rb_define_class_under(rb_cIconv, "InvalidEncoding", rb_eArgError);
+    rb_eIconvIllegalSeq = rb_define_class_under(rb_cIconv, "IllegalSequence", rb_eArgError);
+    rb_eIconvInvalidChar = rb_define_class_under(rb_cIconv, "InvalidCharacter", rb_eArgError);
+    rb_eIconvOutOfRange = rb_define_class_under(rb_cIconv, "OutOfRange", rb_eRuntimeError);
+    rb_eIconvBrokenLibrary = rb_define_class_under(rb_cIconv, "BrokenLibrary", rb_eRuntimeError);
+    rb_include_module(rb_eIconvInvalidEncoding, rb_eIconvFailure);
+    rb_include_module(rb_eIconvIllegalSeq, rb_eIconvFailure);
+    rb_include_module(rb_eIconvInvalidChar, rb_eIconvFailure);
+    rb_include_module(rb_eIconvOutOfRange, rb_eIconvFailure);
+    rb_include_module(rb_eIconvBrokenLibrary, rb_eIconvFailure);
+
+    rb_success = rb_intern("success");
+    rb_failed = rb_intern("failed");
+
+    rb_gc_register_address(&charset_map);
+    charset_map = rb_hash_new();
+    rb_define_singleton_method(rb_cIconv, "charset_map", charset_map_get, 0);
+}

data/ext/iconv/mkwrapper.rb

@@ -0,0 +1,53 @@
+#! /usr/bin/ruby
+require 'rbconfig'
+require 'optparse'
+
+# http://www.ctan.org/get/macros/texinfo/texinfo/gnulib/lib/config.charset
+# Tue, 25 Dec 2007 00:00:00 GMT
+
+HEADER = <<SRC
+require 'iconv.so'
+
+class Iconv
+  case RUBY_PLATFORM
+SRC
+
+def charset_alias(config_charset, mapfile = nil)
+  found = nil
+  src = [HEADER]
+  open(config_charset) do |input|
+    input.find {|line| /^case "\$os" in/ =~ line} or return
+    input.each do |line|
+      case line
+      when /^\s*([-\w\*]+(?:\s*\|\s*[-\w\*]+)*)(?=\))/
+        (s = "  when ") << $&.split('|').collect {|targ|
+          targ.strip!
+          tail = targ.chomp!("*") ? '' : '\z'
+          head = targ.slice!(/\A\*/) ? '' : '\A'
+          targ.gsub!(/\*/, '.*')
+          "/#{head}#{targ}#{tail}/"
+        }.join(", ")
+        src << s
+        found = {}
+      when /^\s*echo "(?:\$\w+\.)?([-\w*]+)\s+([-\w]+)"/
+        sys, can = $1, $2
+        can.downcase!
+        unless found[can] or (/\Aen_(?!US\z)/ =~ sys && /\ACP437\z/i =~ can)
+          found[can] = true
+          src << "    charset_map['#{can}'] = '#{sys}'.freeze"
+        end
+      when /^\s*;;/
+        found = nil
+      end
+    end
+  end
+  src << "  end" << "end"
+  if mapfile
+    open(mapfile, "wb") {|f| f.puts(*src)}
+  else
+    puts(*src)
+  end
+end
+
+(1..2) === ARGV.size or abort "usage: #{$0} config_charset [mapfile]"
+charset_alias(*ARGV)

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: iconv
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Yukihiro Matsumoto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-19 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: If you're using bundler, and your OS doesn't have iconv for some reason (silly FreeBSD), you can install it with this gem!
+email: 
+executables: []
+
+extensions: 
+- ext/iconv/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/iconv/charset_alias.rb
+- ext/iconv/extconf.rb
+- ext/iconv/iconv.c
+- ext/iconv/mkwrapper.rb
+has_rdoc: true
+homepage: http://github.com/ruby/ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: iconv extension. The same as you can install with ruby
+test_files: []
+