// ***************************************************************************
// *
// *   Copyright (C) 2004, International Business Machines
// *   Corporation and others.  All Rights Reserved.
// *
// ***************************************************************************
// 

mt {
// Spellout rules.  Experimental.

    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 punt one two
                // three") replaces the >>.
            "x.x: << punt >>;\n"
                // the rules for the values from 0 to 19 are simply the
                // words for those numbers
            "żero; wieħed; tnejn; tlieta; erbgħa; ħamsa; sitta; sebgħa; tmienja; disgħa;\n"
            "għaxra; ħdax; tnax; tlettax; erbatax; ħmistax; sittax;\n"
            "    sbatax; tmintax; dsatax;\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: [>> u ]għoxrin;\n"
            "30: [>> u ]tletin;\n"
            "40: [>> u ]erbgħin;\n"
            "50: [>> u ]ħamsin;\n"
            "60: [>> u ]sittin;\n"
            "70: [>> u ]sebgħin;\n"
            "80: [>> u ]tmenin;\n"
            "90: [>> u ]disgħin;\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: mija[ u >>];\n"
            "200: mitejn[ u >>];\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: << elf[ u >>];\n"
            "2000: << elfejn[ u >>];\n"
            "3000: tliet elef [ u >>];\n"
            "1,000,000: << miljun[ u >>];\n"
            "1,000,000,000: << biljun[ >>];\n"
            "1,000,000,000,000: << triljun[ >>];\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: << punt >>;\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: mija[ >%%and>];\n"
            "200: mitejn[ >%%and>];\n"
            "300: tlett mija[ >%%and>];\n"
            "400: erbgħa mija[ >%%and>];\n"
            "500: ħames mija[ >%%and>];\n"
            "600: sitt mija[ >%%and>];\n"
            "700: sebgħa mija[ >%%and>];\n"
            "800: tmin mija[ >%%and>];\n"
            "900: disgħa mija[ >%%and>];\n"
            "1000: << elf[ >%%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"
            "u =%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"
    }


    DurationRules {
        // main rule set for formatting with words
        "%with-words:\n"
                // take care of singular and plural forms of "second"
            "0 sekondi; 1 sekonda; =0= sekondi;\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 minuti; 1 minuta; =0= minuti;\n"
        // this rule set takes care of the singular and plural forms
        // of "hour"
        "%%hr:\n"
            "0 siegħat; 1 siegħa; =0= siegħat;\n"

        // main rule set for formatting in numerals
        "%in-numerals:\n"
                // values below 60 seconds are shown with "sec."
            "=0= sek.;\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" 
    }
}