// ******************************************************************************* // * // * Copyright (C) 1997-2000, International Business Machines // * Corporation and others. All Rights Reserved. // * // ******************************************************************************* en { NumberPatterns { "#,##0.###;-#,##0.###", "\u00A4#,##0.00;-\u00A4#,##0.00", "#,##0%", } // Format for the display name of a Transliterator. // This is the English form of this resource. TransliteratorNamePattern { "{0,choice,0#|1#{1}|2#{1} to {2}}" } // Transliterator display names "%Translit%Hex" { "Hex Escape" } "%Translit%UnicodeName" { "Unicode Name" } "%Translit%UnicodeChar" { "Unicode Character" } zoneStrings { { "PST", "Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT", } { "America/Los_Angeles", "Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT", } { "MST", "Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT", } { "America/Denver", "Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT", } { "PNT", "Mountain Standard Time", "MST", "Mountain Standard Time", "MST", } { "America/Phoenix", "Mountain Standard Time", "MST", "Mountain Standard Time", "MST", } { "CST", "Central Standard Time", "CST", "Central Daylight Time", "CDT", } { "America/Chicago", "Central Standard Time", "CST", "Central Daylight Time", "CDT", } { "EST", "Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT", } { "America/New_York", "Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT", } { "IET", "Eastern Standard Time", "EST", "Eastern Standard Time", "EST", } { "America/Indianapolis", "Eastern Standard Time", "EST", "Eastern Standard Time", "EST", } { "HST", "Hawaii Standard Time", "HST", "Hawaii Standard Time", "HST", } { "Pacific/Honolulu", "Hawaii Standard Time", "HST", "Hawaii Standard Time", "HST", } { "AST", "Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT", } { "America/Anchorage", "Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT", } { "America/Halifax", "Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT", } { "CNT", "Newfoundland Standard Time", "NST", "Newfoundland Daylight Time", "NDT", } { "America/St_Johns", "Newfoundland Standard Time", "NST", "Newfoundland Daylight Time", "NDT", } { "ECT", "Central European Standard Time", "CET", "Central European Daylight Time", "CEST", } { "Europe/Paris", "Central European Standard Time", "CET", "Central European Daylight Time", "CEST", } { "GMT", "Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT", } { "Africa/Casablanca", "Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT", } { "Asia/Jerusalem", "Israel Standard Time", "IST", "Israel Daylight Time", "IDT", } { "JST", "Japan Standard Time", "JST", "Japan Standard Time", "JST", } { "Asia/Tokyo", "Japan Standard Time", "JST", "Japan Standard Time", "JST", } { "Europe/Bucharest", "Eastern European Standard Time", "EET", "Eastern European Daylight Time", "EEST", } { "CTT", "China Standard Time", "CST", "China Standard Time", "CDT", } { "Asia/Shanghai", "China Standard Time", "CST", "China Standard Time", "CDT", } } LocaleID { "09" } LocaleScript{ "Latn", // ISO 15924 Name } //------------------------------------------------------------ // Rule Based Number Format Support //------------------------------------------------------------ // * Spellout rules for U.S. English. This rule set has two variants: // * %simplified is a set of rules showing the simple method of spelling // * out numbers in English: 289 is formatted as "two hundred eighty-nine". // * %default uses a more complicated algorithm to format // * numbers in a more natural way: 289 is formatted as "two hundred AND // * eighty-nine" and commas are inserted between the thousands groups for // * values above 100,000. SpelloutRules { // This rule set shows the normal simple formatting rules for English "%simplified:\n" // negative number rule. This rule is used to format negative // numbers. The result of formatting the number's absolute // value is placed where the >> is. " -x: minus >>;\n" // faction rule. This rule is used for formatting numbers // with fractional parts. The result of formatting the // number's integral part is substituted for the <<, and // the result of formatting the number's fractional part // (one digit at a time, e.g., 0.123 is "zero point one two // three") replaces the >>. " x.x: << point >>;\n" // the rules for the values from 0 to 19 are simply the // words for those numbers " zero; one; two; three; four; five; six; seven; eight; nine;\n" " ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n" " seventeen; eighteen; nineteen;\n" // beginning at 20, we use the >> to mark the position where // the result of formatting the number's ones digit. Thus, // we only need a new rule at every multiple of 10. Text in // backets is omitted if the value being formatted is an // even multiple of 10. " 20: twenty[->>];\n" " 30: thirty[->>];\n" " 40: forty[->>];\n" " 50: fifty[->>];\n" " 60: sixty[->>];\n" " 70: seventy[->>];\n" " 80: eighty[->>];\n" " 90: ninety[->>];\n" // beginning at 100, we can use << to mark the position where // the result of formatting the multiple of 100 is to be // inserted. Notice also that the meaning of >> has shifted: // here, it refers to both the ones place and the tens place. // The meanings of the << and >> tokens depend on the base value // of the rule. A rule's divisor is (usually) the highest // power of 10 that is less than or equal to the rule's base // value. The value being formatted is divided by the rule's // divisor, and the integral quotient is used to get the text // for <<, while the remainder is used to produce the text // for >>. Again, text in brackets is omitted if the value // being formatted is an even multiple of the rule's divisor // (in this case, an even multiple of 100) " 100: << hundred[ >>];\n" // The rules for the higher numbers work the same way as the // rule for 100: Again, the << and >> tokens depend on the // rule's divisor, which for all these rules is also the rule's // base value. To group by thousand, we simply don't have any // rules between 1,000 and 1,000,000. " 1000: << thousand[ >>];\n" " 1,000,000: << million[ >>];\n" " 1,000,000,000: << billion[ >>];\n" " 1,000,000,000,000: << trillion[ >>];\n" // overflow rule. This rule specifies that values of a // quadrillion or more are shown in numerals rather than words. // The == token means to format (with new rules) the value // being formatted by this rule and place the result where // the == is. The #,##0 inside the == signs is a // DecimalFormat pattern. It specifies that the value should // be formatted with a DecimalFormat object, and that it // should be formatted with no decimal places, at least one // digit, and a thousands separator. " 1,000,000,000,000,000: =#,##0=;\n" // %default is a more elaborate form of %simplified; It is basically // the same, except that it introduces "and" before the ones digit // when appropriate (basically, between the tens and ones digits) and // separates the thousands groups with commas in values over 100,000. "%default:\n" // negative-number and fraction rules. These are the same // as those for %simplified, but have to be stated here too // because this is an entry point " -x: minus >>;\n" " x.x: << point >>;\n" // just use %simplified for values below 100 " =%simplified=;\n" // for values from 100 to 9,999 use %%and to decide whether or // not to interpose the "and" " 100: << hundred[ >%%and>];\n" " 1000: << thousand[ >%%and>];\n" // for values of 100,000 and up, use %%commas to interpose the // commas in the right places (and also to interpose the "and") " 100,000>>: << thousand[>%%commas>];\n" " 1,000,000: << million[>%%commas>];\n" " 1,000,000,000: << billion[>%%commas>];\n" " 1,000,000,000,000: << trillion[>%%commas>];\n" " 1,000,000,000,000,000: =#,##0=;\n" // if the value passed to this rule set is greater than 100, don't // add the "and"; if it's less than 100, add "and" before the last // digits "%%and:\n" " and =%default=;\n" " 100: =%default=;\n" // this rule set is used to place the commas "%%commas:\n" // for values below 100, add "and" (the apostrophe at the // beginning is ignored, but causes the space that follows it // to be significant: this is necessary because the rules // calling %%commas don't put a space before it) " ' and =%default=;\n" // put a comma after the thousands (or whatever preceded the // hundreds) " 100: , =%default=;\n" // put a comma after the millions (or whatever precedes the // thousands) " 1000: , <%default< thousand, >%default>;\n" // and so on... " 1,000,000: , =%default=;" // %%lenient-parse isn't really a set of number formatting rules; // it's a set of collation rules. Lenient-parse mode uses a Collator // object to compare fragments of the text being parsed to the text // in the rules, allowing more leeway in the matching text. This set // of rules tells the formatter to ignore commas when parsing (it // already ignores spaces, which is why we refer to the space; it also // ignores hyphens, making "twenty one" and "twenty-one" parse // identically) "%%lenient-parse:\n" // " & ' ' , ',' ;\n" " &\u0000 << ' ' << ',' << '-'; \n" } // * This rule set adds an English ordinal abbreviation to the end of a // * number. For example, 2 is formatted as "2nd". Parsing doesn't work with // * this rule set. To parse, use DecimalFormat on the numeral. OrdinalRules { // this rule set formats the numeral and calls %%abbrev to // supply the abbreviation "%main:\n" " =#,##0==%%abbrev=;\n" // this rule set supplies the abbreviation "%%abbrev:\n" // the abbreviations. Everything from 4 to 19 ends in "th" " th; st; nd; rd; th;\n" // at 20, we begin repeating the cycle every 10 (13 is "13th", // but 23 and 33 are "23rd" and "33rd") We do this by // ignoring all bug the ones digit in selecting the abbreviation " 20: >>;\n" // at 100, we repeat the whole cycle by considering only the // tens and ones digits in picking an abbreviation " 100: >>;\n" } // * This rule set formats a number of seconds in sexagesimal notation // * (i.e., hours, minutes, and seconds). %with-words formats it with // * words (3,740 is "1 hour, 2 minutes, 20 seconds") and %in-numerals // * formats it entirely in numerals (3,740 is "1:02:20"). DurationRules { // main rule set for formatting with words "%with-words:\n" // take care of singular and plural forms of "second" " 0 seconds; 1 second; =0= seconds;\n" // use %%min to format values greater than 60 seconds " 60/60: <%%min<[, >>];\n" // use %%hr to format values greater than 3,600 seconds // (the ">>>" below causes us to see the number of minutes // when when there are zero minutes) " 3600/60: <%%hr<[, >>>];\n" // this rule set takes care of the singular and plural forms // of "minute" "%%min:\n" " 0 minutes; 1 minute; =0= minutes;\n" // this rule set takes care of the singular and plural forms // of "hour" "%%hr:\n" " 0 hours; 1 hour; =0= hours;\n" // main rule set for formatting in numerals "%in-numerals:\n" // values below 60 seconds are shown with "sec." " =0= sec.;\n" // higher values are shown with colons: %%min-sec is used for // values below 3,600 seconds... " 60: =%%min-sec=;\n" // ...and %%hr-min-sec is used for values of 3,600 seconds // and above " 3600: =%%hr-min-sec=;\n" // this rule causes values of less than 10 minutes to show without // a leading zero "%%min-sec:\n" " 0: :=00=;\n" " 60/60: <0<>>;\n" // this rule set is used for values of 3,600 or more. Minutes are always // shown, and always shown with two digits "%%hr-min-sec:\n" " 0: :=00=;\n" " 60/60: <00<>>;\n" " 3600/60: <#,##0<:>>>;\n" // the lenient-parse rules allow several different characters to be used // as delimiters between hours, minutes, and seconds "%%lenient-parse:\n" " & ':' = '.' = ' ' = '-';\n" } }