icu4r 0.1.3.2006.01.26 → 0.1.4.2006.05.29

data/icu4r.c

@@ -3,6 +3,8 @@ extern void initialize_calendar(void);
 extern void initialize_uregexp(void);
 extern void initialize_ucore_ext(void);
 extern void initialize_ubundle(void);
+extern void initialize_converter(void);
+extern void initialize_collator(void);
 void Init_icu4r (void) {
 
  initialize_ustring();
@@ -10,5 +12,7 @@ void Init_icu4r (void) {
  initialize_ucore_ext();
  initialize_ubundle();
  initialize_calendar();
+ initialize_converter();
+ initialize_collator();
 
 }

data/icu_common.h

@@ -23,7 +23,7 @@ typedef struct {
     long len;
     long capa;
     UChar *ptr;
-    char busy;
+    unsigned char busy;
 } ICUString ;
 #define USTRING(obj) ((ICUString *)DATA_PTR(obj))
 #define UREGEX(obj)  ((ICURegexp *)DATA_PTR(obj))

data/test/test_calendar.rb

@@ -5,9 +5,9 @@ class UCalendarTest < Test::Unit::TestCase
 	
 	def test_time_zones
 		v = UCalendar.time_zones
-		assert_equal(v.size, 577)
-		assert_equal( UString, v[0].class)
-		assert_equal("ACT".u, v[0] )
+		assert_kind_of(Array, v)
+		assert_kind_of(UString, v[0])
+    assert(v.include?("Europe/Kiev".u))
 	end
 	
 	def test_default
@@ -15,7 +15,8 @@ class UCalendarTest < Test::Unit::TestCase
 		UCalendar.default_tz ="Europe/Paris".u
 		assert_equal( "Europe/Paris".u, UCalendar.default_tz)
 		c = UCalendar.new
-		assert_equal( "GMT+01:00".u, c.time_zone)
+    assert_equal( 3_600_000, c[:zone_offset])
+		# assert_equal( "GMT+01:00".u, c.time_zone("root")) # this should work also
 	end
 	
 	def test_dst
@@ -106,4 +107,17 @@ class UCalendarTest < Test::Unit::TestCase
 		assert(!c.eql?(d))
 		assert(c == d)
 	end
+	
+   def test_parse_date
+	UCalendar.default_tz="UTC".u
+        t1 = UCalendar.parse("HH:mm:ss E dd/MM/yyyy z".u, "en", "20:15:01 Fri 13/01/2006 GMT+00".u)
+	assert_equal(2006, t1[:year])
+	assert_equal(0, t1[:month])
+	assert_equal(13, t1[:date])
+	assert_equal(20, t1[:hour_of_day])
+	assert_equal(15, t1[:minute])
+	assert_equal(01, t1[:second])
+    end
+
+
 end

data/test/test_collator.rb

@@ -0,0 +1,33 @@
+require './icu4r'
+require 'test/unit'
+# these tests are ICU 3.4 dependent
+class UCollatorTest < Test::Unit::TestCase
+  def test_strength
+    c = UCollator.new("root")
+    assert_equal(0,  c.strcoll("a".u, "a".u))
+    assert_equal(1,  c.strcoll("A".u, "a".u))
+    c.strength = UCollator::UCOL_SECONDARY
+    assert_equal(0,  c.strcoll("A".u, "a".u))
+  end
+  
+  def test_attrs
+   c = UCollator.new("root")
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_ON
+   ar = %w(100 10 20 30 200 300).map {|a| a.to_u }.sort {|a,b| c.strcoll(a,b)}.map {|s| s.to_s }
+   assert_equal(["10", "20", "30", "100", "200", "300"], ar)
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_OFF
+   ar = %w(100 10 20 30 200 300).map {|a| a.to_u }.sort {|a,b| c.strcoll(a,b)}.map {|s| s.to_s }
+   assert_equal( ["10", "100", "20", "200", "30", "300"], ar)
+  end
+  
+  def test_sort_key
+   c = UCollator.new("root")
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_ON
+   ar = %w(100 10 20 30 200 300).sort_by {|a| c.sort_key(a.to_u) }
+   assert_equal(["10", "20", "30", "100", "200", "300"], ar)
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_OFF
+   ar = %w(100 10 20 30 200 300).sort_by {|a| c.sort_key(a.to_u) }
+   assert_equal( ["10", "100", "20", "200", "30", "300"], ar)
+  end
+
+end

data/test/test_converter.rb

@@ -0,0 +1,72 @@
+require './icu4r'
+require 'test/unit'
+# these tests are ICU 3.4 dependent
+class UConverterTest < Test::Unit::TestCase
+  
+  def test_a_new_and_name
+    c = UConverter.new("UTF8")
+    assert_kind_of( UConverter, c)
+    assert_equal('UTF-8', c.name)
+  end
+
+  def test_b_list_avail
+    a = UConverter.list_available
+    assert_kind_of(Array, a)
+    assert(a.include?("UTF-8"))
+  end
+  
+  def test_c_all_names
+    a = UConverter.all_names
+    assert_kind_of(Array, a)
+    assert(a.include?("UTF-8"))
+  end
+  
+  def test_d_std_names
+    a = UConverter.std_names("koi8r", "MIME")
+    assert_kind_of(Array, a)
+    assert(a.include?("KOI8-R"))
+    a = UConverter.std_names("cp1251", "IANA")
+    assert_kind_of(Array, a)
+    assert(a.include?("windows-1251"))
+  end
+
+  def test_e_convert_class_method
+    a_s = "\357\360\356\342\345\360\352\340 abcd" 
+    u_s = UConverter.convert("utf8", "cp1251", a_s)
+    assert_equal("проверка abcd", u_s)
+    r_s = UConverter.convert("cp1251", "utf8", u_s)
+    assert_equal(r_s, a_s)
+  end
+
+  def test_f_to_from_u
+    c = UConverter.new("cp1251")
+    a_s = "\357\360\356\342\345\360\352\340 abcd" 
+    u_s = c.to_u(a_s)
+    assert_kind_of(UString, u_s)
+    r_s = c.from_u(u_s)
+    assert_equal(r_s, a_s)
+  end
+
+  def test_g_convert_instance_method
+    c1 = UConverter.new("EUC-JP")
+    c2 = UConverter.new("Cp1251")
+    a_s = "\247\322\247\335\247\361!"
+    b_s = a_s * 1000
+    a1 = UConverter.convert("Cp1251", "EUC-JP", b_s)
+    a2 = c1.convert(c2,  b_s)
+    assert_equal(a1.size, a2.size)
+    assert_equal(a2.size, 4 * 1000)
+    assert_equal(a1, a2)
+    assert_equal("\341\353\377!", c1.convert(c2, a_s))
+  end
+
+  def test_h_subst_chars
+    c1 = UConverter.new("US-ASCII")
+    assert_kind_of(String, c1.subst_chars)
+    c1.subst_chars="!"
+    assert_equal( "I!t!rn!ti!n!liz!ti!n", c1.from_u("Iñtërnâtiônàlizætiøn".u))
+    c1.subst_chars=" "
+    assert_equal( "I t rn ti n liz ti n", c1.from_u("Iñtërnâtiônàlizætiøn".u))
+  end
+  
+end

data/test/test_ustring.rb

@@ -68,6 +68,19 @@ class UnicodeStringTest < Test::Unit::TestCase
    assert_equal( "hello".u.index('a'.u), nil)           
    assert_equal( "hello".u.index(ure('[aeiou]'), -3),  4)
    assert_equal( "hello".u.rindex(ure('[aeiou]'), -2), 1)
+    
+    assert_equal(1, S("hello").index(S("ell")))
+    assert_equal(2, S("hello").index(/ll./.U))
+
+    assert_equal(3, S("hello").index(S("l"), 3))
+    assert_equal(3, S("hello").index(/l./.U, 3))
+
+    assert_nil(S("hello").index(S("z"), 3))
+    assert_nil(S("hello").index(/z./.U, 3))
+
+    assert_nil(S("hello").index(S("z")))
+    assert_nil(S("hello").index(/z./.U))
+
  end
  
  def test_insert
@@ -245,12 +258,6 @@ class UnicodeStringTest < Test::Unit::TestCase
 	  assert_equal("Iñtërnâtiônàlizætiøn".u,v.norm_D.norm_KC)
     end
 
-    def test_parse_date
-      assert_equal(Time.local(2006,"jan",13,20,15,1), 
-        "HH:mm:ss E dd/MM/yyyy".u.parse_date("en", "20:15:01 Fri 13/01/2006".u))
-      assert_equal(Time.local(2006, "jan", 18, 0, 0), "d MMMM, yyyy".u.parse_date("ar_SY", "١٨ كانون الثاني, ٢٠٠٦".u))
-    end
-
     def test_scan
       a = "cruel world".u
       assert_equal(a.scan(/\w+/.U)        ,["cruel".u , "world".u ])
@@ -258,21 +265,32 @@ class UnicodeStringTest < Test::Unit::TestCase
       assert_equal(a.scan(/(...)/.U)      ,["cru".u , "el ".u , "wor".u ])
       assert_equal(a.scan(/(..)(..)/.U)   ,[["cr".u , "ue".u ], ["l ".u , "wo".u ]]	    )
     end
-
+    def S(str)
+      str.to_u
+    end
     def test_split
-	re = URegexp.new("[,:/]".u)
-	assert_equal(["split test".u ,  "west".u ,  "best".u ,  "east".u ], re.split("split test,west:best/east".u, nil))
-        assert_equal(["split test".u, "west:best/east".u], re.split("split test,west:best/east".u, 2))
+		  re = URegexp.new("[,:/]".u)
+		  assert_equal(["split test".u ,  "west".u ,  "best".u ,  "east".u ], re.split("split test,west:best/east".u, nil))
+      assert_equal(["split test".u, "west:best/east".u], re.split("split test,west:best/east".u, 2))
+      assert_equal([S("a"), S("b"), S("c")], S("a   b\t c").split(S("\\s+")))
+      assert_equal([S(" a "), S(" b "), S(" c ")], S(" a | b | c ").split(S("\\|")))
+      assert_equal([S("a"), S("b"), S("c")], S("aXXbXXcXX").split(/X./.U))
+      assert_equal([S("a|b|c")], S("a|b|c").split(S('\|'), 1))
+      assert_equal([S("a"), S("b|c")], S("a|b|c").split(S('\|'), 2))
+      assert_equal([S("a"), S("b"), S("c")], S("a|b|c").split(S('\|'), 3))
+      assert_equal([S("a"), S("b"), S("c")], S("a|b|c|").split(S('\|'), -1))
+      assert_equal([S("a"), S("b"), S("c"), S("") ], S("a|b|c||").split(S('\|'), -1))
+      assert_equal([S("a"), S(""), S("b"), S("c")], S("a||b|c|").split(S('\|'), -1))
     end
 
+
     def test_strcoll
     assert_equal(0,  UString::strcoll("a".u, "a".u))
-    assert_equal(0,  UString::strcoll("ой её".u, "ОИ ЕЕ".u, "ru", 0))
-    assert_equal(0,  UString::strcoll("ой её".u, "ОЙ ЕЁ".u, "ru", 1))
     assert_equal(-1, UString::strcoll("y".u, "k".u, "lv"))
     assert_equal(1,  UString::strcoll("я".u, "а".u))
     assert_equal(1,  UString::strcoll("я".u, "А".u, "ru"))
     assert_equal(0,  UString::strcoll("İSTANBUL".u, "istanbul".u, "tr", 0))
+    assert_equal(0,  UString::strcoll("ой её".u, "ОЙ ЕЁ".u, "ru", 1))
     end
 
     def test_gsub_block
@@ -378,4 +396,113 @@ class UnicodeStringTest < Test::Unit::TestCase
 		"\320\275\320\270\321\207\320\265\320\263\320\276 \320\275\320\265 \321\200\320\260\320\261\320\276\321\202\320\260\320\265\321\202 :( ?")
    end
 
