X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/46f4442e9a5a4f3b98b7c1083586332f6a8a99a4..3d1f044b704633e2e541231cd17ae9ecf9ad5c7a:/icuSources/i18n/plurrule_impl.h
diff --git a/icuSources/i18n/plurrule_impl.h b/icuSources/i18n/plurrule_impl.h
index 82f79ca9..3a919ea9 100644
--- a/icuSources/i18n/plurrule_impl.h
+++ b/icuSources/i18n/plurrule_impl.h
@@ -1,6 +1,8 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
-* Copyright (C) 2007-2008, International Business Machines Corporation and
+* Copyright (C) 2007-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*
@@ -10,140 +12,296 @@
*/
-#ifndef PLURRULE_IMPLE
-#define PLURRULE_IMPLE
+#ifndef PLURRULE_IMPL
+#define PLURRULE_IMPL
+
+// Internal definitions for the PluralRules implementation.
+
+#include "unicode/utypes.h"
-/**
- * \file
- * \brief C++ API: Defines rules for mapping positive long values onto a small set of keywords.
- */
-
#if !UCONFIG_NO_FORMATTING
#include "unicode/format.h"
#include "unicode/locid.h"
#include "unicode/parseerr.h"
-#include "unicode/utypes.h"
+#include "unicode/strenum.h"
+#include "unicode/ures.h"
#include "uvector.h"
#include "hash.h"
+#include "uassert.h"
+
+class PluralRulesTest;
U_NAMESPACE_BEGIN
-#define DOT ((UChar)0x002E)
-#define SINGLE_QUOTE ((UChar)0x0027)
-#define SLASH ((UChar)0x002F)
-#define BACKSLASH ((UChar)0x005C)
-#define SPACE ((UChar)0x0020)
-#define QUOTATION_MARK ((UChar)0x0022)
-#define NUMBER_SIGN ((UChar)0x0023)
-#define ASTERISK ((UChar)0x002A)
-#define COMMA ((UChar)0x002C)
-#define HYPHEN ((UChar)0x002D)
-#define U_ZERO ((UChar)0x0030)
-#define U_ONE ((UChar)0x0031)
-#define U_TWO ((UChar)0x0032)
-#define U_THREE ((UChar)0x0033)
-#define U_FOUR ((UChar)0x0034)
-#define U_FIVE ((UChar)0x0035)
-#define U_SIX ((UChar)0x0036)
-#define U_SEVEN ((UChar)0x0037)
-#define U_EIGHT ((UChar)0x0038)
-#define U_NINE ((UChar)0x0039)
-#define COLON ((UChar)0x003A)
-#define SEMI_COLON ((UChar)0x003B)
-#define CAP_A ((UChar)0x0041)
-#define CAP_B ((UChar)0x0042)
-#define CAP_R ((UChar)0x0052)
-#define CAP_Z ((UChar)0x005A)
-#define LOWLINE ((UChar)0x005F)
-#define LEFTBRACE ((UChar)0x007B)
-#define RIGHTBRACE ((UChar)0x007D)
-
-#define LOW_A ((UChar)0x0061)
-#define LOW_B ((UChar)0x0062)
-#define LOW_C ((UChar)0x0063)
-#define LOW_D ((UChar)0x0064)
-#define LOW_E ((UChar)0x0065)
-#define LOW_F ((UChar)0x0066)
-#define LOW_G ((UChar)0x0067)
-#define LOW_H ((UChar)0x0068)
-#define LOW_I ((UChar)0x0069)
-#define LOW_J ((UChar)0x006a)
-#define LOW_K ((UChar)0x006B)
-#define LOW_L ((UChar)0x006C)
-#define LOW_M ((UChar)0x006D)
-#define LOW_N ((UChar)0x006E)
-#define LOW_O ((UChar)0x006F)
-#define LOW_P ((UChar)0x0070)
-#define LOW_Q ((UChar)0x0071)
-#define LOW_R ((UChar)0x0072)
-#define LOW_S ((UChar)0x0073)
-#define LOW_T ((UChar)0x0074)
-#define LOW_U ((UChar)0x0075)
-#define LOW_V ((UChar)0x0076)
-#define LOW_W ((UChar)0x0077)
-#define LOW_Y ((UChar)0x0079)
-#define LOW_Z ((UChar)0x007A)
-
-
-#define PLURAL_RANGE_HIGH 0x7fffffff;
-
-
-class UnicodeSet;
-
-typedef enum PluralKey {
- pZero,
- pOne,
- pTwo,
- pFew,
- pMany,
- pOther,
- pLast
-}PluralKey;
-
-typedef enum tokenType {
+class AndConstraint;
+class RuleChain;
+class DigitInterval;
+class PluralRules;
+class VisibleDigits;
+
+namespace pluralimpl {
+
+// TODO: Remove this and replace with u"" literals. Was for EBCDIC compatibility.
+
+static const UChar DOT = ((UChar) 0x002E);
+static const UChar SINGLE_QUOTE = ((UChar) 0x0027);
+static const UChar SLASH = ((UChar) 0x002F);
+static const UChar BACKSLASH = ((UChar) 0x005C);
+static const UChar SPACE = ((UChar) 0x0020);
+static const UChar EXCLAMATION = ((UChar) 0x0021);
+static const UChar QUOTATION_MARK = ((UChar) 0x0022);
+static const UChar NUMBER_SIGN = ((UChar) 0x0023);
+static const UChar PERCENT_SIGN = ((UChar) 0x0025);
+static const UChar ASTERISK = ((UChar) 0x002A);
+static const UChar COMMA = ((UChar) 0x002C);
+static const UChar HYPHEN = ((UChar) 0x002D);
+static const UChar U_ZERO = ((UChar) 0x0030);
+static const UChar U_ONE = ((UChar) 0x0031);
+static const UChar U_TWO = ((UChar) 0x0032);
+static const UChar U_THREE = ((UChar) 0x0033);
+static const UChar U_FOUR = ((UChar) 0x0034);
+static const UChar U_FIVE = ((UChar) 0x0035);
+static const UChar U_SIX = ((UChar) 0x0036);
+static const UChar U_SEVEN = ((UChar) 0x0037);
+static const UChar U_EIGHT = ((UChar) 0x0038);
+static const UChar U_NINE = ((UChar) 0x0039);
+static const UChar COLON = ((UChar) 0x003A);
+static const UChar SEMI_COLON = ((UChar) 0x003B);
+static const UChar EQUALS = ((UChar) 0x003D);
+static const UChar AT = ((UChar) 0x0040);
+static const UChar CAP_A = ((UChar) 0x0041);
+static const UChar CAP_B = ((UChar) 0x0042);
+static const UChar CAP_R = ((UChar) 0x0052);
+static const UChar CAP_Z = ((UChar) 0x005A);
+static const UChar LOWLINE = ((UChar) 0x005F);
+static const UChar LEFTBRACE = ((UChar) 0x007B);
+static const UChar RIGHTBRACE = ((UChar) 0x007D);
+static const UChar TILDE = ((UChar) 0x007E);
+static const UChar ELLIPSIS = ((UChar) 0x2026);
+
+static const UChar LOW_A = ((UChar) 0x0061);
+static const UChar LOW_B = ((UChar) 0x0062);
+static const UChar LOW_C = ((UChar) 0x0063);
+static const UChar LOW_D = ((UChar) 0x0064);
+static const UChar LOW_E = ((UChar) 0x0065);
+static const UChar LOW_F = ((UChar) 0x0066);
+static const UChar LOW_G = ((UChar) 0x0067);
+static const UChar LOW_H = ((UChar) 0x0068);
+static const UChar LOW_I = ((UChar) 0x0069);
+static const UChar LOW_J = ((UChar) 0x006a);
+static const UChar LOW_K = ((UChar) 0x006B);
+static const UChar LOW_L = ((UChar) 0x006C);
+static const UChar LOW_M = ((UChar) 0x006D);
+static const UChar LOW_N = ((UChar) 0x006E);
+static const UChar LOW_O = ((UChar) 0x006F);
+static const UChar LOW_P = ((UChar) 0x0070);
+static const UChar LOW_Q = ((UChar) 0x0071);
+static const UChar LOW_R = ((UChar) 0x0072);
+static const UChar LOW_S = ((UChar) 0x0073);
+static const UChar LOW_T = ((UChar) 0x0074);
+static const UChar LOW_U = ((UChar) 0x0075);
+static const UChar LOW_V = ((UChar) 0x0076);
+static const UChar LOW_W = ((UChar) 0x0077);
+static const UChar LOW_Y = ((UChar) 0x0079);
+static const UChar LOW_Z = ((UChar) 0x007A);
+
+}
+
+
+static const int32_t PLURAL_RANGE_HIGH = 0x7fffffff;
+
+enum tokenType {
none,
- tLetter,
tNumber,
tComma,
tSemiColon,
tSpace,
tColon,
+ tAt, // '@'
tDot,
+ tDot2,
+ tEllipsis,
tKeyword,
- tZero,
- tOne,
- tTwo,
- tFew,
- tMany,
- tOther,
tAnd,
tOr,
- tMod,
- tNot,
- tIn,
+ tMod, // 'mod' or '%'
+ tNot, // 'not' only.
+ tIn, // 'in' only.
+ tEqual, // '=' only.
+ tNotEqual, // '!='
+ tTilde,
tWithin,
- tNotIn,
- tVariableN,
tIs,
- tLeftBrace,
- tRightBrace
-}tokenType;
+ tVariableN,
+ tVariableI,
+ tVariableF,
+ tVariableV,
+ tVariableT,
+ tDecimal,
+ tInteger,
+ tEOF
+};
-class RuleParser : public UMemory {
+
+class PluralRuleParser: public UMemory {
public:
- RuleParser();
- virtual ~RuleParser();
- void getNextToken(const UnicodeString& ruleData, int32_t *ruleIndex, UnicodeString& token,
- tokenType& type, UErrorCode &status);
- void checkSyntax(tokenType prevType, tokenType curType, UErrorCode &status);
+ PluralRuleParser();
+ virtual ~PluralRuleParser();
+
+ void parse(const UnicodeString &rules, PluralRules *dest, UErrorCode &status);
+ void getNextToken(UErrorCode &status);
+ void checkSyntax(UErrorCode &status);
+ static int32_t getNumberValue(const UnicodeString &token);
+
private:
- UnicodeSet *idStartFilter;
- UnicodeSet *idContinueFilter;
-
- void getKeyType(const UnicodeString& token, tokenType& type, UErrorCode &status);
- UBool inRange(UChar ch, tokenType& type);
- UBool isValidKeyword(const UnicodeString& token);
+ static tokenType getKeyType(const UnicodeString& token, tokenType type);
+ static tokenType charType(UChar ch);
+ static UBool isValidKeyword(const UnicodeString& token);
+
+ const UnicodeString *ruleSrc; // The rules string.
+ int32_t ruleIndex; // String index in the input rules, the current parse position.
+ UnicodeString token; // Token most recently scanned.
+ tokenType type;
+ tokenType prevType;
+
+ // The items currently being parsed & built.
+ // Note: currentChain may not be the last RuleChain in the
+ // list because the "other" chain is forced to the end.
+ AndConstraint *curAndConstraint;
+ RuleChain *currentChain;
+
+ int32_t rangeLowIdx; // Indices in the UVector of ranges of the
+ int32_t rangeHiIdx; // low and hi values currently being parsed.
+
+ enum EParseState {
+ kKeyword,
+ kExpr,
+ kValue,
+ kRangeList,
+ kSamples
+ };
+};
+
+enum PluralOperand {
+ /**
+ * The double value of the entire number.
+ */
+ PLURAL_OPERAND_N,
+
+ /**
+ * The integer value, with the fraction digits truncated off.
+ */
+ PLURAL_OPERAND_I,
+
+ /**
+ * All visible fraction digits as an integer, including trailing zeros.
+ */
+ PLURAL_OPERAND_F,
+
+ /**
+ * Visible fraction digits as an integer, not including trailing zeros.
+ */
+ PLURAL_OPERAND_T,
+
+ /**
+ * Number of visible fraction digits.
+ */
+ PLURAL_OPERAND_V,
+
+ /**
+ * Number of visible fraction digits, not including trailing zeros.
+ */
+ PLURAL_OPERAND_W,
+
+ /**
+ * THIS OPERAND IS DEPRECATED AND HAS BEEN REMOVED FROM THE SPEC.
+ *
+ * Returns the integer value, but will fail if the number has fraction digits.
+ * That is, using "j" instead of "i" is like implicitly adding "v is 0".
+ *
+ *
For example, "j is 3" is equivalent to "i is 3 and v is 0": it matches
+ * "3" but not "3.1" or "3.0".
+ */
+ PLURAL_OPERAND_J
+};
+
+/**
+ * Converts from the tokenType enum to PluralOperand. Asserts that the given
+ * tokenType can be mapped to a PluralOperand.
+ */
+PluralOperand tokenTypeToPluralOperand(tokenType tt);
+
+/**
+ * An interface to FixedDecimal, allowing for other implementations.
+ * @internal
+ */
+class U_I18N_API IFixedDecimal {
+ public:
+ virtual ~IFixedDecimal();
+
+ /**
+ * Returns the value corresponding to the specified operand (n, i, f, t, v, or w).
+ * If the operand is 'n', returns a double; otherwise, returns an integer.
+ */
+ virtual double getPluralOperand(PluralOperand operand) const = 0;
+
+ virtual bool isNaN() const = 0;
+
+ virtual bool isInfinite() const = 0;
+
+ /** Whether the number has no nonzero fraction digits. */
+ virtual bool hasIntegerValue() const = 0;
+};
+
+/**
+ * class FixedDecimal serves to communicate the properties
+ * of a formatted number from a decimal formatter to PluralRules::select()
+ *
+ * see DecimalFormat::getFixedDecimal()
+ * @internal
+ */
+class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
+ public:
+ /**
+ * @param n the number, e.g. 12.345
+ * @param v The number of visible fraction digits, e.g. 3
+ * @param f The fraction digits, e.g. 345
+ */
+ FixedDecimal(double n, int32_t v, int64_t f);
+ FixedDecimal(double n, int32_t);
+ explicit FixedDecimal(double n);
+ FixedDecimal();
+ ~FixedDecimal() U_OVERRIDE;
+ FixedDecimal(const UnicodeString &s, UErrorCode &ec);
+ FixedDecimal(const FixedDecimal &other);
+
+ double getPluralOperand(PluralOperand operand) const U_OVERRIDE;
+ bool isNaN() const U_OVERRIDE;
+ bool isInfinite() const U_OVERRIDE;
+ bool hasIntegerValue() const U_OVERRIDE;
+
+ bool isNanOrInfinity() const; // used in decimfmtimpl.cpp
+
+ int32_t getVisibleFractionDigitCount() const;
+
+ void init(double n, int32_t v, int64_t f);
+ void init(double n);
+ UBool quickInit(double n); // Try a fast-path only initialization,
+ // return TRUE if successful.
+ void adjustForMinFractionDigits(int32_t min);
+ static int64_t getFractionalDigits(double n, int32_t v);
+ static int32_t decimals(double n);
+
+ double source;
+ int32_t visibleDecimalDigitCount;
+ int64_t decimalDigits;
+ int64_t decimalDigitsWithoutTrailingZeros;
+ int64_t intValue;
+ UBool _hasIntegerValue;
+ UBool isNegative;
+ UBool _isNaN;
+ UBool _isInfinite;
};
class AndConstraint : public UMemory {
@@ -152,51 +310,60 @@ public:
NONE,
MOD
} RuleOp;
- RuleOp op;
- int32_t opNum;
- int32_t rangeLow;
- int32_t rangeHigh;
- UBool notIn;
- UBool integerOnly;
- AndConstraint *next;
-
- AndConstraint();
+ RuleOp op = AndConstraint::NONE;
+ int32_t opNum = -1; // for mod expressions, the right operand of the mod.
+ int32_t value = -1; // valid for 'is' rules only.
+ UVector32 *rangeList = nullptr; // for 'in', 'within' rules. Null otherwise.
+ UBool negated = FALSE; // TRUE for negated rules.
+ UBool integerOnly = FALSE; // TRUE for 'within' rules.
+ tokenType digitsType = none; // n | i | v | f constraint.
+ AndConstraint *next = nullptr;
+ // Internal error status, used for errors that occur during the copy constructor.
+ UErrorCode fInternalStatus = U_ZERO_ERROR;
+
+ AndConstraint() = default;
AndConstraint(const AndConstraint& other);
virtual ~AndConstraint();
- AndConstraint* add();
- UBool isFulfilled(double number);
- int32_t updateRepeatLimit(int32_t maxLimit);
+ AndConstraint* add(UErrorCode& status);
+ // UBool isFulfilled(double number);
+ UBool isFulfilled(const IFixedDecimal &number);
};
class OrConstraint : public UMemory {
public:
- AndConstraint *childNode;
- OrConstraint *next;
- OrConstraint();
-
+ AndConstraint *childNode = nullptr;
+ OrConstraint *next = nullptr;
+ // Internal error status, used for errors that occur during the copy constructor.
+ UErrorCode fInternalStatus = U_ZERO_ERROR;
+
+ OrConstraint() = default;
OrConstraint(const OrConstraint& other);
virtual ~OrConstraint();
- AndConstraint* add();
- UBool isFulfilled(double number);
+ AndConstraint* add(UErrorCode& status);
+ // UBool isFulfilled(double number);
+ UBool isFulfilled(const IFixedDecimal &number);
};
class RuleChain : public UMemory {
public:
- OrConstraint *ruleHeader;
- UnicodeString keyword;
- RuleChain();
+ UnicodeString fKeyword;
+ RuleChain *fNext = nullptr;
+ OrConstraint *ruleHeader = nullptr;
+ UnicodeString fDecimalSamples; // Samples strings from rule source
+ UnicodeString fIntegerSamples; // without @decimal or @integer, otherwise unprocessed.
+ UBool fDecimalSamplesUnbounded = FALSE;
+ UBool fIntegerSamplesUnbounded = FALSE;
+ // Internal error status, used for errors that occur during the copy constructor.
+ UErrorCode fInternalStatus = U_ZERO_ERROR;
+
+ RuleChain() = default;
RuleChain(const RuleChain& other);
- RuleChain *next;
-
virtual ~RuleChain();
- UnicodeString select(double number) const;
- void dumpRules(UnicodeString& result);
- int32_t getRepeatLimit();
- UErrorCode getKeywords(int32_t maxArraySize, UnicodeString *keywords, int32_t& arraySize) const;
- UBool isKeyword(const UnicodeString& keyword) const;
- void setRepeatLimit();
-private:
- int32_t repeatLimit;
+
+ UnicodeString select(const IFixedDecimal &number) const;
+ void dumpRules(UnicodeString& result);
+ UErrorCode getKeywords(int32_t maxArraySize, UnicodeString *keywords, int32_t& arraySize) const;
+ UBool isKeyword(const UnicodeString& keyword) const;
};
class PluralKeywordEnumeration : public StringEnumeration {
@@ -209,8 +376,22 @@ public:
virtual void reset(UErrorCode& status);
virtual int32_t count(UErrorCode& status) const;
private:
- int32_t pos;
- UVector fKeywordNames;
+ int32_t pos;
+ UVector fKeywordNames;
+};
+
+
+class U_I18N_API PluralAvailableLocalesEnumeration: public StringEnumeration {
+ public:
+ PluralAvailableLocalesEnumeration(UErrorCode &status);
+ virtual ~PluralAvailableLocalesEnumeration();
+ virtual const char* next(int32_t *resultLength, UErrorCode& status);
+ virtual void reset(UErrorCode& status);
+ virtual int32_t count(UErrorCode& status) const;
+ private:
+ UErrorCode fOpenStatus;
+ UResourceBundle *fLocales = nullptr;
+ UResourceBundle *fRes = nullptr;
};
U_NAMESPACE_END