icuSources/i18n/plurrule_impl.h

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2007-2016, International Business Machines Corporation and
   6 * others. All Rights Reserved.
   7 *******************************************************************************
   8 *
   9 * File PLURRULE_IMPL.H
  10 *
  11 *******************************************************************************
  12 */
  13
  14
  15 #ifndef PLURRULE_IMPL
  16 #define PLURRULE_IMPL
  17
  18 // Internal definitions for the PluralRules implementation.
  19
  20 #include "unicode/utypes.h"
  21
  22 #if !UCONFIG_NO_FORMATTING
  23
  24 #include "unicode/format.h"
  25 #include "unicode/locid.h"
  26 #include "unicode/parseerr.h"
  27 #include "unicode/strenum.h"
  28 #include "unicode/ures.h"
  29 #include "uvector.h"
  30 #include "hash.h"
  31 #include "uassert.h"
  32
  33 class PluralRulesTest;
  34
  35 U_NAMESPACE_BEGIN
  36
  37 class AndConstraint;
  38 class RuleChain;
  39 class DigitInterval;
  40 class PluralRules;
  41 class VisibleDigits;
  42
  43 namespace pluralimpl {
  44
  45 // TODO: Remove this and replace with u"" literals. Was for EBCDIC compatibility.
  46
  47 static const UChar DOT = ((UChar) 0x002E);
  48 static const UChar SINGLE_QUOTE = ((UChar) 0x0027);
  49 static const UChar SLASH = ((UChar) 0x002F);
  50 static const UChar BACKSLASH = ((UChar) 0x005C);
  51 static const UChar SPACE = ((UChar) 0x0020);
  52 static const UChar EXCLAMATION = ((UChar) 0x0021);
  53 static const UChar QUOTATION_MARK = ((UChar) 0x0022);
  54 static const UChar NUMBER_SIGN = ((UChar) 0x0023);
  55 static const UChar PERCENT_SIGN = ((UChar) 0x0025);
  56 static const UChar ASTERISK = ((UChar) 0x002A);
  57 static const UChar COMMA = ((UChar) 0x002C);
  58 static const UChar HYPHEN = ((UChar) 0x002D);
  59 static const UChar U_ZERO = ((UChar) 0x0030);
  60 static const UChar U_ONE = ((UChar) 0x0031);
  61 static const UChar U_TWO = ((UChar) 0x0032);
  62 static const UChar U_THREE = ((UChar) 0x0033);
  63 static const UChar U_FOUR = ((UChar) 0x0034);
  64 static const UChar U_FIVE = ((UChar) 0x0035);
  65 static const UChar U_SIX = ((UChar) 0x0036);
  66 static const UChar U_SEVEN = ((UChar) 0x0037);
  67 static const UChar U_EIGHT = ((UChar) 0x0038);
  68 static const UChar U_NINE = ((UChar) 0x0039);
  69 static const UChar COLON = ((UChar) 0x003A);
  70 static const UChar SEMI_COLON = ((UChar) 0x003B);
  71 static const UChar EQUALS = ((UChar) 0x003D);
  72 static const UChar AT = ((UChar) 0x0040);
  73 static const UChar CAP_A = ((UChar) 0x0041);
  74 static const UChar CAP_B = ((UChar) 0x0042);
  75 static const UChar CAP_R = ((UChar) 0x0052);
  76 static const UChar CAP_Z = ((UChar) 0x005A);
  77 static const UChar LOWLINE = ((UChar) 0x005F);
  78 static const UChar LEFTBRACE = ((UChar) 0x007B);
  79 static const UChar RIGHTBRACE = ((UChar) 0x007D);
  80 static const UChar TILDE = ((UChar) 0x007E);
  81 static const UChar ELLIPSIS = ((UChar) 0x2026);
  82
  83 static const UChar LOW_A = ((UChar) 0x0061);
  84 static const UChar LOW_B = ((UChar) 0x0062);
  85 static const UChar LOW_C = ((UChar) 0x0063);
  86 static const UChar LOW_D = ((UChar) 0x0064);
  87 static const UChar LOW_E = ((UChar) 0x0065);
  88 static const UChar LOW_F = ((UChar) 0x0066);
  89 static const UChar LOW_G = ((UChar) 0x0067);
  90 static const UChar LOW_H = ((UChar) 0x0068);
  91 static const UChar LOW_I = ((UChar) 0x0069);
  92 static const UChar LOW_J = ((UChar) 0x006a);
  93 static const UChar LOW_K = ((UChar) 0x006B);
  94 static const UChar LOW_L = ((UChar) 0x006C);
  95 static const UChar LOW_M = ((UChar) 0x006D);
  96 static const UChar LOW_N = ((UChar) 0x006E);
  97 static const UChar LOW_O = ((UChar) 0x006F);
  98 static const UChar LOW_P = ((UChar) 0x0070);
  99 static const UChar LOW_Q = ((UChar) 0x0071);
 100 static const UChar LOW_R = ((UChar) 0x0072);
 101 static const UChar LOW_S = ((UChar) 0x0073);
 102 static const UChar LOW_T = ((UChar) 0x0074);
 103 static const UChar LOW_U = ((UChar) 0x0075);
 104 static const UChar LOW_V = ((UChar) 0x0076);
 105 static const UChar LOW_W = ((UChar) 0x0077);
 106 static const UChar LOW_Y = ((UChar) 0x0079);
 107 static const UChar LOW_Z = ((UChar) 0x007A);
 108
 109 }
 110
 111
 112 static const int32_t PLURAL_RANGE_HIGH = 0x7fffffff;
 113
 114 enum tokenType {
 115   none,
 116   tNumber,
 117   tComma,
 118   tSemiColon,
 119   tSpace,
 120   tColon,
 121   tAt,           // '@'
 122   tDot,
 123   tDot2,
 124   tEllipsis,
 125   tKeyword,
 126   tAnd,
 127   tOr,
 128   tMod,          // 'mod' or '%'
 129   tNot,          //  'not' only.
 130   tIn,           //  'in'  only.
 131   tEqual,        //  '='   only.
 132   tNotEqual,     //  '!='
 133   tTilde,
 134   tWithin,
 135   tIs,
 136   tVariableN,
 137   tVariableI,
 138   tVariableF,
 139   tVariableV,
 140   tVariableT,
 141   tDecimal,
 142   tInteger,
 143   tEOF
 144 };
 145
 146
 147 class PluralRuleParser: public UMemory {
 148 public:
 149     PluralRuleParser();
 150     virtual ~PluralRuleParser();
 151
 152     void parse(const UnicodeString &rules, PluralRules *dest, UErrorCode &status);
 153     void getNextToken(UErrorCode &status);
 154     void checkSyntax(UErrorCode &status);
 155     static int32_t getNumberValue(const UnicodeString &token);
 156
 157 private:
 158     static tokenType getKeyType(const UnicodeString& token, tokenType type);
 159     static tokenType charType(UChar ch);
 160     static UBool isValidKeyword(const UnicodeString& token);
 161
 162     const UnicodeString  *ruleSrc;  // The rules string.
 163     int32_t        ruleIndex;       // String index in the input rules, the current parse position.
 164     UnicodeString  token;           // Token most recently scanned.
 165     tokenType      type;
 166     tokenType      prevType;
 167
 168                                     // The items currently being parsed & built.
 169                                     // Note: currentChain may not be the last RuleChain in the
 170                                     //       list because the "other" chain is forced to the end.
 171     AndConstraint *curAndConstraint;
 172     RuleChain     *currentChain;
 173
 174     int32_t        rangeLowIdx;     // Indices in the UVector of ranges of the
 175     int32_t        rangeHiIdx;      //    low and hi values currently being parsed.
 176
 177     enum EParseState {
 178        kKeyword,
 179        kExpr,
 180        kValue,
 181        kRangeList,
 182        kSamples
 183     };
 184 };
 185
 186 enum PluralOperand {
 187     /**
 188     * The double value of the entire number.
 189     */
 190     PLURAL_OPERAND_N,
 191
 192     /**
 193      * The integer value, with the fraction digits truncated off.
 194      */
 195     PLURAL_OPERAND_I,
 196
 197     /**
 198      * All visible fraction digits as an integer, including trailing zeros.
 199      */
 200     PLURAL_OPERAND_F,
 201
 202     /**
 203      * Visible fraction digits as an integer, not including trailing zeros.
 204      */
 205     PLURAL_OPERAND_T,
 206
 207     /**
 208      * Number of visible fraction digits.
 209      */
 210     PLURAL_OPERAND_V,
 211
 212     /**
 213      * Number of visible fraction digits, not including trailing zeros.
 214      */
 215     PLURAL_OPERAND_W,
 216
 217     /**
 218      * THIS OPERAND IS DEPRECATED AND HAS BEEN REMOVED FROM THE SPEC.
 219      *
 220      * <p>Returns the integer value, but will fail if the number has fraction digits.
 221      * That is, using "j" instead of "i" is like implicitly adding "v is 0".
 222      *
 223      * <p>For example, "j is 3" is equivalent to "i is 3 and v is 0": it matches
 224      * "3" but not "3.1" or "3.0".
 225      */
 226     PLURAL_OPERAND_J
 227 };
 228
 229 /**
 230  * Converts from the tokenType enum to PluralOperand. Asserts that the given
 231  * tokenType can be mapped to a PluralOperand.
 232  */
 233 PluralOperand tokenTypeToPluralOperand(tokenType tt);
 234
 235 /**
 236  * An interface to FixedDecimal, allowing for other implementations.
 237  * @internal
 238  */
 239 class U_I18N_API IFixedDecimal {
 240   public:
 241     virtual ~IFixedDecimal();
 242
 243     /**
 244      * Returns the value corresponding to the specified operand (n, i, f, t, v, or w).
 245      * If the operand is 'n', returns a double; otherwise, returns an integer.
 246      */
 247     virtual double getPluralOperand(PluralOperand operand) const = 0;
 248
 249     virtual bool isNaN() const = 0;
 250
 251     virtual bool isInfinite() const = 0;
 252
 253     /** Whether the number has no nonzero fraction digits. */
 254     virtual bool hasIntegerValue() const = 0;
 255 };
 256
 257 /**
 258  * class FixedDecimal serves to communicate the properties
 259  * of a formatted number from a decimal formatter to PluralRules::select()
 260  *
 261  * see DecimalFormat::getFixedDecimal()
 262  * @internal
 263  */
 264 class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
 265   public:
 266     /**
 267       * @param n   the number, e.g. 12.345
 268       * @param v   The number of visible fraction digits, e.g. 3
 269       * @param f   The fraction digits, e.g. 345
 270       */
 271     FixedDecimal(double  n, int32_t v, int64_t f);
 272     FixedDecimal(double n, int32_t);
 273     explicit FixedDecimal(double n);
 274     FixedDecimal();
 275     ~FixedDecimal() U_OVERRIDE;
 276     FixedDecimal(const UnicodeString &s, UErrorCode &ec);
 277     FixedDecimal(const FixedDecimal &other);
 278
 279     double getPluralOperand(PluralOperand operand) const U_OVERRIDE;
 280     bool isNaN() const U_OVERRIDE;
 281     bool isInfinite() const U_OVERRIDE;
 282     bool hasIntegerValue() const U_OVERRIDE;
 283
 284     bool isNanOrInfinity() const;  // used in decimfmtimpl.cpp
 285
 286     int32_t getVisibleFractionDigitCount() const;
 287
 288     void init(double n, int32_t v, int64_t f);
 289     void init(double n);
 290     UBool quickInit(double n);  // Try a fast-path only initialization,
 291                                 //    return TRUE if successful.
 292     void adjustForMinFractionDigits(int32_t min);
 293     static int64_t getFractionalDigits(double n, int32_t v);
 294     static int32_t decimals(double n);
 295
 296     double      source;
 297     int32_t     visibleDecimalDigitCount;
 298     int64_t     decimalDigits;
 299     int64_t     decimalDigitsWithoutTrailingZeros;
 300     int64_t     intValue;
 301     UBool       _hasIntegerValue;
 302     UBool       isNegative;
 303     UBool       _isNaN;
 304     UBool       _isInfinite;
 305 };
 306
 307 class AndConstraint : public UMemory  {
 308 public:
 309     typedef enum RuleOp {
 310         NONE,
 311         MOD
 312     } RuleOp;
 313     RuleOp op = AndConstraint::NONE;
 314     int32_t opNum = -1;             // for mod expressions, the right operand of the mod.
 315     int32_t value = -1;             // valid for 'is' rules only.
 316     UVector32 *rangeList = nullptr; // for 'in', 'within' rules. Null otherwise.
 317     UBool negated = FALSE;          // TRUE for negated rules.
 318     UBool integerOnly = FALSE;      // TRUE for 'within' rules.
 319     tokenType digitsType = none;    // n | i | v | f constraint.
 320     AndConstraint *next = nullptr;
 321     // Internal error status, used for errors that occur during the copy constructor.
 322     UErrorCode fInternalStatus = U_ZERO_ERROR;
 323
 324     AndConstraint() = default;
 325     AndConstraint(const AndConstraint& other);
 326     virtual ~AndConstraint();
 327     AndConstraint* add(UErrorCode& status);
 328     // UBool isFulfilled(double number);
 329     UBool isFulfilled(const IFixedDecimal &number);
 330 };
 331
 332 class OrConstraint : public UMemory  {
 333 public:
 334     AndConstraint *childNode = nullptr;
 335     OrConstraint *next = nullptr;
 336     // Internal error status, used for errors that occur during the copy constructor.
 337     UErrorCode fInternalStatus = U_ZERO_ERROR;
 338
 339     OrConstraint() = default;
 340     OrConstraint(const OrConstraint& other);
 341     virtual ~OrConstraint();
 342     AndConstraint* add(UErrorCode& status);
 343     // UBool isFulfilled(double number);
 344     UBool isFulfilled(const IFixedDecimal &number);
 345 };
 346
 347 class RuleChain : public UMemory  {
 348 public:
 349     UnicodeString   fKeyword;
 350     RuleChain      *fNext = nullptr;
 351     OrConstraint   *ruleHeader = nullptr;
 352     UnicodeString   fDecimalSamples;  // Samples strings from rule source
 353     UnicodeString   fIntegerSamples;  //   without @decimal or @integer, otherwise unprocessed.
 354     UBool           fDecimalSamplesUnbounded = FALSE;
 355     UBool           fIntegerSamplesUnbounded = FALSE;
 356     // Internal error status, used for errors that occur during the copy constructor.
 357     UErrorCode      fInternalStatus = U_ZERO_ERROR;
 358
 359     RuleChain() = default;
 360     RuleChain(const RuleChain& other);
 361     virtual ~RuleChain();
 362
 363     UnicodeString select(const IFixedDecimal &number) const;
 364     void          dumpRules(UnicodeString& result);
 365     UErrorCode    getKeywords(int32_t maxArraySize, UnicodeString *keywords, int32_t& arraySize) const;
 366     UBool         isKeyword(const UnicodeString& keyword) const;
 367 };
 368
 369 class PluralKeywordEnumeration : public StringEnumeration {
 370 public:
 371     PluralKeywordEnumeration(RuleChain *header, UErrorCode& status);
 372     virtual ~PluralKeywordEnumeration();
 373     static UClassID U_EXPORT2 getStaticClassID(void);
 374     virtual UClassID getDynamicClassID(void) const;
 375     virtual const UnicodeString* snext(UErrorCode& status);
 376     virtual void reset(UErrorCode& status);
 377     virtual int32_t count(UErrorCode& status) const;
 378 private:
 379     int32_t         pos;
 380     UVector         fKeywordNames;
 381 };
 382
 383
 384 class U_I18N_API PluralAvailableLocalesEnumeration: public StringEnumeration {
 385   public:
 386     PluralAvailableLocalesEnumeration(UErrorCode &status);
 387     virtual ~PluralAvailableLocalesEnumeration();
 388     virtual const char* next(int32_t *resultLength, UErrorCode& status);
 389     virtual void reset(UErrorCode& status);
 390     virtual int32_t count(UErrorCode& status) const;
 391   private:
 392     UErrorCode      fOpenStatus;
 393     UResourceBundle *fLocales = nullptr;
 394     UResourceBundle *fRes = nullptr;
 395 };
 396
 397 U_NAMESPACE_END
 398
 399 #endif /* #if !UCONFIG_NO_FORMATTING */
 400
 401 #endif // _PLURRULE_IMPL
 402 //eof