diff options
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/data/rbnf/en.txt')
-rw-r--r-- | Build/source/libs/icu/icu-xetex/data/rbnf/en.txt | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/data/rbnf/en.txt b/Build/source/libs/icu/icu-xetex/data/rbnf/en.txt new file mode 100644 index 00000000000..3cbcecb2825 --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/data/rbnf/en.txt @@ -0,0 +1,219 @@ +// *************************************************************************** +// * +// * Copyright (C) 2004, International Business Machines +// * Corporation and others. All Rights Reserved. +// * +// *************************************************************************** +// + +en { + + + //------------------------------------------------------------ + // 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" + } +} |