icu4r 0.1.3.2006.01.26

data/calendar.c

@@ -0,0 +1,576 @@
+#include <unicode/ucal.h>
+#include <unicode/uenum.h>
+#include <unicode/udat.h>
+#include "icu_common.h"
+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;
+extern VALUE rb_cUCalendar;
+#define UCALENDAR(obj) ((UCalendar *)DATA_PTR(obj))
+/**
+ * Document-class: UCalendar
+ *
+ * The UCalendar class  provides methods for converting between a specific instant in 
+ * time and a set of calendar fields such as YEAR, MONTH, DAY_OF_MONTH, HOUR, and so on,
+ * and for manipulating the calendar fields, such as getting the date of the next week. 
+ * An instant in time can be represented by a millisecond value that is an offset from the 
+ * Epoch, January 1, 1970 00:00:00.000 GMT (Gregorian).
+ *
+ * Also timezone info and methods are provided.
+ *
+ * NOTE: months are zero-based.
+ */
+
+/**
+ * call-seq:
+ *     UCalendar.time_zones
+ *
+ * Returns array with all time zones (as UString values). 
+ */
+VALUE icu4r_cal_all_tz (VALUE obj)
+{
+	UErrorCode  status = U_ZERO_ERROR;
+	UEnumeration * zones ; 
+	VALUE ret ;
+	UChar * name;
+	int32_t len;
+	zones = ucal_openTimeZones (&status);
+	ICU_RAISE(status);
+	ret = rb_ary_new();
+	while( (name = (UChar*)uenum_unext(zones, &len, &status))) {
+		rb_ary_push(ret, icu_ustr_new(name, len));
+	}
+	uenum_close(zones);
+	return ret;
+}
+
+
+/**
+ * call-seq:
+ *     UCalendar.tz_for_country(country)
+ *  
+ * Returns array with all time zones associated with the given country.
+ * Note: <code>country</code> must be value of type String.
+ * Returned array content is UString's
+ *
+ *     UCalendar.tz_for_country("GB") # => [ "Europe/Belfast", "Europe/London", "GB",  "GB-Eire"]
+ *
+ */
+VALUE icu4r_cal_country_tz (VALUE obj, VALUE ctry)
+{
+	UErrorCode  status = U_ZERO_ERROR;
+	UEnumeration * zones ; 
+	VALUE ret ;
+	UChar * name;
+	int32_t len;
+	Check_Type(ctry, T_STRING);
+	zones = ucal_openCountryTimeZones (RSTRING(ctry)->ptr, &status) ;
+	ICU_RAISE(status);
+	ret = rb_ary_new();
+	while( (name = (UChar*)uenum_unext(zones, &len, &status))) {
+		rb_ary_push(ret, icu_ustr_new(name, len));
+	}
+	uenum_close(zones);
+	return ret;
+}
+
+/**
+ * call-seq:
+ *     UCalendar.default_tz => ustring
+ *
+ * Returns the default time zone (UString).
+ *
+ *     UCalendar.default_tz # "EET"
+ *
+ */
+VALUE icu4r_cal_get_default_tz(VALUE obj) 
+{
+	UErrorCode  status = U_ZERO_ERROR;
+	UChar * buf ;
+	long capa = 0;
+	capa = ucal_getDefaultTimeZone (buf, capa, &status);
+	if( U_BUFFER_OVERFLOW_ERROR == status) {
+		buf = ALLOC_N(UChar, capa+1);
+		status = U_ZERO_ERROR;
+		capa = ucal_getDefaultTimeZone (buf, capa, &status);
+		return icu_ustr_new_set(buf, capa, capa+1);
+	}
+	ICU_RAISE(status);
+	return Qnil;
+}
+
+/** 
+ * call-seq:
+ *     UCalendar.default_tz = ustring
+ *
+ * Set the default time zone.
+ *
+ *      UCalendar.default_tz="GMT+00".u
+ *      UCalendar.default_tz="Europe/Paris".u
+ */
+VALUE icu4r_cal_set_default_tz(VALUE obj, VALUE tz) 
+{
+	UErrorCode  status = U_ZERO_ERROR;
+	Check_Class(tz, rb_cUString);
+  	ucal_setDefaultTimeZone (ICU_PTR(tz), &status);	
+	ICU_RAISE(status);
+	return tz;
+}
+/**
+ * call-seq:
+ *      UCalendar.dst_savings(zone_id)
+ *
+ * Return the amount of time in milliseconds that the clock is advanced 
+ * during daylight  savings time for the given time zone, or zero if the time 
+ * zone does not observe daylight savings time. 
+ *
+ *       UCalendar.dst_savings("GMT+00".u) # =>  3600000
+ *
+ */
+VALUE icu4r_cal_dst_savings(VALUE obj, VALUE zone) 
+{
+	UErrorCode  status = U_ZERO_ERROR;
+	int32_t dst;
+	Check_Class(zone, rb_cUString);
+  	dst = ucal_getDSTSavings (ICU_PTR(zone), &status);
+	ICU_RAISE(status);
+	return INT2FIX(dst);
+}
+
+/**
+ * call-seq:
+ *     UCalendar.now
+ *
+ * Get the current date and time. in millis
+ *
+ *       UCalendar.now # => 1137934561000.0
+ *
+ */
+VALUE icu4r_cal_now(VALUE obj){
+	return rb_float_new(ucal_getNow());
+}
+//-----------------
+
+void icu4r_cal_free(UCalendar * cal){
+    ucal_close(cal);
+}
+
+/**
+ * call-seq:
+ *     UCalendar.new(zone_id = nil, locale = nil, traditional = false)
+ *
+ * Creates new instance of UCalendar, for given time zone id (UString),
+ * locale (Ruby String), and kind , by default gregorian.
+ * New instance has current time.
+ *
+ */
+VALUE icu4r_cal_init (int argc, VALUE * argv, VALUE self)
+{
+         VALUE zone, loc, cal_type;
+	 UChar * zone_id = NULL;
+	 char  * locale  = NULL;
+	 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) {
+	     Check_Class(zone, rb_cUString);
+	     zone_id = ICU_PTR(zone);
+	     zone_len = ICU_LEN(zone);
+	 }
+	 if( n >= 2) {
+	     Check_Type(loc, T_STRING);
+	     locale = RSTRING(loc)->ptr;
+	     locale_len = RSTRING(loc)->len;
+	 }
+	 if( n >= 3) {
+	     if( Qtrue == cal_type ) {
+	     	c_type = UCAL_TRADITIONAL;
+	     }
+	 }
+	 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;
+}
+
+int icu4r_get_cal_field_int(VALUE field)
+{
+	VALUE  field_const;
+	field_const = rb_hash_aref(s_calendar_fields, field);
+	if(field_const == Qnil)
+	rb_raise(rb_eArgError, "no  such field %s", rb_obj_as_string(field));
+	return NUM2INT(field_const);
+}
+
+/** 
+ * call-seq:
+ *     calendar.add(field, int_amount)
+ *
+ * Add a specified signed amount to a particular field in a UCalendar.
+ *
+ *      c.add(:week_of_year, 2)
+ */
+VALUE icu4r_cal_add(VALUE obj, VALUE field, VALUE amount) 
+{
+	UErrorCode status = U_ZERO_ERROR;
+	int  date_field;
+	Check_Type(field, T_SYMBOL);
+	Check_Type(amount, T_FIXNUM);
+	date_field = icu4r_get_cal_field_int(field);
+	ucal_add(UCALENDAR(obj), date_field, FIX2INT(amount) , &status); 
+	ICU_RAISE(status);
+	return Qnil;
+}
+
+/** 
+ * call-seq:
+ *     calendar.roll(field, int_amount)
+ *
+ * Adds a signed amount to the specified calendar field without changing larger fields. 
+ * A negative roll amount means to subtract from field without changing larger fields. 
+ * If the specified amount is 0, this method performs nothing.
+ *
+ * Example: Consider a GregorianCalendar originally set to August 31, 1999. Calling roll(:month, 8) 
+ * sets the calendar to April 30, 1999. Using a Gregorian Calendar, the :day_of_month field cannot 
+ * be 31 in the month April. :day_of_month is set to the closest possible value, 30. The :year field 
+ * maintains the value of 1999 because it is a larger field than :month. 
+ */
+VALUE icu4r_cal_roll(VALUE obj, VALUE field, VALUE amount) 
+{
+	UErrorCode status = U_ZERO_ERROR;
+	int  date_field;
+	Check_Type(field, T_SYMBOL);
+	Check_Type(amount, T_FIXNUM);
+	date_field = icu4r_get_cal_field_int(field);
+	ucal_roll(UCALENDAR(obj), date_field, FIX2INT(amount) , &status); 
+	ICU_RAISE(status);
+	return Qnil;
+}
+/** 
+ * call-seq:
+ *     calendar[field]
+ *
+ * Get the current value of a field from a UCalendar.
+ *
+ */
+VALUE icu4r_cal_aref(VALUE obj, VALUE field) 
+{
+	UErrorCode status = U_ZERO_ERROR;
+	int  date_field;
+	int32_t value;
+	Check_Type(field, T_SYMBOL);
+	date_field = icu4r_get_cal_field_int(field);
+	value = ucal_get(UCALENDAR(obj), date_field, &status); 
+	ICU_RAISE(status);
+	return INT2FIX(value);
+}
+
+/** 
+ * call-seq:
+ *    calendar[field]=int_value
+ *
+ * Set the value of a field in a UCalendar.
+ */
+VALUE icu4r_cal_aset(VALUE obj, VALUE field, VALUE amount) 
+{
+	int  date_field, ret;
+	UErrorCode status = U_ZERO_ERROR;
+	Check_Type(field, T_SYMBOL);
+	Check_Type(amount, T_FIXNUM);
+	date_field = icu4r_get_cal_field_int(field);
+	ucal_set(UCALENDAR(obj), date_field, FIX2INT(amount) ); 
+	ret = ucal_get(UCALENDAR(obj), date_field, &status); 
+
+	return INT2FIX(ret);
+}
+/**
+ * call-seq:
+ *     calendar.millis
+ *
+ * return this calendar value in milliseconds.
+ */
+VALUE icu4r_cal_millis(VALUE obj)
+{
+	UErrorCode status = U_ZERO_ERROR;
+	double  millis;
+	millis = ucal_getMillis(UCALENDAR(obj), &status); 
+	ICU_RAISE(status);
+	return rb_float_new(millis);
+}
+/**
+ * call-seq:
+ *     calendar.millis = new_value
+ *
+ * Sets calendar's value in milliseconds.
+ */
+VALUE icu4r_cal_set_millis(VALUE obj,VALUE milli)
+{
+	UErrorCode status = U_ZERO_ERROR;
+	Check_Type(milli, T_FLOAT);
+	ucal_setMillis(UCALENDAR(obj), rb_num2dbl(milli), &status); 
+	ICU_RAISE(status);
+	return Qnil;
+}
+
+/**
+ * call-seq:
+ *     calendar.set_date(year, month, date)
+ *
+ * Set a UCalendar's current date.
+ */
+VALUE icu4r_cal_set_date(VALUE obj,VALUE year, VALUE mon, VALUE date)
+{
+	UErrorCode status = U_ZERO_ERROR;
+	Check_Type(year, T_FIXNUM);
+	Check_Type(mon,  T_FIXNUM);
+	Check_Type(date, T_FIXNUM);
+	ucal_setDate(UCALENDAR(obj), FIX2INT(year), FIX2INT(mon), FIX2INT(date), &status); 
+	ICU_RAISE(status);
+	return Qnil;
+}
+/**
+ * call-seq:
+ *     calendar.set_date_time(year, month, date, hour, minute, second)
+ *
+ * Set a UCalendar's current date and time.
+ */
+VALUE icu4r_cal_set_date_time(VALUE obj,VALUE year, VALUE mon, VALUE date, VALUE hour, VALUE min, VALUE sec)
+{
+	UErrorCode status = U_ZERO_ERROR;
+	Check_Type(year, T_FIXNUM);
+	Check_Type(mon,  T_FIXNUM);
+	Check_Type(date, T_FIXNUM);
+	Check_Type(hour, T_FIXNUM);
+	Check_Type(min,  T_FIXNUM);
+	Check_Type(sec, T_FIXNUM);
+
+	ucal_setDateTime(UCALENDAR(obj), 
+		FIX2INT(year), FIX2INT(mon), FIX2INT(date), 
+		FIX2INT(hour), FIX2INT(min), FIX2INT(sec), 
+	&status); 
+	ICU_RAISE(status);
+	return Qnil;
+}
+
+/** 
+ * call-seq:
+ *     calendar.time_zone = zone_id
+ *
+ * Set the TimeZone used by a UCalendar. 
+ */
+VALUE icu4r_cal_set_tz(VALUE obj, VALUE zone)
+{
+	UErrorCode status = U_ZERO_ERROR;
+	Check_Class(zone, rb_cUString);
+	ucal_setTimeZone(UCALENDAR(obj), ICU_PTR(zone), ICU_LEN(zone), &status);
+	ICU_RAISE(status);
+	return Qnil;
+
+}
+
+/**
+ * call-seq: 
+ *      calendar.in_daylight_time?
+ *
+ * Determine if a UCalendar is currently in daylight savings time.
+ *
+ * Daylight savings time is not used in all parts of the world
+ */
+VALUE icu4r_cal_in_daylight(VALUE obj)
+{
+	UErrorCode status = U_ZERO_ERROR;
+	int32_t	answer;
+	answer = ucal_inDaylightTime(UCALENDAR(obj), &status);
+	ICU_RAISE(status);
+	return answer ? Qtrue : Qfalse;
+}
+
+/** 
+ * call-seq:
+ *     calendar.time_zone 
+ *
+ * Returns the TimeZone used by a UCalendar. 
+ */
+VALUE icu4r_cal_get_tz (int argc, VALUE * argv, VALUE obj)
+{
+	UErrorCode  status = U_ZERO_ERROR;
+	UChar * buf  = NULL;
+	long capa = 0;
+	char *locale = NULL;
+	VALUE loc;
+	if( rb_scan_args(argc, argv, "01", &loc) == 1){
+		Check_Type(loc, T_STRING);
+		locale = RSTRING(loc)->ptr;
+	}
+	
+	capa = ucal_getTimeZoneDisplayName(UCALENDAR(obj), UCAL_STANDARD, locale, buf, capa, &status);
+	if( U_BUFFER_OVERFLOW_ERROR == status) {
+		buf = ALLOC_N(UChar, capa+1);
+		status = U_ZERO_ERROR;
+		capa = ucal_getTimeZoneDisplayName(UCALENDAR(obj), UCAL_STANDARD, locale, buf, capa, &status);
+		return icu_ustr_new_set(buf, capa, capa+1);
+	}
+	ICU_RAISE(status);
+	return Qnil;
+
+}
+/** call-seq:
+ *     calendar.format(pattern = nil , locale = nil)
+ *
+ * Formats this calendar time using given pattern and locale. Returns UString or nil on failure
+ */
+VALUE icu4r_cal_format(int argc, VALUE * argv, VALUE obj) 
+{
+	UErrorCode status = U_ZERO_ERROR;
+	UDateFormat * format;
+	UDate   time_to_format;
+	UChar * buf = NULL, * pattern = NULL;
+	long capa = 0, pattern_len = 0;
+	char *locale = NULL;
+	VALUE loc, pat, ret = Qnil;
+	int n ;
+	
+	
+	
+	n = rb_scan_args(argc, argv, "02", &pat, &loc);
+	if( n == 2) {
+		Check_Type(loc, T_STRING);
+		locale = RSTRING(loc)->ptr;
+	}
+	if (n >= 1 && pat != Qnil) {
+		Check_Class(pat, rb_cUString);
+		pattern = ICU_PTR(pat);
+		pattern_len = ICU_LEN(pat);
+	}
+	
+	format = udat_open(UDAT_FULL, UDAT_FULL, locale, NULL, 0,  NULL, 0, &status);
+	if( pattern ) {
+	   udat_applyPattern(format, 0, pattern, pattern_len);
+	}
+	ICU_RAISE(status);
+	udat_setCalendar(format, UCALENDAR(obj));
+	time_to_format = ucal_getMillis(UCALENDAR(obj), &status); 
+
+	capa = udat_format(format, time_to_format, buf, capa, NULL, &status);
+	if( U_BUFFER_OVERFLOW_ERROR == status) {
+		buf = ALLOC_N(UChar, capa+1);
+		status = U_ZERO_ERROR;
+		capa = udat_format(format, time_to_format, buf, capa, NULL, &status);
+		ret = icu_ustr_new_set(buf, capa, capa+1);
+	}
+	udat_close(format);
+	ICU_RAISE(status);
+	return ret;
+}
+
+/**
+ * Document-method: clone
+ *
+ * call-seq:
+ *     cal.clone => UCalendar
+ *
+ * Create and return a copy of this calendar.
+ */
+extern VALUE icu4r_cal_clone(VALUE obj);
+/**
+ * Document-method: eql?
+ * 
+ * call-seq:
+ *	cal.eql?(other)
+ *
+ * Compares the equality of two UCalendar objects.
+ * 
+ * This comparison is very exacting; two UCalendar objects must be in exactly the 
+ * same state to be considered equal.
+ */
+extern VALUE icu4r_cal_equal(VALUE obj, VALUE other);
+
+/**
+ * Document-method: >
+ *
+ * call-seq:
+ *     cal > when
+ *
+ * True if the current time of this UCalendar is after the time of UCalendar +when+; false otherwise.
+ */
+extern VALUE icu4r_cal_after(VALUE obj, VALUE other);
+/**
+ * Document-method: <
+ *
+ * call-seq:
+ *     cal < when
+ *
+ * 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: ==
+ *
+ * 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);
+
+void initialize_calendar(void) {
+
+rb_cUCalendar = rb_define_class("UCalendar", rb_cObject);
+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, 
+ :am_pm , :hour , :hour_of_day , :minute , :second , :millisecond , :zone_offset , :dst_offset: 
+*/
+rb_define_const(rb_cUCalendar, "UCALENDAR_FIELDS", s_calendar_fields);
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("era")), INT2NUM(UCAL_ERA ));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("year")), INT2NUM(UCAL_YEAR ));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("month")), INT2NUM(UCAL_MONTH));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("week_of_year")), INT2NUM(UCAL_WEEK_OF_YEAR ));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("week_of_month")), INT2NUM(UCAL_WEEK_OF_MONTH));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("date")), INT2NUM(UCAL_DATE));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("day_of_year")), INT2NUM(UCAL_DAY_OF_YEAR));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("day_of_week")), INT2NUM(UCAL_DAY_OF_WEEK));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("day_of_week_in_month")), INT2NUM(UCAL_DAY_OF_WEEK_IN_MONTH));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("am_pm")), INT2NUM(UCAL_AM_PM));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("hour")), INT2NUM(UCAL_HOUR));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("hour_of_day")), INT2NUM(UCAL_HOUR_OF_DAY));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("minute")), INT2NUM(UCAL_MINUTE ));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("second")), INT2NUM(UCAL_SECOND));
+rb_hash_aset(s_calendar_fields, ID2SYM(rb_intern("millisecond")), INT2NUM(UCAL_MILLISECOND ));
+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));
+
+
+rb_define_singleton_method(rb_cUCalendar, "now", icu4r_cal_now, 0);
+
+rb_define_singleton_method(rb_cUCalendar, "default_tz=", icu4r_cal_set_default_tz, 1);
+rb_define_singleton_method(rb_cUCalendar, "default_tz",  icu4r_cal_get_default_tz, 0);
+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, "new", 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);
+rb_define_method(rb_cUCalendar, "[]=", icu4r_cal_aset, 2);
+rb_define_method(rb_cUCalendar, "millis=", icu4r_cal_set_millis, 1);
+rb_define_method(rb_cUCalendar, "millis", icu4r_cal_millis,0);
+rb_define_method(rb_cUCalendar, "set_date", icu4r_cal_set_date,3);
+rb_define_method(rb_cUCalendar, "set_date_time", icu4r_cal_set_date_time,6);
+rb_define_method(rb_cUCalendar, "time_zone=", icu4r_cal_set_tz,1);
+rb_define_method(rb_cUCalendar, "time_zone", icu4r_cal_get_tz,-1);
+rb_define_method(rb_cUCalendar, "in_daylight_time?", icu4r_cal_in_daylight,0);
+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);
+
+}	