+   def test_nested_blocks
+   	a = "Модифицируемые строки иногда напрягают :)".u
+	b = "".u
+   	assert_nothing_raised {
+		a.scan(/./.U) { |s|
+			b = a.gsub(ure('и')) { |m| 
+				t = m[0] + "".u
+				a.each_char { |c|
+			       		t << c if c == 'о' .u
+			   	}
+				t
+			}
+		}
+	}
+	assert_equal("Модиооофиоооциоооруемые строкиооо иоооногда напрягают :)".u, b)
+   end
+   
+  def test_AREF # '[]'
+    assert_equal(S("A"),  S("AooBar")[0])
+    assert_equal(S("B"),  S("FooBaB")[-1])
+    assert_equal(nil, S("FooBar")[6])
+    assert_equal(nil, S("FooBar")[-7])
+
+    assert_equal(S("Foo"), S("FooBar")[0,3])
+    assert_equal(S("Bar"), S("FooBar")[-3,3])
+    assert_equal(S(""),    S("FooBar")[6,2])
+    assert_equal(nil,      S("FooBar")[-7,10])
+
+    assert_equal(S("Foo"), S("FooBar")[0..2])
+    assert_equal(S("Foo"), S("FooBar")[0...3])
+    assert_equal(S("Bar"), S("FooBar")[-3..-1])
+    assert_equal(S(""),    S("FooBar")[6..2])
+    assert_equal(nil,      S("FooBar")[-10..-7])
+
+    assert_equal(S("Foo"), S("FooBar")[/^F../.U])
+    assert_equal(S("Bar"), S("FooBar")[/..r$/.U])
+    assert_equal(nil,      S("FooBar")[/xyzzy/.U])
+    assert_equal(nil,      S("FooBar")[/plugh/.U])
+
+    assert_equal(S("Foo"), S("FooBar")[S("Foo")])
+    assert_equal(S("Bar"), S("FooBar")[S("Bar")])
+    assert_equal(nil,      S("FooBar")[S("xyzzy")])
+    assert_equal(nil,      S("FooBar")[S("plugh")])
+
+      assert_equal(S("Foo"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, 1])
+      assert_equal(S("Bar"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, 2])
+      assert_equal(nil,      S("FooBar")[/([A-Z]..)([A-Z]..)/.U, 3])
+      assert_equal(S("Bar"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, -1])
+      assert_equal(S("Foo"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, -2])
+      assert_equal(nil,      S("FooBar")[ure("([A-Z]..)([A-Z]..)"), -3])
+  end
+  
+  def test_ASET # '[]='
+    s = S("FooBar")
+    s[0] = S('A')
+    assert_equal(S("AooBar"), s)
+
+    s[-1]= S('B')
+    assert_equal(S("AooBaB"), s)
+    assert_raise(IndexError) { s[-7] = S("xyz") }
+    assert_equal(S("AooBaB"), s)
+    s[0] = S("ABC")
+    assert_equal(S("ABCooBaB"), s)
+
+    s = S("FooBar")
+    s[0,3] = S("A")
+    assert_equal(S("ABar"),s)
+    s[0] = S("Foo")
+    assert_equal(S("FooBar"), s)
+    s[-3,3] = S("Foo")
+    assert_equal(S("FooFoo"), s)
+    assert_raise (IndexError) { s[7,3] =  S("Bar") }
+    assert_raise (IndexError) { s[-7,3] = S("Bar") }
+
+    s = S("FooBar")
+    s[0..2] = S("A")
+    assert_equal(S("ABar"), s)
+    s[1..3] = S("Foo")
+    assert_equal(S("AFoo"), s)
+    s[-4..-4] = S("Foo")
+    assert_equal(S("FooFoo"), s)
+    assert_raise (RangeError) { s[7..10]   = S("Bar") }
+    assert_raise (RangeError) { s[-7..-10] = S("Bar") }
+
+    s = S("FooBar")
+    s[/^F../.U]= S("Bar")
+    assert_equal(S("BarBar"), s)
+    s[/..r$/.U] = S("Foo")
+    assert_equal(S("BarFoo"), s)
+    
+      s[/([A-Z]..)([A-Z]..)/.U, 1] = S("Foo")
+      assert_equal(S("FooFoo"), s)
+      s[/([A-Z]..)([A-Z]..)/.U, 2] = S("Bar")
+      assert_equal(S("FooBar"), s)
+      assert_raise (IndexError) { s[/([A-Z]..)([A-Z]..)/.U, 3] = "None" }
+      s[ure("([A-Z]..)([A-Z]..)"), -1] = S("Foo")
+      assert_equal(S("FooFoo"), s)
+      s[/([A-Z]..)([A-Z]..)/.U, -2] = S("Bar")
+      assert_equal(S("BarFoo"), s)
+      #      assert_raise (IndexError) { s[/([A-Z]..)([A-Z]..)/.U, -3] = "None" }
+
+    s = S("FooBar")
+    s[S("Foo")] = S("Bar")
+    assert_equal(S("BarBar"), s)
+
+   s = S("a string")
+    s[0..s.size] = S("another string")
+    assert_equal(S("another string"), s)
+  end
 end

