The Tor Browser: intl/icu/source/common/messagepattern.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/messagepattern.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/messagepattern.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
 *******************************************************************************
 *   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 "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() &&
 ==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

The Tor Browser / annotate

intl/icu/source/common/messagepattern.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/messagepattern.cpp