summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-xetex/data/rbnf/en.txt
diff options
context:
space:
mode:
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.txt219
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"
+ }
+}