| /* | |
| ******************************************************************************* | |
| * Copyright (C) 2009-2015, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ******************************************************************************* | |
| * | |
| * File PLURFMT.CPP | |
| ******************************************************************************* | |
| */ | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/decimfmt.h" | |
| #include "unicode/messagepattern.h" | |
| #include "unicode/plurfmt.h" | |
| #include "unicode/plurrule.h" | |
| #include "unicode/utypes.h" | |
| #include "cmemory.h" | |
| #include "messageimpl.h" | |
| #include "nfrule.h" | |
| #include "plurrule_impl.h" | |
| #include "uassert.h" | |
| #include "uhash.h" | |
| #include "precision.h" | |
| #include "visibledigits.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| U_NAMESPACE_BEGIN | |
| static const UChar OTHER_STRING[] = { | |
| 0x6F, 0x74, 0x68, 0x65, 0x72, 0 // "other" | |
| }; | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralFormat) | |
| PluralFormat::PluralFormat(UErrorCode& status) | |
| : locale(Locale::getDefault()), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(NULL, UPLURAL_TYPE_CARDINAL, status); | |
| } | |
| PluralFormat::PluralFormat(const Locale& loc, UErrorCode& status) | |
| : locale(loc), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(NULL, UPLURAL_TYPE_CARDINAL, status); | |
| } | |
| PluralFormat::PluralFormat(const PluralRules& rules, UErrorCode& status) | |
| : locale(Locale::getDefault()), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(&rules, UPLURAL_TYPE_COUNT, status); | |
| } | |
| PluralFormat::PluralFormat(const Locale& loc, | |
| const PluralRules& rules, | |
| UErrorCode& status) | |
| : locale(loc), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(&rules, UPLURAL_TYPE_COUNT, status); | |
| } | |
| PluralFormat::PluralFormat(const Locale& loc, | |
| UPluralType type, | |
| UErrorCode& status) | |
| : locale(loc), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(NULL, type, status); | |
| } | |
| PluralFormat::PluralFormat(const UnicodeString& pat, | |
| UErrorCode& status) | |
| : locale(Locale::getDefault()), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(NULL, UPLURAL_TYPE_CARDINAL, status); | |
| applyPattern(pat, status); | |
| } | |
| PluralFormat::PluralFormat(const Locale& loc, | |
| const UnicodeString& pat, | |
| UErrorCode& status) | |
| : locale(loc), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(NULL, UPLURAL_TYPE_CARDINAL, status); | |
| applyPattern(pat, status); | |
| } | |
| PluralFormat::PluralFormat(const PluralRules& rules, | |
| const UnicodeString& pat, | |
| UErrorCode& status) | |
| : locale(Locale::getDefault()), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(&rules, UPLURAL_TYPE_COUNT, status); | |
| applyPattern(pat, status); | |
| } | |
| PluralFormat::PluralFormat(const Locale& loc, | |
| const PluralRules& rules, | |
| const UnicodeString& pat, | |
| UErrorCode& status) | |
| : locale(loc), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(&rules, UPLURAL_TYPE_COUNT, status); | |
| applyPattern(pat, status); | |
| } | |
| PluralFormat::PluralFormat(const Locale& loc, | |
| UPluralType type, | |
| const UnicodeString& pat, | |
| UErrorCode& status) | |
| : locale(loc), | |
| msgPattern(status), | |
| numberFormat(NULL), | |
| offset(0) { | |
| init(NULL, type, status); | |
| applyPattern(pat, status); | |
| } | |
| PluralFormat::PluralFormat(const PluralFormat& other) | |
| : Format(other), | |
| locale(other.locale), | |
| msgPattern(other.msgPattern), | |
| numberFormat(NULL), | |
| offset(other.offset) { | |
| copyObjects(other); | |
| } | |
| void | |
| PluralFormat::copyObjects(const PluralFormat& other) { | |
| UErrorCode status = U_ZERO_ERROR; | |
| if (numberFormat != NULL) { | |
| delete numberFormat; | |
| } | |
| if (pluralRulesWrapper.pluralRules != NULL) { | |
| delete pluralRulesWrapper.pluralRules; | |
| } | |
| if (other.numberFormat == NULL) { | |
| numberFormat = NumberFormat::createInstance(locale, status); | |
| } else { | |
| numberFormat = (NumberFormat*)other.numberFormat->clone(); | |
| } | |
| if (other.pluralRulesWrapper.pluralRules == NULL) { | |
| pluralRulesWrapper.pluralRules = PluralRules::forLocale(locale, status); | |
| } else { | |
| pluralRulesWrapper.pluralRules = other.pluralRulesWrapper.pluralRules->clone(); | |
| } | |
| } | |
| PluralFormat::~PluralFormat() { | |
| delete numberFormat; | |
| } | |
| void | |
| PluralFormat::init(const PluralRules* rules, UPluralType type, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (rules==NULL) { | |
| pluralRulesWrapper.pluralRules = PluralRules::forLocale(locale, type, status); | |
| } else { | |
| pluralRulesWrapper.pluralRules = rules->clone(); | |
| if (pluralRulesWrapper.pluralRules == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } | |
| numberFormat= NumberFormat::createInstance(locale, status); | |
| } | |
| void | |
| PluralFormat::applyPattern(const UnicodeString& newPattern, UErrorCode& status) { | |
| msgPattern.parsePluralStyle(newPattern, NULL, status); | |
| if (U_FAILURE(status)) { | |
| msgPattern.clear(); | |
| offset = 0; | |
| return; | |
| } | |
| offset = msgPattern.getPluralOffset(0); | |
| } | |
| UnicodeString& | |
| PluralFormat::format(const Formattable& obj, | |
| UnicodeString& appendTo, | |
| FieldPosition& pos, | |
| UErrorCode& status) const | |
| { | |
| if (U_FAILURE(status)) return appendTo; | |
| if (obj.isNumeric()) { | |
| return format(obj, obj.getDouble(), appendTo, pos, status); | |
| } else { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return appendTo; | |
| } | |
| } | |
| UnicodeString | |
| PluralFormat::format(int32_t number, UErrorCode& status) const { | |
| FieldPosition fpos(0); | |
| UnicodeString result; | |
| return format(Formattable(number), number, result, fpos, status); | |
| } | |
| UnicodeString | |
| PluralFormat::format(double number, UErrorCode& status) const { | |
| FieldPosition fpos(0); | |
| UnicodeString result; | |
| return format(Formattable(number), number, result, fpos, status); | |
| } | |
| UnicodeString& | |
| PluralFormat::format(int32_t number, | |
| UnicodeString& appendTo, | |
| FieldPosition& pos, | |
| UErrorCode& status) const { | |
| return format(Formattable(number), (double)number, appendTo, pos, status); | |
| } | |
| UnicodeString& | |
| PluralFormat::format(double number, | |
| UnicodeString& appendTo, | |
| FieldPosition& pos, | |
| UErrorCode& status) const { | |
| return format(Formattable(number), (double)number, appendTo, pos, status); | |
| } | |
| UnicodeString& | |
| PluralFormat::format(const Formattable& numberObject, double number, | |
| UnicodeString& appendTo, | |
| FieldPosition& pos, | |
| UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| if (msgPattern.countParts() == 0) { | |
| return numberFormat->format(numberObject, appendTo, pos, status); | |
| } | |
| // Get the appropriate sub-message. | |
| // Select it based on the formatted number-offset. | |
| double numberMinusOffset = number - offset; | |
| UnicodeString numberString; | |
| FieldPosition ignorePos; | |
| FixedPrecision fp; | |
| VisibleDigitsWithExponent dec; | |
| fp.initVisibleDigitsWithExponent(numberMinusOffset, dec, status); | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| if (offset == 0) { | |
| DecimalFormat *decFmt = dynamic_cast<DecimalFormat *>(numberFormat); | |
| if(decFmt != NULL) { | |
| decFmt->initVisibleDigitsWithExponent( | |
| numberObject, dec, status); | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| decFmt->format(dec, numberString, ignorePos, status); | |
| } else { | |
| numberFormat->format( | |
| numberObject, numberString, ignorePos, status); // could be BigDecimal etc. | |
| } | |
| } else { | |
| DecimalFormat *decFmt = dynamic_cast<DecimalFormat *>(numberFormat); | |
| if(decFmt != NULL) { | |
| decFmt->initVisibleDigitsWithExponent( | |
| numberMinusOffset, dec, status); | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| decFmt->format(dec, numberString, ignorePos, status); | |
| } else { | |
| numberFormat->format( | |
| numberMinusOffset, numberString, ignorePos, status); | |
| } | |
| } | |
| int32_t partIndex = findSubMessage(msgPattern, 0, pluralRulesWrapper, &dec, number, status); | |
| if (U_FAILURE(status)) { return appendTo; } | |
| // Replace syntactic # signs in the top level of this sub-message | |
| // (not in nested arguments) with the formatted number-offset. | |
| const UnicodeString& pattern = msgPattern.getPatternString(); | |
| int32_t prevIndex = msgPattern.getPart(partIndex).getLimit(); | |
| for (;;) { | |
| const MessagePattern::Part& part = msgPattern.getPart(++partIndex); | |
| const UMessagePatternPartType type = part.getType(); | |
| int32_t index = part.getIndex(); | |
| if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) { | |
| return appendTo.append(pattern, prevIndex, index - prevIndex); | |
| } else if ((type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) || | |
| (type == UMSGPAT_PART_TYPE_SKIP_SYNTAX && MessageImpl::jdkAposMode(msgPattern))) { | |
| appendTo.append(pattern, prevIndex, index - prevIndex); | |
| if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) { | |
| appendTo.append(numberString); | |
| } | |
| prevIndex = part.getLimit(); | |
| } else if (type == UMSGPAT_PART_TYPE_ARG_START) { | |
| appendTo.append(pattern, prevIndex, index - prevIndex); | |
| prevIndex = index; | |
| partIndex = msgPattern.getLimitPartIndex(partIndex); | |
| index = msgPattern.getPart(partIndex).getLimit(); | |
| MessageImpl::appendReducedApostrophes(pattern, prevIndex, index, appendTo); | |
| prevIndex = index; | |
| } | |
| } | |
| } | |
| UnicodeString& | |
| PluralFormat::toPattern(UnicodeString& appendTo) { | |
| if (0 == msgPattern.countParts()) { | |
| appendTo.setToBogus(); | |
| } else { | |
| appendTo.append(msgPattern.getPatternString()); | |
| } | |
| return appendTo; | |
| } | |
| void | |
| PluralFormat::setLocale(const Locale& loc, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| locale = loc; | |
| msgPattern.clear(); | |
| delete numberFormat; | |
| offset = 0; | |
| numberFormat = NULL; | |
| pluralRulesWrapper.reset(); | |
| init(NULL, UPLURAL_TYPE_CARDINAL, status); | |
| } | |
| void | |
| PluralFormat::setNumberFormat(const NumberFormat* format, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| NumberFormat* nf = (NumberFormat*)format->clone(); | |
| if (nf != NULL) { | |
| delete numberFormat; | |
| numberFormat = nf; | |
| } else { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| Format* | |
| PluralFormat::clone() const | |
| { | |
| return new PluralFormat(*this); | |
| } | |
| PluralFormat& | |
| PluralFormat::operator=(const PluralFormat& other) { | |
| if (this != &other) { | |
| locale = other.locale; | |
| msgPattern = other.msgPattern; | |
| offset = other.offset; | |
| copyObjects(other); | |
| } | |
| return *this; | |
| } | |
| UBool | |
| PluralFormat::operator==(const Format& other) const { | |
| if (this == &other) { | |
| return TRUE; | |
| } | |
| if (!Format::operator==(other)) { | |
| return FALSE; | |
| } | |
| const PluralFormat& o = (const PluralFormat&)other; | |
| return | |
| locale == o.locale && | |
| msgPattern == o.msgPattern && // implies same offset | |
| (numberFormat == NULL) == (o.numberFormat == NULL) && | |
| (numberFormat == NULL || *numberFormat == *o.numberFormat) && | |
| (pluralRulesWrapper.pluralRules == NULL) == (o.pluralRulesWrapper.pluralRules == NULL) && | |
| (pluralRulesWrapper.pluralRules == NULL || | |
| *pluralRulesWrapper.pluralRules == *o.pluralRulesWrapper.pluralRules); | |
| } | |
| UBool | |
| PluralFormat::operator!=(const Format& other) const { | |
| return !operator==(other); | |
| } | |
| void | |
| PluralFormat::parseObject(const UnicodeString& /*source*/, | |
| Formattable& /*result*/, | |
| ParsePosition& pos) const | |
| { | |
| // Parsing not supported. | |
| pos.setErrorIndex(pos.getIndex()); | |
| } | |
| int32_t PluralFormat::findSubMessage(const MessagePattern& pattern, int32_t partIndex, | |
| const PluralSelector& selector, void *context, | |
| double number, UErrorCode& ec) { | |
| if (U_FAILURE(ec)) { | |
| return 0; | |
| } | |
| int32_t count=pattern.countParts(); | |
| double offset; | |
| const MessagePattern::Part* part=&pattern.getPart(partIndex); | |
| if (MessagePattern::Part::hasNumericValue(part->getType())) { | |
| offset=pattern.getNumericValue(*part); | |
| ++partIndex; | |
| } else { | |
| offset=0; | |
| } | |
| // The keyword is empty until we need to match against a non-explicit, not-"other" value. | |
| // Then we get the keyword from the selector. | |
| // (In other words, we never call the selector if we match against an explicit value, | |
| // or if the only non-explicit keyword is "other".) | |
| UnicodeString keyword; | |
| UnicodeString other(FALSE, OTHER_STRING, 5); | |
| // When we find a match, we set msgStart>0 and also set this boolean to true | |
| // to avoid matching the keyword again (duplicates are allowed) | |
| // while we continue to look for an explicit-value match. | |
| UBool haveKeywordMatch=FALSE; | |
| // msgStart is 0 until we find any appropriate sub-message. | |
| // We remember the first "other" sub-message if we have not seen any | |
| // appropriate sub-message before. | |
| // We remember the first matching-keyword sub-message if we have not seen | |
| // one of those before. | |
| // (The parser allows [does not check for] duplicate keywords. | |
| // We just have to make sure to take the first one.) | |
| // We avoid matching the keyword twice by also setting haveKeywordMatch=true | |
| // at the first keyword match. | |
| // We keep going until we find an explicit-value match or reach the end of the plural style. | |
| int32_t msgStart=0; | |
| // Iterate over (ARG_SELECTOR [ARG_INT|ARG_DOUBLE] message) tuples | |
| // until ARG_LIMIT or end of plural-only pattern. | |
| do { | |
| part=&pattern.getPart(partIndex++); | |
| const UMessagePatternPartType type = part->getType(); | |
| if(type==UMSGPAT_PART_TYPE_ARG_LIMIT) { | |
| break; | |
| } | |
| U_ASSERT (type==UMSGPAT_PART_TYPE_ARG_SELECTOR); | |
| // part is an ARG_SELECTOR followed by an optional explicit value, and then a message | |
| if(MessagePattern::Part::hasNumericValue(pattern.getPartType(partIndex))) { | |
| // explicit value like "=2" | |
| part=&pattern.getPart(partIndex++); | |
| if(number==pattern.getNumericValue(*part)) { | |
| // matches explicit value | |
| return partIndex; | |
| } | |
| } else if(!haveKeywordMatch) { | |
| // plural keyword like "few" or "other" | |
| // Compare "other" first and call the selector if this is not "other". | |
| if(pattern.partSubstringMatches(*part, other)) { | |
| if(msgStart==0) { | |
| msgStart=partIndex; | |
| if(0 == keyword.compare(other)) { | |
| // This is the first "other" sub-message, | |
| // and the selected keyword is also "other". | |
| // Do not match "other" again. | |
| haveKeywordMatch=TRUE; | |
| } | |
| } | |
| } else { | |
| if(keyword.isEmpty()) { | |
| keyword=selector.select(context, number-offset, ec); | |
| if(msgStart!=0 && (0 == keyword.compare(other))) { | |
| // We have already seen an "other" sub-message. | |
| // Do not match "other" again. | |
| haveKeywordMatch=TRUE; | |
| // Skip keyword matching but do getLimitPartIndex(). | |
| } | |
| } | |
| if(!haveKeywordMatch && pattern.partSubstringMatches(*part, keyword)) { | |
| // keyword matches | |
| msgStart=partIndex; | |
| // Do not match this keyword again. | |
| haveKeywordMatch=TRUE; | |
| } | |
| } | |
| } | |
| partIndex=pattern.getLimitPartIndex(partIndex); | |
| } while(++partIndex<count); | |
| return msgStart; | |
| } | |
| void PluralFormat::parseType(const UnicodeString& source, const NFRule *rbnfLenientScanner, Formattable& result, FieldPosition& pos) const { | |
| // If no pattern was applied, return null. | |
| if (msgPattern.countParts() == 0) { | |
| pos.setBeginIndex(-1); | |
| pos.setEndIndex(-1); | |
| return; | |
| } | |
| int partIndex = 0; | |
| int currMatchIndex; | |
| int count=msgPattern.countParts(); | |
| int startingAt = pos.getBeginIndex(); | |
| if (startingAt < 0) { | |
| startingAt = 0; | |
| } | |
| // The keyword is null until we need to match against a non-explicit, not-"other" value. | |
| // Then we get the keyword from the selector. | |
| // (In other words, we never call the selector if we match against an explicit value, | |
| // or if the only non-explicit keyword is "other".) | |
| UnicodeString keyword; | |
| UnicodeString matchedWord; | |
| const UnicodeString& pattern = msgPattern.getPatternString(); | |
| int matchedIndex = -1; | |
| // Iterate over (ARG_SELECTOR ARG_START message ARG_LIMIT) tuples | |
| // until the end of the plural-only pattern. | |
| while (partIndex < count) { | |
| const MessagePattern::Part* partSelector = &msgPattern.getPart(partIndex++); | |
| if (partSelector->getType() != UMSGPAT_PART_TYPE_ARG_SELECTOR) { | |
| // Bad format | |
| continue; | |
| } | |
| const MessagePattern::Part* partStart = &msgPattern.getPart(partIndex++); | |
| if (partStart->getType() != UMSGPAT_PART_TYPE_MSG_START) { | |
| // Bad format | |
| continue; | |
| } | |
| const MessagePattern::Part* partLimit = &msgPattern.getPart(partIndex++); | |
| if (partLimit->getType() != UMSGPAT_PART_TYPE_MSG_LIMIT) { | |
| // Bad format | |
| continue; | |
| } | |
| UnicodeString currArg = pattern.tempSubString(partStart->getLimit(), partLimit->getIndex() - partStart->getLimit()); | |
| if (rbnfLenientScanner != NULL) { | |
| // If lenient parsing is turned ON, we've got some time consuming parsing ahead of us. | |
| int32_t length = -1; | |
| currMatchIndex = rbnfLenientScanner->findTextLenient(source, currArg, startingAt, &length); | |
| } | |
| else { | |
| currMatchIndex = source.indexOf(currArg, startingAt); | |
| } | |
| if (currMatchIndex >= 0 && currMatchIndex >= matchedIndex && currArg.length() > matchedWord.length()) { | |
| matchedIndex = currMatchIndex; | |
| matchedWord = currArg; | |
| keyword = pattern.tempSubString(partStart->getLimit(), partLimit->getIndex() - partStart->getLimit()); | |
| } | |
| } | |
| if (matchedIndex >= 0) { | |
| pos.setBeginIndex(matchedIndex); | |
| pos.setEndIndex(matchedIndex + matchedWord.length()); | |
| result.setString(keyword); | |
| return; | |
| } | |
| // Not found! | |
| pos.setBeginIndex(-1); | |
| pos.setEndIndex(-1); | |
| } | |
| PluralFormat::PluralSelector::~PluralSelector() {} | |
| PluralFormat::PluralSelectorAdapter::~PluralSelectorAdapter() { | |
| delete pluralRules; | |
| } | |
| UnicodeString PluralFormat::PluralSelectorAdapter::select(void *context, double number, | |
| UErrorCode& /*ec*/) const { | |
| (void)number; // unused except in the assertion | |
| VisibleDigitsWithExponent *dec=static_cast<VisibleDigitsWithExponent *>(context); | |
| return pluralRules->select(*dec); | |
| } | |
| void PluralFormat::PluralSelectorAdapter::reset() { | |
| delete pluralRules; | |
| pluralRules = NULL; | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| //eof |