| /* | |
| * Copyright (C) 2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| * file name: affixpatternparser.cpp | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/dcfmtsym.h" | |
| #include "unicode/plurrule.h" | |
| #include "unicode/ucurr.h" | |
| #include "affixpatternparser.h" | |
| #include "charstr.h" | |
| #include "precision.h" | |
| #include "uassert.h" | |
| #include "unistrappender.h" | |
| static UChar gDefaultSymbols[] = {0xa4, 0xa4, 0xa4}; | |
| static UChar gPercent = 0x25; | |
| static UChar gPerMill = 0x2030; | |
| static UChar gNegative = 0x2D; | |
| static UChar gPositive = 0x2B; | |
| #define PACK_TOKEN_AND_LENGTH(t, l) ((UChar) (((t) << 8) | (l & 0xFF))) | |
| #define UNPACK_TOKEN(c) ((AffixPattern::ETokenType) (((c) >> 8) & 0x7F)) | |
| #define UNPACK_LONG(c) (((c) >> 8) & 0x80) | |
| #define UNPACK_LENGTH(c) ((c) & 0xFF) | |
| U_NAMESPACE_BEGIN | |
| static int32_t | |
| nextToken(const UChar *buffer, int32_t idx, int32_t len, UChar *token) { | |
| if (buffer[idx] != 0x27 || idx + 1 == len) { | |
| *token = buffer[idx]; | |
| return 1; | |
| } | |
| *token = buffer[idx + 1]; | |
| if (buffer[idx + 1] == 0xA4) { | |
| int32_t i = 2; | |
| for (; idx + i < len && i < 4 && buffer[idx + i] == buffer[idx + 1]; ++i); | |
| return i; | |
| } | |
| return 2; | |
| } | |
| static int32_t | |
| nextUserToken(const UChar *buffer, int32_t idx, int32_t len, UChar *token) { | |
| *token = buffer[idx]; | |
| int32_t max; | |
| switch (buffer[idx]) { | |
| case 0x27: | |
| max = 2; | |
| break; | |
| case 0xA4: | |
| max = 3; | |
| break; | |
| default: | |
| max = 1; | |
| break; | |
| } | |
| int32_t i = 1; | |
| for (; idx + i < len && i < max && buffer[idx + i] == buffer[idx]; ++i); | |
| return i; | |
| } | |
| CurrencyAffixInfo::CurrencyAffixInfo() | |
| : fSymbol(gDefaultSymbols, 1), | |
| fISO(gDefaultSymbols, 2), | |
| fLong(DigitAffix(gDefaultSymbols, 3)), | |
| fIsDefault(TRUE) { | |
| } | |
| void | |
| CurrencyAffixInfo::set( | |
| const char *locale, | |
| const PluralRules *rules, | |
| const UChar *currency, | |
| UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| fIsDefault = FALSE; | |
| if (currency == NULL) { | |
| fSymbol.setTo(gDefaultSymbols, 1); | |
| fISO.setTo(gDefaultSymbols, 2); | |
| fLong.remove(); | |
| fLong.append(gDefaultSymbols, 3); | |
| fIsDefault = TRUE; | |
| return; | |
| } | |
| int32_t len; | |
| UBool unusedIsChoice; | |
| const UChar *symbol = ucurr_getName( | |
| currency, locale, UCURR_SYMBOL_NAME, &unusedIsChoice, | |
| &len, &status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| fSymbol.setTo(symbol, len); | |
| fISO.setTo(currency, u_strlen(currency)); | |
| fLong.remove(); | |
| StringEnumeration* keywords = rules->getKeywords(status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| const UnicodeString* pluralCount; | |
| while ((pluralCount = keywords->snext(status)) != NULL) { | |
| CharString pCount; | |
| pCount.appendInvariantChars(*pluralCount, status); | |
| const UChar *pluralName = ucurr_getPluralName( | |
| currency, locale, &unusedIsChoice, pCount.data(), | |
| &len, &status); | |
| fLong.setVariant(pCount.data(), UnicodeString(pluralName, len), status); | |
| } | |
| delete keywords; | |
| } | |
| void | |
| CurrencyAffixInfo::adjustPrecision( | |
| const UChar *currency, const UCurrencyUsage usage, | |
| FixedPrecision &precision, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| int32_t digitCount = ucurr_getDefaultFractionDigitsForUsage( | |
| currency, usage, &status); | |
| precision.fMin.setFracDigitCount(digitCount); | |
| precision.fMax.setFracDigitCount(digitCount); | |
| double increment = ucurr_getRoundingIncrementForUsage( | |
| currency, usage, &status); | |
| if (increment == 0.0) { | |
| precision.fRoundingIncrement.clear(); | |
| } else { | |
| precision.fRoundingIncrement.set(increment); | |
| // guard against round-off error | |
| precision.fRoundingIncrement.round(6); | |
| } | |
| } | |
| void | |
| AffixPattern::addLiteral( | |
| const UChar *literal, int32_t start, int32_t len) { | |
| char32Count += u_countChar32(literal + start, len); | |
| literals.append(literal, start, len); | |
| int32_t tlen = tokens.length(); | |
| // Takes 4 UChars to encode maximum literal length. | |
| UChar *tokenChars = tokens.getBuffer(tlen + 4); | |
| // find start of literal size. May be tlen if there is no literal. | |
| // While finding start of literal size, compute literal length | |
| int32_t literalLength = 0; | |
| int32_t tLiteralStart = tlen; | |
| while (tLiteralStart > 0 && UNPACK_TOKEN(tokenChars[tLiteralStart - 1]) == kLiteral) { | |
| tLiteralStart--; | |
| literalLength <<= 8; | |
| literalLength |= UNPACK_LENGTH(tokenChars[tLiteralStart]); | |
| } | |
| // Add number of chars we just added to literal | |
| literalLength += len; | |
| // Now encode the new length starting at tLiteralStart | |
| tlen = tLiteralStart; | |
| tokenChars[tlen++] = PACK_TOKEN_AND_LENGTH(kLiteral, literalLength & 0xFF); | |
| literalLength >>= 8; | |
| while (literalLength) { | |
| tokenChars[tlen++] = PACK_TOKEN_AND_LENGTH(kLiteral | 0x80, literalLength & 0xFF); | |
| literalLength >>= 8; | |
| } | |
| tokens.releaseBuffer(tlen); | |
| } | |
| void | |
| AffixPattern::add(ETokenType t) { | |
| add(t, 1); | |
| } | |
| void | |
| AffixPattern::addCurrency(uint8_t count) { | |
| add(kCurrency, count); | |
| } | |
| void | |
| AffixPattern::add(ETokenType t, uint8_t count) { | |
| U_ASSERT(t != kLiteral); | |
| char32Count += count; | |
| switch (t) { | |
| case kCurrency: | |
| hasCurrencyToken = TRUE; | |
| break; | |
| case kPercent: | |
| hasPercentToken = TRUE; | |
| break; | |
| case kPerMill: | |
| hasPermillToken = TRUE; | |
| break; | |
| default: | |
| // Do nothing | |
| break; | |
| } | |
| tokens.append(PACK_TOKEN_AND_LENGTH(t, count)); | |
| } | |
| AffixPattern & | |
| AffixPattern::append(const AffixPattern &other) { | |
| AffixPatternIterator iter; | |
| other.iterator(iter); | |
| UnicodeString literal; | |
| while (iter.nextToken()) { | |
| switch (iter.getTokenType()) { | |
| case kLiteral: | |
| iter.getLiteral(literal); | |
| addLiteral(literal.getBuffer(), 0, literal.length()); | |
| break; | |
| case kCurrency: | |
| addCurrency(iter.getTokenLength()); | |
| break; | |
| default: | |
| add(iter.getTokenType()); | |
| break; | |
| } | |
| } | |
| return *this; | |
| } | |
| void | |
| AffixPattern::remove() { | |
| tokens.remove(); | |
| literals.remove(); | |
| hasCurrencyToken = FALSE; | |
| hasPercentToken = FALSE; | |
| hasPermillToken = FALSE; | |
| char32Count = 0; | |
| } | |
| // escapes literals for strings where special characters are NOT escaped | |
| // except for apostrophe. | |
| static void escapeApostropheInLiteral( | |
| const UnicodeString &literal, UnicodeStringAppender &appender) { | |
| int32_t len = literal.length(); | |
| const UChar *buffer = literal.getBuffer(); | |
| for (int32_t i = 0; i < len; ++i) { | |
| UChar ch = buffer[i]; | |
| switch (ch) { | |
| case 0x27: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x27); | |
| break; | |
| default: | |
| appender.append(ch); | |
| break; | |
| } | |
| } | |
| } | |
| // escapes literals for user strings where special characters in literals | |
| // are escaped with apostrophe. | |
| static void escapeLiteral( | |
| const UnicodeString &literal, UnicodeStringAppender &appender) { | |
| int32_t len = literal.length(); | |
| const UChar *buffer = literal.getBuffer(); | |
| for (int32_t i = 0; i < len; ++i) { | |
| UChar ch = buffer[i]; | |
| switch (ch) { | |
| case 0x27: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0x25: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x25); | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0x2030: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x2030); | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0xA4: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0xA4); | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0x2D: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x2D); | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0x2B: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x2B); | |
| appender.append((UChar) 0x27); | |
| break; | |
| default: | |
| appender.append(ch); | |
| break; | |
| } | |
| } | |
| } | |
| UnicodeString & | |
| AffixPattern::toString(UnicodeString &appendTo) const { | |
| AffixPatternIterator iter; | |
| iterator(iter); | |
| UnicodeStringAppender appender(appendTo); | |
| UnicodeString literal; | |
| while (iter.nextToken()) { | |
| switch (iter.getTokenType()) { | |
| case kLiteral: | |
| escapeApostropheInLiteral(iter.getLiteral(literal), appender); | |
| break; | |
| case kPercent: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x25); | |
| break; | |
| case kPerMill: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x2030); | |
| break; | |
| case kCurrency: | |
| { | |
| appender.append((UChar) 0x27); | |
| int32_t cl = iter.getTokenLength(); | |
| for (int32_t i = 0; i < cl; ++i) { | |
| appender.append((UChar) 0xA4); | |
| } | |
| } | |
| break; | |
| case kNegative: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x2D); | |
| break; | |
| case kPositive: | |
| appender.append((UChar) 0x27); | |
| appender.append((UChar) 0x2B); | |
| break; | |
| default: | |
| U_ASSERT(FALSE); | |
| break; | |
| } | |
| } | |
| return appendTo; | |
| } | |
| UnicodeString & | |
| AffixPattern::toUserString(UnicodeString &appendTo) const { | |
| AffixPatternIterator iter; | |
| iterator(iter); | |
| UnicodeStringAppender appender(appendTo); | |
| UnicodeString literal; | |
| while (iter.nextToken()) { | |
| switch (iter.getTokenType()) { | |
| case kLiteral: | |
| escapeLiteral(iter.getLiteral(literal), appender); | |
| break; | |
| case kPercent: | |
| appender.append((UChar) 0x25); | |
| break; | |
| case kPerMill: | |
| appender.append((UChar) 0x2030); | |
| break; | |
| case kCurrency: | |
| { | |
| int32_t cl = iter.getTokenLength(); | |
| for (int32_t i = 0; i < cl; ++i) { | |
| appender.append((UChar) 0xA4); | |
| } | |
| } | |
| break; | |
| case kNegative: | |
| appender.append((UChar) 0x2D); | |
| break; | |
| case kPositive: | |
| appender.append((UChar) 0x2B); | |
| break; | |
| default: | |
| U_ASSERT(FALSE); | |
| break; | |
| } | |
| } | |
| return appendTo; | |
| } | |
| class AffixPatternAppender : public UMemory { | |
| public: | |
| AffixPatternAppender(AffixPattern &dest) : fDest(&dest), fIdx(0) { } | |
| inline void append(UChar x) { | |
| if (fIdx == UPRV_LENGTHOF(fBuffer)) { | |
| fDest->addLiteral(fBuffer, 0, fIdx); | |
| fIdx = 0; | |
| } | |
| fBuffer[fIdx++] = x; | |
| } | |
| inline void append(UChar32 x) { | |
| if (fIdx >= UPRV_LENGTHOF(fBuffer) - 1) { | |
| fDest->addLiteral(fBuffer, 0, fIdx); | |
| fIdx = 0; | |
| } | |
| U16_APPEND_UNSAFE(fBuffer, fIdx, x); | |
| } | |
| inline void flush() { | |
| if (fIdx) { | |
| fDest->addLiteral(fBuffer, 0, fIdx); | |
| } | |
| fIdx = 0; | |
| } | |
| /** | |
| * flush the buffer when we go out of scope. | |
| */ | |
| ~AffixPatternAppender() { | |
| flush(); | |
| } | |
| private: | |
| AffixPattern *fDest; | |
| int32_t fIdx; | |
| UChar fBuffer[32]; | |
| AffixPatternAppender(const AffixPatternAppender &other); | |
| AffixPatternAppender &operator=(const AffixPatternAppender &other); | |
| }; | |
| AffixPattern & | |
| AffixPattern::parseUserAffixString( | |
| const UnicodeString &affixStr, | |
| AffixPattern &appendTo, | |
| UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| int32_t len = affixStr.length(); | |
| const UChar *buffer = affixStr.getBuffer(); | |
| // 0 = not quoted; 1 = quoted. | |
| int32_t state = 0; | |
| AffixPatternAppender appender(appendTo); | |
| for (int32_t i = 0; i < len; ) { | |
| UChar token; | |
| int32_t tokenSize = nextUserToken(buffer, i, len, &token); | |
| i += tokenSize; | |
| if (token == 0x27 && tokenSize == 1) { // quote | |
| state = 1 - state; | |
| continue; | |
| } | |
| if (state == 0) { | |
| switch (token) { | |
| case 0x25: | |
| appender.flush(); | |
| appendTo.add(kPercent, 1); | |
| break; | |
| case 0x27: // double quote | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0x2030: | |
| appender.flush(); | |
| appendTo.add(kPerMill, 1); | |
| break; | |
| case 0x2D: | |
| appender.flush(); | |
| appendTo.add(kNegative, 1); | |
| break; | |
| case 0x2B: | |
| appender.flush(); | |
| appendTo.add(kPositive, 1); | |
| break; | |
| case 0xA4: | |
| appender.flush(); | |
| appendTo.add(kCurrency, tokenSize); | |
| break; | |
| default: | |
| appender.append(token); | |
| break; | |
| } | |
| } else { | |
| switch (token) { | |
| case 0x27: // double quote | |
| appender.append((UChar) 0x27); | |
| break; | |
| case 0xA4: // included b/c tokenSize can be > 1 | |
| for (int32_t j = 0; j < tokenSize; ++j) { | |
| appender.append((UChar) 0xA4); | |
| } | |
| break; | |
| default: | |
| appender.append(token); | |
| break; | |
| } | |
| } | |
| } | |
| return appendTo; | |
| } | |
| AffixPattern & | |
| AffixPattern::parseAffixString( | |
| const UnicodeString &affixStr, | |
| AffixPattern &appendTo, | |
| UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| int32_t len = affixStr.length(); | |
| const UChar *buffer = affixStr.getBuffer(); | |
| for (int32_t i = 0; i < len; ) { | |
| UChar token; | |
| int32_t tokenSize = nextToken(buffer, i, len, &token); | |
| if (tokenSize == 1) { | |
| int32_t literalStart = i; | |
| ++i; | |
| while (i < len && (tokenSize = nextToken(buffer, i, len, &token)) == 1) { | |
| ++i; | |
| } | |
| appendTo.addLiteral(buffer, literalStart, i - literalStart); | |
| // If we reached end of string, we are done | |
| if (i == len) { | |
| return appendTo; | |
| } | |
| } | |
| i += tokenSize; | |
| switch (token) { | |
| case 0x25: | |
| appendTo.add(kPercent, 1); | |
| break; | |
| case 0x2030: | |
| appendTo.add(kPerMill, 1); | |
| break; | |
| case 0x2D: | |
| appendTo.add(kNegative, 1); | |
| break; | |
| case 0x2B: | |
| appendTo.add(kPositive, 1); | |
| break; | |
| case 0xA4: | |
| { | |
| if (tokenSize - 1 > 3) { | |
| status = U_PARSE_ERROR; | |
| return appendTo; | |
| } | |
| appendTo.add(kCurrency, tokenSize - 1); | |
| } | |
| break; | |
| default: | |
| appendTo.addLiteral(&token, 0, 1); | |
| break; | |
| } | |
| } | |
| return appendTo; | |
| } | |
| AffixPatternIterator & | |
| AffixPattern::iterator(AffixPatternIterator &result) const { | |
| result.nextLiteralIndex = 0; | |
| result.lastLiteralLength = 0; | |
| result.nextTokenIndex = 0; | |
| result.tokens = &tokens; | |
| result.literals = &literals; | |
| return result; | |
| } | |
| UBool | |
| AffixPatternIterator::nextToken() { | |
| int32_t tlen = tokens->length(); | |
| if (nextTokenIndex == tlen) { | |
| return FALSE; | |
| } | |
| ++nextTokenIndex; | |
| const UChar *tokenBuffer = tokens->getBuffer(); | |
| if (UNPACK_TOKEN(tokenBuffer[nextTokenIndex - 1]) == | |
| AffixPattern::kLiteral) { | |
| while (nextTokenIndex < tlen && | |
| UNPACK_LONG(tokenBuffer[nextTokenIndex])) { | |
| ++nextTokenIndex; | |
| } | |
| lastLiteralLength = 0; | |
| int32_t i = nextTokenIndex - 1; | |
| for (; UNPACK_LONG(tokenBuffer[i]); --i) { | |
| lastLiteralLength <<= 8; | |
| lastLiteralLength |= UNPACK_LENGTH(tokenBuffer[i]); | |
| } | |
| lastLiteralLength <<= 8; | |
| lastLiteralLength |= UNPACK_LENGTH(tokenBuffer[i]); | |
| nextLiteralIndex += lastLiteralLength; | |
| } | |
| return TRUE; | |
| } | |
| AffixPattern::ETokenType | |
| AffixPatternIterator::getTokenType() const { | |
| return UNPACK_TOKEN(tokens->charAt(nextTokenIndex - 1)); | |
| } | |
| UnicodeString & | |
| AffixPatternIterator::getLiteral(UnicodeString &result) const { | |
| const UChar *buffer = literals->getBuffer(); | |
| result.setTo(buffer + (nextLiteralIndex - lastLiteralLength), lastLiteralLength); | |
| return result; | |
| } | |
| int32_t | |
| AffixPatternIterator::getTokenLength() const { | |
| const UChar *tokenBuffer = tokens->getBuffer(); | |
| AffixPattern::ETokenType type = UNPACK_TOKEN(tokenBuffer[nextTokenIndex - 1]); | |
| return type == AffixPattern::kLiteral ? lastLiteralLength : UNPACK_LENGTH(tokenBuffer[nextTokenIndex - 1]); | |
| } | |
| AffixPatternParser::AffixPatternParser() | |
| : fPercent(gPercent), fPermill(gPerMill), fNegative(gNegative), fPositive(gPositive) { | |
| } | |
| AffixPatternParser::AffixPatternParser( | |
| const DecimalFormatSymbols &symbols) { | |
| setDecimalFormatSymbols(symbols); | |
| } | |
| void | |
| AffixPatternParser::setDecimalFormatSymbols( | |
| const DecimalFormatSymbols &symbols) { | |
| fPercent = symbols.getConstSymbol(DecimalFormatSymbols::kPercentSymbol); | |
| fPermill = symbols.getConstSymbol(DecimalFormatSymbols::kPerMillSymbol); | |
| fNegative = symbols.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol); | |
| fPositive = symbols.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol); | |
| } | |
| PluralAffix & | |
| AffixPatternParser::parse( | |
| const AffixPattern &affixPattern, | |
| const CurrencyAffixInfo ¤cyAffixInfo, | |
| PluralAffix &appendTo, | |
| UErrorCode &status) const { | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| AffixPatternIterator iter; | |
| affixPattern.iterator(iter); | |
| UnicodeString literal; | |
| while (iter.nextToken()) { | |
| switch (iter.getTokenType()) { | |
| case AffixPattern::kPercent: | |
| appendTo.append(fPercent, UNUM_PERCENT_FIELD); | |
| break; | |
| case AffixPattern::kPerMill: | |
| appendTo.append(fPermill, UNUM_PERMILL_FIELD); | |
| break; | |
| case AffixPattern::kNegative: | |
| appendTo.append(fNegative, UNUM_SIGN_FIELD); | |
| break; | |
| case AffixPattern::kPositive: | |
| appendTo.append(fPositive, UNUM_SIGN_FIELD); | |
| break; | |
| case AffixPattern::kCurrency: | |
| switch (iter.getTokenLength()) { | |
| case 1: | |
| appendTo.append( | |
| currencyAffixInfo.getSymbol(), UNUM_CURRENCY_FIELD); | |
| break; | |
| case 2: | |
| appendTo.append( | |
| currencyAffixInfo.getISO(), UNUM_CURRENCY_FIELD); | |
| break; | |
| case 3: | |
| appendTo.append( | |
| currencyAffixInfo.getLong(), UNUM_CURRENCY_FIELD, status); | |
| break; | |
| default: | |
| U_ASSERT(FALSE); | |
| break; | |
| } | |
| break; | |
| case AffixPattern::kLiteral: | |
| appendTo.append(iter.getLiteral(literal)); | |
| break; | |
| default: | |
| U_ASSERT(FALSE); | |
| break; | |
| } | |
| } | |
| return appendTo; | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |