icu4r_19 1.0

data/collator.c

@@ -0,0 +1,233 @@
+#include "icu_common.h"
+extern VALUE rb_cUString;
+extern VALUE rb_cUCollator;
+extern int icu_collator_cmp (UCollator * collator, VALUE str1, VALUE str2) ;
+
+/**
+ * Document-class: UCollator
+ *
+ * API for UCollator performs locale-sensitive string comparison. You use this service to build searching and 
+ * sorting routines for natural language text.
+ * 
+ * Attributes that collation service understands:
+ * 
+ *     UCOL_FRENCH_COLLATION    Attribute for direction of secondary weights - used in French. UCOL_ON, UCOL_OFF
+ *     
+ *     UCOL_ALTERNATE_HANDLING  Attribute for handling variable elements. UCOL_NON_IGNORABLE (default), UCOL_SHIFTED 
+ *     
+ *     UCOL_CASE_FIRST          Controls the ordering of upper and lower case letters. 
+ *                              UCOL_OFF (default),  UCOL_UPPER_FIRST, UCOL_LOWER_FIRST
+ *     
+ *     UCOL_CASE_LEVEL          Controls whether an extra case level (positioned before the third level) is 
+ *                              generated or not. UCOL_OFF (default), UCOL_ON
+ *                              
+ *     UCOL_NORMALIZATION_MODE  Controls whether the normalization check and necessary normalizations are performed.  
+ *                              When set to UCOL_ON, an incremental check is performed to see whether the input data 
+ *                              is in the FCD form. If the data is not in the FCD form, incremental NFD normalization 
+ *                              is performed.
+ *                              
+ *     UCOL_DECOMPOSITION_MODE  An alias for UCOL_NORMALIZATION_MODE attribute
+ *     
+ *     UCOL_STRENGTH            The strength attribute. 
+ *                              Can be either UCOL_PRIMARY, UCOL_SECONDARY, UCOL_TERTIARY, UCOL_QUATERNARY, UCOL_IDENTICAL. 
+ *                              The usual strength for most locales (except Japanese) is tertiary. 
+ *    
+ *     UCOL_HIRAGANA_QUATERNARY_MODE  when turned on, this attribute positions Hiragana before all non-ignorables on 
+ *                                    quaternary level This is a sneaky way to produce JIS sort order
+ *     UCOL_NUMERIC_COLLATION   when turned on, this attribute generates a collation key for the numeric value of 
+ *                              substrings of digits. This is a way to get '100' to sort AFTER '2'. 
+ *                          
+ * Attribute values:
+ * 
+ *      UCOL_DEFAULT           accepted by most attributes
+ *      UCOL_PRIMARY           Primary collation strength
+ *      UCOL_SECONDARY         Secondary collation strength
+ *      UCOL_TERTIARY          Tertiary collation strength
+ *      UCOL_DEFAULT_STRENGTH  Default collation strength
+ *      UCOL_QUATERNARY        Quaternary collation strength
+ *      UCOL_IDENTICAL         Identical collation strength
+ *      UCOL_OFF               Turn the feature off - works for 
+ *                             UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, 
+ *                             UCOL_HIRAGANA_QUATERNARY_MODE & UCOL_DECOMPOSITION_MODE
+ *                             
+ *      UCOL_ON                Turn the feature on - works for UCOL_FRENCH_COLLATION, UCOL_CASE_LEVEL, 
+ *                             UCOL_HIRAGANA_QUATERNARY_MODE & UCOL_DECOMPOSITION_MODE
+ *                             
+ *      UCOL_SHIFTED           Valid for UCOL_ALTERNATE_HANDLING. Alternate handling will be shifted
+ *      UCOL_NON_IGNORABLE     Valid for UCOL_ALTERNATE_HANDLING. Alternate handling will be non ignorable
+ *      UCOL_LOWER_FIRST       Valid for UCOL_CASE_FIRST - lower case sorts before upper case
+ *      UCOL_UPPER_FIRST       upper case sorts before lower case
+ **/
+
+#define UCOLLATOR(obj) ((UCollator *)DATA_PTR(obj))
+ 
+void icu4r_col_free(UCollator * col)
+{
+    ucol_close(col);
+}
+static VALUE icu4r_col_alloc(VALUE klass)
+{
+    return Data_Wrap_Struct(klass, 0, icu4r_col_free, 0);
+}
+/**
+ * call-seq:
+ *       col = UCollator.new(locale = nil)
+ *       
+ * Open a UCollator for comparing strings for the given locale containing the required collation rules. 
+ * Special values for locales can be passed in - if +nil+ is passed for the locale, the default locale 
+ * collation rules will be used. If empty string ("") or "root" are passed, UCA rules will be used.
+ */
+VALUE icu4r_col_init(int argc, VALUE * argv, VALUE self)
+{
+    UCollator * col;
+    UErrorCode status = U_ZERO_ERROR;
+    VALUE  loc;
+    char * locale = NULL;
+	  if( rb_scan_args(argc, argv, "01", &loc)) 
+    {
+	     Check_Type(loc, T_STRING);
+       locale = RSTRING_PTR(loc);
+    }
+    col = ucol_open(locale,  &status);
+    ICU_RAISE(status);
+    DATA_PTR(self)=col;
+    return self;
+}
+
+/**
+ * call-seq:
+ *     collator.strength 
+ *
+ * Get the collation strength used in a UCollator. The strength influences how strings are compared.
+ **/
+VALUE icu4r_col_get_strength(VALUE self)
+{
+    return INT2NUM(ucol_getStrength(UCOLLATOR(self)));
+}
+
+/**
+ * call-seq:
+ *     collator.strength = new_strength
+ *
+ * Sets the collation strength used in a UCollator. The strength influences how strings are compared.
+ **/
+VALUE icu4r_col_set_strength(VALUE self, VALUE obj)
+{
+    Check_Type(obj, T_FIXNUM);
+    ucol_setStrength(UCOLLATOR(self), FIX2INT(obj));
+    return Qnil;
+}
+
+/**
+ * call-seq:
+ *     collator.get_attr(attribute)
+ *     collator[attribute]
+ *
+ * Universal attribute setter. See above for valid attributes and their values
+ **/
+VALUE icu4r_col_get_attr(VALUE self, VALUE obj)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    UColAttributeValue val;
+    Check_Type(obj, T_FIXNUM);
+    val = ucol_getAttribute(UCOLLATOR(self), FIX2INT(obj), &status);
+    ICU_RAISE(status);
+    return INT2FIX(val);
+}
+
+/**
+ * call-seq:
+ *     collator.set_attr(attribute, value)
+ *     collator[attribute]=value 
+ * 
+ * Universal attribute setter. See above for valid attributes and their values
+ **/
+VALUE icu4r_col_set_attr(VALUE self, VALUE obj, VALUE new_val)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    Check_Type(obj, T_FIXNUM);
+    Check_Type(new_val, T_FIXNUM);
+    ucol_setAttribute(UCOLLATOR(self), FIX2INT(obj), FIX2INT(new_val), &status);
+    ICU_RAISE(status);
+    return Qnil;
+}
+/**
+ * call-seq:
+ *     collator.strcoll(ustr1, ustr2)
+ *
+ * Compare two UString's. The strings will be compared using the options already specified.
+ **/
+VALUE icu4r_col_strcoll(VALUE self, VALUE str1, VALUE str2)
+{
+    Check_Class(str1, rb_cUString);
+    Check_Class(str2, rb_cUString);
+    return INT2FIX(icu_collator_cmp(UCOLLATOR(self), str1,  str2));
+}
+/**
+ * call-seq:
+ *     collator.sort_key(an_ustring) -> String
+ *
+ * Get a sort key for a string from a UCollator. Sort keys may be compared using strcmp.
+ **/
+VALUE icu4r_col_sort_key(VALUE self, VALUE str)
+{
+    int32_t needed , capa ;
+    unsigned char * buffer ; 
+    VALUE ret;
+    Check_Class(str, rb_cUString);
+    capa = ICU_LEN(str);
+    buffer = ALLOC_N(unsigned char, capa);
+    needed = ucol_getSortKey(UCOLLATOR(self), ICU_PTR(str), ICU_LEN(str), buffer, capa);
+    if(needed > capa){
+      REALLOC_N(buffer,unsigned char, needed);
+      needed = ucol_getSortKey(UCOLLATOR(self), ICU_PTR(str), ICU_LEN(str), buffer, needed);
+    }
+    ret = rb_str_new((char *)buffer, needed);
+    free(buffer);
+    return ret;
+}
+void initialize_collator()
+{
+  rb_cUCollator = rb_define_class("UCollator", rb_cObject);
+  rb_define_alloc_func(rb_cUCollator, icu4r_col_alloc);
+
+  rb_define_method(rb_cUCollator, "initialize", icu4r_col_init, -1);
+  rb_define_method(rb_cUCollator, "strength",  icu4r_col_get_strength, 0);
+  rb_define_method(rb_cUCollator, "strength=", icu4r_col_set_strength, 1);
+  rb_define_method(rb_cUCollator, "get_attr",  icu4r_col_get_attr, 1);
+  rb_define_alias(rb_cUCollator, "[]", "get_attr");
+  rb_define_method(rb_cUCollator, "set_attr",  icu4r_col_set_attr, 2);
+  rb_define_alias(rb_cUCollator, "[]=", "set_attr");
+  rb_define_method(rb_cUCollator, "strcoll", icu4r_col_strcoll, 2);
+  rb_define_method(rb_cUCollator, "sort_key",icu4r_col_sort_key, 1);
+  
+  /* attributes */
+  rb_define_const(rb_cUCollator, "UCOL_FRENCH_COLLATION", INT2FIX(UCOL_FRENCH_COLLATION));
+  rb_define_const(rb_cUCollator, "UCOL_ALTERNATE_HANDLING", INT2FIX(UCOL_ALTERNATE_HANDLING));
+  rb_define_const(rb_cUCollator, "UCOL_CASE_FIRST", INT2FIX(UCOL_CASE_FIRST)); 
+  rb_define_const(rb_cUCollator, "UCOL_CASE_LEVEL", INT2FIX(UCOL_CASE_LEVEL));
+  rb_define_const(rb_cUCollator, "UCOL_NORMALIZATION_MODE", INT2FIX(UCOL_NORMALIZATION_MODE)); 
+  rb_define_const(rb_cUCollator, "UCOL_DECOMPOSITION_MODE", INT2FIX(UCOL_DECOMPOSITION_MODE));
+  rb_define_const(rb_cUCollator, "UCOL_STRENGTH", INT2FIX(UCOL_STRENGTH));
+  rb_define_const(rb_cUCollator, "UCOL_HIRAGANA_QUATERNARY_MODE", INT2FIX(UCOL_HIRAGANA_QUATERNARY_MODE));
+  rb_define_const(rb_cUCollator, "UCOL_NUMERIC_COLLATION", INT2FIX(UCOL_NUMERIC_COLLATION));
+  rb_define_const(rb_cUCollator, "UCOL_ATTRIBUTE_COUNT", INT2FIX(UCOL_ATTRIBUTE_COUNT));
+
+  /* attribute values */
+  rb_define_const(rb_cUCollator, "UCOL_DEFAULT", INT2FIX(UCOL_DEFAULT));
+  rb_define_const(rb_cUCollator, "UCOL_PRIMARY", INT2FIX(UCOL_PRIMARY));
+  rb_define_const(rb_cUCollator, "UCOL_SECONDARY", INT2FIX(UCOL_SECONDARY));
+  rb_define_const(rb_cUCollator, "UCOL_TERTIARY", INT2FIX(UCOL_TERTIARY));
+  rb_define_const(rb_cUCollator, "UCOL_DEFAULT_STRENGTH", INT2FIX(UCOL_DEFAULT_STRENGTH));
+  rb_define_const(rb_cUCollator, "UCOL_CE_STRENGTH_LIMIT", INT2FIX(UCOL_CE_STRENGTH_LIMIT)); 
+  rb_define_const(rb_cUCollator, "UCOL_QUATERNARY", INT2FIX(UCOL_QUATERNARY));
+  rb_define_const(rb_cUCollator, "UCOL_IDENTICAL", INT2FIX(UCOL_IDENTICAL));
+  rb_define_const(rb_cUCollator, "UCOL_STRENGTH_LIMIT", INT2FIX(UCOL_STRENGTH_LIMIT)); 
+  rb_define_const(rb_cUCollator, "UCOL_OFF", INT2FIX(UCOL_OFF)); 
+  rb_define_const(rb_cUCollator, "UCOL_ON", INT2FIX(UCOL_ON));
+  rb_define_const(rb_cUCollator, "UCOL_SHIFTED", INT2FIX(UCOL_SHIFTED));
+  rb_define_const(rb_cUCollator, "UCOL_NON_IGNORABLE", INT2FIX(UCOL_NON_IGNORABLE));
+  rb_define_const(rb_cUCollator, "UCOL_LOWER_FIRST", INT2FIX(UCOL_LOWER_FIRST));
+  rb_define_const(rb_cUCollator, "UCOL_UPPER_FIRST", INT2FIX(UCOL_UPPER_FIRST));
+  
+}