data/docs/FORMATTING

@@ -0,0 +1,131 @@
+=== Locale-sensitive Message Formatting
+
+Basic pattern rules are:
+
+     messageFormatPattern := string ( "{" messageFormatElement "}" string )*
+
+     messageFormatElement := argument { "," elementFormat }
+
+     elementFormat := "time" { "," datetimeStyle }
+                    | "date" { "," datetimeStyle }
+                    | "number" { "," numberStyle }
+                    | "spellout"
+                    | "ordinal"
+                    | "duration"
+                    | "choice" "," choiceStyle
+
+     datetimeStyle := "short"
+                    | "medium"
+                    | "long"
+                    | "full"
+                    | dateFormatPattern
+
+     numberStyle :=   "currency"
+                    | "percent"
+                    | "integer"
+                    | numberFormatPattern
+
+     choiceStyle :=   choiceFormatPattern
+
+=== numberFormatPattern
+
+    pattern    := subpattern{;subpattern}
+    subpattern := {prefix}integer{.fraction}{suffix}
+              
+    prefix     := '\\u0000'..'\\uFFFD' - specialCharacters
+    suffix     := '\\u0000'..'\\uFFFD' - specialCharacters
+    integer    := '#'* '0'* '0'
+    fraction   := '0'* '#'*
+                                
+Notation:
+     X*       0 or more instances of X
+     (X | Y)  either X or Y.
+     X..Y     any character from X up to Y, inclusive.
+     S - T    characters in S, except those in T
+
+The first subpattern is for positive numbers. The second (optional)
+subpattern is used for negative numbers. (In both cases, ',' can
+occur inside the integer portion--it is just too messy to indicate
+in BNF.)  For the second subpattern, only the PREFIX and SUFFIX are
+noted; other attributes are taken only from the first subpattern.
+
+Here are the special characters used in the parts of the
+subpattern, with notes on their usage.
+
+Symbol   Meaning
+     0      a digit, showing up a zero if it is zero
+     #      a digit, supressed if zero
+     .      placeholder for decimal separator
+     ,      placeholder for grouping separator.
+     E      separates mantissa and exponent for exponential formats.
+     ;      separates formats.
+     -      default negative prefix.
+     %      multiply by 100 and show as percentage
+     \u2030 multiply by 1000 and show as per mille
+     \u00A4 currency sign; replaced by currency symbol; if  doubled, replaced by international currency symbol.
+            If present in a pattern, the monetary decimal separator
+            is used instead of the decimal separator.
+     X      any other characters can be used in the prefix or suffix
+     '      used to quote special characters in a prefix or suffix.
+
+=== dateFormatPattern
+
+    Symbol   Meaning                 Presentation       Example
+    ------   -------                 ------------       -------
+    G        era designator          (Text)             AD
+    y        year                    (Number)           1996
+    Y        year/week of year       (Number)           1996
+    M        month in year           (Text & Number)    July & 07
+    d        day in month            (Number)           10
+    h        hour in am/pm (1~12)    (Number)           12
+    H        hour in day (0~23)      (Number)           0
+    m        minute in hour          (Number)           30
+    s        second in minute        (Number)           55
+    S        millisecond             (Number)           978
+    E        day of week             (Text)             Tuesday
+    e        day of week/local (1~7) (Number)           2
+    D        day of year             (Number)           189
+    F        day of week in month    (Number)           2 (2nd Wed in July)
+    w        week in year            (Number)           27
+    W        week in month           (Number)           2
+    a        am/pm marker            (Text)             PM
+    k        hour in day (1~24)      (Number)           24
+    K        hour in am/pm (0~11)    (Number)           0
+    z        time zone               (Text)             Pacific Standard Time
+    '        escape for text
+    ''       single quote                               '
+
+
+=== choiceFormatPattern
+In most cases, the preferred way to define a ChoiceFormat is with a pattern. Here is an example of a ChoiceFormat pattern:
+
+     0≤are no files|1≤is one file|1<are many files
+
+or equivalently,
+
+     0#are no files|1#is one file|1<are many files
+
+The pattern consists of a number or range specifiers separated by vertical bars '|' (U+007C). There is no vertical bar after the last range. Each range specifier is of the form:
+
+  Number is a floating point number that can be parsed by a default 
+  NumberFormat for the US locale. It gives the lower limit of this range. 
+  The lower limit is either inclusive or exclusive, depending on the separator. 
+  The upper limit is given by the lower limit of the next range. The Unicode infinity 
+  sign ∞ (U+221E) is recognized for positive infinity. It may be preceded by '-' (U+002D) 
+  to indicate negative infinity.
+
+  String is the format string for this range, with special characters enclosed in single 
+  quotes ('The # sign'). Single quotes themselves are indicated by two single quotes in a 
+  row ('o''clock').
+
+  Separator is one of the following single characters:
+* '≤' (U+2264) or '#' (U+0023) indicates that the lower limit given by 
+Number is inclusive. (The two characters are equivalent to ChoiceFormat.) 
+This means that the limit value Number belongs to this range. Another way of 
+saying this is that the corresponding closure is FALSE.
+
+* '<' (U+003C) indicates that the lower limit given by Number is exclusive. 
+This means that the value Number belongs to the prior range. Another way of saying 
+this is that the corresponding closure is TRUE.
+                    
+See ICU docs for more info and examples.