data/tools/doc.sh

@@ -1,2 +1,2 @@
 #!/bin/sh
-rdoc -T ./tools/km.rb -c utf-8 README docs/FORMATTING docs/UNICODE_REGEXPS *.c
+rdoc -T ./tools/km.rb -c utf-8 README docs/FORMATTING docs/UNICODE_REGEXPS *.c MIT-LICENSE

data/ubundle.c

@@ -170,13 +170,20 @@ VALUE icu_bundle_open_direct(klass, package, locale)
  *	URES_INT_VECTOR vectors of 32-bit integers.      Array of fixnums
  *
  */
-VALUE icu_bundle_aref( bundle, key)
-	VALUE bundle, key;
+VALUE icu_bundle_aref( argc, argv, bundle)
+	int argc;
+	VALUE *argv;
+	VALUE bundle;
 {
 	UErrorCode 	status = U_ZERO_ERROR;
 	UResourceBundle * res , * orig;
-	VALUE 		out;
-
+	VALUE 		out, tmp, locale_str;
+	VALUE		key, locale_flag = Qfalse;
+	int		return_locale = 0;
+	if( rb_scan_args(argc, argv, "11", &key, &locale_flag) )
+	{
+		if(Qtrue == locale_flag) return_locale = 1;
+	}
 	Check_Type(key, T_STRING);
 	orig = (UResourceBundle*)DATA_PTR(bundle);
 	
@@ -186,6 +193,13 @@ VALUE icu_bundle_aref( bundle, key)
 	 	rb_raise(rb_eArgError, u_errorName(status));
 	}
 	out = icu_bundle_read(res);
