icu4r 0.1.3.2006.01.26 → 0.1.4.2006.05.29

data/README

@@ -29,11 +29,14 @@ and provides following classes and functionality:
 
 * UCalendar - date manipulation and timezone info.
 
+* UConverter - codepage conversions API
+
+* UCollator - locale-sensitive string comparison
+
 == Install and usage
 
    > ruby extconf.rb
-   > make
-   > ruby test/test_ustring.rb
+   > make && make check
    > make install
 
 Now, in your scripts just require 'icu4r'.
@@ -71,7 +74,7 @@ To build and use ICU4R you will need GCC and ICU v3.4 libraries[2].
    gory details, but in short: locale dependent notion of character can be presented using 
    more than one codepoint - base letter and combining (accents) (also possible more than one!), and
    each codepoint can require more than one codeunit to store (for UTF8 codeunit size is 8bit, though
-   some codepoints require up to 6bytes). So, UString has normalization and locale dependent break
+   some codepoints require up to 4bytes). So, UString has normalization and locale dependent break
    iterators.
 	
 6. Currently UString doesn't include Enumerable module.

data/calendar.c

@@ -5,7 +5,7 @@
 extern VALUE rb_cUString;
 extern VALUE icu_ustr_new(UChar * ptr, long len);
 extern VALUE icu_ustr_new_set(UChar * ptr, long len, long capa);
-static VALUE s_calendar_fields;
+static VALUE s_calendar_fields, s_calendar_formats;
 extern VALUE rb_cUCalendar;
 #define UCALENDAR(obj) ((UCalendar *)DATA_PTR(obj))
 /**
@@ -79,7 +79,7 @@ VALUE icu4r_cal_country_tz (VALUE obj, VALUE ctry)
  * call-seq:
  *     UCalendar.default_tz => ustring
  *
- * Returns the default time zone (UString).
+ * Returns the default time zone name as UString.
  *
  *     UCalendar.default_tz # "EET"
  *
@@ -155,7 +155,10 @@ VALUE icu4r_cal_now(VALUE obj){
 void icu4r_cal_free(UCalendar * cal){
     ucal_close(cal);
 }
-
+static VALUE icu4r_cal_alloc(VALUE klass)
+{
+    return Data_Wrap_Struct(klass, 0, icu4r_cal_free, 0);
+}
 /**
  * call-seq:
  *     UCalendar.new(zone_id = nil, locale = nil, traditional = false)
@@ -173,7 +176,6 @@ VALUE icu4r_cal_init (int argc, VALUE * argv, VALUE self)
 	 UCalendarType  c_type = UCAL_GREGORIAN;
 	 int32_t n, zone_len =0 , locale_len =0;
 	 UCalendar * calendar;
-	 VALUE ret;
 	 UErrorCode  status = U_ZERO_ERROR;
 	 n = rb_scan_args(argc, argv, "03", &zone, &loc, &cal_type);
 	 if( n >= 1) {
@@ -193,8 +195,8 @@ VALUE icu4r_cal_init (int argc, VALUE * argv, VALUE self)
 	 }
 	 calendar = ucal_open(zone_id, zone_len, locale,  c_type, &status);
 	 ICU_RAISE(status);
-	 ret = Data_Wrap_Struct(self, 0, icu4r_cal_free, calendar);
-	 return ret;
+	 DATA_PTR(self) = calendar;
+	 return self;
 }
 
 int icu4r_get_cal_field_int(VALUE field)
@@ -391,9 +393,9 @@ VALUE icu4r_cal_in_daylight(VALUE obj)
 
 /** 
  * call-seq:
- *     calendar.time_zone 
+ *     calendar.time_zone(locale = nil) 
  *
- * Returns the TimeZone used by a UCalendar. 
+ * Returns the TimeZone name used in this UCalendar. Name is returned in requested locale or default, if not set.
  */
 VALUE icu4r_cal_get_tz (int argc, VALUE * argv, VALUE obj)
 {
@@ -418,10 +420,25 @@ VALUE icu4r_cal_get_tz (int argc, VALUE * argv, VALUE obj)
 	return Qnil;
 
 }
+int icu4r_get_cal_format_int(VALUE field)
+{
+	VALUE  field_const;
+	field_const = rb_hash_aref(s_calendar_formats, field);
+	if(field_const == Qnil)	{
+		rb_warn("no  such format %s , using default", RSTRING(rb_obj_as_string(field))->ptr);
+		return UDAT_DEFAULT;
+	}
+	return NUM2INT(field_const);
+}
 /** call-seq:
  *     calendar.format(pattern = nil , locale = nil)
  *
- * Formats this calendar time using given pattern and locale. Returns UString or nil on failure
+ * Formats this calendar time using given pattern and locale. Returns UString or nil on failure.
+ * Valid value types for pattern are:
+ *      nil        - long format for date and time
+ *      UString    - specification of format, as defined in docs/FORMATTING
+ *      Symbol     - one of :short, :medium, :long, :full, :none , sets format for both date and time
+ *      Hash       - {:time => aSymbol, :date => aSymbol} - sets separate formats for date and time, valid symbols see above
  */
 VALUE icu4r_cal_format(int argc, VALUE * argv, VALUE obj) 
 {
@@ -432,9 +449,7 @@ VALUE icu4r_cal_format(int argc, VALUE * argv, VALUE obj)
 	long capa = 0, pattern_len = 0;
 	char *locale = NULL;
 	VALUE loc, pat, ret = Qnil;
-	int n ;
-	
-	
+	int n , def_d_format = UDAT_FULL, def_t_format = UDAT_FULL;
 	
 	n = rb_scan_args(argc, argv, "02", &pat, &loc);
 	if( n == 2) {
@@ -442,12 +457,23 @@ VALUE icu4r_cal_format(int argc, VALUE * argv, VALUE obj)
 		locale = RSTRING(loc)->ptr;
 	}
 	if (n >= 1 && pat != Qnil) {
-		Check_Class(pat, rb_cUString);
-		pattern = ICU_PTR(pat);
-		pattern_len = ICU_LEN(pat);
+		switch(TYPE(pat)) {
+			case T_SYMBOL:
+			 	def_d_format = def_t_format = icu4r_get_cal_format_int(pat);
+				break;
+			case T_HASH:
+			 	def_d_format = icu4r_get_cal_format_int(rb_hash_aref(pat, ID2SYM(rb_intern("date"))));
+				def_t_format = icu4r_get_cal_format_int(rb_hash_aref(pat, ID2SYM(rb_intern("time"))));
+				break;
+			default:
+				Check_Class(pat, rb_cUString);
+				pattern = ICU_PTR(pat);
+				pattern_len = ICU_LEN(pat);
+				break;
+		}
 	}
 	
-	format = udat_open(UDAT_FULL, UDAT_FULL, locale, NULL, 0,  NULL, 0, &status);
+	format = udat_open(def_t_format, def_d_format, locale, NULL, 0,  NULL, 0, &status);
 	if( pattern ) {
 	   udat_applyPattern(format, 0, pattern, pattern_len);
 	}
@@ -490,36 +516,60 @@ extern VALUE icu4r_cal_clone(VALUE obj);
 extern VALUE icu4r_cal_equal(VALUE obj, VALUE other);
 
 /**
- * Document-method: >
- *
- * call-seq:
- *     cal > when
+ *  call-seq:
+ *     cal <=> other_cal   => -1, 0, +1
+ *  
+ *  Comparison---Returns -1 if <i>other_cal</i> is before than, 0 if
+ *  <i>other_cal</i> is equal to, and +1 if <i>other_cal</i> is after than
+ *  <i>str</i>. 
  *
- * True if the current time of this UCalendar is after the time of UCalendar +when+; false otherwise.
+ *  Value of calendar's milliseconds are compared.
  */
-extern VALUE icu4r_cal_after(VALUE obj, VALUE other);
+
+VALUE icu4r_cal_cmp (VALUE c1, VALUE c2) 
+{
+	UErrorCode status = U_ZERO_ERROR;
+	double  millis1, millis2;
+	Check_Class(c1, rb_cUCalendar);
+	Check_Class(c2, rb_cUCalendar);
+	millis1 = ucal_getMillis(UCALENDAR(c1), &status); 
+	millis2 = ucal_getMillis(UCALENDAR(c2), &status); 
+	ICU_RAISE(status);
+	if(millis1 < millis2) return INT2FIX(-1);
+	if(millis1 > millis2) return INT2FIX(1);
+	return INT2FIX(0);
+}
+/* parsing     */
+extern UCalendar * icu_date_parse(UChar * str, int32_t str_len, char * locale, UChar * val, int32_t len);
+
 /**
- * Document-method: <
- *
  * call-seq:
- *     cal < when
+ *     UCalendar.parse( pattern, locale, value)
+ *  
+ * Parses given  value, using format pattern with respect to +locale+.
  *
- * True if the current time of this UCalendar is before the time of UCalendar +when+; false otherwise.
- */
-extern VALUE icu4r_cal_before(VALUE obj, VALUE other);
-/**
- * Document-method: ==
+ *     UCalendar.parse("HH:mm:ss E dd/MM/yyyy".u, "en", "20:15:01 Fri 13/01/2006".u) # => Time.local(2006,"jan",13,20,15,1) 
  *
- * call-seq:
- *	cal == when
- *
- * True if the current time of this UCalendar is equal to the time of UCalendar +when+; false otherwise.
- */
-extern VALUE icu4r_cal_time_equals(VALUE obj, VALUE other);
+ */	
+ 
+VALUE 
+icu4r_cal_parse( obj, str,  locale, val)
+		VALUE obj, str, locale, val;
+{
+   UCalendar 		* cal;
+   VALUE 		ret;
+   Check_Type(locale, T_STRING);
+   Check_Class(val, rb_cUString);
+   cal = icu_date_parse(ICU_PTR(str), ICU_LEN(str), RSTRING(locale)->ptr, ICU_PTR(val), ICU_LEN(val));
+      ret = Data_Wrap_Struct(obj, 0, icu4r_cal_free, cal);
+   return ret;
+}
 
 void initialize_calendar(void) {
 
 rb_cUCalendar = rb_define_class("UCalendar", rb_cObject);
+rb_define_alloc_func(rb_cUCalendar, icu4r_cal_alloc);
+
 s_calendar_fields = rb_hash_new();
 /* Valid symbols to use as field reference in UCalendar#[],  UCalendar#[]=, UCalendar#add are:
  :era , :year , :month , :week_of_year , :week_of_month , :date , :day_of_year , :day_of_week,  :day_of_week_in_month, 
@@ -544,6 +594,15 @@ rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("millisecond")), INT2NUM(UCAL_M
 rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("zone_offset")), INT2NUM(UCAL_ZONE_OFFSET));
 rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("dst_offset")), INT2NUM(UCAL_DST_OFFSET));
 
+s_calendar_formats = rb_hash_new();
+rb_define_const(rb_cUCalendar, "UCALENDAR_FORMATS", s_calendar_formats);
+rb_hash_aset(s_calendar_formats, ID2SYM(rb_intern("full")), INT2NUM(UDAT_FULL));
+rb_hash_aset(s_calendar_formats, ID2SYM(rb_intern("long")), INT2NUM(UDAT_LONG));
+rb_hash_aset(s_calendar_formats, ID2SYM(rb_intern("medium")), INT2NUM(UDAT_MEDIUM));
+rb_hash_aset(s_calendar_formats, ID2SYM(rb_intern("short")), INT2NUM(UDAT_SHORT));
+rb_hash_aset(s_calendar_formats, ID2SYM(rb_intern("default")), INT2NUM(UDAT_DEFAULT));
+rb_hash_aset(s_calendar_formats, ID2SYM(rb_intern("none")), INT2NUM(UDAT_NONE));
+
 
 rb_define_singleton_method(rb_cUCalendar, "now", icu4r_cal_now, 0);
 
@@ -552,8 +611,9 @@ rb_define_singleton_method(rb_cUCalendar, "default_tz",  icu4r_cal_get_default_t
 rb_define_singleton_method(rb_cUCalendar, "time_zones",  icu4r_cal_all_tz, 0);
 rb_define_singleton_method(rb_cUCalendar, "tz_for_country",  icu4r_cal_country_tz, 1);
 rb_define_singleton_method(rb_cUCalendar, "dst_savings",  icu4r_cal_dst_savings, 1);
+rb_define_singleton_method(rb_cUCalendar, "parse",  icu4r_cal_parse, 3);
 
-rb_define_singleton_method(rb_cUCalendar, "new", icu4r_cal_init, -1);
+rb_define_method(rb_cUCalendar, "initialize", icu4r_cal_init, -1);
 rb_define_method(rb_cUCalendar, "add", icu4r_cal_add, 2);
 rb_define_method(rb_cUCalendar, "roll", icu4r_cal_roll, 2);
 rb_define_method(rb_cUCalendar, "[]", icu4r_cal_aref, 1);
@@ -569,8 +629,8 @@ rb_define_method(rb_cUCalendar, "format", icu4r_cal_format,-1);
 
 rb_define_method(rb_cUCalendar, "clone", icu4r_cal_clone,0);
 rb_define_method(rb_cUCalendar, "eql?", icu4r_cal_equal,1);
-rb_define_method(rb_cUCalendar, "<", icu4r_cal_before,1);
-rb_define_method(rb_cUCalendar, ">", icu4r_cal_after,1);
-rb_define_method(rb_cUCalendar, "==", icu4r_cal_time_equals, 1);
+rb_define_method(rb_cUCalendar, "<=>", icu4r_cal_cmp,1);
+
+rb_include_module(rb_cUCalendar, rb_mComparable);
 
 }	

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(loc)->ptr;
+    }
+    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 ;
+    char * buffer ; 
+    VALUE ret;
+    Check_Class(str, rb_cUString);
+    capa = ICU_LEN(str);
+    buffer = ALLOC_N(char, capa);
+    needed = ucol_getSortKey(UCOLLATOR(self), ICU_PTR(str), ICU_LEN(str), buffer, capa);
+    if(needed > capa){
+      REALLOC_N(buffer,char, needed);
+      needed = ucol_getSortKey(UCOLLATOR(self), ICU_PTR(str), ICU_LEN(str), buffer, needed);
+    }
+    ret = rb_str_new(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));
+  
+}