| /* | |
| ****************************************************************************** | |
| * Copyright (C) 2014-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ****************************************************************************** | |
| * simplepatternformatter.cpp | |
| */ | |
| #if defined(STARBOARD) | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #endif // defined(STARBOARD) | |
| #include "simplepatternformatter.h" | |
| #include "cstring.h" | |
| #include "uassert.h" | |
| U_NAMESPACE_BEGIN | |
| static UBool isInvalidArray(const void *array, int32_t size) { | |
| return (size < 0 || (size > 0 && array == NULL)); | |
| } | |
| typedef enum SimplePatternFormatterCompileState { | |
| INIT, | |
| APOSTROPHE, | |
| PLACEHOLDER | |
| } SimplePatternFormatterCompileState; | |
| // Handles parsing placeholders in the pattern string, e.g {4} or {35} | |
| class SimplePatternFormatterIdBuilder { | |
| public: | |
| SimplePatternFormatterIdBuilder() : id(0), idLen(0) { } | |
| ~SimplePatternFormatterIdBuilder() { } | |
| // Resets so that this object has seen no placeholder ID. | |
| void reset() { id = 0; idLen = 0; } | |
| // Returns the numeric placeholder ID parsed so far | |
| int32_t getId() const { return id; } | |
| // Appends the numeric placeholder ID parsed so far back to a | |
| // UChar buffer. Used to recover if parser using this object finds | |
| // no closing curly brace. | |
| void appendTo(UChar *buffer, int32_t *len) const; | |
| // Returns true if this object has seen a placeholder ID. | |
| UBool isValid() const { return (idLen > 0); } | |
| // Processes a single digit character. Pattern string parser calls this | |
| // as it processes digits after an opening curly brace. | |
| void add(UChar ch); | |
| private: | |
| int32_t id; | |
| int32_t idLen; | |
| SimplePatternFormatterIdBuilder( | |
| const SimplePatternFormatterIdBuilder &other); | |
| SimplePatternFormatterIdBuilder &operator=( | |
| const SimplePatternFormatterIdBuilder &other); | |
| }; | |
| void SimplePatternFormatterIdBuilder::appendTo( | |
| UChar *buffer, int32_t *len) const { | |
| int32_t origLen = *len; | |
| int32_t kId = id; | |
| for (int32_t i = origLen + idLen - 1; i >= origLen; i--) { | |
| int32_t digit = kId % 10; | |
| buffer[i] = digit + 0x30; | |
| kId /= 10; | |
| } | |
| *len = origLen + idLen; | |
| } | |
| void SimplePatternFormatterIdBuilder::add(UChar ch) { | |
| id = id * 10 + (ch - 0x30); | |
| idLen++; | |
| } | |
| // Represents placeholder values. | |
| class SimplePatternFormatterPlaceholderValues : public UMemory { | |
| public: | |
| SimplePatternFormatterPlaceholderValues( | |
| const UnicodeString * const *values, | |
| int32_t valuesCount); | |
| // Returns TRUE if appendTo value is at any index besides exceptIndex. | |
| UBool isAppendToInAnyIndexExcept( | |
| const UnicodeString &appendTo, int32_t exceptIndex) const; | |
| // For each appendTo value, stores the snapshot of it in its place. | |
| void snapshotAppendTo(const UnicodeString &appendTo); | |
| // Returns the placeholder value at index. No range checking performed. | |
| // Returned reference is valid for as long as this object exists. | |
| const UnicodeString &get(int32_t index) const; | |
| private: | |
| const UnicodeString * const *fValues; | |
| int32_t fValuesCount; | |
| const UnicodeString *fAppendTo; | |
| UnicodeString fAppendToCopy; | |
| SimplePatternFormatterPlaceholderValues( | |
| const SimplePatternFormatterPlaceholderValues &); | |
| SimplePatternFormatterPlaceholderValues &operator=( | |
| const SimplePatternFormatterPlaceholderValues &); | |
| }; | |
| SimplePatternFormatterPlaceholderValues::SimplePatternFormatterPlaceholderValues( | |
| const UnicodeString * const *values, | |
| int32_t valuesCount) | |
| : fValues(values), | |
| fValuesCount(valuesCount), | |
| fAppendTo(NULL), | |
| fAppendToCopy() { | |
| } | |
| UBool SimplePatternFormatterPlaceholderValues::isAppendToInAnyIndexExcept( | |
| const UnicodeString &appendTo, int32_t exceptIndex) const { | |
| for (int32_t i = 0; i < fValuesCount; ++i) { | |
| if (i != exceptIndex && fValues[i] == &appendTo) { | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| void SimplePatternFormatterPlaceholderValues::snapshotAppendTo( | |
| const UnicodeString &appendTo) { | |
| fAppendTo = &appendTo; | |
| fAppendToCopy = appendTo; | |
| } | |
| const UnicodeString &SimplePatternFormatterPlaceholderValues::get( | |
| int32_t index) const { | |
| if (fAppendTo == NULL || fAppendTo != fValues[index]) { | |
| return *fValues[index]; | |
| } | |
| return fAppendToCopy; | |
| } | |
| SimplePatternFormatter::SimplePatternFormatter() : | |
| noPlaceholders(), | |
| placeholders(), | |
| placeholderSize(0), | |
| placeholderCount(0), | |
| firstPlaceholderReused(FALSE) { | |
| } | |
| SimplePatternFormatter::SimplePatternFormatter(const UnicodeString &pattern) : | |
| noPlaceholders(), | |
| placeholders(), | |
| placeholderSize(0), | |
| placeholderCount(0), | |
| firstPlaceholderReused(FALSE) { | |
| UErrorCode status = U_ZERO_ERROR; | |
| compile(pattern, status); | |
| } | |
| SimplePatternFormatter::SimplePatternFormatter(const UnicodeString &pattern, | |
| int32_t min, int32_t max, | |
| UErrorCode &errorCode) | |
| : noPlaceholders(), | |
| placeholders(), | |
| placeholderSize(0), | |
| placeholderCount(0), | |
| firstPlaceholderReused(FALSE) { | |
| compileMinMaxPlaceholders(pattern, min, max, errorCode); | |
| } | |
| SimplePatternFormatter::SimplePatternFormatter( | |
| const SimplePatternFormatter &other) : | |
| noPlaceholders(other.noPlaceholders), | |
| placeholders(), | |
| placeholderSize(0), | |
| placeholderCount(other.placeholderCount), | |
| firstPlaceholderReused(other.firstPlaceholderReused) { | |
| placeholderSize = ensureCapacity(other.placeholderSize); | |
| uprv_memcpy( | |
| placeholders.getAlias(), | |
| other.placeholders.getAlias(), | |
| placeholderSize * sizeof(PlaceholderInfo)); | |
| } | |
| SimplePatternFormatter &SimplePatternFormatter::operator=( | |
| const SimplePatternFormatter& other) { | |
| if (this == &other) { | |
| return *this; | |
| } | |
| noPlaceholders = other.noPlaceholders; | |
| placeholderSize = ensureCapacity(other.placeholderSize); | |
| placeholderCount = other.placeholderCount; | |
| firstPlaceholderReused = other.firstPlaceholderReused; | |
| uprv_memcpy( | |
| placeholders.getAlias(), | |
| other.placeholders.getAlias(), | |
| placeholderSize * sizeof(PlaceholderInfo)); | |
| return *this; | |
| } | |
| SimplePatternFormatter::~SimplePatternFormatter() { | |
| } | |
| UBool SimplePatternFormatter::compileMinMaxPlaceholders( | |
| const UnicodeString &pattern, | |
| int32_t min, int32_t max, | |
| UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return FALSE; | |
| } | |
| const UChar *patternBuffer = pattern.getBuffer(); | |
| int32_t patternLength = pattern.length(); | |
| UChar *buffer = noPlaceholders.getBuffer(patternLength); | |
| int32_t len = 0; | |
| placeholderSize = 0; | |
| placeholderCount = 0; | |
| SimplePatternFormatterCompileState state = INIT; | |
| SimplePatternFormatterIdBuilder idBuilder; | |
| for (int32_t i = 0; i < patternLength; ++i) { | |
| UChar ch = patternBuffer[i]; | |
| switch (state) { | |
| case INIT: | |
| if (ch == 0x27) { | |
| state = APOSTROPHE; | |
| } else if (ch == 0x7B) { | |
| state = PLACEHOLDER; | |
| idBuilder.reset(); | |
| } else { | |
| buffer[len++] = ch; | |
| } | |
| break; | |
| case APOSTROPHE: | |
| if (ch == 0x27) { | |
| buffer[len++] = 0x27; | |
| } else if (ch == 0x7B) { | |
| buffer[len++] = 0x7B; | |
| } else { | |
| buffer[len++] = 0x27; | |
| buffer[len++] = ch; | |
| } | |
| state = INIT; | |
| break; | |
| case PLACEHOLDER: | |
| if (ch >= 0x30 && ch <= 0x39) { | |
| idBuilder.add(ch); | |
| } else if (ch == 0x7D && idBuilder.isValid()) { | |
| if (!addPlaceholder(idBuilder.getId(), len)) { | |
| noPlaceholders.releaseBuffer(0); | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return FALSE; | |
| } | |
| state = INIT; | |
| } else { | |
| buffer[len++] = 0x7B; | |
| idBuilder.appendTo(buffer, &len); | |
| buffer[len++] = ch; | |
| state = INIT; | |
| } | |
| break; | |
| default: | |
| U_ASSERT(FALSE); | |
| break; | |
| } | |
| } | |
| switch (state) { | |
| case INIT: | |
| break; | |
| case APOSTROPHE: | |
| buffer[len++] = 0x27; | |
| break; | |
| case PLACEHOLDER: | |
| buffer[len++] = 0X7B; | |
| idBuilder.appendTo(buffer, &len); | |
| break; | |
| default: | |
| U_ASSERT(false); | |
| break; | |
| } | |
| noPlaceholders.releaseBuffer(len); | |
| if (placeholderCount < min || max < placeholderCount) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return FALSE; | |
| } | |
| return TRUE; | |
| } | |
| UnicodeString& SimplePatternFormatter::format( | |
| const UnicodeString &arg0, | |
| UnicodeString &appendTo, | |
| UErrorCode &status) const { | |
| const UnicodeString *params[] = {&arg0}; | |
| return formatAndAppend( | |
| params, | |
| UPRV_LENGTHOF(params), | |
| appendTo, | |
| NULL, | |
| 0, | |
| status); | |
| } | |
| UnicodeString& SimplePatternFormatter::format( | |
| const UnicodeString &arg0, | |
| const UnicodeString &arg1, | |
| UnicodeString &appendTo, | |
| UErrorCode &status) const { | |
| const UnicodeString *params[] = {&arg0, &arg1}; | |
| return formatAndAppend( | |
| params, | |
| UPRV_LENGTHOF(params), | |
| appendTo, | |
| NULL, | |
| 0, | |
| status); | |
| } | |
| UnicodeString& SimplePatternFormatter::format( | |
| const UnicodeString &arg0, | |
| const UnicodeString &arg1, | |
| const UnicodeString &arg2, | |
| UnicodeString &appendTo, | |
| UErrorCode &status) const { | |
| const UnicodeString *params[] = {&arg0, &arg1, &arg2}; | |
| return formatAndAppend( | |
| params, | |
| UPRV_LENGTHOF(params), | |
| appendTo, | |
| NULL, | |
| 0, | |
| status); | |
| } | |
| static void updatePlaceholderOffset( | |
| int32_t placeholderId, | |
| int32_t placeholderOffset, | |
| int32_t *offsetArray, | |
| int32_t offsetArrayLength) { | |
| if (placeholderId < offsetArrayLength) { | |
| offsetArray[placeholderId] = placeholderOffset; | |
| } | |
| } | |
| static void appendRange( | |
| const UnicodeString &src, | |
| int32_t start, | |
| int32_t end, | |
| UnicodeString &dest) { | |
| // This check improves performance significantly. | |
| if (start == end) { | |
| return; | |
| } | |
| dest.append(src, start, end - start); | |
| } | |
| UnicodeString& SimplePatternFormatter::formatAndAppend( | |
| const UnicodeString * const *placeholderValues, | |
| int32_t placeholderValueCount, | |
| UnicodeString &appendTo, | |
| int32_t *offsetArray, | |
| int32_t offsetArrayLength, | |
| UErrorCode &status) const { | |
| if (U_FAILURE(status)) { | |
| return appendTo; | |
| } | |
| if (isInvalidArray(placeholderValues, placeholderValueCount) | |
| || isInvalidArray(offsetArray, offsetArrayLength)) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return appendTo; | |
| } | |
| if (placeholderValueCount < placeholderCount) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return appendTo; | |
| } | |
| // Since we are disallowing parameter values that are the same as | |
| // appendTo, we have to check all placeholderValues as opposed to | |
| // the first placeholderCount placeholder values. | |
| SimplePatternFormatterPlaceholderValues values( | |
| placeholderValues, placeholderValueCount); | |
| if (values.isAppendToInAnyIndexExcept(appendTo, -1)) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return appendTo; | |
| } | |
| return formatAndAppend( | |
| values, | |
| appendTo, | |
| offsetArray, | |
| offsetArrayLength); | |
| } | |
| UnicodeString& SimplePatternFormatter::formatAndReplace( | |
| const UnicodeString * const *placeholderValues, | |
| int32_t placeholderValueCount, | |
| UnicodeString &result, | |
| int32_t *offsetArray, | |
| int32_t offsetArrayLength, | |
| UErrorCode &status) const { | |
| if (U_FAILURE(status)) { | |
| return result; | |
| } | |
| if (isInvalidArray(placeholderValues, placeholderValueCount) | |
| || isInvalidArray(offsetArray, offsetArrayLength)) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return result; | |
| } | |
| if (placeholderValueCount < placeholderCount) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return result; | |
| } | |
| SimplePatternFormatterPlaceholderValues values( | |
| placeholderValues, placeholderCount); | |
| int32_t placeholderAtStart = getUniquePlaceholderAtStart(); | |
| // If pattern starts with a unique placeholder and that placeholder | |
| // value is result, we may be able to optimize by just appending to result. | |
| if (placeholderAtStart >= 0 | |
| && placeholderValues[placeholderAtStart] == &result) { | |
| // If result is the value for other placeholders, call off optimization. | |
| if (values.isAppendToInAnyIndexExcept(result, placeholderAtStart)) { | |
| values.snapshotAppendTo(result); | |
| result.remove(); | |
| return formatAndAppend( | |
| values, | |
| result, | |
| offsetArray, | |
| offsetArrayLength); | |
| } | |
| // Otherwise we can optimize | |
| formatAndAppend( | |
| values, | |
| result, | |
| offsetArray, | |
| offsetArrayLength); | |
| // We have to make the offset for the placeholderAtStart | |
| // placeholder be 0. Otherwise it would be the length of the | |
| // previous value of result. | |
| if (offsetArrayLength > placeholderAtStart) { | |
| offsetArray[placeholderAtStart] = 0; | |
| } | |
| return result; | |
| } | |
| if (values.isAppendToInAnyIndexExcept(result, -1)) { | |
| values.snapshotAppendTo(result); | |
| } | |
| result.remove(); | |
| return formatAndAppend( | |
| values, | |
| result, | |
| offsetArray, | |
| offsetArrayLength); | |
| } | |
| UnicodeString& SimplePatternFormatter::formatAndAppend( | |
| const SimplePatternFormatterPlaceholderValues &values, | |
| UnicodeString &appendTo, | |
| int32_t *offsetArray, | |
| int32_t offsetArrayLength) const { | |
| for (int32_t i = 0; i < offsetArrayLength; ++i) { | |
| offsetArray[i] = -1; | |
| } | |
| if (placeholderSize == 0) { | |
| appendTo.append(noPlaceholders); | |
| return appendTo; | |
| } | |
| appendRange( | |
| noPlaceholders, | |
| 0, | |
| placeholders[0].offset, | |
| appendTo); | |
| updatePlaceholderOffset( | |
| placeholders[0].id, | |
| appendTo.length(), | |
| offsetArray, | |
| offsetArrayLength); | |
| const UnicodeString *placeholderValue = &values.get(placeholders[0].id); | |
| if (placeholderValue != &appendTo) { | |
| appendTo.append(*placeholderValue); | |
| } | |
| for (int32_t i = 1; i < placeholderSize; ++i) { | |
| appendRange( | |
| noPlaceholders, | |
| placeholders[i - 1].offset, | |
| placeholders[i].offset, | |
| appendTo); | |
| updatePlaceholderOffset( | |
| placeholders[i].id, | |
| appendTo.length(), | |
| offsetArray, | |
| offsetArrayLength); | |
| placeholderValue = &values.get(placeholders[i].id); | |
| if (placeholderValue != &appendTo) { | |
| appendTo.append(*placeholderValue); | |
| } | |
| } | |
| appendRange( | |
| noPlaceholders, | |
| placeholders[placeholderSize - 1].offset, | |
| noPlaceholders.length(), | |
| appendTo); | |
| return appendTo; | |
| } | |
| int32_t SimplePatternFormatter::getUniquePlaceholderAtStart() const { | |
| if (placeholderSize == 0 | |
| || firstPlaceholderReused || placeholders[0].offset != 0) { | |
| return -1; | |
| } | |
| return placeholders[0].id; | |
| } | |
| int32_t SimplePatternFormatter::ensureCapacity( | |
| int32_t desiredCapacity, int32_t allocationSize) { | |
| if (allocationSize < desiredCapacity) { | |
| allocationSize = desiredCapacity; | |
| } | |
| if (desiredCapacity <= placeholders.getCapacity()) { | |
| return desiredCapacity; | |
| } | |
| // allocate new buffer | |
| if (placeholders.resize(allocationSize, placeholderSize) == NULL) { | |
| return placeholders.getCapacity(); | |
| } | |
| return desiredCapacity; | |
| } | |
| UBool SimplePatternFormatter::addPlaceholder(int32_t id, int32_t offset) { | |
| if (ensureCapacity(placeholderSize + 1, 2 * placeholderSize) < placeholderSize + 1) { | |
| return FALSE; | |
| } | |
| ++placeholderSize; | |
| PlaceholderInfo *placeholderEnd = &placeholders[placeholderSize - 1]; | |
| placeholderEnd->offset = offset; | |
| placeholderEnd->id = id; | |
| if (id >= placeholderCount) { | |
| placeholderCount = id + 1; | |
| } | |
| if (placeholderSize > 1 | |
| && placeholders[placeholderSize - 1].id == placeholders[0].id) { | |
| firstPlaceholderReused = TRUE; | |
| } | |
| return TRUE; | |
| } | |
| U_NAMESPACE_END |