+	if( return_locale ) {
+		locale_str = rb_str_new2(ures_getLocale(res, &status));
+		tmp = rb_ary_new();
+		rb_ary_push(tmp, out);
+		rb_ary_push(tmp, locale_str);
+		out = tmp;
+	}
 	ures_close(res);
 	return out;
 }
@@ -202,7 +216,7 @@ VALUE icu_bundle_clone( bundle)
 }	
 void initialize_ubundle(void) { 
 	rb_cUResourceBundle = rb_define_class("UResourceBundle", rb_cObject);
-	rb_define_method(rb_cUResourceBundle, "[]", icu_bundle_aref, 1);
+	rb_define_method(rb_cUResourceBundle, "[]", icu_bundle_aref, -1);
 	rb_define_method(rb_cUResourceBundle, "clone", icu_bundle_clone, 0);
 	rb_define_singleton_method(rb_cUResourceBundle, "open", icu_bundle_open, 2);
 	rb_define_singleton_method(rb_cUResourceBundle, "open_direct", icu_bundle_open_direct, 2);

data/uregex.c

@@ -79,7 +79,7 @@ icu_reg_get_pattern(ptr, len)
      ICURegexp      *ptr;
      int32_t        *len;
 {
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
     *len = 0;
     return uregex_pattern(ptr->pattern, len, &error);
 }
@@ -206,28 +206,42 @@ icu_reg_split(self, str, limit)
 {
     VALUE splits;
     URegularExpression *theRegEx = UREGEX(self)->pattern;
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
     UChar * dest_buf, **dest_fields;
     int32_t limt, req_cap, total, i;
     Check_Class(str, rb_cUString);
     if (limit != Qnil)
 	Check_Type(limit, T_FIXNUM);
-    splits = rb_ary_new();
-    dest_buf = ALLOCA_N(UChar, USTRING(str)->len * 2);
-    dest_fields = ALLOCA_N(UChar *, USTRING(str)->len);
-    limt = limit == Qnil ? USTRING(str)->len : FIX2INT(limit);
+    dest_buf = ALLOC_N(UChar, USTRING(str)->len * 2 + 2);
+    limt = (limit == Qnil ? USTRING(str)->len + 1 : FIX2INT(limit));
+    dest_fields = ALLOC_N(UChar *, limt);
     uregex_setText(theRegEx, USTRING(str)->ptr, USTRING(str)->len, &error);
-    if (U_FAILURE(error))
+    if (U_FAILURE(error)) {
+	free(dest_buf);
+	free(dest_fields);
 	rb_raise(rb_eArgError, u_errorName(error));
+    }
     req_cap = 0;
     total =
 	uregex_split(theRegEx, dest_buf, USTRING(str)->len * 2, &req_cap,
 		     dest_fields, limt, &error);
-    if (U_FAILURE(error))
+    if (U_BUFFER_OVERFLOW_ERROR == error) {
+       error = U_ZERO_ERROR;
+       REALLOC_N( dest_buf, UChar, req_cap);
+       total = uregex_split(theRegEx, dest_buf, req_cap, &req_cap,  dest_fields, limt, &error);
+    }
+    if (U_FAILURE(error) ) {
+	free(dest_buf);
+	free(dest_fields);
 	rb_raise(rb_eArgError, u_errorName(error));
-
+    }
+    splits = rb_ary_new();
     for (i = 0; i < total; i++)
 	rb_ary_push(splits, icu_ustr_new2(dest_fields[i]));
+    
+    	free(dest_buf);
+	free(dest_fields);
+
     return splits;
 }
 
@@ -238,7 +252,7 @@ icu_reg_search(re, str, pos, reverse)
      long            pos,
                      reverse;
 {
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
     long            cur_pos = 0;
     long            start,
                     last;
@@ -261,7 +275,7 @@ icu_reg_search(re, str, pos, reverse)
     if (reverse) {
 	while (uregex_findNext(UREGEX(re)->pattern, &error)) {
 	    last = uregex_start(UREGEX(re)->pattern, 0, &error);
-	    error = 0;
+	    error = U_ZERO_ERROR;
 	    if (reverse && last > pos)
 		break;
 	    cur_pos = last;
@@ -271,6 +285,13 @@ icu_reg_search(re, str, pos, reverse)
 	return -1;
     return cur_pos;
 }
+long
+icu_group_count(re)
+     VALUE           re;
+{
+    UErrorCode      error = U_ZERO_ERROR;
+    return uregex_groupCount(UREGEX(re)->pattern, &error);
+}
 
 VALUE
 icu_reg_nth_match(re, nth)
@@ -278,9 +299,14 @@ icu_reg_nth_match(re, nth)
      long            nth;
 {
     URegularExpression *the_expr = UREGEX(re)->pattern;
-    UErrorCode      error = 0;
-    long            start = uregex_start(the_expr, nth, &error), end;
+    UErrorCode      error = U_ZERO_ERROR;
+    long            start, end;
     int32_t len;
+    if( nth < 0 ) {
+    	nth += icu_group_count(re) + 1;
+	if(nth<=0) return Qnil;
+    }
+    start = uregex_start(the_expr, nth, &error);
     if (U_FAILURE(error)) {
 	return Qnil;
     }
@@ -298,7 +324,11 @@ icu_reg_range(re, nth, start, end)
      long           *end;
 {
     URegularExpression *the_expr = UREGEX(re)->pattern;
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
+    if(nth < 0) {
+       nth += icu_group_count(re) + 1;
+       if(nth <= 0) return Qnil;
+    }
     *start = uregex_start(the_expr, nth, &error);
     if (U_FAILURE(error))
 	return Qnil;
@@ -321,7 +351,7 @@ icu_reg_match(re, str)
      VALUE           re,
                      str;
 {
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
     Check_Class(str, rb_cUString);
     uregex_setText(UREGEX(re)->pattern, USTRING(str)->ptr,
 		   USTRING(str)->len, &error);
@@ -362,20 +392,14 @@ icu_reg_eqq(re, str)
 }
 
 
-long
-icu_group_count(re)
-     VALUE           re;
-{
-    UErrorCode      error = 0;
-    return uregex_groupCount(UREGEX(re)->pattern, &error);
-}
+
 
 int
 icu_reg_find_next(pat)
      VALUE           pat;
 {
     URegularExpression *the_expr = UREGEX(pat)->pattern;
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
     return uregex_findNext(the_expr, &error);
 }
 
@@ -478,7 +502,7 @@ icu_reg_get_prematch(pat, prev_end)
      long            prev_end;
 {
     URegularExpression *the_expr = UREGEX(pat)->pattern;
-    UErrorCode      error = 0;
+    UErrorCode      error = U_ZERO_ERROR;
     int32_t         len = 0;
     int32_t         cur_start = uregex_start(the_expr, 0, &error);
     const UChar    *temp = uregex_getText(the_expr, &len, &error);
@@ -599,7 +623,7 @@ icu_umatch_init( self, re)
     
     Check_Class(re, rb_cURegexp);
     the_regex = UREGEX(re)->pattern;
-    count = uregex_groupCount(the_regex, &status);
+    count = icu_group_count(re); 
     if (U_FAILURE(status)) {
 	rb_raise(rb_eArgError, u_errorName(status));
     }