// Copyright (C) 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /******************************************************************** * COPYRIGHT: * Copyright (c) 1997-2015, International Business Machines Corporation and * others. All Rights Reserved. ******************************************************************** * * File MSGFMT.CPP * * Modification History: * * Date Name Description * 02/19/97 aliu Converted from java. * 03/20/97 helena Finished first cut of implementation. * 04/10/97 aliu Made to work on AIX. Added stoi to replace wtoi. * 06/11/97 helena Fixed addPattern to take the pattern correctly. * 06/17/97 helena Fixed the getPattern to return the correct pattern. * 07/09/97 helena Made ParsePosition into a class. * 02/22/99 stephen Removed character literals for EBCDIC safety * 11/01/09 kirtig Added SelectFormat ********************************************************************/ #include "unicode/utypes.h" #if !UCONFIG_NO_FORMATTING #include "unicode/appendable.h" #include "unicode/choicfmt.h" #include "unicode/datefmt.h" #include "unicode/decimfmt.h" #include "unicode/localpointer.h" #include "unicode/msgfmt.h" #include "unicode/plurfmt.h" #include "unicode/rbnf.h" #include "unicode/selfmt.h" #include "unicode/smpdtfmt.h" #include "unicode/umsg.h" #include "unicode/ustring.h" #include "cmemory.h" #include "patternprops.h" #include "messageimpl.h" #include "msgfmt_impl.h" #include "plurrule_impl.h" #include "uassert.h" #include "uelement.h" #include "uhash.h" #include "ustrfmt.h" #include "util.h" #include "uvector.h" #include "visibledigits.h" // ***************************************************************************** // class MessageFormat // ***************************************************************************** #define SINGLE_QUOTE ((UChar)0x0027) #define COMMA ((UChar)0x002C) #define LEFT_CURLY_BRACE ((UChar)0x007B) #define RIGHT_CURLY_BRACE ((UChar)0x007D) //--------------------------------------- // static data static const UChar ID_NUMBER[] = { 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0 /* "number" */ }; static const UChar ID_DATE[] = { 0x64, 0x61, 0x74, 0x65, 0 /* "date" */ }; static const UChar ID_TIME[] = { 0x74, 0x69, 0x6D, 0x65, 0 /* "time" */ }; static const UChar ID_SPELLOUT[] = { 0x73, 0x70, 0x65, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0 /* "spellout" */ }; static const UChar ID_ORDINAL[] = { 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0 /* "ordinal" */ }; static const UChar ID_DURATION[] = { 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0 /* "duration" */ }; // MessageFormat Type List Number, Date, Time or Choice static const UChar * const TYPE_IDS[] = { ID_NUMBER, ID_DATE, ID_TIME, ID_SPELLOUT, ID_ORDINAL, ID_DURATION, NULL, }; static const UChar ID_EMPTY[] = { 0 /* empty string, used for default so that null can mark end of list */ }; static const UChar ID_CURRENCY[] = { 0x63, 0x75, 0x72, 0x72, 0x65, 0x6E, 0x63, 0x79, 0 /* "currency" */ }; static const UChar ID_PERCENT[] = { 0x70, 0x65, 0x72, 0x63, 0x65, 0x6E, 0x74, 0 /* "percent" */ }; static const UChar ID_INTEGER[] = { 0x69, 0x6E, 0x74, 0x65, 0x67, 0x65, 0x72, 0 /* "integer" */ }; // NumberFormat modifier list, default, currency, percent or integer static const UChar * const NUMBER_STYLE_IDS[] = { ID_EMPTY, ID_CURRENCY, ID_PERCENT, ID_INTEGER, NULL, }; static const UChar ID_SHORT[] = { 0x73, 0x68, 0x6F, 0x72, 0x74, 0 /* "short" */ }; static const UChar ID_MEDIUM[] = { 0x6D, 0x65, 0x64, 0x69, 0x75, 0x6D, 0 /* "medium" */ }; static const UChar ID_LONG[] = { 0x6C, 0x6F, 0x6E, 0x67, 0 /* "long" */ }; static const UChar ID_FULL[] = { 0x66, 0x75, 0x6C, 0x6C, 0 /* "full" */ }; // DateFormat modifier list, default, short, medium, long or full static const UChar * const DATE_STYLE_IDS[] = { ID_EMPTY, ID_SHORT, ID_MEDIUM, ID_LONG, ID_FULL, NULL, }; static const icu::DateFormat::EStyle DATE_STYLES[] = { icu::DateFormat::kDefault, icu::DateFormat::kShort, icu::DateFormat::kMedium, icu::DateFormat::kLong, icu::DateFormat::kFull, }; static const int32_t DEFAULT_INITIAL_CAPACITY = 10; static const UChar NULL_STRING[] = { 0x6E, 0x75, 0x6C, 0x6C, 0 // "null" }; static const UChar OTHER_STRING[] = { 0x6F, 0x74, 0x68, 0x65, 0x72, 0 // "other" }; U_CDECL_BEGIN static UBool U_CALLCONV equalFormatsForHash(const UHashTok key1, const UHashTok key2) { return icu::MessageFormat::equalFormats(key1.pointer, key2.pointer); } U_CDECL_END U_NAMESPACE_BEGIN // ------------------------------------- UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MessageFormat) UOBJECT_DEFINE_RTTI_IMPLEMENTATION(FormatNameEnumeration) //-------------------------------------------------------------------- /** * Convert an integer value to a string and append the result to * the given UnicodeString. */ static UnicodeString& itos(int32_t i, UnicodeString& appendTo) { UChar temp[16]; uprv_itou(temp,16,i,10,0); // 10 == radix appendTo.append(temp, -1); return appendTo; } // AppendableWrapper: encapsulates the result of formatting, keeping track // of the string and its length. class AppendableWrapper : public UMemory { public: AppendableWrapper(Appendable& appendable) : app(appendable), len(0) { } void append(const UnicodeString& s) { app.appendString(s.getBuffer(), s.length()); len += s.length(); } void append(const UChar* s, const int32_t sLength) { app.appendString(s, sLength); len += sLength; } void append(const UnicodeString& s, int32_t start, int32_t length) { append(s.tempSubString(start, length)); } void formatAndAppend(const Format* formatter, const Formattable& arg, UErrorCode& ec) { UnicodeString s; formatter->format(arg, s, ec); if (U_SUCCESS(ec)) { append(s); } } void formatAndAppend(const Format* formatter, const Formattable& arg, const UnicodeString &argString, UErrorCode& ec) { if (!argString.isEmpty()) { if (U_SUCCESS(ec)) { append(argString); } } else { formatAndAppend(formatter, arg, ec); } } int32_t length() { return len; } private: Appendable& app; int32_t len; }; // ------------------------------------- // Creates a MessageFormat instance based on the pattern. MessageFormat::MessageFormat(const UnicodeString& pattern, UErrorCode& success) : fLocale(Locale::getDefault()), // Uses the default locale msgPattern(success), formatAliases(NULL), formatAliasesCapacity(0), argTypes(NULL), argTypeCount(0), argTypeCapacity(0), hasArgTypeConflicts(FALSE), defaultNumberFormat(NULL), defaultDateFormat(NULL), cachedFormatters(NULL), customFormatArgStarts(NULL), pluralProvider(*this, UPLURAL_TYPE_CARDINAL), ordinalProvider(*this, UPLURAL_TYPE_ORDINAL) { setLocaleIDs(fLocale.getName(), fLocale.getName()); applyPattern(pattern, success); } MessageFormat::MessageFormat(const UnicodeString& pattern, const Locale& newLocale, UErrorCode& success) : fLocale(newLocale), msgPattern(success), formatAliases(NULL), formatAliasesCapacity(0), argTypes(NULL), argTypeCount(0), argTypeCapacity(0), hasArgTypeConflicts(FALSE), defaultNumberFormat(NULL), defaultDateFormat(NULL), cachedFormatters(NULL), customFormatArgStarts(NULL), pluralProvider(*this, UPLURAL_TYPE_CARDINAL), ordinalProvider(*this, UPLURAL_TYPE_ORDINAL) { setLocaleIDs(fLocale.getName(), fLocale.getName()); applyPattern(pattern, success); } MessageFormat::MessageFormat(const UnicodeString& pattern, const Locale& newLocale, UParseError& parseError, UErrorCode& success) : fLocale(newLocale), msgPattern(success), formatAliases(NULL), formatAliasesCapacity(0), argTypes(NULL), argTypeCount(0), argTypeCapacity(0), hasArgTypeConflicts(FALSE), defaultNumberFormat(NULL), defaultDateFormat(NULL), cachedFormatters(NULL), customFormatArgStarts(NULL), pluralProvider(*this, UPLURAL_TYPE_CARDINAL), ordinalProvider(*this, UPLURAL_TYPE_ORDINAL) { setLocaleIDs(fLocale.getName(), fLocale.getName()); applyPattern(pattern, parseError, success); } MessageFormat::MessageFormat(const MessageFormat& that) : Format(that), fLocale(that.fLocale), msgPattern(that.msgPattern), formatAliases(NULL), formatAliasesCapacity(0), argTypes(NULL), argTypeCount(0), argTypeCapacity(0), hasArgTypeConflicts(that.hasArgTypeConflicts), defaultNumberFormat(NULL), defaultDateFormat(NULL), cachedFormatters(NULL), customFormatArgStarts(NULL), pluralProvider(*this, UPLURAL_TYPE_CARDINAL), ordinalProvider(*this, UPLURAL_TYPE_ORDINAL) { // This will take care of creating the hash tables (since they are NULL). UErrorCode ec = U_ZERO_ERROR; copyObjects(that, ec); if (U_FAILURE(ec)) { resetPattern(); } } MessageFormat::~MessageFormat() { uhash_close(cachedFormatters); uhash_close(customFormatArgStarts); uprv_free(argTypes); uprv_free(formatAliases); delete defaultNumberFormat; delete defaultDateFormat; } //-------------------------------------------------------------------- // Variable-size array management /** * Allocate argTypes[] to at least the given capacity and return * TRUE if successful. If not, leave argTypes[] unchanged. * * If argTypes is NULL, allocate it. If it is not NULL, enlarge it * if necessary to be at least as large as specified. */ UBool MessageFormat::allocateArgTypes(int32_t capacity, UErrorCode& status) { if (U_FAILURE(status)) { return FALSE; } if (argTypeCapacity >= capacity) { return TRUE; } if (capacity < DEFAULT_INITIAL_CAPACITY) { capacity = DEFAULT_INITIAL_CAPACITY; } else if (capacity < 2*argTypeCapacity) { capacity = 2*argTypeCapacity; } Formattable::Type* a = (Formattable::Type*) uprv_realloc(argTypes, sizeof(*argTypes) * capacity); if (a == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return FALSE; } argTypes = a; argTypeCapacity = capacity; return TRUE; } // ------------------------------------- // assignment operator const MessageFormat& MessageFormat::operator=(const MessageFormat& that) { if (this != &that) { // Calls the super class for assignment first. Format::operator=(that); setLocale(that.fLocale); msgPattern = that.msgPattern; hasArgTypeConflicts = that.hasArgTypeConflicts; UErrorCode ec = U_ZERO_ERROR; copyObjects(that, ec); if (U_FAILURE(ec)) { resetPattern(); } } return *this; } UBool MessageFormat::operator==(const Format& rhs) const { if (this == &rhs) return TRUE; MessageFormat& that = (MessageFormat&)rhs; // Check class ID before checking MessageFormat members if (!Format::operator==(rhs) || msgPattern != that.msgPattern || fLocale != that.fLocale) { return FALSE; } // Compare hashtables. if ((customFormatArgStarts == NULL) != (that.customFormatArgStarts == NULL)) { return FALSE; } if (customFormatArgStarts == NULL) { return TRUE; } UErrorCode ec = U_ZERO_ERROR; const int32_t count = uhash_count(customFormatArgStarts); const int32_t rhs_count = uhash_count(that.customFormatArgStarts); if (count != rhs_count) { return FALSE; } int32_t idx = 0, rhs_idx = 0, pos = UHASH_FIRST, rhs_pos = UHASH_FIRST; for (; idx < count && rhs_idx < rhs_count && U_SUCCESS(ec); ++idx, ++rhs_idx) { const UHashElement* cur = uhash_nextElement(customFormatArgStarts, &pos); const UHashElement* rhs_cur = uhash_nextElement(that.customFormatArgStarts, &rhs_pos); if (cur->key.integer != rhs_cur->key.integer) { return FALSE; } const Format* format = (const Format*)uhash_iget(cachedFormatters, cur->key.integer); const Format* rhs_format = (const Format*)uhash_iget(that.cachedFormatters, rhs_cur->key.integer); if (*format != *rhs_format) { return FALSE; } } return TRUE; } // ------------------------------------- // Creates a copy of this MessageFormat, the caller owns the copy. Format* MessageFormat::clone() const { return new MessageFormat(*this); } // ------------------------------------- // Sets the locale of this MessageFormat object to theLocale. void MessageFormat::setLocale(const Locale& theLocale) { if (fLocale != theLocale) { delete defaultNumberFormat; defaultNumberFormat = NULL; delete defaultDateFormat; defaultDateFormat = NULL; fLocale = theLocale; setLocaleIDs(fLocale.getName(), fLocale.getName()); pluralProvider.reset(); ordinalProvider.reset(); } } // ------------------------------------- // Gets the locale of this MessageFormat object. const Locale& MessageFormat::getLocale() const { return fLocale; } void MessageFormat::applyPattern(const UnicodeString& newPattern, UErrorCode& status) { UParseError parseError; applyPattern(newPattern,parseError,status); } // ------------------------------------- // Applies the new pattern and returns an error if the pattern // is not correct. void MessageFormat::applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& ec) { if(U_FAILURE(ec)) { return; } msgPattern.parse(pattern, &parseError, ec); cacheExplicitFormats(ec); if (U_FAILURE(ec)) { resetPattern(); } } void MessageFormat::resetPattern() { msgPattern.clear(); uhash_close(cachedFormatters); cachedFormatters = NULL; uhash_close(customFormatArgStarts); customFormatArgStarts = NULL; argTypeCount = 0; hasArgTypeConflicts = FALSE; } void MessageFormat::applyPattern(const UnicodeString& pattern, UMessagePatternApostropheMode aposMode, UParseError* parseError, UErrorCode& status) { if (aposMode != msgPattern.getApostropheMode()) { msgPattern.clearPatternAndSetApostropheMode(aposMode); } applyPattern(pattern, *parseError, status); } // ------------------------------------- // Converts this MessageFormat instance to a pattern. UnicodeString& MessageFormat::toPattern(UnicodeString& appendTo) const { if ((customFormatArgStarts != NULL && 0 != uhash_count(customFormatArgStarts)) || 0 == msgPattern.countParts() ) { appendTo.setToBogus(); return appendTo; } return appendTo.append(msgPattern.getPatternString()); } int32_t MessageFormat::nextTopLevelArgStart(int32_t partIndex) const { if (partIndex != 0) { partIndex = msgPattern.getLimitPartIndex(partIndex); } for (;;) { UMessagePatternPartType type = msgPattern.getPartType(++partIndex); if (type == UMSGPAT_PART_TYPE_ARG_START) { return partIndex; } if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) { return -1; } } } void MessageFormat::setArgStartFormat(int32_t argStart, Format* formatter, UErrorCode& status) { if (U_FAILURE(status)) { delete formatter; return; } if (cachedFormatters == NULL) { cachedFormatters=uhash_open(uhash_hashLong, uhash_compareLong, equalFormatsForHash, &status); if (U_FAILURE(status)) { delete formatter; return; } uhash_setValueDeleter(cachedFormatters, uprv_deleteUObject); } if (formatter == NULL) { formatter = new DummyFormat(); } uhash_iput(cachedFormatters, argStart, formatter, &status); } UBool MessageFormat::argNameMatches(int32_t partIndex, const UnicodeString& argName, int32_t argNumber) { const MessagePattern::Part& part = msgPattern.getPart(partIndex); return part.getType() == UMSGPAT_PART_TYPE_ARG_NAME ? msgPattern.partSubstringMatches(part, argName) : part.getValue() == argNumber; // ARG_NUMBER } // Sets a custom formatter for a MessagePattern ARG_START part index. // "Custom" formatters are provided by the user via setFormat() or similar APIs. void MessageFormat::setCustomArgStartFormat(int32_t argStart, Format* formatter, UErrorCode& status) { setArgStartFormat(argStart, formatter, status); if (customFormatArgStarts == NULL) { customFormatArgStarts=uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); } uhash_iputi(customFormatArgStarts, argStart, 1, &status); } Format* MessageFormat::getCachedFormatter(int32_t argumentNumber) const { if (cachedFormatters == NULL) { return NULL; } void* ptr = uhash_iget(cachedFormatters, argumentNumber); if (ptr != NULL && dynamic_cast<DummyFormat*>((Format*)ptr) == NULL) { return (Format*) ptr; } else { // Not cached, or a DummyFormat representing setFormat(NULL). return NULL; } } // ------------------------------------- // Adopts the new formats array and updates the array count. // This MessageFormat instance owns the new formats. void MessageFormat::adoptFormats(Format** newFormats, int32_t count) { if (newFormats == NULL || count < 0) { return; } // Throw away any cached formatters. if (cachedFormatters != NULL) { uhash_removeAll(cachedFormatters); } if (customFormatArgStarts != NULL) { uhash_removeAll(customFormatArgStarts); } int32_t formatNumber = 0; UErrorCode status = U_ZERO_ERROR; for (int32_t partIndex = 0; formatNumber < count && U_SUCCESS(status) && (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { setCustomArgStartFormat(partIndex, newFormats[formatNumber], status); ++formatNumber; } // Delete those that didn't get used (if any). for (; formatNumber < count; ++formatNumber) { delete newFormats[formatNumber]; } } // ------------------------------------- // Sets the new formats array and updates the array count. // This MessageFormat instance maks a copy of the new formats. void MessageFormat::setFormats(const Format** newFormats, int32_t count) { if (newFormats == NULL || count < 0) { return; } // Throw away any cached formatters. if (cachedFormatters != NULL) { uhash_removeAll(cachedFormatters); } if (customFormatArgStarts != NULL) { uhash_removeAll(customFormatArgStarts); } UErrorCode status = U_ZERO_ERROR; int32_t formatNumber = 0; for (int32_t partIndex = 0; formatNumber < count && U_SUCCESS(status) && (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { Format* newFormat = NULL; if (newFormats[formatNumber] != NULL) { newFormat = newFormats[formatNumber]->clone(); if (newFormat == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } } setCustomArgStartFormat(partIndex, newFormat, status); ++formatNumber; } if (U_FAILURE(status)) { resetPattern(); } } // ------------------------------------- // Adopt a single format by format number. // Do nothing if the format number is not less than the array count. void MessageFormat::adoptFormat(int32_t n, Format *newFormat) { LocalPointer<Format> p(newFormat); if (n >= 0) { int32_t formatNumber = 0; for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { if (n == formatNumber) { UErrorCode status = U_ZERO_ERROR; setCustomArgStartFormat(partIndex, p.orphan(), status); return; } ++formatNumber; } } } // ------------------------------------- // Adopt a single format by format name. // Do nothing if there is no match of formatName. void MessageFormat::adoptFormat(const UnicodeString& formatName, Format* formatToAdopt, UErrorCode& status) { LocalPointer<Format> p(formatToAdopt); if (U_FAILURE(status)) { return; } int32_t argNumber = MessagePattern::validateArgumentName(formatName); if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) { status = U_ILLEGAL_ARGUMENT_ERROR; return; } for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0 && U_SUCCESS(status); ) { if (argNameMatches(partIndex + 1, formatName, argNumber)) { Format* f; if (p.isValid()) { f = p.orphan(); } else if (formatToAdopt == NULL) { f = NULL; } else { f = formatToAdopt->clone(); if (f == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } } setCustomArgStartFormat(partIndex, f, status); } } } // ------------------------------------- // Set a single format. // Do nothing if the variable is not less than the array count. void MessageFormat::setFormat(int32_t n, const Format& newFormat) { if (n >= 0) { int32_t formatNumber = 0; for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { if (n == formatNumber) { Format* new_format = newFormat.clone(); if (new_format) { UErrorCode status = U_ZERO_ERROR; setCustomArgStartFormat(partIndex, new_format, status); } return; } ++formatNumber; } } } // ------------------------------------- // Get a single format by format name. // Do nothing if the variable is not less than the array count. Format * MessageFormat::getFormat(const UnicodeString& formatName, UErrorCode& status) { if (U_FAILURE(status) || cachedFormatters == NULL) return NULL; int32_t argNumber = MessagePattern::validateArgumentName(formatName); if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) { status = U_ILLEGAL_ARGUMENT_ERROR; return NULL; } for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { if (argNameMatches(partIndex + 1, formatName, argNumber)) { return getCachedFormatter(partIndex); } } return NULL; } // ------------------------------------- // Set a single format by format name // Do nothing if the variable is not less than the array count. void MessageFormat::setFormat(const UnicodeString& formatName, const Format& newFormat, UErrorCode& status) { if (U_FAILURE(status)) return; int32_t argNumber = MessagePattern::validateArgumentName(formatName); if (argNumber < UMSGPAT_ARG_NAME_NOT_NUMBER) { status = U_ILLEGAL_ARGUMENT_ERROR; return; } for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0 && U_SUCCESS(status); ) { if (argNameMatches(partIndex + 1, formatName, argNumber)) { Format* new_format = newFormat.clone(); if (new_format == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } setCustomArgStartFormat(partIndex, new_format, status); } } } // ------------------------------------- // Gets the format array. const Format** MessageFormat::getFormats(int32_t& cnt) const { // This old API returns an array (which we hold) of Format* // pointers. The array is valid up to the next call to any // method on this object. We construct and resize an array // on demand that contains aliases to the subformats[i].format // pointers. MessageFormat* t = const_cast<MessageFormat*> (this); cnt = 0; if (formatAliases == NULL) { t->formatAliasesCapacity = (argTypeCount<10) ? 10 : argTypeCount; Format** a = (Format**) uprv_malloc(sizeof(Format*) * formatAliasesCapacity); if (a == NULL) { t->formatAliasesCapacity = 0; return NULL; } t->formatAliases = a; } else if (argTypeCount > formatAliasesCapacity) { Format** a = (Format**) uprv_realloc(formatAliases, sizeof(Format*) * argTypeCount); if (a == NULL) { t->formatAliasesCapacity = 0; return NULL; } t->formatAliases = a; t->formatAliasesCapacity = argTypeCount; } for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { t->formatAliases[cnt++] = getCachedFormatter(partIndex); } return (const Format**)formatAliases; } UnicodeString MessageFormat::getArgName(int32_t partIndex) { const MessagePattern::Part& part = msgPattern.getPart(partIndex); return msgPattern.getSubstring(part); } StringEnumeration* MessageFormat::getFormatNames(UErrorCode& status) { if (U_FAILURE(status)) return NULL; UVector *fFormatNames = new UVector(status); if (U_FAILURE(status)) { status = U_MEMORY_ALLOCATION_ERROR; return NULL; } fFormatNames->setDeleter(uprv_deleteUObject); for (int32_t partIndex = 0; (partIndex = nextTopLevelArgStart(partIndex)) >= 0;) { fFormatNames->addElement(new UnicodeString(getArgName(partIndex + 1)), status); } StringEnumeration* nameEnumerator = new FormatNameEnumeration(fFormatNames, status); return nameEnumerator; } // ------------------------------------- // Formats the source Formattable array and copy into the result buffer. // Ignore the FieldPosition result for error checking. UnicodeString& MessageFormat::format(const Formattable* source, int32_t cnt, UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success) const { return format(source, NULL, cnt, appendTo, &ignore, success); } // ------------------------------------- // Internally creates a MessageFormat instance based on the // pattern and formats the arguments Formattable array and // copy into the appendTo buffer. UnicodeString& MessageFormat::format( const UnicodeString& pattern, const Formattable* arguments, int32_t cnt, UnicodeString& appendTo, UErrorCode& success) { MessageFormat temp(pattern, success); return temp.format(arguments, NULL, cnt, appendTo, NULL, success); } // ------------------------------------- // Formats the source Formattable object and copy into the // appendTo buffer. The Formattable object must be an array // of Formattable instances, returns error otherwise. UnicodeString& MessageFormat::format(const Formattable& source, UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success) const { if (U_FAILURE(success)) return appendTo; if (source.getType() != Formattable::kArray) { success = U_ILLEGAL_ARGUMENT_ERROR; return appendTo; } int32_t cnt; const Formattable* tmpPtr = source.getArray(cnt); return format(tmpPtr, NULL, cnt, appendTo, &ignore, success); } UnicodeString& MessageFormat::format(const UnicodeString* argumentNames, const Formattable* arguments, int32_t count, UnicodeString& appendTo, UErrorCode& success) const { return format(arguments, argumentNames, count, appendTo, NULL, success); } // Does linear search to find the match for an ArgName. const Formattable* MessageFormat::getArgFromListByName(const Formattable* arguments, const UnicodeString *argumentNames, int32_t cnt, UnicodeString& name) const { for (int32_t i = 0; i < cnt; ++i) { if (0 == argumentNames[i].compare(name)) { return arguments + i; } } return NULL; } UnicodeString& MessageFormat::format(const Formattable* arguments, const UnicodeString *argumentNames, int32_t cnt, UnicodeString& appendTo, FieldPosition* pos, UErrorCode& status) const { if (U_FAILURE(status)) { return appendTo; } UnicodeStringAppendable usapp(appendTo); AppendableWrapper app(usapp); format(0, NULL, arguments, argumentNames, cnt, app, pos, status); return appendTo; } namespace { /** * Mutable input/output values for the PluralSelectorProvider. * Separate so that it is possible to make MessageFormat Freezable. */ class PluralSelectorContext { public: PluralSelectorContext(int32_t start, const UnicodeString &name, const Formattable &num, double off, UErrorCode &errorCode) : startIndex(start), argName(name), offset(off), numberArgIndex(-1), formatter(NULL), forReplaceNumber(FALSE) { // number needs to be set even when select() is not called. // Keep it as a Number/Formattable: // For format() methods, and to preserve information (e.g., BigDecimal). if(off == 0) { number = num; } else { number = num.getDouble(errorCode) - off; } } // Input values for plural selection with decimals. int32_t startIndex; const UnicodeString &argName; /** argument number - plural offset */ Formattable number; double offset; // Output values for plural selection with decimals. /** -1 if REPLACE_NUMBER, 0 arg not found, >0 ARG_START index */ int32_t numberArgIndex; const Format *formatter; /** formatted argument number - plural offset */ UnicodeString numberString; /** TRUE if number-offset was formatted with the stock number formatter */ UBool forReplaceNumber; }; } // namespace // if argumentNames is NULL, this means arguments is a numeric array. // arguments can not be NULL. // We use const void *plNumber rather than const PluralSelectorContext *pluralNumber // so that we need not declare the PluralSelectorContext in the public header file. void MessageFormat::format(int32_t msgStart, const void *plNumber, const Formattable* arguments, const UnicodeString *argumentNames, int32_t cnt, AppendableWrapper& appendTo, FieldPosition* ignore, UErrorCode& success) const { if (U_FAILURE(success)) { return; } const UnicodeString& msgString = msgPattern.getPatternString(); int32_t prevIndex = msgPattern.getPart(msgStart).getLimit(); for (int32_t i = msgStart + 1; U_SUCCESS(success) ; ++i) { const MessagePattern::Part* part = &msgPattern.getPart(i); const UMessagePatternPartType type = part->getType(); int32_t index = part->getIndex(); appendTo.append(msgString, prevIndex, index - prevIndex); if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) { return; } prevIndex = part->getLimit(); if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) { const PluralSelectorContext &pluralNumber = *static_cast<const PluralSelectorContext *>(plNumber); if(pluralNumber.forReplaceNumber) { // number-offset was already formatted. appendTo.formatAndAppend(pluralNumber.formatter, pluralNumber.number, pluralNumber.numberString, success); } else { const NumberFormat* nf = getDefaultNumberFormat(success); appendTo.formatAndAppend(nf, pluralNumber.number, success); } continue; } if (type != UMSGPAT_PART_TYPE_ARG_START) { continue; } int32_t argLimit = msgPattern.getLimitPartIndex(i); UMessagePatternArgType argType = part->getArgType(); part = &msgPattern.getPart(++i); const Formattable* arg; UBool noArg = FALSE; UnicodeString argName = msgPattern.getSubstring(*part); if (argumentNames == NULL) { int32_t argNumber = part->getValue(); // ARG_NUMBER if (0 <= argNumber && argNumber < cnt) { arg = arguments + argNumber; } else { arg = NULL; noArg = TRUE; } } else { arg = getArgFromListByName(arguments, argumentNames, cnt, argName); if (arg == NULL) { noArg = TRUE; } } ++i; int32_t prevDestLength = appendTo.length(); const Format* formatter = NULL; if (noArg) { appendTo.append( UnicodeString(LEFT_CURLY_BRACE).append(argName).append(RIGHT_CURLY_BRACE)); } else if (arg == NULL) { appendTo.append(NULL_STRING, 4); } else if(plNumber!=NULL && static_cast<const PluralSelectorContext *>(plNumber)->numberArgIndex==(i-2)) { const PluralSelectorContext &pluralNumber = *static_cast<const PluralSelectorContext *>(plNumber); if(pluralNumber.offset == 0) { // The number was already formatted with this formatter. appendTo.formatAndAppend(pluralNumber.formatter, pluralNumber.number, pluralNumber.numberString, success); } else { // Do not use the formatted (number-offset) string for a named argument // that formats the number without subtracting the offset. appendTo.formatAndAppend(pluralNumber.formatter, *arg, success); } } else if ((formatter = getCachedFormatter(i -2))) { // Handles all ArgType.SIMPLE, and formatters from setFormat() and its siblings. if (dynamic_cast<const ChoiceFormat*>(formatter) || dynamic_cast<const PluralFormat*>(formatter) || dynamic_cast<const SelectFormat*>(formatter)) { // We only handle nested formats here if they were provided via // setFormat() or its siblings. Otherwise they are not cached and instead // handled below according to argType. UnicodeString subMsgString; formatter->format(*arg, subMsgString, success); if (subMsgString.indexOf(LEFT_CURLY_BRACE) >= 0 || (subMsgString.indexOf(SINGLE_QUOTE) >= 0 && !MessageImpl::jdkAposMode(msgPattern)) ) { MessageFormat subMsgFormat(subMsgString, fLocale, success); subMsgFormat.format(0, NULL, arguments, argumentNames, cnt, appendTo, ignore, success); } else { appendTo.append(subMsgString); } } else { appendTo.formatAndAppend(formatter, *arg, success); } } else if (argType == UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_iget(cachedFormatters, i - 2))) { // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table. // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check // for the hash table containind DummyFormat. if (arg->isNumeric()) { const NumberFormat* nf = getDefaultNumberFormat(success); appendTo.formatAndAppend(nf, *arg, success); } else if (arg->getType() == Formattable::kDate) { const DateFormat* df = getDefaultDateFormat(success); appendTo.formatAndAppend(df, *arg, success); } else { appendTo.append(arg->getString(success)); } } else if (argType == UMSGPAT_ARG_TYPE_CHOICE) { if (!arg->isNumeric()) { success = U_ILLEGAL_ARGUMENT_ERROR; return; } // We must use the Formattable::getDouble() variant with the UErrorCode parameter // because only this one converts non-double numeric types to double. const double number = arg->getDouble(success); int32_t subMsgStart = ChoiceFormat::findSubMessage(msgPattern, i, number); formatComplexSubMessage(subMsgStart, NULL, arguments, argumentNames, cnt, appendTo, success); } else if (UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType)) { if (!arg->isNumeric()) { success = U_ILLEGAL_ARGUMENT_ERROR; return; } const PluralSelectorProvider &selector = argType == UMSGPAT_ARG_TYPE_PLURAL ? pluralProvider : ordinalProvider; // We must use the Formattable::getDouble() variant with the UErrorCode parameter // because only this one converts non-double numeric types to double. double offset = msgPattern.getPluralOffset(i); PluralSelectorContext context(i, argName, *arg, offset, success); int32_t subMsgStart = PluralFormat::findSubMessage( msgPattern, i, selector, &context, arg->getDouble(success), success); formatComplexSubMessage(subMsgStart, &context, arguments, argumentNames, cnt, appendTo, success); } else if (argType == UMSGPAT_ARG_TYPE_SELECT) { int32_t subMsgStart = SelectFormat::findSubMessage(msgPattern, i, arg->getString(success), success); formatComplexSubMessage(subMsgStart, NULL, arguments, argumentNames, cnt, appendTo, success); } else { // This should never happen. success = U_INTERNAL_PROGRAM_ERROR; return; } ignore = updateMetaData(appendTo, prevDestLength, ignore, arg); prevIndex = msgPattern.getPart(argLimit).getLimit(); i = argLimit; } } void MessageFormat::formatComplexSubMessage(int32_t msgStart, const void *plNumber, const Formattable* arguments, const UnicodeString *argumentNames, int32_t cnt, AppendableWrapper& appendTo, UErrorCode& success) const { if (U_FAILURE(success)) { return; } if (!MessageImpl::jdkAposMode(msgPattern)) { format(msgStart, plNumber, arguments, argumentNames, cnt, appendTo, NULL, success); return; } // JDK compatibility mode: (see JDK MessageFormat.format() API docs) // - remove SKIP_SYNTAX; that is, remove half of the apostrophes // - if the result string contains an open curly brace '{' then // instantiate a temporary MessageFormat object and format again; // otherwise just append the result string const UnicodeString& msgString = msgPattern.getPatternString(); UnicodeString sb; int32_t prevIndex = msgPattern.getPart(msgStart).getLimit(); for (int32_t i = msgStart;;) { const MessagePattern::Part& part = msgPattern.getPart(++i); const UMessagePatternPartType type = part.getType(); int32_t index = part.getIndex(); if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) { sb.append(msgString, prevIndex, index - prevIndex); break; } else if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER || type == UMSGPAT_PART_TYPE_SKIP_SYNTAX) { sb.append(msgString, prevIndex, index - prevIndex); if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) { const PluralSelectorContext &pluralNumber = *static_cast<const PluralSelectorContext *>(plNumber); if(pluralNumber.forReplaceNumber) { // number-offset was already formatted. sb.append(pluralNumber.numberString); } else { const NumberFormat* nf = getDefaultNumberFormat(success); sb.append(nf->format(pluralNumber.number, sb, success)); } } prevIndex = part.getLimit(); } else if (type == UMSGPAT_PART_TYPE_ARG_START) { sb.append(msgString, prevIndex, index - prevIndex); prevIndex = index; i = msgPattern.getLimitPartIndex(i); index = msgPattern.getPart(i).getLimit(); MessageImpl::appendReducedApostrophes(msgString, prevIndex, index, sb); prevIndex = index; } } if (sb.indexOf(LEFT_CURLY_BRACE) >= 0) { UnicodeString emptyPattern; // gcc 3.3.3 fails with "UnicodeString()" as the first parameter. MessageFormat subMsgFormat(emptyPattern, fLocale, success); subMsgFormat.applyPattern(sb, UMSGPAT_APOS_DOUBLE_REQUIRED, NULL, success); subMsgFormat.format(0, NULL, arguments, argumentNames, cnt, appendTo, NULL, success); } else { appendTo.append(sb); } } UnicodeString MessageFormat::getLiteralStringUntilNextArgument(int32_t from) const { const UnicodeString& msgString=msgPattern.getPatternString(); int32_t prevIndex=msgPattern.getPart(from).getLimit(); UnicodeString b; for (int32_t i = from + 1; ; ++i) { const MessagePattern::Part& part = msgPattern.getPart(i); const UMessagePatternPartType type=part.getType(); int32_t index=part.getIndex(); b.append(msgString, prevIndex, index - prevIndex); if(type==UMSGPAT_PART_TYPE_ARG_START || type==UMSGPAT_PART_TYPE_MSG_LIMIT) { return b; } // Unexpected Part "part" in parsed message. U_ASSERT(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX || type==UMSGPAT_PART_TYPE_INSERT_CHAR); prevIndex=part.getLimit(); } } FieldPosition* MessageFormat::updateMetaData(AppendableWrapper& /*dest*/, int32_t /*prevLength*/, FieldPosition* /*fp*/, const Formattable* /*argId*/) const { // Unlike in Java, there are no field attributes defined for MessageFormat. Do nothing. return NULL; /* if (fp != NULL && Field.ARGUMENT.equals(fp.getFieldAttribute())) { fp->setBeginIndex(prevLength); fp->setEndIndex(dest.get_length()); return NULL; } return fp; */ } int32_t MessageFormat::findOtherSubMessage(int32_t partIndex) const { int32_t count=msgPattern.countParts(); const MessagePattern::Part *part = &msgPattern.getPart(partIndex); if(MessagePattern::Part::hasNumericValue(part->getType())) { ++partIndex; } // Iterate over (ARG_SELECTOR [ARG_INT|ARG_DOUBLE] message) tuples // until ARG_LIMIT or end of plural-only pattern. UnicodeString other(FALSE, OTHER_STRING, 5); do { part=&msgPattern.getPart(partIndex++); 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(msgPattern.partSubstringMatches(*part, other)) { return partIndex; } if(MessagePattern::Part::hasNumericValue(msgPattern.getPartType(partIndex))) { ++partIndex; // skip the numeric-value part of "=1" etc. } partIndex=msgPattern.getLimitPartIndex(partIndex); } while(++partIndex<count); return 0; } int32_t MessageFormat::findFirstPluralNumberArg(int32_t msgStart, const UnicodeString &argName) const { for(int32_t i=msgStart+1;; ++i) { const MessagePattern::Part &part=msgPattern.getPart(i); UMessagePatternPartType type=part.getType(); if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) { return 0; } if(type==UMSGPAT_PART_TYPE_REPLACE_NUMBER) { return -1; } if(type==UMSGPAT_PART_TYPE_ARG_START) { UMessagePatternArgType argType=part.getArgType(); if(!argName.isEmpty() && (argType==UMSGPAT_ARG_TYPE_NONE || argType==UMSGPAT_ARG_TYPE_SIMPLE)) { // ARG_NUMBER or ARG_NAME if(msgPattern.partSubstringMatches(msgPattern.getPart(i+1), argName)) { return i; } } i=msgPattern.getLimitPartIndex(i); } } } void MessageFormat::copyObjects(const MessageFormat& that, UErrorCode& ec) { // Deep copy pointer fields. // We need not copy the formatAliases because they are re-filled // in each getFormats() call. // The defaultNumberFormat, defaultDateFormat and pluralProvider.rules // also get created on demand. argTypeCount = that.argTypeCount; if (argTypeCount > 0) { if (!allocateArgTypes(argTypeCount, ec)) { return; } uprv_memcpy(argTypes, that.argTypes, argTypeCount * sizeof(argTypes[0])); } if (cachedFormatters != NULL) { uhash_removeAll(cachedFormatters); } if (customFormatArgStarts != NULL) { uhash_removeAll(customFormatArgStarts); } if (that.cachedFormatters) { if (cachedFormatters == NULL) { cachedFormatters=uhash_open(uhash_hashLong, uhash_compareLong, equalFormatsForHash, &ec); if (U_FAILURE(ec)) { return; } uhash_setValueDeleter(cachedFormatters, uprv_deleteUObject); } const int32_t count = uhash_count(that.cachedFormatters); int32_t pos, idx; for (idx = 0, pos = UHASH_FIRST; idx < count && U_SUCCESS(ec); ++idx) { const UHashElement* cur = uhash_nextElement(that.cachedFormatters, &pos); Format* newFormat = ((Format*)(cur->value.pointer))->clone(); if (newFormat) { uhash_iput(cachedFormatters, cur->key.integer, newFormat, &ec); } else { ec = U_MEMORY_ALLOCATION_ERROR; return; } } } if (that.customFormatArgStarts) { if (customFormatArgStarts == NULL) { customFormatArgStarts=uhash_open(uhash_hashLong, uhash_compareLong, NULL, &ec); } const int32_t count = uhash_count(that.customFormatArgStarts); int32_t pos, idx; for (idx = 0, pos = UHASH_FIRST; idx < count && U_SUCCESS(ec); ++idx) { const UHashElement* cur = uhash_nextElement(that.customFormatArgStarts, &pos); uhash_iputi(customFormatArgStarts, cur->key.integer, cur->value.integer, &ec); } } } Formattable* MessageFormat::parse(int32_t msgStart, const UnicodeString& source, ParsePosition& pos, int32_t& count, UErrorCode& ec) const { count = 0; if (U_FAILURE(ec)) { pos.setErrorIndex(pos.getIndex()); return NULL; } // parse() does not work with named arguments. if (msgPattern.hasNamedArguments()) { ec = U_ARGUMENT_TYPE_MISMATCH; pos.setErrorIndex(pos.getIndex()); return NULL; } LocalArray<Formattable> resultArray(new Formattable[argTypeCount ? argTypeCount : 1]); const UnicodeString& msgString=msgPattern.getPatternString(); int32_t prevIndex=msgPattern.getPart(msgStart).getLimit(); int32_t sourceOffset = pos.getIndex(); ParsePosition tempStatus(0); for(int32_t i=msgStart+1; ; ++i) { UBool haveArgResult = FALSE; const MessagePattern::Part* part=&msgPattern.getPart(i); const UMessagePatternPartType type=part->getType(); int32_t index=part->getIndex(); // Make sure the literal string matches. int32_t len = index - prevIndex; if (len == 0 || (0 == msgString.compare(prevIndex, len, source, sourceOffset, len))) { sourceOffset += len; prevIndex += len; } else { pos.setErrorIndex(sourceOffset); return NULL; // leave index as is to signal error } if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) { // Things went well! Done. pos.setIndex(sourceOffset); return resultArray.orphan(); } if(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX || type==UMSGPAT_PART_TYPE_INSERT_CHAR) { prevIndex=part->getLimit(); continue; } // We do not support parsing Plural formats. (No REPLACE_NUMBER here.) // Unexpected Part "part" in parsed message. U_ASSERT(type==UMSGPAT_PART_TYPE_ARG_START); int32_t argLimit=msgPattern.getLimitPartIndex(i); UMessagePatternArgType argType=part->getArgType(); part=&msgPattern.getPart(++i); int32_t argNumber = part->getValue(); // ARG_NUMBER UnicodeString key; ++i; const Format* formatter = NULL; Formattable& argResult = resultArray[argNumber]; if(cachedFormatters!=NULL && (formatter = getCachedFormatter(i - 2))!=NULL) { // Just parse using the formatter. tempStatus.setIndex(sourceOffset); formatter->parseObject(source, argResult, tempStatus); if (tempStatus.getIndex() == sourceOffset) { pos.setErrorIndex(sourceOffset); return NULL; // leave index as is to signal error } sourceOffset = tempStatus.getIndex(); haveArgResult = TRUE; } else if( argType==UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_iget(cachedFormatters, i -2))) { // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table. // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check // for the hash table containind DummyFormat. // Match as a string. // if at end, use longest possible match // otherwise uses first match to intervening string // does NOT recursively try all possibilities UnicodeString stringAfterArgument = getLiteralStringUntilNextArgument(argLimit); int32_t next; if (!stringAfterArgument.isEmpty()) { next = source.indexOf(stringAfterArgument, sourceOffset); } else { next = source.length(); } if (next < 0) { pos.setErrorIndex(sourceOffset); return NULL; // leave index as is to signal error } else { UnicodeString strValue(source.tempSubString(sourceOffset, next - sourceOffset)); UnicodeString compValue; compValue.append(LEFT_CURLY_BRACE); itos(argNumber, compValue); compValue.append(RIGHT_CURLY_BRACE); if (0 != strValue.compare(compValue)) { argResult.setString(strValue); haveArgResult = TRUE; } sourceOffset = next; } } else if(argType==UMSGPAT_ARG_TYPE_CHOICE) { tempStatus.setIndex(sourceOffset); double choiceResult = ChoiceFormat::parseArgument(msgPattern, i, source, tempStatus); if (tempStatus.getIndex() == sourceOffset) { pos.setErrorIndex(sourceOffset); return NULL; // leave index as is to signal error } argResult.setDouble(choiceResult); haveArgResult = TRUE; sourceOffset = tempStatus.getIndex(); } else if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) || argType==UMSGPAT_ARG_TYPE_SELECT) { // Parsing not supported. ec = U_UNSUPPORTED_ERROR; return NULL; } else { // This should never happen. ec = U_INTERNAL_PROGRAM_ERROR; return NULL; } if (haveArgResult && count <= argNumber) { count = argNumber + 1; } prevIndex=msgPattern.getPart(argLimit).getLimit(); i=argLimit; } } // ------------------------------------- // Parses the source pattern and returns the Formattable objects array, // the array count and the ending parse position. The caller of this method // owns the array. Formattable* MessageFormat::parse(const UnicodeString& source, ParsePosition& pos, int32_t& count) const { UErrorCode ec = U_ZERO_ERROR; return parse(0, source, pos, count, ec); } // ------------------------------------- // Parses the source string and returns the array of // Formattable objects and the array count. The caller // owns the returned array. Formattable* MessageFormat::parse(const UnicodeString& source, int32_t& cnt, UErrorCode& success) const { if (msgPattern.hasNamedArguments()) { success = U_ARGUMENT_TYPE_MISMATCH; return NULL; } ParsePosition status(0); // Calls the actual implementation method and starts // from zero offset of the source text. Formattable* result = parse(source, status, cnt); if (status.getIndex() == 0) { success = U_MESSAGE_PARSE_ERROR; delete[] result; return NULL; } return result; } // ------------------------------------- // Parses the source text and copy into the result buffer. void MessageFormat::parseObject( const UnicodeString& source, Formattable& result, ParsePosition& status) const { int32_t cnt = 0; Formattable* tmpResult = parse(source, status, cnt); if (tmpResult != NULL) result.adoptArray(tmpResult, cnt); } UnicodeString MessageFormat::autoQuoteApostrophe(const UnicodeString& pattern, UErrorCode& status) { UnicodeString result; if (U_SUCCESS(status)) { int32_t plen = pattern.length(); const UChar* pat = pattern.getBuffer(); int32_t blen = plen * 2 + 1; // space for null termination, convenience UChar* buf = result.getBuffer(blen); if (buf == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } else { int32_t len = umsg_autoQuoteApostrophe(pat, plen, buf, blen, &status); result.releaseBuffer(U_SUCCESS(status) ? len : 0); } } if (U_FAILURE(status)) { result.setToBogus(); } return result; } // ------------------------------------- static Format* makeRBNF(URBNFRuleSetTag tag, const Locale& locale, const UnicodeString& defaultRuleSet, UErrorCode& ec) { RuleBasedNumberFormat* fmt = new RuleBasedNumberFormat(tag, locale, ec); if (fmt == NULL) { ec = U_MEMORY_ALLOCATION_ERROR; } else if (U_SUCCESS(ec) && defaultRuleSet.length() > 0) { UErrorCode localStatus = U_ZERO_ERROR; // ignore unrecognized default rule set fmt->setDefaultRuleSet(defaultRuleSet, localStatus); } return fmt; } void MessageFormat::cacheExplicitFormats(UErrorCode& status) { if (U_FAILURE(status)) { return; } if (cachedFormatters != NULL) { uhash_removeAll(cachedFormatters); } if (customFormatArgStarts != NULL) { uhash_removeAll(customFormatArgStarts); } // The last two "parts" can at most be ARG_LIMIT and MSG_LIMIT // which we need not examine. int32_t limit = msgPattern.countParts() - 2; argTypeCount = 0; // We also need not look at the first two "parts" // (at most MSG_START and ARG_START) in this loop. // We determine the argTypeCount first so that we can allocateArgTypes // so that the next loop can set argTypes[argNumber]. // (This is for the C API which needs the argTypes to read its va_arg list.) for (int32_t i = 2; i < limit && U_SUCCESS(status); ++i) { const MessagePattern::Part& part = msgPattern.getPart(i); if (part.getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) { const int argNumber = part.getValue(); if (argNumber >= argTypeCount) { argTypeCount = argNumber + 1; } } } if (!allocateArgTypes(argTypeCount, status)) { return; } // Set all argTypes to kObject, as a "none" value, for lack of any better value. // We never use kObject for real arguments. // We use it as "no argument yet" for the check for hasArgTypeConflicts. for (int32_t i = 0; i < argTypeCount; ++i) { argTypes[i] = Formattable::kObject; } hasArgTypeConflicts = FALSE; // This loop starts at part index 1 because we do need to examine // ARG_START parts. (But we can ignore the MSG_START.) for (int32_t i = 1; i < limit && U_SUCCESS(status); ++i) { const MessagePattern::Part* part = &msgPattern.getPart(i); if (part->getType() != UMSGPAT_PART_TYPE_ARG_START) { continue; } UMessagePatternArgType argType = part->getArgType(); int32_t argNumber = -1; part = &msgPattern.getPart(i + 1); if (part->getType() == UMSGPAT_PART_TYPE_ARG_NUMBER) { argNumber = part->getValue(); } Formattable::Type formattableType; switch (argType) { case UMSGPAT_ARG_TYPE_NONE: formattableType = Formattable::kString; break; case UMSGPAT_ARG_TYPE_SIMPLE: { int32_t index = i; i += 2; UnicodeString explicitType = msgPattern.getSubstring(msgPattern.getPart(i++)); UnicodeString style; if ((part = &msgPattern.getPart(i))->getType() == UMSGPAT_PART_TYPE_ARG_STYLE) { style = msgPattern.getSubstring(*part); ++i; } UParseError parseError; Format* formatter = createAppropriateFormat(explicitType, style, formattableType, parseError, status); setArgStartFormat(index, formatter, status); break; } case UMSGPAT_ARG_TYPE_CHOICE: case UMSGPAT_ARG_TYPE_PLURAL: case UMSGPAT_ARG_TYPE_SELECTORDINAL: formattableType = Formattable::kDouble; break; case UMSGPAT_ARG_TYPE_SELECT: formattableType = Formattable::kString; break; default: status = U_INTERNAL_PROGRAM_ERROR; // Should be unreachable. formattableType = Formattable::kString; break; } if (argNumber != -1) { if (argTypes[argNumber] != Formattable::kObject && argTypes[argNumber] != formattableType) { hasArgTypeConflicts = TRUE; } argTypes[argNumber] = formattableType; } } } Format* MessageFormat::createAppropriateFormat(UnicodeString& type, UnicodeString& style, Formattable::Type& formattableType, UParseError& parseError, UErrorCode& ec) { if (U_FAILURE(ec)) { return NULL; } Format* fmt = NULL; int32_t typeID, styleID; DateFormat::EStyle date_style; switch (typeID = findKeyword(type, TYPE_IDS)) { case 0: // number formattableType = Formattable::kDouble; switch (findKeyword(style, NUMBER_STYLE_IDS)) { case 0: // default fmt = NumberFormat::createInstance(fLocale, ec); break; case 1: // currency fmt = NumberFormat::createCurrencyInstance(fLocale, ec); break; case 2: // percent fmt = NumberFormat::createPercentInstance(fLocale, ec); break; case 3: // integer formattableType = Formattable::kLong; fmt = createIntegerFormat(fLocale, ec); break; default: // pattern fmt = NumberFormat::createInstance(fLocale, ec); if (fmt) { DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(fmt); if (decfmt != NULL) { decfmt->applyPattern(style,parseError,ec); } } break; } break; case 1: // date case 2: // time formattableType = Formattable::kDate; styleID = findKeyword(style, DATE_STYLE_IDS); date_style = (styleID >= 0) ? DATE_STYLES[styleID] : DateFormat::kDefault; if (typeID == 1) { fmt = DateFormat::createDateInstance(date_style, fLocale); } else { fmt = DateFormat::createTimeInstance(date_style, fLocale); } if (styleID < 0 && fmt != NULL) { SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(fmt); if (sdtfmt != NULL) { sdtfmt->applyPattern(style); } } break; case 3: // spellout formattableType = Formattable::kDouble; fmt = makeRBNF(URBNF_SPELLOUT, fLocale, style, ec); break; case 4: // ordinal formattableType = Formattable::kDouble; fmt = makeRBNF(URBNF_ORDINAL, fLocale, style, ec); break; case 5: // duration formattableType = Formattable::kDouble; fmt = makeRBNF(URBNF_DURATION, fLocale, style, ec); break; default: formattableType = Formattable::kString; ec = U_ILLEGAL_ARGUMENT_ERROR; break; } return fmt; } //------------------------------------- // Finds the string, s, in the string array, list. int32_t MessageFormat::findKeyword(const UnicodeString& s, const UChar * const *list) { if (s.isEmpty()) { return 0; // default } int32_t length = s.length(); const UChar *ps = PatternProps::trimWhiteSpace(s.getBuffer(), length); UnicodeString buffer(FALSE, ps, length); // Trims the space characters and turns all characters // in s to lower case. buffer.toLower(""); for (int32_t i = 0; list[i]; ++i) { if (!buffer.compare(list[i], u_strlen(list[i]))) { return i; } } return -1; } /** * Convenience method that ought to be in NumberFormat */ NumberFormat* MessageFormat::createIntegerFormat(const Locale& locale, UErrorCode& status) const { NumberFormat *temp = NumberFormat::createInstance(locale, status); DecimalFormat *temp2; if (temp != NULL && (temp2 = dynamic_cast<DecimalFormat*>(temp)) != NULL) { temp2->setMaximumFractionDigits(0); temp2->setDecimalSeparatorAlwaysShown(FALSE); temp2->setParseIntegerOnly(TRUE); } return temp; } /** * Return the default number format. Used to format a numeric * argument when subformats[i].format is NULL. Returns NULL * on failure. * * Semantically const but may modify *this. */ const NumberFormat* MessageFormat::getDefaultNumberFormat(UErrorCode& ec) const { if (defaultNumberFormat == NULL) { MessageFormat* t = (MessageFormat*) this; t->defaultNumberFormat = NumberFormat::createInstance(fLocale, ec); if (U_FAILURE(ec)) { delete t->defaultNumberFormat; t->defaultNumberFormat = NULL; } else if (t->defaultNumberFormat == NULL) { ec = U_MEMORY_ALLOCATION_ERROR; } } return defaultNumberFormat; } /** * Return the default date format. Used to format a date * argument when subformats[i].format is NULL. Returns NULL * on failure. * * Semantically const but may modify *this. */ const DateFormat* MessageFormat::getDefaultDateFormat(UErrorCode& ec) const { if (defaultDateFormat == NULL) { MessageFormat* t = (MessageFormat*) this; t->defaultDateFormat = DateFormat::createDateTimeInstance(DateFormat::kShort, DateFormat::kShort, fLocale); if (t->defaultDateFormat == NULL) { ec = U_MEMORY_ALLOCATION_ERROR; } } return defaultDateFormat; } UBool MessageFormat::usesNamedArguments() const { return msgPattern.hasNamedArguments(); } int32_t MessageFormat::getArgTypeCount() const { return argTypeCount; } UBool MessageFormat::equalFormats(const void* left, const void* right) { return *(const Format*)left==*(const Format*)right; } UBool MessageFormat::DummyFormat::operator==(const Format&) const { return TRUE; } Format* MessageFormat::DummyFormat::clone() const { return new DummyFormat(); } UnicodeString& MessageFormat::DummyFormat::format(const Formattable&, UnicodeString& appendTo, UErrorCode& status) const { if (U_SUCCESS(status)) { status = U_UNSUPPORTED_ERROR; } return appendTo; } UnicodeString& MessageFormat::DummyFormat::format(const Formattable&, UnicodeString& appendTo, FieldPosition&, UErrorCode& status) const { if (U_SUCCESS(status)) { status = U_UNSUPPORTED_ERROR; } return appendTo; } UnicodeString& MessageFormat::DummyFormat::format(const Formattable&, UnicodeString& appendTo, FieldPositionIterator*, UErrorCode& status) const { if (U_SUCCESS(status)) { status = U_UNSUPPORTED_ERROR; } return appendTo; } void MessageFormat::DummyFormat::parseObject(const UnicodeString&, Formattable&, ParsePosition& ) const { } FormatNameEnumeration::FormatNameEnumeration(UVector *fNameList, UErrorCode& /*status*/) { pos=0; fFormatNames = fNameList; } const UnicodeString* FormatNameEnumeration::snext(UErrorCode& status) { if (U_SUCCESS(status) && pos < fFormatNames->size()) { return (const UnicodeString*)fFormatNames->elementAt(pos++); } return NULL; } void FormatNameEnumeration::reset(UErrorCode& /*status*/) { pos=0; } int32_t FormatNameEnumeration::count(UErrorCode& /*status*/) const { return (fFormatNames==NULL) ? 0 : fFormatNames->size(); } FormatNameEnumeration::~FormatNameEnumeration() { delete fFormatNames; } MessageFormat::PluralSelectorProvider::PluralSelectorProvider(const MessageFormat &mf, UPluralType t) : msgFormat(mf), rules(NULL), type(t) { } MessageFormat::PluralSelectorProvider::~PluralSelectorProvider() { delete rules; } UnicodeString MessageFormat::PluralSelectorProvider::select(void *ctx, double number, UErrorCode& ec) const { if (U_FAILURE(ec)) { return UnicodeString(FALSE, OTHER_STRING, 5); } MessageFormat::PluralSelectorProvider* t = const_cast<MessageFormat::PluralSelectorProvider*>(this); if(rules == NULL) { t->rules = PluralRules::forLocale(msgFormat.fLocale, type, ec); if (U_FAILURE(ec)) { return UnicodeString(FALSE, OTHER_STRING, 5); } } // Select a sub-message according to how the number is formatted, // which is specified in the selected sub-message. // We avoid this circle by looking at how // the number is formatted in the "other" sub-message // which must always be present and usually contains the number. // Message authors should be consistent across sub-messages. PluralSelectorContext &context = *static_cast<PluralSelectorContext *>(ctx); int32_t otherIndex = msgFormat.findOtherSubMessage(context.startIndex); context.numberArgIndex = msgFormat.findFirstPluralNumberArg(otherIndex, context.argName); if(context.numberArgIndex > 0 && msgFormat.cachedFormatters != NULL) { context.formatter = (const Format*)uhash_iget(msgFormat.cachedFormatters, context.numberArgIndex); } if(context.formatter == NULL) { context.formatter = msgFormat.getDefaultNumberFormat(ec); context.forReplaceNumber = TRUE; } U_ASSERT(context.number.getDouble(ec) == number); // argument number minus the offset context.formatter->format(context.number, context.numberString, ec); const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(context.formatter); if(decFmt != NULL) { VisibleDigitsWithExponent digits; decFmt->initVisibleDigitsWithExponent(context.number, digits, ec); if (U_FAILURE(ec)) { return UnicodeString(FALSE, OTHER_STRING, 5); } return rules->select(digits); } else { return rules->select(number); } } void MessageFormat::PluralSelectorProvider::reset() { delete rules; rules = NULL; } U_NAMESPACE_END #endif /* #if !UCONFIG_NO_FORMATTING */ //eof