data/converter.c

@@ -0,0 +1,322 @@
+#include "icu_common.h"
+extern VALUE rb_cUString;
+extern VALUE icu_ustr_new_set(UChar * ptr, long len, long capa);
+extern VALUE rb_cUConverter;
+
+#define UCONVERTER(obj) ((UConverter *)DATA_PTR(obj))
+ 
+static void icu4r_cnv_free(UConverter * conv)
+{
+    ucnv_close(conv);
+}
+static VALUE icu4r_cnv_alloc(VALUE klass)
+{
+    return Data_Wrap_Struct(klass, 0, icu4r_cnv_free, 0);
+}
+
+
+/**
+ * call-seq:
+ *       conv = UConverter.new(name)
+ *
+ * Creates new converter, by given name. Name must be a Ruby String and may contain
+ * additional options, e.g.:
+ * 
+ *        "SCSU,locale=ja"    # Converter option for specifying a locale
+ *        "UTF-7,version=1"   # Converter option for specifying a version selector (0..9) for some converters.
+ *        "ibm-1047,swaplfnl" # Converter option for EBCDIC SBCS or mixed-SBCS/DBCS (stateful) codepages.
+ *
+ * To get list of available converters call UConverter.list_available
+ */
+VALUE icu4r_cnv_init(VALUE self, VALUE name)
+{
+    UConverter * converter;
+    UErrorCode status = U_ZERO_ERROR;
+    
+    Check_Type(name, T_STRING);
+    converter = ucnv_open(RSTRING_PTR(name),  &status);
+    ICU_RAISE(status);
+    DATA_PTR(self) = converter;
+    return self;
+} 
+/**
+ * call-seq:
+ *     UConverter.list_available # => Array
+ *
+ *  Returns the names of available converters.
+ */
+VALUE icu4r_cnv_list(VALUE self) 
+{
+    VALUE ret ;
+    int32_t count, i;
+    count = ucnv_countAvailable();
+    ret = rb_ary_new2(count);
+    for( i = 0; i < count ; i++)
+    {
+       rb_ary_store(ret, i, rb_str_new2(ucnv_getAvailableName(i)));
+    }
+    return ret;
+}
+
+/**
+ * call-seq:
+ *     converter.subst_chars
+ *
+ * Returns substitution characters as multiple bytes
+ */
+VALUE icu4r_cnv_get_subst_chars(VALUE self)
+{
+    char buf[16];
+    int8_t len = 16;
+    UErrorCode status = U_ZERO_ERROR;
+    ucnv_getSubstChars(UCONVERTER(self), buf, &len, &status);
+    ICU_RAISE(status);
+    return rb_str_new(buf, len);
+}
+
+/**
+ * call-seq:
+ *     converter.subst_chars=chars
+ *
+ * Sets the substitution chars when converting from unicode to a codepage.
+ * The substitution is specified as a string of 1-4 bytes
+ */
+VALUE icu4r_cnv_set_subst_chars(VALUE self, VALUE str)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    Check_Type(str, T_STRING);
+    ucnv_setSubstChars(UCONVERTER(self), RSTRING_PTR(str), RSTRING_LEN(str), &status);
+    ICU_RAISE(status);
+    return Qnil;
+}
+
+/**
+ * call-seq:
+ *     conv.name
+ * 
+ * Gets the internal, canonical name of the converter. 
+ */
+VALUE icu4r_cnv_name(VALUE self)
+{
+    UConverter * cnv = UCONVERTER(self);
+    UErrorCode status = U_ZERO_ERROR;
+    return rb_str_new2(ucnv_getName(cnv, &status));
+}
+
+/**
+ * call-seq:
+ *     converter.reset
+ *
+ * Resets the state of a converter to the default state.  
+ * This is used in the case of an error, to restart a conversion from a known default state.
+ * It will also empty the internal output buffers.
+ */
+VALUE icu4r_cnv_reset(VALUE self)
+{
+    UConverter * cnv = UCONVERTER(self);
+    ucnv_reset(cnv);
+    return Qnil;
+} 
+
+/** 
+ * call-seq:
+ *     conv.from_u(ustring) -> String 
+ *
+ * Convert the Unicode string into a codepage string using an existing UConverter.
+ */
+VALUE icu4r_cnv_from_unicode(VALUE self, VALUE str)
+{
+    UConverter * conv = UCONVERTER(self);
+    UErrorCode status = U_ZERO_ERROR;
+    int32_t enclen, capa;
+    char * buf;
+    VALUE s = Qnil;
+    Check_Class(str, rb_cUString);
+    capa = ICU_LEN(str) + 1;
+    buf = ALLOC_N(char, capa);
+    enclen = 	ucnv_fromUChars(conv, buf, capa-1, ICU_PTR(str), ICU_LEN(str), &status);
+    if (U_BUFFER_OVERFLOW_ERROR == status) {
+      REALLOC_N(buf, char, enclen + 1);
+      status = 0;
+      ucnv_fromUChars(conv, buf, enclen, ICU_PTR(str), ICU_LEN(str), &status);
+    }
+    if( U_FAILURE(status) ){
+      free(buf);
+      rb_raise(rb_eArgError, u_errorName(status));
+    }
+    s = rb_str_new(buf, enclen);
+    return s;
+}
+
+/**
+ * call-seq:
+ *     conv.to_u(string) -> UString 
+ *
+ * Convert the codepage string into a Unicode string using an existing UConverter.
+ */
+VALUE icu4r_cnv_to_unicode(VALUE self, VALUE str) 
+{
+    UConverter * conv = UCONVERTER(self);
+    UErrorCode status = U_ZERO_ERROR;
+    long len, capa;
+    VALUE s;
+    UChar * buf;
+    Check_Type(str, T_STRING);
+    capa = RSTRING_LEN(str) + 1;
+    buf = ALLOC_N(UChar, capa);
+    len = ucnv_toUChars(conv, buf, capa-1, RSTRING_PTR(str), RSTRING_LEN(str), &status);
+    if (U_BUFFER_OVERFLOW_ERROR == status) {
+	      capa = len+1;
+        REALLOC_N(buf, UChar, capa);
+        status = 0;
+        len = ucnv_toUChars(conv, buf, capa-1, RSTRING_PTR(str), RSTRING_LEN(str), &status);
+        if (U_FAILURE(status)) {
+          free(buf);
+          rb_raise(rb_eArgError, u_errorName(status));
+	      } 
+    }
+    s = icu_ustr_new_set(buf, len, capa);
+    return s;
+}
+
+#define BUF_SIZE 1024
+/**
+ * call-seq:
+ *     conv.convert(other_conv, string)
+ *
+ * Convert from one external charset to another using two existing UConverters,
+ * ignoring the location of errors.
+ */
+VALUE icu4r_cnv_convert_to(VALUE self, VALUE other, VALUE src) 
+{
+   UConverter * cnv, * other_cnv;
+   UErrorCode status = U_ZERO_ERROR;
+   UChar pivotBuffer[BUF_SIZE];
+   UChar *pivot, *pivot2;
+   char * target,buffer[BUF_SIZE], *target_limit;
+   const char * src_ptr, * src_end;
+   VALUE ret;
+   Check_Class(other, rb_cUConverter);
+   Check_Type(src, T_STRING);
+   pivot=pivot2=pivotBuffer;
+   cnv = UCONVERTER(self);
+   other_cnv = UCONVERTER(other);
+   src_ptr = RSTRING_PTR(src);
+   src_end = src_ptr + RSTRING_LEN(src);
+   ret = rb_str_new2("");
+   ucnv_reset(other_cnv);
+   ucnv_reset(cnv);
+   target_limit = buffer+BUF_SIZE;
+   do {
+     status = U_ZERO_ERROR;
+     target = buffer;
+     ucnv_convertEx( other_cnv, cnv, &target, target_limit,
+        &src_ptr, src_end, pivotBuffer, &pivot, &pivot2, pivotBuffer+BUF_SIZE, FALSE, TRUE, &status);
+
+     if(U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) {
+       ICU_RAISE(status);
+     }
+     rb_str_buf_cat(ret, buffer, (int32_t)(target-buffer));
+  } while (status == U_BUFFER_OVERFLOW_ERROR);
+  return ret;
+}
+
+/** 
+ * call-seq:
+ *     UConverter.convert(to_converter_name, from_converter_name, source) # => String
+ *
+ * Convert from one external charset to another.
+ * Internally, two converters are opened according to the name arguments, then the text is converted to and from using them.
+ */
+VALUE icu4r_cnv_convert(VALUE self, VALUE to_conv_name, VALUE from_conv_name, VALUE src)
+{
+     UErrorCode status = U_ZERO_ERROR;
+     char * target = NULL;
+     int32_t target_capa, len;
+     VALUE ret;
+     target_capa = ucnv_convert( RSTRING_PTR(to_conv_name), RSTRING_PTR(from_conv_name),
+                   target, 0,
+                   RSTRING_PTR(src), RSTRING_LEN(src), &status);
+     if(status == U_BUFFER_OVERFLOW_ERROR){
+        status = U_ZERO_ERROR;
+        target_capa += 1;
+        target = ALLOC_N(char, target_capa);
+        len = ucnv_convert( RSTRING_PTR(to_conv_name), RSTRING_PTR(from_conv_name),
+                   target, target_capa,
+                   RSTRING_PTR(src), RSTRING_LEN(src), &status);
+        if(U_FAILURE(status)){           
+          free(target);
+          ICU_RAISE(status);
+        }
+        ret = rb_str_new(target, len);
+        free(target);
+        return ret;
+     } else ICU_RAISE(status);
+     return rb_str_new2("");
+}
+/**
+ * call-seq:
+ *     UConverter.std_names(conv_name, std_name)
+ *
+ * Returns list of alias names for a given converter that are recognized by a standard; MIME and IANA are such standards
+ */
+VALUE icu4r_cnv_standard_names(VALUE self, VALUE cnv_name, VALUE std_name) 
+{
+	UEnumeration * name_list; 
+  UErrorCode status = U_ZERO_ERROR;
+	VALUE ret ;
+	char * name;
+	int32_t len;
+  Check_Type(cnv_name, T_STRING);
+  Check_Type(std_name, T_STRING);
+	name_list = ucnv_openStandardNames(RSTRING_PTR(cnv_name), RSTRING_PTR(std_name), &status);
+	ICU_RAISE(status);
+	ret = rb_ary_new();
+	while( (name = (char*)uenum_next(name_list, &len, &status))) {
+		rb_ary_push(ret, rb_str_new2(name));
+	}
+	uenum_close(name_list);
+	return ret;
+}
+
+/**
+ * call-seq:
+ *     UConverter.all_names
+ *
+ * Returns all of the canonical converter names, regardless of the ability to open each converter.
+ */
+VALUE icu4r_cnv_all_names(VALUE self) 
+{
+	UEnumeration * name_list; 
+  UErrorCode status = U_ZERO_ERROR;
+	VALUE ret ;
+	char * name;
+	int32_t len;
+	name_list = ucnv_openAllNames(&status);
+	ICU_RAISE(status);
+	ret = rb_ary_new();
+	while( (name = (char*)uenum_next(name_list, &len, &status))) {
+		rb_ary_push(ret, rb_str_new2(name));
+	}
+	uenum_close(name_list);
+	return ret;
+}
+void initialize_converter(void)
+{
+  rb_cUConverter = rb_define_class("UConverter", rb_cObject);
+  rb_define_alloc_func(rb_cUConverter, icu4r_cnv_alloc);
+  rb_define_method(rb_cUConverter, "initialize", icu4r_cnv_init, 1);
+
+  rb_define_method(rb_cUConverter, "to_u", icu4r_cnv_to_unicode, 1);
+  rb_define_method(rb_cUConverter, "from_u", icu4r_cnv_from_unicode, 1);
+  rb_define_method(rb_cUConverter, "reset", icu4r_cnv_reset, 0);
+  rb_define_method(rb_cUConverter, "name",  icu4r_cnv_name, 0);
+  rb_define_method(rb_cUConverter, "convert", icu4r_cnv_convert_to, 2);
+  rb_define_method(rb_cUConverter, "subst_chars=", icu4r_cnv_set_subst_chars, 1);
+  rb_define_method(rb_cUConverter, "subst_chars",  icu4r_cnv_get_subst_chars, 0);
+  rb_define_singleton_method(rb_cUConverter, "convert", icu4r_cnv_convert, 3);
+  rb_define_singleton_method(rb_cUConverter, "list_available", icu4r_cnv_list, 0); 
+  rb_define_singleton_method(rb_cUConverter, "std_names", icu4r_cnv_standard_names, 2);
+  rb_define_singleton_method(rb_cUConverter, "all_names", icu4r_cnv_all_names, 0);
+}
+