| /* | |
| ******************************************************************************* | |
| * Copyright (C) 2011-2012, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ******************************************************************************* | |
| * file name: messagepattern.cpp | |
| * encoding: US-ASCII | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2011mar14 | |
| * created by: Markus W. Scherer | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/stdlib_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/messagepattern.h" | |
| #include "unicode/unistr.h" | |
| #include "unicode/utf16.h" | |
| #include "cmemory.h" | |
| #include "cstring.h" | |
| #include "messageimpl.h" | |
| #include "patternprops.h" | |
| #include "putilimp.h" | |
| #include "uassert.h" | |
| U_NAMESPACE_BEGIN | |
| // Unicode character/code point constants ---------------------------------- *** | |
| static const UChar u_pound=0x23; | |
| static const UChar u_apos=0x27; | |
| static const UChar u_plus=0x2B; | |
| static const UChar u_comma=0x2C; | |
| static const UChar u_minus=0x2D; | |
| static const UChar u_dot=0x2E; | |
| static const UChar u_colon=0x3A; | |
| static const UChar u_lessThan=0x3C; | |
| static const UChar u_equal=0x3D; | |
| static const UChar u_A=0x41; | |
| static const UChar u_C=0x43; | |
| static const UChar u_D=0x44; | |
| static const UChar u_E=0x45; | |
| static const UChar u_H=0x48; | |
| static const UChar u_I=0x49; | |
| static const UChar u_L=0x4C; | |
| static const UChar u_N=0x4E; | |
| static const UChar u_O=0x4F; | |
| static const UChar u_P=0x50; | |
| static const UChar u_R=0x52; | |
| static const UChar u_S=0x53; | |
| static const UChar u_T=0x54; | |
| static const UChar u_U=0x55; | |
| static const UChar u_Z=0x5A; | |
| static const UChar u_a=0x61; | |
| static const UChar u_c=0x63; | |
| static const UChar u_d=0x64; | |
| static const UChar u_e=0x65; | |
| static const UChar u_f=0x66; | |
| static const UChar u_h=0x68; | |
| static const UChar u_i=0x69; | |
| static const UChar u_l=0x6C; | |
| static const UChar u_n=0x6E; | |
| static const UChar u_o=0x6F; | |
| static const UChar u_p=0x70; | |
| static const UChar u_r=0x72; | |
| static const UChar u_s=0x73; | |
| static const UChar u_t=0x74; | |
| static const UChar u_u=0x75; | |
| static const UChar u_z=0x7A; | |
| static const UChar u_leftCurlyBrace=0x7B; | |
| static const UChar u_pipe=0x7C; | |
| static const UChar u_rightCurlyBrace=0x7D; | |
| static const UChar u_lessOrEqual=0x2264; // U+2264 is <= | |
| static const UChar kOffsetColon[]={ // "offset:" | |
| u_o, u_f, u_f, u_s, u_e, u_t, u_colon | |
| }; | |
| static const UChar kOther[]={ // "other" | |
| u_o, u_t, u_h, u_e, u_r | |
| }; | |
| // MessagePatternList ------------------------------------------------------ *** | |
| template<typename T, int32_t stackCapacity> | |
| class MessagePatternList : public UMemory { | |
| public: | |
| MessagePatternList() {} | |
| void copyFrom(const MessagePatternList<T, stackCapacity> &other, | |
| int32_t length, | |
| UErrorCode &errorCode); | |
| UBool ensureCapacityForOneMore(int32_t oldLength, UErrorCode &errorCode); | |
| UBool equals(const MessagePatternList<T, stackCapacity> &other, int32_t length) const { | |
| for(int32_t i=0; i<length; ++i) { | |
| if(a[i]!=other.a[i]) { return FALSE; } | |
| } | |
| return TRUE; | |
| } | |
| MaybeStackArray<T, stackCapacity> a; | |
| }; | |
| template<typename T, int32_t stackCapacity> | |
| void | |
| MessagePatternList<T, stackCapacity>::copyFrom( | |
| const MessagePatternList<T, stackCapacity> &other, | |
| int32_t length, | |
| UErrorCode &errorCode) { | |
| if(U_SUCCESS(errorCode) && length>0) { | |
| if(length>a.getCapacity() && NULL==a.resize(length)) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| uprv_memcpy(a.getAlias(), other.a.getAlias(), length*sizeof(T)); | |
| } | |
| } | |
| template<typename T, int32_t stackCapacity> | |
| UBool | |
| MessagePatternList<T, stackCapacity>::ensureCapacityForOneMore(int32_t oldLength, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return FALSE; | |
| } | |
| if(a.getCapacity()>oldLength || a.resize(2*oldLength, oldLength)!=NULL) { | |
| return TRUE; | |
| } | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return FALSE; | |
| } | |
| // MessagePatternList specializations -------------------------------------- *** | |
| class MessagePatternDoubleList : public MessagePatternList<double, 8> { | |
| }; | |
| class MessagePatternPartsList : public MessagePatternList<MessagePattern::Part, 32> { | |
| }; | |
| // MessagePattern constructors etc. ---------------------------------------- *** | |
| MessagePattern::MessagePattern(UErrorCode &errorCode) | |
| : aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE), | |
| partsList(NULL), parts(NULL), partsLength(0), | |
| numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
| hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) { | |
| init(errorCode); | |
| } | |
| MessagePattern::MessagePattern(UMessagePatternApostropheMode mode, UErrorCode &errorCode) | |
| : aposMode(mode), | |
| partsList(NULL), parts(NULL), partsLength(0), | |
| numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
| hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) { | |
| init(errorCode); | |
| } | |
| MessagePattern::MessagePattern(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) | |
| : aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE), | |
| partsList(NULL), parts(NULL), partsLength(0), | |
| numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
| hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) { | |
| if(init(errorCode)) { | |
| parse(pattern, parseError, errorCode); | |
| } | |
| } | |
| UBool | |
| MessagePattern::init(UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return FALSE; | |
| } | |
| partsList=new MessagePatternPartsList(); | |
| if(partsList==NULL) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return FALSE; | |
| } | |
| parts=partsList->a.getAlias(); | |
| return TRUE; | |
| } | |
| MessagePattern::MessagePattern(const MessagePattern &other) | |
| : UObject(other), aposMode(other.aposMode), msg(other.msg), | |
| partsList(NULL), parts(NULL), partsLength(0), | |
| numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
| hasArgNames(other.hasArgNames), hasArgNumbers(other.hasArgNumbers), | |
| needsAutoQuoting(other.needsAutoQuoting) { | |
| UErrorCode errorCode=U_ZERO_ERROR; | |
| if(!copyStorage(other, errorCode)) { | |
| clear(); | |
| } | |
| } | |
| MessagePattern & | |
| MessagePattern::operator=(const MessagePattern &other) { | |
| if(this==&other) { | |
| return *this; | |
| } | |
| aposMode=other.aposMode; | |
| msg=other.msg; | |
| hasArgNames=other.hasArgNames; | |
| hasArgNumbers=other.hasArgNumbers; | |
| needsAutoQuoting=other.needsAutoQuoting; | |
| UErrorCode errorCode=U_ZERO_ERROR; | |
| if(!copyStorage(other, errorCode)) { | |
| clear(); | |
| } | |
| return *this; | |
| } | |
| UBool | |
| MessagePattern::copyStorage(const MessagePattern &other, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return FALSE; | |
| } | |
| parts=NULL; | |
| partsLength=0; | |
| numericValues=NULL; | |
| numericValuesLength=0; | |
| if(partsList==NULL) { | |
| partsList=new MessagePatternPartsList(); | |
| if(partsList==NULL) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return FALSE; | |
| } | |
| parts=partsList->a.getAlias(); | |
| } | |
| if(other.partsLength>0) { | |
| partsList->copyFrom(*other.partsList, other.partsLength, errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| return FALSE; | |
| } | |
| parts=partsList->a.getAlias(); | |
| partsLength=other.partsLength; | |
| } | |
| if(other.numericValuesLength>0) { | |
| if(numericValuesList==NULL) { | |
| numericValuesList=new MessagePatternDoubleList(); | |
| if(numericValuesList==NULL) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return FALSE; | |
| } | |
| numericValues=numericValuesList->a.getAlias(); | |
| } | |
| numericValuesList->copyFrom( | |
| *other.numericValuesList, other.numericValuesLength, errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| return FALSE; | |
| } | |
| numericValues=numericValuesList->a.getAlias(); | |
| numericValuesLength=other.numericValuesLength; | |
| } | |
| return TRUE; | |
| } | |
| MessagePattern::~MessagePattern() { | |
| delete partsList; | |
| delete numericValuesList; | |
| } | |
| // MessagePattern API ------------------------------------------------------ *** | |
| MessagePattern & | |
| MessagePattern::parse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) { | |
| preParse(pattern, parseError, errorCode); | |
| parseMessage(0, 0, 0, UMSGPAT_ARG_TYPE_NONE, parseError, errorCode); | |
| postParse(); | |
| return *this; | |
| } | |
| MessagePattern & | |
| MessagePattern::parseChoiceStyle(const UnicodeString &pattern, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| preParse(pattern, parseError, errorCode); | |
| parseChoiceStyle(0, 0, parseError, errorCode); | |
| postParse(); | |
| return *this; | |
| } | |
| MessagePattern & | |
| MessagePattern::parsePluralStyle(const UnicodeString &pattern, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| preParse(pattern, parseError, errorCode); | |
| parsePluralOrSelectStyle(UMSGPAT_ARG_TYPE_PLURAL, 0, 0, parseError, errorCode); | |
| postParse(); | |
| return *this; | |
| } | |
| MessagePattern & | |
| MessagePattern::parseSelectStyle(const UnicodeString &pattern, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| preParse(pattern, parseError, errorCode); | |
| parsePluralOrSelectStyle(UMSGPAT_ARG_TYPE_SELECT, 0, 0, parseError, errorCode); | |
| postParse(); | |
| return *this; | |
| } | |
| void | |
| MessagePattern::clear() { | |
| // Mostly the same as preParse(). | |
| msg.remove(); | |
| hasArgNames=hasArgNumbers=FALSE; | |
| needsAutoQuoting=FALSE; | |
| partsLength=0; | |
| numericValuesLength=0; | |
| } | |
| UBool | |
| MessagePattern::operator==(const MessagePattern &other) const { | |
| if(this==&other) { | |
| return TRUE; | |
| } | |
| return | |
| aposMode==other.aposMode && | |
| msg==other.msg && | |
| // parts.equals(o.parts) | |
| partsLength==other.partsLength && | |
| (partsLength==0 || partsList->equals(*other.partsList, partsLength)); | |
| // No need to compare numericValues if msg and parts are the same. | |
| } | |
| int32_t | |
| MessagePattern::hashCode() const { | |
| int32_t hash=(aposMode*37+msg.hashCode())*37+partsLength; | |
| for(int32_t i=0; i<partsLength; ++i) { | |
| hash=hash*37+parts[i].hashCode(); | |
| } | |
| return hash; | |
| } | |
| int32_t | |
| MessagePattern::validateArgumentName(const UnicodeString &name) { | |
| if(!PatternProps::isIdentifier(name.getBuffer(), name.length())) { | |
| return UMSGPAT_ARG_NAME_NOT_VALID; | |
| } | |
| return parseArgNumber(name, 0, name.length()); | |
| } | |
| UnicodeString | |
| MessagePattern::autoQuoteApostropheDeep() const { | |
| if(!needsAutoQuoting) { | |
| return msg; | |
| } | |
| UnicodeString modified(msg); | |
| // Iterate backward so that the insertion indexes do not change. | |
| int32_t count=countParts(); | |
| for(int32_t i=count; i>0;) { | |
| const Part &part=getPart(--i); | |
| if(part.getType()==UMSGPAT_PART_TYPE_INSERT_CHAR) { | |
| modified.insert(part.index, (UChar)part.value); | |
| } | |
| } | |
| return modified; | |
| } | |
| double | |
| MessagePattern::getNumericValue(const Part &part) const { | |
| UMessagePatternPartType type=part.type; | |
| if(type==UMSGPAT_PART_TYPE_ARG_INT) { | |
| return part.value; | |
| } else if(type==UMSGPAT_PART_TYPE_ARG_DOUBLE) { | |
| return numericValues[part.value]; | |
| } else { | |
| return UMSGPAT_NO_NUMERIC_VALUE; | |
| } | |
| } | |
| /** | |
| * Returns the "offset:" value of a PluralFormat argument, or 0 if none is specified. | |
| * @param pluralStart the index of the first PluralFormat argument style part. (0..countParts()-1) | |
| * @return the "offset:" value. | |
| * @draft ICU 4.8 | |
| */ | |
| double | |
| MessagePattern::getPluralOffset(int32_t pluralStart) const { | |
| const Part &part=getPart(pluralStart); | |
| if(Part::hasNumericValue(part.type)) { | |
| return getNumericValue(part); | |
| } else { | |
| return 0; | |
| } | |
| } | |
| // MessagePattern::Part ---------------------------------------------------- *** | |
| UBool | |
| MessagePattern::Part::operator==(const Part &other) const { | |
| if(this==&other) { | |
| return TRUE; | |
| } | |
| return | |
| type==other.type && | |
| index==other.index && | |
| length==other.length && | |
| value==other.value && | |
| limitPartIndex==other.limitPartIndex; | |
| } | |
| // MessagePattern parser --------------------------------------------------- *** | |
| void | |
| MessagePattern::preParse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if(parseError!=NULL) { | |
| parseError->line=0; | |
| parseError->offset=0; | |
| parseError->preContext[0]=0; | |
| parseError->postContext[0]=0; | |
| } | |
| msg=pattern; | |
| hasArgNames=hasArgNumbers=FALSE; | |
| needsAutoQuoting=FALSE; | |
| partsLength=0; | |
| numericValuesLength=0; | |
| } | |
| void | |
| MessagePattern::postParse() { | |
| if(partsList!=NULL) { | |
| parts=partsList->a.getAlias(); | |
| } | |
| if(numericValuesList!=NULL) { | |
| numericValues=numericValuesList->a.getAlias(); | |
| } | |
| } | |
| int32_t | |
| MessagePattern::parseMessage(int32_t index, int32_t msgStartLength, | |
| int32_t nestingLevel, UMessagePatternArgType parentType, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| if(nestingLevel>Part::MAX_VALUE) { | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| int32_t msgStart=partsLength; | |
| addPart(UMSGPAT_PART_TYPE_MSG_START, index, msgStartLength, nestingLevel, errorCode); | |
| index+=msgStartLength; | |
| for(;;) { // while(index<msg.length()) with U_FAILURE(errorCode) check | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| if(index>=msg.length()) { | |
| break; | |
| } | |
| UChar c=msg.charAt(index++); | |
| if(c==u_apos) { | |
| if(index==msg.length()) { | |
| // The apostrophe is the last character in the pattern. | |
| // Add a Part for auto-quoting. | |
| addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0, | |
| u_apos, errorCode); // value=char to be inserted | |
| needsAutoQuoting=TRUE; | |
| } else { | |
| c=msg.charAt(index); | |
| if(c==u_apos) { | |
| // double apostrophe, skip the second one | |
| addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index++, 1, 0, errorCode); | |
| } else if( | |
| aposMode==UMSGPAT_APOS_DOUBLE_REQUIRED || | |
| c==u_leftCurlyBrace || c==u_rightCurlyBrace || | |
| (parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_pipe) || | |
| (UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(parentType) && c==u_pound) | |
| ) { | |
| // skip the quote-starting apostrophe | |
| addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index-1, 1, 0, errorCode); | |
| // find the end of the quoted literal text | |
| for(;;) { | |
| index=msg.indexOf(u_apos, index+1); | |
| if(index>=0) { | |
| if(/*(index+1)<msg.length() &&*/ msg.charAt(index+1)==u_apos) { | |
| // double apostrophe inside quoted literal text | |
| // still encodes a single apostrophe, skip the second one | |
| addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, ++index, 1, 0, errorCode); | |
| } else { | |
| // skip the quote-ending apostrophe | |
| addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index++, 1, 0, errorCode); | |
| break; | |
| } | |
| } else { | |
| // The quoted text reaches to the end of the of the message. | |
| index=msg.length(); | |
| // Add a Part for auto-quoting. | |
| addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0, | |
| u_apos, errorCode); // value=char to be inserted | |
| needsAutoQuoting=TRUE; | |
| break; | |
| } | |
| } | |
| } else { | |
| // Interpret the apostrophe as literal text. | |
| // Add a Part for auto-quoting. | |
| addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0, | |
| u_apos, errorCode); // value=char to be inserted | |
| needsAutoQuoting=TRUE; | |
| } | |
| } | |
| } else if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(parentType) && c==u_pound) { | |
| // The unquoted # in a plural message fragment will be replaced | |
| // with the (number-offset). | |
| addPart(UMSGPAT_PART_TYPE_REPLACE_NUMBER, index-1, 1, 0, errorCode); | |
| } else if(c==u_leftCurlyBrace) { | |
| index=parseArg(index-1, 1, nestingLevel, parseError, errorCode); | |
| } else if((nestingLevel>0 && c==u_rightCurlyBrace) || | |
| (parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_pipe)) { | |
| // Finish the message before the terminator. | |
| // In a choice style, report the "}" substring only for the following ARG_LIMIT, | |
| // not for this MSG_LIMIT. | |
| int32_t limitLength=(parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_rightCurlyBrace) ? 0 : 1; | |
| addLimitPart(msgStart, UMSGPAT_PART_TYPE_MSG_LIMIT, index-1, limitLength, | |
| nestingLevel, errorCode); | |
| if(parentType==UMSGPAT_ARG_TYPE_CHOICE) { | |
| // Let the choice style parser see the '}' or '|'. | |
| return index-1; | |
| } else { | |
| // continue parsing after the '}' | |
| return index; | |
| } | |
| } // else: c is part of literal text | |
| } | |
| if(nestingLevel>0 && !inTopLevelChoiceMessage(nestingLevel, parentType)) { | |
| setParseError(parseError, 0); // Unmatched '{' braces in message. | |
| errorCode=U_UNMATCHED_BRACES; | |
| return 0; | |
| } | |
| addLimitPart(msgStart, UMSGPAT_PART_TYPE_MSG_LIMIT, index, 0, nestingLevel, errorCode); | |
| return index; | |
| } | |
| int32_t | |
| MessagePattern::parseArg(int32_t index, int32_t argStartLength, int32_t nestingLevel, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| int32_t argStart=partsLength; | |
| UMessagePatternArgType argType=UMSGPAT_ARG_TYPE_NONE; | |
| addPart(UMSGPAT_PART_TYPE_ARG_START, index, argStartLength, argType, errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| int32_t nameIndex=index=skipWhiteSpace(index+argStartLength); | |
| if(index==msg.length()) { | |
| setParseError(parseError, 0); // Unmatched '{' braces in message. | |
| errorCode=U_UNMATCHED_BRACES; | |
| return 0; | |
| } | |
| // parse argument name or number | |
| index=skipIdentifier(index); | |
| int32_t number=parseArgNumber(nameIndex, index); | |
| if(number>=0) { | |
| int32_t length=index-nameIndex; | |
| if(length>Part::MAX_LENGTH || number>Part::MAX_VALUE) { | |
| setParseError(parseError, nameIndex); // Argument number too large. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| hasArgNumbers=TRUE; | |
| addPart(UMSGPAT_PART_TYPE_ARG_NUMBER, nameIndex, length, number, errorCode); | |
| } else if(number==UMSGPAT_ARG_NAME_NOT_NUMBER) { | |
| int32_t length=index-nameIndex; | |
| if(length>Part::MAX_LENGTH) { | |
| setParseError(parseError, nameIndex); // Argument name too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| hasArgNames=TRUE; | |
| addPart(UMSGPAT_PART_TYPE_ARG_NAME, nameIndex, length, 0, errorCode); | |
| } else { // number<-1 (ARG_NAME_NOT_VALID) | |
| setParseError(parseError, nameIndex); // Bad argument syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| index=skipWhiteSpace(index); | |
| if(index==msg.length()) { | |
| setParseError(parseError, 0); // Unmatched '{' braces in message. | |
| errorCode=U_UNMATCHED_BRACES; | |
| return 0; | |
| } | |
| UChar c=msg.charAt(index); | |
| if(c==u_rightCurlyBrace) { | |
| // all done | |
| } else if(c!=u_comma) { | |
| setParseError(parseError, nameIndex); // Bad argument syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } else /* ',' */ { | |
| // parse argument type: case-sensitive a-zA-Z | |
| int32_t typeIndex=index=skipWhiteSpace(index+1); | |
| while(index<msg.length() && isArgTypeChar(msg.charAt(index))) { | |
| ++index; | |
| } | |
| int32_t length=index-typeIndex; | |
| index=skipWhiteSpace(index); | |
| if(index==msg.length()) { | |
| setParseError(parseError, 0); // Unmatched '{' braces in message. | |
| errorCode=U_UNMATCHED_BRACES; | |
| return 0; | |
| } | |
| if(length==0 || ((c=msg.charAt(index))!=u_comma && c!=u_rightCurlyBrace)) { | |
| setParseError(parseError, nameIndex); // Bad argument syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| if(length>Part::MAX_LENGTH) { | |
| setParseError(parseError, nameIndex); // Argument type name too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| argType=UMSGPAT_ARG_TYPE_SIMPLE; | |
| if(length==6) { | |
| // case-insensitive comparisons for complex-type names | |
| if(isChoice(typeIndex)) { | |
| argType=UMSGPAT_ARG_TYPE_CHOICE; | |
| } else if(isPlural(typeIndex)) { | |
| argType=UMSGPAT_ARG_TYPE_PLURAL; | |
| } else if(isSelect(typeIndex)) { | |
| argType=UMSGPAT_ARG_TYPE_SELECT; | |
| } | |
| } else if(length==13) { | |
| if(isSelect(typeIndex) && isOrdinal(typeIndex+6)) { | |
| argType=UMSGPAT_ARG_TYPE_SELECTORDINAL; | |
| } | |
| } | |
| // change the ARG_START type from NONE to argType | |
| partsList->a[argStart].value=(int16_t)argType; | |
| if(argType==UMSGPAT_ARG_TYPE_SIMPLE) { | |
| addPart(UMSGPAT_PART_TYPE_ARG_TYPE, typeIndex, length, 0, errorCode); | |
| } | |
| // look for an argument style (pattern) | |
| if(c==u_rightCurlyBrace) { | |
| if(argType!=UMSGPAT_ARG_TYPE_SIMPLE) { | |
| setParseError(parseError, nameIndex); // No style field for complex argument. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| } else /* ',' */ { | |
| ++index; | |
| if(argType==UMSGPAT_ARG_TYPE_SIMPLE) { | |
| index=parseSimpleStyle(index, parseError, errorCode); | |
| } else if(argType==UMSGPAT_ARG_TYPE_CHOICE) { | |
| index=parseChoiceStyle(index, nestingLevel, parseError, errorCode); | |
| } else { | |
| index=parsePluralOrSelectStyle(argType, index, nestingLevel, parseError, errorCode); | |
| } | |
| } | |
| } | |
| // Argument parsing stopped on the '}'. | |
| addLimitPart(argStart, UMSGPAT_PART_TYPE_ARG_LIMIT, index, 1, argType, errorCode); | |
| return index+1; | |
| } | |
| int32_t | |
| MessagePattern::parseSimpleStyle(int32_t index, UParseError *parseError, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| int32_t start=index; | |
| int32_t nestedBraces=0; | |
| while(index<msg.length()) { | |
| UChar c=msg.charAt(index++); | |
| if(c==u_apos) { | |
| // Treat apostrophe as quoting but include it in the style part. | |
| // Find the end of the quoted literal text. | |
| index=msg.indexOf(u_apos, index); | |
| if(index<0) { | |
| // Quoted literal argument style text reaches to the end of the message. | |
| setParseError(parseError, start); | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| // skip the quote-ending apostrophe | |
| ++index; | |
| } else if(c==u_leftCurlyBrace) { | |
| ++nestedBraces; | |
| } else if(c==u_rightCurlyBrace) { | |
| if(nestedBraces>0) { | |
| --nestedBraces; | |
| } else { | |
| int32_t length=--index-start; | |
| if(length>Part::MAX_LENGTH) { | |
| setParseError(parseError, start); // Argument style text too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| addPart(UMSGPAT_PART_TYPE_ARG_STYLE, start, length, 0, errorCode); | |
| return index; | |
| } | |
| } // c is part of literal text | |
| } | |
| setParseError(parseError, 0); // Unmatched '{' braces in message. | |
| errorCode=U_UNMATCHED_BRACES; | |
| return 0; | |
| } | |
| int32_t | |
| MessagePattern::parseChoiceStyle(int32_t index, int32_t nestingLevel, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| int32_t start=index; | |
| index=skipWhiteSpace(index); | |
| if(index==msg.length() || msg.charAt(index)==u_rightCurlyBrace) { | |
| setParseError(parseError, 0); // Missing choice argument pattern. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| for(;;) { | |
| // The choice argument style contains |-separated (number, separator, message) triples. | |
| // Parse the number. | |
| int32_t numberIndex=index; | |
| index=skipDouble(index); | |
| int32_t length=index-numberIndex; | |
| if(length==0) { | |
| setParseError(parseError, start); // Bad choice pattern syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| if(length>Part::MAX_LENGTH) { | |
| setParseError(parseError, numberIndex); // Choice number too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| parseDouble(numberIndex, index, TRUE, parseError, errorCode); // adds ARG_INT or ARG_DOUBLE | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| // Parse the separator. | |
| index=skipWhiteSpace(index); | |
| if(index==msg.length()) { | |
| setParseError(parseError, start); // Bad choice pattern syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| UChar c=msg.charAt(index); | |
| if(!(c==u_pound || c==u_lessThan || c==u_lessOrEqual)) { // U+2264 is <= | |
| setParseError(parseError, start); // Expected choice separator (#<\u2264) instead of c. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, index, 1, 0, errorCode); | |
| // Parse the message fragment. | |
| index=parseMessage(++index, 0, nestingLevel+1, UMSGPAT_ARG_TYPE_CHOICE, parseError, errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| // parseMessage(..., CHOICE) returns the index of the terminator, or msg.length(). | |
| if(index==msg.length()) { | |
| return index; | |
| } | |
| if(msg.charAt(index)==u_rightCurlyBrace) { | |
| if(!inMessageFormatPattern(nestingLevel)) { | |
| setParseError(parseError, start); // Bad choice pattern syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| return index; | |
| } // else the terminator is '|' | |
| index=skipWhiteSpace(index+1); | |
| } | |
| } | |
| int32_t | |
| MessagePattern::parsePluralOrSelectStyle(UMessagePatternArgType argType, | |
| int32_t index, int32_t nestingLevel, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| int32_t start=index; | |
| UBool isEmpty=TRUE; | |
| UBool hasOther=FALSE; | |
| for(;;) { | |
| // First, collect the selector looking for a small set of terminators. | |
| // It would be a little faster to consider the syntax of each possible | |
| // token right here, but that makes the code too complicated. | |
| index=skipWhiteSpace(index); | |
| UBool eos=index==msg.length(); | |
| if(eos || msg.charAt(index)==u_rightCurlyBrace) { | |
| if(eos==inMessageFormatPattern(nestingLevel)) { | |
| setParseError(parseError, start); // Bad plural/select pattern syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| if(!hasOther) { | |
| setParseError(parseError, 0); // Missing 'other' keyword in plural/select pattern. | |
| errorCode=U_DEFAULT_KEYWORD_MISSING; | |
| return 0; | |
| } | |
| return index; | |
| } | |
| int32_t selectorIndex=index; | |
| if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) && msg.charAt(selectorIndex)==u_equal) { | |
| // explicit-value plural selector: =double | |
| index=skipDouble(index+1); | |
| int32_t length=index-selectorIndex; | |
| if(length==1) { | |
| setParseError(parseError, start); // Bad plural/select pattern syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| if(length>Part::MAX_LENGTH) { | |
| setParseError(parseError, selectorIndex); // Argument selector too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, selectorIndex, length, 0, errorCode); | |
| parseDouble(selectorIndex+1, index, FALSE, | |
| parseError, errorCode); // adds ARG_INT or ARG_DOUBLE | |
| } else { | |
| index=skipIdentifier(index); | |
| int32_t length=index-selectorIndex; | |
| if(length==0) { | |
| setParseError(parseError, start); // Bad plural/select pattern syntax. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| // Note: The ':' in "offset:" is just beyond the skipIdentifier() range. | |
| if( UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) && length==6 && index<msg.length() && | |
| 0==msg.compare(selectorIndex, 7, kOffsetColon, 0, 7) | |
| ) { | |
| // plural offset, not a selector | |
| if(!isEmpty) { | |
| // Plural argument 'offset:' (if present) must precede key-message pairs. | |
| setParseError(parseError, start); | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| // allow whitespace between offset: and its value | |
| int32_t valueIndex=skipWhiteSpace(index+1); // The ':' is at index. | |
| index=skipDouble(valueIndex); | |
| if(index==valueIndex) { | |
| setParseError(parseError, start); // Missing value for plural 'offset:'. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| if((index-valueIndex)>Part::MAX_LENGTH) { | |
| setParseError(parseError, valueIndex); // Plural offset value too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| parseDouble(valueIndex, index, FALSE, | |
| parseError, errorCode); // adds ARG_INT or ARG_DOUBLE | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| isEmpty=FALSE; | |
| continue; // no message fragment after the offset | |
| } else { | |
| // normal selector word | |
| if(length>Part::MAX_LENGTH) { | |
| setParseError(parseError, selectorIndex); // Argument selector too long. | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0; | |
| } | |
| addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, selectorIndex, length, 0, errorCode); | |
| if(0==msg.compare(selectorIndex, length, kOther, 0, 5)) { | |
| hasOther=TRUE; | |
| } | |
| } | |
| } | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| // parse the message fragment following the selector | |
| index=skipWhiteSpace(index); | |
| if(index==msg.length() || msg.charAt(index)!=u_leftCurlyBrace) { | |
| setParseError(parseError, selectorIndex); // No message fragment after plural/select selector. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return 0; | |
| } | |
| index=parseMessage(index, 1, nestingLevel+1, argType, parseError, errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| return 0; | |
| } | |
| isEmpty=FALSE; | |
| } | |
| } | |
| int32_t | |
| MessagePattern::parseArgNumber(const UnicodeString &s, int32_t start, int32_t limit) { | |
| // If the identifier contains only ASCII digits, then it is an argument _number_ | |
| // and must not have leading zeros (except "0" itself). | |
| // Otherwise it is an argument _name_. | |
| if(start>=limit) { | |
| return UMSGPAT_ARG_NAME_NOT_VALID; | |
| } | |
| int32_t number; | |
| // Defer numeric errors until we know there are only digits. | |
| UBool badNumber; | |
| UChar c=s.charAt(start++); | |
| if(c==0x30) { | |
| if(start==limit) { | |
| return 0; | |
| } else { | |
| number=0; | |
| badNumber=TRUE; // leading zero | |
| } | |
| } else if(0x31<=c && c<=0x39) { | |
| number=c-0x30; | |
| badNumber=FALSE; | |
| } else { | |
| return UMSGPAT_ARG_NAME_NOT_NUMBER; | |
| } | |
| while(start<limit) { | |
| c=s.charAt(start++); | |
| if(0x30<=c && c<=0x39) { | |
| if(number>=INT32_MAX/10) { | |
| badNumber=TRUE; // overflow | |
| } | |
| number=number*10+(c-0x30); | |
| } else { | |
| return UMSGPAT_ARG_NAME_NOT_NUMBER; | |
| } | |
| } | |
| // There are only ASCII digits. | |
| if(badNumber) { | |
| return UMSGPAT_ARG_NAME_NOT_VALID; | |
| } else { | |
| return number; | |
| } | |
| } | |
| void | |
| MessagePattern::parseDouble(int32_t start, int32_t limit, UBool allowInfinity, | |
| UParseError *parseError, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| U_ASSERT(start<limit); | |
| // fake loop for easy exit and single throw statement | |
| for(;;) { /*loop doesn't iterate*/ | |
| // fast path for small integers and infinity | |
| int32_t value=0; | |
| int32_t isNegative=0; // not boolean so that we can easily add it to value | |
| int32_t index=start; | |
| UChar c=msg.charAt(index++); | |
| if(c==u_minus) { | |
| isNegative=1; | |
| if(index==limit) { | |
| break; // no number | |
| } | |
| c=msg.charAt(index++); | |
| } else if(c==u_plus) { | |
| if(index==limit) { | |
| break; // no number | |
| } | |
| c=msg.charAt(index++); | |
| } | |
| if(c==0x221e) { // infinity | |
| if(allowInfinity && index==limit) { | |
| double infinity=uprv_getInfinity(); | |
| addArgDoublePart( | |
| isNegative!=0 ? -infinity : infinity, | |
| start, limit-start, errorCode); | |
| return; | |
| } else { | |
| break; | |
| } | |
| } | |
| // try to parse the number as a small integer but fall back to a double | |
| while('0'<=c && c<='9') { | |
| value=value*10+(c-'0'); | |
| if(value>(Part::MAX_VALUE+isNegative)) { | |
| break; // not a small-enough integer | |
| } | |
| if(index==limit) { | |
| addPart(UMSGPAT_PART_TYPE_ARG_INT, start, limit-start, | |
| isNegative!=0 ? -value : value, errorCode); | |
| return; | |
| } | |
| c=msg.charAt(index++); | |
| } | |
| // Let Double.parseDouble() throw a NumberFormatException. | |
| char numberChars[128]; | |
| int32_t capacity=(int32_t)sizeof(numberChars); | |
| int32_t length=limit-start; | |
| if(length>=capacity) { | |
| break; // number too long | |
| } | |
| msg.extract(start, length, numberChars, capacity, US_INV); | |
| if((int32_t)uprv_strlen(numberChars)<length) { | |
| break; // contains non-invariant character that was turned into NUL | |
| } | |
| char *end; | |
| double numericValue=uprv_strtod(numberChars, &end); | |
| if(end!=(numberChars+length)) { | |
| break; // parsing error | |
| } | |
| addArgDoublePart(numericValue, start, length, errorCode); | |
| return; | |
| } | |
| setParseError(parseError, start /*, limit*/); // Bad syntax for numeric value. | |
| errorCode=U_PATTERN_SYNTAX_ERROR; | |
| return; | |
| } | |
| int32_t | |
| MessagePattern::skipWhiteSpace(int32_t index) { | |
| const UChar *s=msg.getBuffer(); | |
| int32_t msgLength=msg.length(); | |
| const UChar *t=PatternProps::skipWhiteSpace(s+index, msgLength-index); | |
| return (int32_t)(t-s); | |
| } | |
| int32_t | |
| MessagePattern::skipIdentifier(int32_t index) { | |
| const UChar *s=msg.getBuffer(); | |
| int32_t msgLength=msg.length(); | |
| const UChar *t=PatternProps::skipIdentifier(s+index, msgLength-index); | |
| return (int32_t)(t-s); | |
| } | |
| int32_t | |
| MessagePattern::skipDouble(int32_t index) { | |
| int32_t msgLength=msg.length(); | |
| while(index<msgLength) { | |
| UChar c=msg.charAt(index); | |
| // U+221E: Allow the infinity symbol, for ChoiceFormat patterns. | |
| if((c<0x30 && c!=u_plus && c!=u_minus && c!=u_dot) || (c>0x39 && c!=u_e && c!=u_E && c!=0x221e)) { | |
| break; | |
| } | |
| ++index; | |
| } | |
| return index; | |
| } | |
| UBool | |
| MessagePattern::isArgTypeChar(UChar32 c) { | |
| return (u_a<=c && c<=u_z) || (u_A<=c && c<=u_Z); | |
| } | |
| UBool | |
| MessagePattern::isChoice(int32_t index) { | |
| UChar c; | |
| return | |
| ((c=msg.charAt(index++))==u_c || c==u_C) && | |
| ((c=msg.charAt(index++))==u_h || c==u_H) && | |
| ((c=msg.charAt(index++))==u_o || c==u_O) && | |
| ((c=msg.charAt(index++))==u_i || c==u_I) && | |
| ((c=msg.charAt(index++))==u_c || c==u_C) && | |
| ((c=msg.charAt(index))==u_e || c==u_E); | |
| } | |
| UBool | |
| MessagePattern::isPlural(int32_t index) { | |
| UChar c; | |
| return | |
| ((c=msg.charAt(index++))==u_p || c==u_P) && | |
| ((c=msg.charAt(index++))==u_l || c==u_L) && | |
| ((c=msg.charAt(index++))==u_u || c==u_U) && | |
| ((c=msg.charAt(index++))==u_r || c==u_R) && | |
| ((c=msg.charAt(index++))==u_a || c==u_A) && | |
| ((c=msg.charAt(index))==u_l || c==u_L); | |
| } | |
| UBool | |
| MessagePattern::isSelect(int32_t index) { | |
| UChar c; | |
| return | |
| ((c=msg.charAt(index++))==u_s || c==u_S) && | |
| ((c=msg.charAt(index++))==u_e || c==u_E) && | |
| ((c=msg.charAt(index++))==u_l || c==u_L) && | |
| ((c=msg.charAt(index++))==u_e || c==u_E) && | |
| ((c=msg.charAt(index++))==u_c || c==u_C) && | |
| ((c=msg.charAt(index))==u_t || c==u_T); | |
| } | |
| UBool | |
| MessagePattern::isOrdinal(int32_t index) { | |
| UChar c; | |
| return | |
| ((c=msg.charAt(index++))==u_o || c==u_O) && | |
| ((c=msg.charAt(index++))==u_r || c==u_R) && | |
| ((c=msg.charAt(index++))==u_d || c==u_D) && | |
| ((c=msg.charAt(index++))==u_i || c==u_I) && | |
| ((c=msg.charAt(index++))==u_n || c==u_N) && | |
| ((c=msg.charAt(index++))==u_a || c==u_A) && | |
| ((c=msg.charAt(index))==u_l || c==u_L); | |
| } | |
| UBool | |
| MessagePattern::inMessageFormatPattern(int32_t nestingLevel) { | |
| return nestingLevel>0 || partsList->a[0].type==UMSGPAT_PART_TYPE_MSG_START; | |
| } | |
| UBool | |
| MessagePattern::inTopLevelChoiceMessage(int32_t nestingLevel, UMessagePatternArgType parentType) { | |
| return | |
| nestingLevel==1 && | |
| parentType==UMSGPAT_ARG_TYPE_CHOICE && | |
| partsList->a[0].type!=UMSGPAT_PART_TYPE_MSG_START; | |
| } | |
| void | |
| MessagePattern::addPart(UMessagePatternPartType type, int32_t index, int32_t length, | |
| int32_t value, UErrorCode &errorCode) { | |
| if(partsList->ensureCapacityForOneMore(partsLength, errorCode)) { | |
| Part &part=partsList->a[partsLength++]; | |
| part.type=type; | |
| part.index=index; | |
| part.length=(uint16_t)length; | |
| part.value=(int16_t)value; | |
| part.limitPartIndex=0; | |
| } | |
| } | |
| void | |
| MessagePattern::addLimitPart(int32_t start, | |
| UMessagePatternPartType type, int32_t index, int32_t length, | |
| int32_t value, UErrorCode &errorCode) { | |
| partsList->a[start].limitPartIndex=partsLength; | |
| addPart(type, index, length, value, errorCode); | |
| } | |
| void | |
| MessagePattern::addArgDoublePart(double numericValue, int32_t start, int32_t length, | |
| UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| int32_t numericIndex=numericValuesLength; | |
| if(numericValuesList==NULL) { | |
| numericValuesList=new MessagePatternDoubleList(); | |
| if(numericValuesList==NULL) { | |
| errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } else if(!numericValuesList->ensureCapacityForOneMore(numericValuesLength, errorCode)) { | |
| return; | |
| } else { | |
| if(numericIndex>Part::MAX_VALUE) { | |
| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return; | |
| } | |
| } | |
| numericValuesList->a[numericValuesLength++]=numericValue; | |
| addPart(UMSGPAT_PART_TYPE_ARG_DOUBLE, start, length, numericIndex, errorCode); | |
| } | |
| void | |
| MessagePattern::setParseError(UParseError *parseError, int32_t index) { | |
| if(parseError==NULL) { | |
| return; | |
| } | |
| parseError->offset=index; | |
| // Set preContext to some of msg before index. | |
| // Avoid splitting a surrogate pair. | |
| int32_t length=index; | |
| if(length>=U_PARSE_CONTEXT_LEN) { | |
| length=U_PARSE_CONTEXT_LEN-1; | |
| if(length>0 && U16_IS_TRAIL(msg[index-length])) { | |
| --length; | |
| } | |
| } | |
| msg.extract(index-length, length, parseError->preContext); | |
| parseError->preContext[length]=0; | |
| // Set postContext to some of msg starting at index. | |
| length=msg.length()-index; | |
| if(length>=U_PARSE_CONTEXT_LEN) { | |
| length=U_PARSE_CONTEXT_LEN-1; | |
| if(length>0 && U16_IS_LEAD(msg[index+length-1])) { | |
| --length; | |
| } | |
| } | |
| msg.extract(index, length, parseError->postContext); | |
| parseError->postContext[length]=0; | |
| } | |
| // MessageImpl ------------------------------------------------------------- *** | |
| void | |
| MessageImpl::appendReducedApostrophes(const UnicodeString &s, int32_t start, int32_t limit, | |
| UnicodeString &sb) { | |
| int32_t doubleApos=-1; | |
| for(;;) { | |
| int32_t i=s.indexOf(u_apos, start); | |
| if(i<0 || i>=limit) { | |
| sb.append(s, start, limit-start); | |
| break; | |
| } | |
| if(i==doubleApos) { | |
| // Double apostrophe at start-1 and start==i, append one. | |
| sb.append(u_apos); | |
| ++start; | |
| doubleApos=-1; | |
| } else { | |
| // Append text between apostrophes and skip this one. | |
| sb.append(s, start, i-start); | |
| doubleApos=start=i+1; | |
| } | |
| } | |
| } | |
| // Ported from second half of ICU4J SelectFormat.format(String). | |
| UnicodeString & | |
| MessageImpl::appendSubMessageWithoutSkipSyntax(const MessagePattern &msgPattern, | |
| int32_t msgStart, | |
| UnicodeString &result) { | |
| const UnicodeString &msgString=msgPattern.getPatternString(); | |
| int32_t prevIndex=msgPattern.getPart(msgStart).getLimit(); | |
| for(int32_t i=msgStart;;) { | |
| const MessagePattern::Part &part=msgPattern.getPart(++i); | |
| UMessagePatternPartType type=part.getType(); | |
| int32_t index=part.getIndex(); | |
| if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) { | |
| return result.append(msgString, prevIndex, index-prevIndex); | |
| } else if(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX) { | |
| result.append(msgString, prevIndex, index-prevIndex); | |
| prevIndex=part.getLimit(); | |
| } else if(type==UMSGPAT_PART_TYPE_ARG_START) { | |
| result.append(msgString, prevIndex, index-prevIndex); | |
| prevIndex=index; | |
| i=msgPattern.getLimitPartIndex(i); | |
| index=msgPattern.getPart(i).getLimit(); | |
| appendReducedApostrophes(msgString, prevIndex, index, result); | |
| prevIndex=index; | |
| } | |
| } | |
| } | |
| U_NAMESPACE_END | |
| #endif // !UCONFIG_NO_FORMATTING |