• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  // © 2016 and later: Unicode, Inc. and others.
2  // License & terms of use: http://www.unicode.org/copyright.html
3  /*
4  *******************************************************************************
5  *   Copyright (C) 2011-2012, International Business Machines
6  *   Corporation and others.  All Rights Reserved.
7  *******************************************************************************
8  *   file name:  messagepattern.cpp
9  *   encoding:   UTF-8
10  *   tab size:   8 (not used)
11  *   indentation:4
12  *
13  *   created on: 2011mar14
14  *   created by: Markus W. Scherer
15  */
16  
17  #include "unicode/utypes.h"
18  
19  #if !UCONFIG_NO_FORMATTING
20  
21  #include "unicode/messagepattern.h"
22  #include "unicode/unistr.h"
23  #include "unicode/utf16.h"
24  #include "cmemory.h"
25  #include "cstring.h"
26  #include "messageimpl.h"
27  #include "patternprops.h"
28  #include "putilimp.h"
29  #include "uassert.h"
30  
31  U_NAMESPACE_BEGIN
32  
33  // Unicode character/code point constants ---------------------------------- ***
34  
35  static const UChar u_pound=0x23;
36  static const UChar u_apos=0x27;
37  static const UChar u_plus=0x2B;
38  static const UChar u_comma=0x2C;
39  static const UChar u_minus=0x2D;
40  static const UChar u_dot=0x2E;
41  static const UChar u_colon=0x3A;
42  static const UChar u_lessThan=0x3C;
43  static const UChar u_equal=0x3D;
44  static const UChar u_A=0x41;
45  static const UChar u_C=0x43;
46  static const UChar u_D=0x44;
47  static const UChar u_E=0x45;
48  static const UChar u_H=0x48;
49  static const UChar u_I=0x49;
50  static const UChar u_L=0x4C;
51  static const UChar u_N=0x4E;
52  static const UChar u_O=0x4F;
53  static const UChar u_P=0x50;
54  static const UChar u_R=0x52;
55  static const UChar u_S=0x53;
56  static const UChar u_T=0x54;
57  static const UChar u_U=0x55;
58  static const UChar u_Z=0x5A;
59  static const UChar u_a=0x61;
60  static const UChar u_c=0x63;
61  static const UChar u_d=0x64;
62  static const UChar u_e=0x65;
63  static const UChar u_f=0x66;
64  static const UChar u_h=0x68;
65  static const UChar u_i=0x69;
66  static const UChar u_l=0x6C;
67  static const UChar u_n=0x6E;
68  static const UChar u_o=0x6F;
69  static const UChar u_p=0x70;
70  static const UChar u_r=0x72;
71  static const UChar u_s=0x73;
72  static const UChar u_t=0x74;
73  static const UChar u_u=0x75;
74  static const UChar u_z=0x7A;
75  static const UChar u_leftCurlyBrace=0x7B;
76  static const UChar u_pipe=0x7C;
77  static const UChar u_rightCurlyBrace=0x7D;
78  static const UChar u_lessOrEqual=0x2264;  // U+2264 is <=
79  
80  static const UChar kOffsetColon[]={  // "offset:"
81      u_o, u_f, u_f, u_s, u_e, u_t, u_colon
82  };
83  
84  static const UChar kOther[]={  // "other"
85      u_o, u_t, u_h, u_e, u_r
86  };
87  
88  // MessagePatternList ------------------------------------------------------ ***
89  
90  template<typename T, int32_t stackCapacity>
91  class MessagePatternList : public UMemory {
92  public:
MessagePatternList()93      MessagePatternList() {}
94      void copyFrom(const MessagePatternList<T, stackCapacity> &other,
95                    int32_t length,
96                    UErrorCode &errorCode);
97      UBool ensureCapacityForOneMore(int32_t oldLength, UErrorCode &errorCode);
equals(const MessagePatternList<T,stackCapacity> & other,int32_t length) const98      UBool equals(const MessagePatternList<T, stackCapacity> &other, int32_t length) const {
99          for(int32_t i=0; i<length; ++i) {
100              if(a[i]!=other.a[i]) { return FALSE; }
101          }
102          return TRUE;
103      }
104  
105      MaybeStackArray<T, stackCapacity> a;
106  };
107  
108  template<typename T, int32_t stackCapacity>
109  void
copyFrom(const MessagePatternList<T,stackCapacity> & other,int32_t length,UErrorCode & errorCode)110  MessagePatternList<T, stackCapacity>::copyFrom(
111          const MessagePatternList<T, stackCapacity> &other,
112          int32_t length,
113          UErrorCode &errorCode) {
114      if(U_SUCCESS(errorCode) && length>0) {
115          if(length>a.getCapacity() && NULL==a.resize(length)) {
116              errorCode=U_MEMORY_ALLOCATION_ERROR;
117              return;
118          }
119          uprv_memcpy(a.getAlias(), other.a.getAlias(), (size_t)length*sizeof(T));
120      }
121  }
122  
123  template<typename T, int32_t stackCapacity>
124  UBool
ensureCapacityForOneMore(int32_t oldLength,UErrorCode & errorCode)125  MessagePatternList<T, stackCapacity>::ensureCapacityForOneMore(int32_t oldLength, UErrorCode &errorCode) {
126      if(U_FAILURE(errorCode)) {
127          return FALSE;
128      }
129      if(a.getCapacity()>oldLength || a.resize(2*oldLength, oldLength)!=NULL) {
130          return TRUE;
131      }
132      errorCode=U_MEMORY_ALLOCATION_ERROR;
133      return FALSE;
134  }
135  
136  // MessagePatternList specializations -------------------------------------- ***
137  
138  class MessagePatternDoubleList : public MessagePatternList<double, 8> {
139  };
140  
141  class MessagePatternPartsList : public MessagePatternList<MessagePattern::Part, 32> {
142  };
143  
144  // MessagePattern constructors etc. ---------------------------------------- ***
145  
MessagePattern(UErrorCode & errorCode)146  MessagePattern::MessagePattern(UErrorCode &errorCode)
147          : aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE),
148            partsList(NULL), parts(NULL), partsLength(0),
149            numericValuesList(NULL), numericValues(NULL), numericValuesLength(0),
150            hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) {
151      init(errorCode);
152  }
153  
MessagePattern(UMessagePatternApostropheMode mode,UErrorCode & errorCode)154  MessagePattern::MessagePattern(UMessagePatternApostropheMode mode, UErrorCode &errorCode)
155          : aposMode(mode),
156            partsList(NULL), parts(NULL), partsLength(0),
157            numericValuesList(NULL), numericValues(NULL), numericValuesLength(0),
158            hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) {
159      init(errorCode);
160  }
161  
MessagePattern(const UnicodeString & pattern,UParseError * parseError,UErrorCode & errorCode)162  MessagePattern::MessagePattern(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode)
163          : aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE),
164            partsList(NULL), parts(NULL), partsLength(0),
165            numericValuesList(NULL), numericValues(NULL), numericValuesLength(0),
166            hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) {
167      if(init(errorCode)) {
168          parse(pattern, parseError, errorCode);
169      }
170  }
171  
172  UBool
init(UErrorCode & errorCode)173  MessagePattern::init(UErrorCode &errorCode) {
174      if(U_FAILURE(errorCode)) {
175          return FALSE;
176      }
177      partsList=new MessagePatternPartsList();
178      if(partsList==NULL) {
179          errorCode=U_MEMORY_ALLOCATION_ERROR;
180          return FALSE;
181      }
182      parts=partsList->a.getAlias();
183      return TRUE;
184  }
185  
MessagePattern(const MessagePattern & other)186  MessagePattern::MessagePattern(const MessagePattern &other)
187          : UObject(other), aposMode(other.aposMode), msg(other.msg),
188            partsList(NULL), parts(NULL), partsLength(0),
189            numericValuesList(NULL), numericValues(NULL), numericValuesLength(0),
190            hasArgNames(other.hasArgNames), hasArgNumbers(other.hasArgNumbers),
191            needsAutoQuoting(other.needsAutoQuoting) {
192      UErrorCode errorCode=U_ZERO_ERROR;
193      if(!copyStorage(other, errorCode)) {
194          clear();
195      }
196  }
197  
198  MessagePattern &
operator =(const MessagePattern & other)199  MessagePattern::operator=(const MessagePattern &other) {
200      if(this==&other) {
201          return *this;
202      }
203      aposMode=other.aposMode;
204      msg=other.msg;
205      hasArgNames=other.hasArgNames;
206      hasArgNumbers=other.hasArgNumbers;
207      needsAutoQuoting=other.needsAutoQuoting;
208      UErrorCode errorCode=U_ZERO_ERROR;
209      if(!copyStorage(other, errorCode)) {
210          clear();
211      }
212      return *this;
213  }
214  
215  UBool
copyStorage(const MessagePattern & other,UErrorCode & errorCode)216  MessagePattern::copyStorage(const MessagePattern &other, UErrorCode &errorCode) {
217      if(U_FAILURE(errorCode)) {
218          return FALSE;
219      }
220      parts=NULL;
221      partsLength=0;
222      numericValues=NULL;
223      numericValuesLength=0;
224      if(partsList==NULL) {
225          partsList=new MessagePatternPartsList();
226          if(partsList==NULL) {
227              errorCode=U_MEMORY_ALLOCATION_ERROR;
228              return FALSE;
229          }
230          parts=partsList->a.getAlias();
231      }
232      if(other.partsLength>0) {
233          partsList->copyFrom(*other.partsList, other.partsLength, errorCode);
234          if(U_FAILURE(errorCode)) {
235              return FALSE;
236          }
237          parts=partsList->a.getAlias();
238          partsLength=other.partsLength;
239      }
240      if(other.numericValuesLength>0) {
241          if(numericValuesList==NULL) {
242              numericValuesList=new MessagePatternDoubleList();
243              if(numericValuesList==NULL) {
244                  errorCode=U_MEMORY_ALLOCATION_ERROR;
245                  return FALSE;
246              }
247              numericValues=numericValuesList->a.getAlias();
248          }
249          numericValuesList->copyFrom(
250              *other.numericValuesList, other.numericValuesLength, errorCode);
251          if(U_FAILURE(errorCode)) {
252              return FALSE;
253          }
254          numericValues=numericValuesList->a.getAlias();
255          numericValuesLength=other.numericValuesLength;
256      }
257      return TRUE;
258  }
259  
~MessagePattern()260  MessagePattern::~MessagePattern() {
261      delete partsList;
262      delete numericValuesList;
263  }
264  
265  // MessagePattern API ------------------------------------------------------ ***
266  
267  MessagePattern &
parse(const UnicodeString & pattern,UParseError * parseError,UErrorCode & errorCode)268  MessagePattern::parse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) {
269      preParse(pattern, parseError, errorCode);
270      parseMessage(0, 0, 0, UMSGPAT_ARG_TYPE_NONE, parseError, errorCode);
271      postParse();
272      return *this;
273  }
274  
275  MessagePattern &
parseChoiceStyle(const UnicodeString & pattern,UParseError * parseError,UErrorCode & errorCode)276  MessagePattern::parseChoiceStyle(const UnicodeString &pattern,
277                                   UParseError *parseError, UErrorCode &errorCode) {
278      preParse(pattern, parseError, errorCode);
279      parseChoiceStyle(0, 0, parseError, errorCode);
280      postParse();
281      return *this;
282  }
283  
284  MessagePattern &
parsePluralStyle(const UnicodeString & pattern,UParseError * parseError,UErrorCode & errorCode)285  MessagePattern::parsePluralStyle(const UnicodeString &pattern,
286                                   UParseError *parseError, UErrorCode &errorCode) {
287      preParse(pattern, parseError, errorCode);
288      parsePluralOrSelectStyle(UMSGPAT_ARG_TYPE_PLURAL, 0, 0, parseError, errorCode);
289      postParse();
290      return *this;
291  }
292  
293  MessagePattern &
parseSelectStyle(const UnicodeString & pattern,UParseError * parseError,UErrorCode & errorCode)294  MessagePattern::parseSelectStyle(const UnicodeString &pattern,
295                                   UParseError *parseError, UErrorCode &errorCode) {
296      preParse(pattern, parseError, errorCode);
297      parsePluralOrSelectStyle(UMSGPAT_ARG_TYPE_SELECT, 0, 0, parseError, errorCode);
298      postParse();
299      return *this;
300  }
301  
302  void
clear()303  MessagePattern::clear() {
304      // Mostly the same as preParse().
305      msg.remove();
306      hasArgNames=hasArgNumbers=FALSE;
307      needsAutoQuoting=FALSE;
308      partsLength=0;
309      numericValuesLength=0;
310  }
311  
312  UBool
operator ==(const MessagePattern & other) const313  MessagePattern::operator==(const MessagePattern &other) const {
314      if(this==&other) {
315          return TRUE;
316      }
317      return
318          aposMode==other.aposMode &&
319          msg==other.msg &&
320          // parts.equals(o.parts)
321          partsLength==other.partsLength &&
322          (partsLength==0 || partsList->equals(*other.partsList, partsLength));
323      // No need to compare numericValues if msg and parts are the same.
324  }
325  
326  int32_t
hashCode() const327  MessagePattern::hashCode() const {
328      int32_t hash=(aposMode*37+msg.hashCode())*37+partsLength;
329      for(int32_t i=0; i<partsLength; ++i) {
330          hash=hash*37+parts[i].hashCode();
331      }
332      return hash;
333  }
334  
335  int32_t
validateArgumentName(const UnicodeString & name)336  MessagePattern::validateArgumentName(const UnicodeString &name) {
337      if(!PatternProps::isIdentifier(name.getBuffer(), name.length())) {
338          return UMSGPAT_ARG_NAME_NOT_VALID;
339      }
340      return parseArgNumber(name, 0, name.length());
341  }
342  
343  UnicodeString
autoQuoteApostropheDeep() const344  MessagePattern::autoQuoteApostropheDeep() const {
345      if(!needsAutoQuoting) {
346          return msg;
347      }
348      UnicodeString modified(msg);
349      // Iterate backward so that the insertion indexes do not change.
350      int32_t count=countParts();
351      for(int32_t i=count; i>0;) {
352          const Part &part=getPart(--i);
353          if(part.getType()==UMSGPAT_PART_TYPE_INSERT_CHAR) {
354             modified.insert(part.index, (UChar)part.value);
355          }
356      }
357      return modified;
358  }
359  
360  double
getNumericValue(const Part & part) const361  MessagePattern::getNumericValue(const Part &part) const {
362      UMessagePatternPartType type=part.type;
363      if(type==UMSGPAT_PART_TYPE_ARG_INT) {
364          return part.value;
365      } else if(type==UMSGPAT_PART_TYPE_ARG_DOUBLE) {
366          return numericValues[part.value];
367      } else {
368          return UMSGPAT_NO_NUMERIC_VALUE;
369      }
370  }
371  
372  /**
373    * Returns the "offset:" value of a PluralFormat argument, or 0 if none is specified.
374    * @param pluralStart the index of the first PluralFormat argument style part. (0..countParts()-1)
375    * @return the "offset:" value.
376    * @draft ICU 4.8
377    */
378  double
getPluralOffset(int32_t pluralStart) const379  MessagePattern::getPluralOffset(int32_t pluralStart) const {
380      const Part &part=getPart(pluralStart);
381      if(Part::hasNumericValue(part.type)) {
382          return getNumericValue(part);
383      } else {
384          return 0;
385      }
386  }
387  
388  // MessagePattern::Part ---------------------------------------------------- ***
389  
390  UBool
operator ==(const Part & other) const391  MessagePattern::Part::operator==(const Part &other) const {
392      if(this==&other) {
393          return TRUE;
394      }
395      return
396          type==other.type &&
397          index==other.index &&
398          length==other.length &&
399          value==other.value &&
400          limitPartIndex==other.limitPartIndex;
401  }
402  
403  // MessagePattern parser --------------------------------------------------- ***
404  
405  void
preParse(const UnicodeString & pattern,UParseError * parseError,UErrorCode & errorCode)406  MessagePattern::preParse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) {
407      if(U_FAILURE(errorCode)) {
408          return;
409      }
410      if(parseError!=NULL) {
411          parseError->line=0;
412          parseError->offset=0;
413          parseError->preContext[0]=0;
414          parseError->postContext[0]=0;
415      }
416      msg=pattern;
417      hasArgNames=hasArgNumbers=FALSE;
418      needsAutoQuoting=FALSE;
419      partsLength=0;
420      numericValuesLength=0;
421  }
422  
423  void
postParse()424  MessagePattern::postParse() {
425      if(partsList!=NULL) {
426          parts=partsList->a.getAlias();
427      }
428      if(numericValuesList!=NULL) {
429          numericValues=numericValuesList->a.getAlias();
430      }
431  }
432  
433  int32_t
parseMessage(int32_t index,int32_t msgStartLength,int32_t nestingLevel,UMessagePatternArgType parentType,UParseError * parseError,UErrorCode & errorCode)434  MessagePattern::parseMessage(int32_t index, int32_t msgStartLength,
435                               int32_t nestingLevel, UMessagePatternArgType parentType,
436                               UParseError *parseError, UErrorCode &errorCode) {
437      if(U_FAILURE(errorCode)) {
438          return 0;
439      }
440      if(nestingLevel>Part::MAX_VALUE) {
441          errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
442          return 0;
443      }
444      int32_t msgStart=partsLength;
445      addPart(UMSGPAT_PART_TYPE_MSG_START, index, msgStartLength, nestingLevel, errorCode);
446      index+=msgStartLength;
447      for(;;) {  // while(index<msg.length()) with U_FAILURE(errorCode) check
448          if(U_FAILURE(errorCode)) {
449              return 0;
450          }
451          if(index>=msg.length()) {
452              break;
453          }
454          UChar c=msg.charAt(index++);
455          if(c==u_apos) {
456              if(index==msg.length()) {
457                  // The apostrophe is the last character in the pattern.
458                  // Add a Part for auto-quoting.
459                  addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0,
460                          u_apos, errorCode);  // value=char to be inserted
461                  needsAutoQuoting=TRUE;
462              } else {
463                  c=msg.charAt(index);
464                  if(c==u_apos) {
465                      // double apostrophe, skip the second one
466                      addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index++, 1, 0, errorCode);
467                  } else if(
468                      aposMode==UMSGPAT_APOS_DOUBLE_REQUIRED ||
469                      c==u_leftCurlyBrace || c==u_rightCurlyBrace ||
470                      (parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_pipe) ||
471                      (UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(parentType) && c==u_pound)
472                  ) {
473                      // skip the quote-starting apostrophe
474                      addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index-1, 1, 0, errorCode);
475                      // find the end of the quoted literal text
476                      for(;;) {
477                          index=msg.indexOf(u_apos, index+1);
478                          if(index>=0) {
479                              if(/*(index+1)<msg.length() &&*/ msg.charAt(index+1)==u_apos) {
480                                  // double apostrophe inside quoted literal text
481                                  // still encodes a single apostrophe, skip the second one
482                                  addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, ++index, 1, 0, errorCode);
483                              } else {
484                                  // skip the quote-ending apostrophe
485                                  addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index++, 1, 0, errorCode);
486                                  break;
487                              }
488                          } else {
489                              // The quoted text reaches to the end of the of the message.
490                              index=msg.length();
491                              // Add a Part for auto-quoting.
492                              addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0,
493                                      u_apos, errorCode);  // value=char to be inserted
494                              needsAutoQuoting=TRUE;
495                              break;
496                          }
497                      }
498                  } else {
499                      // Interpret the apostrophe as literal text.
500                      // Add a Part for auto-quoting.
501                      addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0,
502                              u_apos, errorCode);  // value=char to be inserted
503                      needsAutoQuoting=TRUE;
504                  }
505              }
506          } else if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(parentType) && c==u_pound) {
507              // The unquoted # in a plural message fragment will be replaced
508              // with the (number-offset).
509              addPart(UMSGPAT_PART_TYPE_REPLACE_NUMBER, index-1, 1, 0, errorCode);
510          } else if(c==u_leftCurlyBrace) {
511              index=parseArg(index-1, 1, nestingLevel, parseError, errorCode);
512          } else if((nestingLevel>0 && c==u_rightCurlyBrace) ||
513                    (parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_pipe)) {
514              // Finish the message before the terminator.
515              // In a choice style, report the "}" substring only for the following ARG_LIMIT,
516              // not for this MSG_LIMIT.
517              int32_t limitLength=(parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_rightCurlyBrace) ? 0 : 1;
518              addLimitPart(msgStart, UMSGPAT_PART_TYPE_MSG_LIMIT, index-1, limitLength,
519                           nestingLevel, errorCode);
520              if(parentType==UMSGPAT_ARG_TYPE_CHOICE) {
521                  // Let the choice style parser see the '}' or '|'.
522                  return index-1;
523              } else {
524                  // continue parsing after the '}'
525                  return index;
526              }
527          }  // else: c is part of literal text
528      }
529      if(nestingLevel>0 && !inTopLevelChoiceMessage(nestingLevel, parentType)) {
530          setParseError(parseError, 0);  // Unmatched '{' braces in message.
531          errorCode=U_UNMATCHED_BRACES;
532          return 0;
533      }
534      addLimitPart(msgStart, UMSGPAT_PART_TYPE_MSG_LIMIT, index, 0, nestingLevel, errorCode);
535      return index;
536  }
537  
538  int32_t
parseArg(int32_t index,int32_t argStartLength,int32_t nestingLevel,UParseError * parseError,UErrorCode & errorCode)539  MessagePattern::parseArg(int32_t index, int32_t argStartLength, int32_t nestingLevel,
540                           UParseError *parseError, UErrorCode &errorCode) {
541      int32_t argStart=partsLength;
542      UMessagePatternArgType argType=UMSGPAT_ARG_TYPE_NONE;
543      addPart(UMSGPAT_PART_TYPE_ARG_START, index, argStartLength, argType, errorCode);
544      if(U_FAILURE(errorCode)) {
545          return 0;
546      }
547      int32_t nameIndex=index=skipWhiteSpace(index+argStartLength);
548      if(index==msg.length()) {
549          setParseError(parseError, 0);  // Unmatched '{' braces in message.
550          errorCode=U_UNMATCHED_BRACES;
551          return 0;
552      }
553      // parse argument name or number
554      index=skipIdentifier(index);
555      int32_t number=parseArgNumber(nameIndex, index);
556      if(number>=0) {
557          int32_t length=index-nameIndex;
558          if(length>Part::MAX_LENGTH || number>Part::MAX_VALUE) {
559              setParseError(parseError, nameIndex);  // Argument number too large.
560              errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
561              return 0;
562          }
563          hasArgNumbers=TRUE;
564          addPart(UMSGPAT_PART_TYPE_ARG_NUMBER, nameIndex, length, number, errorCode);
565      } else if(number==UMSGPAT_ARG_NAME_NOT_NUMBER) {
566          int32_t length=index-nameIndex;
567          if(length>Part::MAX_LENGTH) {
568              setParseError(parseError, nameIndex);  // Argument name too long.
569              errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
570              return 0;
571          }
572          hasArgNames=TRUE;
573          addPart(UMSGPAT_PART_TYPE_ARG_NAME, nameIndex, length, 0, errorCode);
574      } else {  // number<-1 (ARG_NAME_NOT_VALID)
575          setParseError(parseError, nameIndex);  // Bad argument syntax.
576          errorCode=U_PATTERN_SYNTAX_ERROR;
577          return 0;
578      }
579      index=skipWhiteSpace(index);
580      if(index==msg.length()) {
581          setParseError(parseError, 0);  // Unmatched '{' braces in message.
582          errorCode=U_UNMATCHED_BRACES;
583          return 0;
584      }
585      UChar c=msg.charAt(index);
586      if(c==u_rightCurlyBrace) {
587          // all done
588      } else if(c!=u_comma) {
589          setParseError(parseError, nameIndex);  // Bad argument syntax.
590          errorCode=U_PATTERN_SYNTAX_ERROR;
591          return 0;
592      } else /* ',' */ {
593          // parse argument type: case-sensitive a-zA-Z
594          int32_t typeIndex=index=skipWhiteSpace(index+1);
595          while(index<msg.length() && isArgTypeChar(msg.charAt(index))) {
596              ++index;
597          }
598          int32_t length=index-typeIndex;
599          index=skipWhiteSpace(index);
600          if(index==msg.length()) {
601              setParseError(parseError, 0);  // Unmatched '{' braces in message.
602              errorCode=U_UNMATCHED_BRACES;
603              return 0;
604          }
605          if(length==0 || ((c=msg.charAt(index))!=u_comma && c!=u_rightCurlyBrace)) {
606              setParseError(parseError, nameIndex);  // Bad argument syntax.
607              errorCode=U_PATTERN_SYNTAX_ERROR;
608              return 0;
609          }
610          if(length>Part::MAX_LENGTH) {
611              setParseError(parseError, nameIndex);  // Argument type name too long.
612              errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
613              return 0;
614          }
615          argType=UMSGPAT_ARG_TYPE_SIMPLE;
616          if(length==6) {
617              // case-insensitive comparisons for complex-type names
618              if(isChoice(typeIndex)) {
619                  argType=UMSGPAT_ARG_TYPE_CHOICE;
620              } else if(isPlural(typeIndex)) {
621                  argType=UMSGPAT_ARG_TYPE_PLURAL;
622              } else if(isSelect(typeIndex)) {
623                  argType=UMSGPAT_ARG_TYPE_SELECT;
624              }
625          } else if(length==13) {
626              if(isSelect(typeIndex) && isOrdinal(typeIndex+6)) {
627                  argType=UMSGPAT_ARG_TYPE_SELECTORDINAL;
628              }
629          }
630          // change the ARG_START type from NONE to argType
631          partsList->a[argStart].value=(int16_t)argType;
632          if(argType==UMSGPAT_ARG_TYPE_SIMPLE) {
633              addPart(UMSGPAT_PART_TYPE_ARG_TYPE, typeIndex, length, 0, errorCode);
634          }
635          // look for an argument style (pattern)
636          if(c==u_rightCurlyBrace) {
637              if(argType!=UMSGPAT_ARG_TYPE_SIMPLE) {
638                  setParseError(parseError, nameIndex);  // No style field for complex argument.
639                  errorCode=U_PATTERN_SYNTAX_ERROR;
640                  return 0;
641              }
642          } else /* ',' */ {
643              ++index;
644              if(argType==UMSGPAT_ARG_TYPE_SIMPLE) {
645                  index=parseSimpleStyle(index, parseError, errorCode);
646              } else if(argType==UMSGPAT_ARG_TYPE_CHOICE) {
647                  index=parseChoiceStyle(index, nestingLevel, parseError, errorCode);
648              } else {
649                  index=parsePluralOrSelectStyle(argType, index, nestingLevel, parseError, errorCode);
650              }
651          }
652      }
653      // Argument parsing stopped on the '}'.
654      addLimitPart(argStart, UMSGPAT_PART_TYPE_ARG_LIMIT, index, 1, argType, errorCode);
655      return index+1;
656  }
657  
658  int32_t
parseSimpleStyle(int32_t index,UParseError * parseError,UErrorCode & errorCode)659  MessagePattern::parseSimpleStyle(int32_t index, UParseError *parseError, UErrorCode &errorCode) {
660      if(U_FAILURE(errorCode)) {
661          return 0;
662      }
663      int32_t start=index;
664      int32_t nestedBraces=0;
665      while(index<msg.length()) {
666          UChar c=msg.charAt(index++);
667          if(c==u_apos) {
668              // Treat apostrophe as quoting but include it in the style part.
669              // Find the end of the quoted literal text.
670              index=msg.indexOf(u_apos, index);
671              if(index<0) {
672                  // Quoted literal argument style text reaches to the end of the message.
673                  setParseError(parseError, start);
674                  errorCode=U_PATTERN_SYNTAX_ERROR;
675                  return 0;
676              }
677              // skip the quote-ending apostrophe
678              ++index;
679          } else if(c==u_leftCurlyBrace) {
680              ++nestedBraces;
681          } else if(c==u_rightCurlyBrace) {
682              if(nestedBraces>0) {
683                  --nestedBraces;
684              } else {
685                  int32_t length=--index-start;
686                  if(length>Part::MAX_LENGTH) {
687                      setParseError(parseError, start);  // Argument style text too long.
688                      errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
689                      return 0;
690                  }
691                  addPart(UMSGPAT_PART_TYPE_ARG_STYLE, start, length, 0, errorCode);
692                  return index;
693              }
694          }  // c is part of literal text
695      }
696      setParseError(parseError, 0);  // Unmatched '{' braces in message.
697      errorCode=U_UNMATCHED_BRACES;
698      return 0;
699  }
700  
701  int32_t
parseChoiceStyle(int32_t index,int32_t nestingLevel,UParseError * parseError,UErrorCode & errorCode)702  MessagePattern::parseChoiceStyle(int32_t index, int32_t nestingLevel,
703                                   UParseError *parseError, UErrorCode &errorCode) {
704      if(U_FAILURE(errorCode)) {
705          return 0;
706      }
707      int32_t start=index;
708      index=skipWhiteSpace(index);
709      if(index==msg.length() || msg.charAt(index)==u_rightCurlyBrace) {
710          setParseError(parseError, 0);  // Missing choice argument pattern.
711          errorCode=U_PATTERN_SYNTAX_ERROR;
712          return 0;
713      }
714      for(;;) {
715          // The choice argument style contains |-separated (number, separator, message) triples.
716          // Parse the number.
717          int32_t numberIndex=index;
718          index=skipDouble(index);
719          int32_t length=index-numberIndex;
720          if(length==0) {
721              setParseError(parseError, start);  // Bad choice pattern syntax.
722              errorCode=U_PATTERN_SYNTAX_ERROR;
723              return 0;
724          }
725          if(length>Part::MAX_LENGTH) {
726              setParseError(parseError, numberIndex);  // Choice number too long.
727              errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
728              return 0;
729          }
730          parseDouble(numberIndex, index, TRUE, parseError, errorCode);  // adds ARG_INT or ARG_DOUBLE
731          if(U_FAILURE(errorCode)) {
732              return 0;
733          }
734          // Parse the separator.
735          index=skipWhiteSpace(index);
736          if(index==msg.length()) {
737              setParseError(parseError, start);  // Bad choice pattern syntax.
738              errorCode=U_PATTERN_SYNTAX_ERROR;
739              return 0;
740          }
741          UChar c=msg.charAt(index);
742          if(!(c==u_pound || c==u_lessThan || c==u_lessOrEqual)) {  // U+2264 is <=
743              setParseError(parseError, start);  // Expected choice separator (#<\u2264) instead of c.
744              errorCode=U_PATTERN_SYNTAX_ERROR;
745              return 0;
746          }
747          addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, index, 1, 0, errorCode);
748          // Parse the message fragment.
749          index=parseMessage(++index, 0, nestingLevel+1, UMSGPAT_ARG_TYPE_CHOICE, parseError, errorCode);
750          if(U_FAILURE(errorCode)) {
751              return 0;
752          }
753          // parseMessage(..., CHOICE) returns the index of the terminator, or msg.length().
754          if(index==msg.length()) {
755              return index;
756          }
757          if(msg.charAt(index)==u_rightCurlyBrace) {
758              if(!inMessageFormatPattern(nestingLevel)) {
759                  setParseError(parseError, start);  // Bad choice pattern syntax.
760                  errorCode=U_PATTERN_SYNTAX_ERROR;
761                  return 0;
762              }
763              return index;
764          }  // else the terminator is '|'
765          index=skipWhiteSpace(index+1);
766      }
767  }
768  
769  int32_t
parsePluralOrSelectStyle(UMessagePatternArgType argType,int32_t index,int32_t nestingLevel,UParseError * parseError,UErrorCode & errorCode)770  MessagePattern::parsePluralOrSelectStyle(UMessagePatternArgType argType,
771                                           int32_t index, int32_t nestingLevel,
772                                           UParseError *parseError, UErrorCode &errorCode) {
773      if(U_FAILURE(errorCode)) {
774          return 0;
775      }
776      int32_t start=index;
777      UBool isEmpty=TRUE;
778      UBool hasOther=FALSE;
779      for(;;) {
780          // First, collect the selector looking for a small set of terminators.
781          // It would be a little faster to consider the syntax of each possible
782          // token right here, but that makes the code too complicated.
783          index=skipWhiteSpace(index);
784          UBool eos=index==msg.length();
785          if(eos || msg.charAt(index)==u_rightCurlyBrace) {
786              if(eos==inMessageFormatPattern(nestingLevel)) {
787                  setParseError(parseError, start);  // Bad plural/select pattern syntax.
788                  errorCode=U_PATTERN_SYNTAX_ERROR;
789                  return 0;
790              }
791              if(!hasOther) {
792                  setParseError(parseError, 0);  // Missing 'other' keyword in plural/select pattern.
793                  errorCode=U_DEFAULT_KEYWORD_MISSING;
794                  return 0;
795              }
796              return index;
797          }
798          int32_t selectorIndex=index;
799          if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) && msg.charAt(selectorIndex)==u_equal) {
800              // explicit-value plural selector: =double
801              index=skipDouble(index+1);
802              int32_t length=index-selectorIndex;
803              if(length==1) {
804                  setParseError(parseError, start);  // Bad plural/select pattern syntax.
805                  errorCode=U_PATTERN_SYNTAX_ERROR;
806                  return 0;
807              }
808              if(length>Part::MAX_LENGTH) {
809                  setParseError(parseError, selectorIndex);  // Argument selector too long.
810                  errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
811                  return 0;
812              }
813              addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, selectorIndex, length, 0, errorCode);
814              parseDouble(selectorIndex+1, index, FALSE,
815                          parseError, errorCode);  // adds ARG_INT or ARG_DOUBLE
816          } else {
817              index=skipIdentifier(index);
818              int32_t length=index-selectorIndex;
819              if(length==0) {
820                  setParseError(parseError, start);  // Bad plural/select pattern syntax.
821                  errorCode=U_PATTERN_SYNTAX_ERROR;
822                  return 0;
823              }
824              // Note: The ':' in "offset:" is just beyond the skipIdentifier() range.
825              if( UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) && length==6 && index<msg.length() &&
826                  0==msg.compare(selectorIndex, 7, kOffsetColon, 0, 7)
827              ) {
828                  // plural offset, not a selector
829                  if(!isEmpty) {
830                      // Plural argument 'offset:' (if present) must precede key-message pairs.
831                      setParseError(parseError, start);
832                      errorCode=U_PATTERN_SYNTAX_ERROR;
833                      return 0;
834                  }
835                  // allow whitespace between offset: and its value
836                  int32_t valueIndex=skipWhiteSpace(index+1);  // The ':' is at index.
837                  index=skipDouble(valueIndex);
838                  if(index==valueIndex) {
839                      setParseError(parseError, start);  // Missing value for plural 'offset:'.
840                      errorCode=U_PATTERN_SYNTAX_ERROR;
841                      return 0;
842                  }
843                  if((index-valueIndex)>Part::MAX_LENGTH) {
844                      setParseError(parseError, valueIndex);  // Plural offset value too long.
845                      errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
846                      return 0;
847                  }
848                  parseDouble(valueIndex, index, FALSE,
849                              parseError, errorCode);  // adds ARG_INT or ARG_DOUBLE
850                  if(U_FAILURE(errorCode)) {
851                      return 0;
852                  }
853                  isEmpty=FALSE;
854                  continue;  // no message fragment after the offset
855              } else {
856                  // normal selector word
857                  if(length>Part::MAX_LENGTH) {
858                      setParseError(parseError, selectorIndex);  // Argument selector too long.
859                      errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
860                      return 0;
861                  }
862                  addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, selectorIndex, length, 0, errorCode);
863                  if(0==msg.compare(selectorIndex, length, kOther, 0, 5)) {
864                      hasOther=TRUE;
865                  }
866              }
867          }
868          if(U_FAILURE(errorCode)) {
869              return 0;
870          }
871  
872          // parse the message fragment following the selector
873          index=skipWhiteSpace(index);
874          if(index==msg.length() || msg.charAt(index)!=u_leftCurlyBrace) {
875              setParseError(parseError, selectorIndex);  // No message fragment after plural/select selector.
876              errorCode=U_PATTERN_SYNTAX_ERROR;
877              return 0;
878          }
879          index=parseMessage(index, 1, nestingLevel+1, argType, parseError, errorCode);
880          if(U_FAILURE(errorCode)) {
881              return 0;
882          }
883          isEmpty=FALSE;
884      }
885  }
886  
887  int32_t
parseArgNumber(const UnicodeString & s,int32_t start,int32_t limit)888  MessagePattern::parseArgNumber(const UnicodeString &s, int32_t start, int32_t limit) {
889      // If the identifier contains only ASCII digits, then it is an argument _number_
890      // and must not have leading zeros (except "0" itself).
891      // Otherwise it is an argument _name_.
892      if(start>=limit) {
893          return UMSGPAT_ARG_NAME_NOT_VALID;
894      }
895      int32_t number;
896      // Defer numeric errors until we know there are only digits.
897      UBool badNumber;
898      UChar c=s.charAt(start++);
899      if(c==0x30) {
900          if(start==limit) {
901              return 0;
902          } else {
903              number=0;
904              badNumber=TRUE;  // leading zero
905          }
906      } else if(0x31<=c && c<=0x39) {
907          number=c-0x30;
908          badNumber=FALSE;
909      } else {
910          return UMSGPAT_ARG_NAME_NOT_NUMBER;
911      }
912      while(start<limit) {
913          c=s.charAt(start++);
914          if(0x30<=c && c<=0x39) {
915              if(number>=INT32_MAX/10) {
916                  badNumber=TRUE;  // overflow
917              }
918              number=number*10+(c-0x30);
919          } else {
920              return UMSGPAT_ARG_NAME_NOT_NUMBER;
921          }
922      }
923      // There are only ASCII digits.
924      if(badNumber) {
925          return UMSGPAT_ARG_NAME_NOT_VALID;
926      } else {
927          return number;
928      }
929  }
930  
931  void
parseDouble(int32_t start,int32_t limit,UBool allowInfinity,UParseError * parseError,UErrorCode & errorCode)932  MessagePattern::parseDouble(int32_t start, int32_t limit, UBool allowInfinity,
933                              UParseError *parseError, UErrorCode &errorCode) {
934      if(U_FAILURE(errorCode)) {
935          return;
936      }
937      U_ASSERT(start<limit);
938      // fake loop for easy exit and single throw statement
939      for(;;) { /*loop doesn't iterate*/
940          // fast path for small integers and infinity
941          int32_t value=0;
942          int32_t isNegative=0;  // not boolean so that we can easily add it to value
943          int32_t index=start;
944          UChar c=msg.charAt(index++);
945          if(c==u_minus) {
946              isNegative=1;
947              if(index==limit) {
948                  break;  // no number
949              }
950              c=msg.charAt(index++);
951          } else if(c==u_plus) {
952              if(index==limit) {
953                  break;  // no number
954              }
955              c=msg.charAt(index++);
956          }
957          if(c==0x221e) {  // infinity
958              if(allowInfinity && index==limit) {
959                  double infinity=uprv_getInfinity();
960                  addArgDoublePart(
961                      isNegative!=0 ? -infinity : infinity,
962                      start, limit-start, errorCode);
963                  return;
964              } else {
965                  break;
966              }
967          }
968          // try to parse the number as a small integer but fall back to a double
969          while('0'<=c && c<='9') {
970              value=value*10+(c-'0');
971              if(value>(Part::MAX_VALUE+isNegative)) {
972                  break;  // not a small-enough integer
973              }
974              if(index==limit) {
975                  addPart(UMSGPAT_PART_TYPE_ARG_INT, start, limit-start,
976                          isNegative!=0 ? -value : value, errorCode);
977                  return;
978              }
979              c=msg.charAt(index++);
980          }
981          // Let Double.parseDouble() throw a NumberFormatException.
982          char numberChars[128];
983          int32_t capacity=(int32_t)sizeof(numberChars);
984          int32_t length=limit-start;
985          if(length>=capacity) {
986              break;  // number too long
987          }
988          msg.extract(start, length, numberChars, capacity, US_INV);
989          if((int32_t)uprv_strlen(numberChars)<length) {
990              break;  // contains non-invariant character that was turned into NUL
991          }
992          char *end;
993          double numericValue=uprv_strtod(numberChars, &end);
994          if(end!=(numberChars+length)) {
995              break;  // parsing error
996          }
997          addArgDoublePart(numericValue, start, length, errorCode);
998          return;
999      }
1000      setParseError(parseError, start /*, limit*/);  // Bad syntax for numeric value.
1001      errorCode=U_PATTERN_SYNTAX_ERROR;
1002      return;
1003  }
1004  
1005  int32_t
skipWhiteSpace(int32_t index)1006  MessagePattern::skipWhiteSpace(int32_t index) {
1007      const UChar *s=msg.getBuffer();
1008      int32_t msgLength=msg.length();
1009      const UChar *t=PatternProps::skipWhiteSpace(s+index, msgLength-index);
1010      return (int32_t)(t-s);
1011  }
1012  
1013  int32_t
skipIdentifier(int32_t index)1014  MessagePattern::skipIdentifier(int32_t index) {
1015      const UChar *s=msg.getBuffer();
1016      int32_t msgLength=msg.length();
1017      const UChar *t=PatternProps::skipIdentifier(s+index, msgLength-index);
1018      return (int32_t)(t-s);
1019  }
1020  
1021  int32_t
skipDouble(int32_t index)1022  MessagePattern::skipDouble(int32_t index) {
1023      int32_t msgLength=msg.length();
1024      while(index<msgLength) {
1025          UChar c=msg.charAt(index);
1026          // U+221E: Allow the infinity symbol, for ChoiceFormat patterns.
1027          if((c<0x30 && c!=u_plus && c!=u_minus && c!=u_dot) || (c>0x39 && c!=u_e && c!=u_E && c!=0x221e)) {
1028              break;
1029          }
1030          ++index;
1031      }
1032      return index;
1033  }
1034  
1035  UBool
isArgTypeChar(UChar32 c)1036  MessagePattern::isArgTypeChar(UChar32 c) {
1037      return (u_a<=c && c<=u_z) || (u_A<=c && c<=u_Z);
1038  }
1039  
1040  UBool
isChoice(int32_t index)1041  MessagePattern::isChoice(int32_t index) {
1042      UChar c;
1043      return
1044          ((c=msg.charAt(index++))==u_c || c==u_C) &&
1045          ((c=msg.charAt(index++))==u_h || c==u_H) &&
1046          ((c=msg.charAt(index++))==u_o || c==u_O) &&
1047          ((c=msg.charAt(index++))==u_i || c==u_I) &&
1048          ((c=msg.charAt(index++))==u_c || c==u_C) &&
1049          ((c=msg.charAt(index))==u_e || c==u_E);
1050  }
1051  
1052  UBool
isPlural(int32_t index)1053  MessagePattern::isPlural(int32_t index) {
1054      UChar c;
1055      return
1056          ((c=msg.charAt(index++))==u_p || c==u_P) &&
1057          ((c=msg.charAt(index++))==u_l || c==u_L) &&
1058          ((c=msg.charAt(index++))==u_u || c==u_U) &&
1059          ((c=msg.charAt(index++))==u_r || c==u_R) &&
1060          ((c=msg.charAt(index++))==u_a || c==u_A) &&
1061          ((c=msg.charAt(index))==u_l || c==u_L);
1062  }
1063  
1064  UBool
isSelect(int32_t index)1065  MessagePattern::isSelect(int32_t index) {
1066      UChar c;
1067      return
1068          ((c=msg.charAt(index++))==u_s || c==u_S) &&
1069          ((c=msg.charAt(index++))==u_e || c==u_E) &&
1070          ((c=msg.charAt(index++))==u_l || c==u_L) &&
1071          ((c=msg.charAt(index++))==u_e || c==u_E) &&
1072          ((c=msg.charAt(index++))==u_c || c==u_C) &&
1073          ((c=msg.charAt(index))==u_t || c==u_T);
1074  }
1075  
1076  UBool
isOrdinal(int32_t index)1077  MessagePattern::isOrdinal(int32_t index) {
1078      UChar c;
1079      return
1080          ((c=msg.charAt(index++))==u_o || c==u_O) &&
1081          ((c=msg.charAt(index++))==u_r || c==u_R) &&
1082          ((c=msg.charAt(index++))==u_d || c==u_D) &&
1083          ((c=msg.charAt(index++))==u_i || c==u_I) &&
1084          ((c=msg.charAt(index++))==u_n || c==u_N) &&
1085          ((c=msg.charAt(index++))==u_a || c==u_A) &&
1086          ((c=msg.charAt(index))==u_l || c==u_L);
1087  }
1088  
1089  UBool
inMessageFormatPattern(int32_t nestingLevel)1090  MessagePattern::inMessageFormatPattern(int32_t nestingLevel) {
1091      return nestingLevel>0 || partsList->a[0].type==UMSGPAT_PART_TYPE_MSG_START;
1092  }
1093  
1094  UBool
inTopLevelChoiceMessage(int32_t nestingLevel,UMessagePatternArgType parentType)1095  MessagePattern::inTopLevelChoiceMessage(int32_t nestingLevel, UMessagePatternArgType parentType) {
1096      return
1097          nestingLevel==1 &&
1098          parentType==UMSGPAT_ARG_TYPE_CHOICE &&
1099          partsList->a[0].type!=UMSGPAT_PART_TYPE_MSG_START;
1100  }
1101  
1102  void
addPart(UMessagePatternPartType type,int32_t index,int32_t length,int32_t value,UErrorCode & errorCode)1103  MessagePattern::addPart(UMessagePatternPartType type, int32_t index, int32_t length,
1104                          int32_t value, UErrorCode &errorCode) {
1105      if(partsList->ensureCapacityForOneMore(partsLength, errorCode)) {
1106          Part &part=partsList->a[partsLength++];
1107          part.type=type;
1108          part.index=index;
1109          part.length=(uint16_t)length;
1110          part.value=(int16_t)value;
1111          part.limitPartIndex=0;
1112      }
1113  }
1114  
1115  void
addLimitPart(int32_t start,UMessagePatternPartType type,int32_t index,int32_t length,int32_t value,UErrorCode & errorCode)1116  MessagePattern::addLimitPart(int32_t start,
1117                               UMessagePatternPartType type, int32_t index, int32_t length,
1118                               int32_t value, UErrorCode &errorCode) {
1119      partsList->a[start].limitPartIndex=partsLength;
1120      addPart(type, index, length, value, errorCode);
1121  }
1122  
1123  void
addArgDoublePart(double numericValue,int32_t start,int32_t length,UErrorCode & errorCode)1124  MessagePattern::addArgDoublePart(double numericValue, int32_t start, int32_t length,
1125                                   UErrorCode &errorCode) {
1126      if(U_FAILURE(errorCode)) {
1127          return;
1128      }
1129      int32_t numericIndex=numericValuesLength;
1130      if(numericValuesList==NULL) {
1131          numericValuesList=new MessagePatternDoubleList();
1132          if(numericValuesList==NULL) {
1133              errorCode=U_MEMORY_ALLOCATION_ERROR;
1134              return;
1135          }
1136      } else if(!numericValuesList->ensureCapacityForOneMore(numericValuesLength, errorCode)) {
1137          return;
1138      } else {
1139          if(numericIndex>Part::MAX_VALUE) {
1140              errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1141              return;
1142          }
1143      }
1144      numericValuesList->a[numericValuesLength++]=numericValue;
1145      addPart(UMSGPAT_PART_TYPE_ARG_DOUBLE, start, length, numericIndex, errorCode);
1146  }
1147  
1148  void
setParseError(UParseError * parseError,int32_t index)1149  MessagePattern::setParseError(UParseError *parseError, int32_t index) {
1150      if(parseError==NULL) {
1151          return;
1152      }
1153      parseError->offset=index;
1154  
1155      // Set preContext to some of msg before index.
1156      // Avoid splitting a surrogate pair.
1157      int32_t length=index;
1158      if(length>=U_PARSE_CONTEXT_LEN) {
1159          length=U_PARSE_CONTEXT_LEN-1;
1160          if(length>0 && U16_IS_TRAIL(msg[index-length])) {
1161              --length;
1162          }
1163      }
1164      msg.extract(index-length, length, parseError->preContext);
1165      parseError->preContext[length]=0;
1166  
1167      // Set postContext to some of msg starting at index.
1168      length=msg.length()-index;
1169      if(length>=U_PARSE_CONTEXT_LEN) {
1170          length=U_PARSE_CONTEXT_LEN-1;
1171          if(length>0 && U16_IS_LEAD(msg[index+length-1])) {
1172              --length;
1173          }
1174      }
1175      msg.extract(index, length, parseError->postContext);
1176      parseError->postContext[length]=0;
1177  }
1178  
1179  // MessageImpl ------------------------------------------------------------- ***
1180  
1181  void
appendReducedApostrophes(const UnicodeString & s,int32_t start,int32_t limit,UnicodeString & sb)1182  MessageImpl::appendReducedApostrophes(const UnicodeString &s, int32_t start, int32_t limit,
1183                                        UnicodeString &sb) {
1184      int32_t doubleApos=-1;
1185      for(;;) {
1186          int32_t i=s.indexOf(u_apos, start);
1187          if(i<0 || i>=limit) {
1188              sb.append(s, start, limit-start);
1189              break;
1190          }
1191          if(i==doubleApos) {
1192              // Double apostrophe at start-1 and start==i, append one.
1193              sb.append(u_apos);
1194              ++start;
1195              doubleApos=-1;
1196          } else {
1197              // Append text between apostrophes and skip this one.
1198              sb.append(s, start, i-start);
1199              doubleApos=start=i+1;
1200          }
1201      }
1202  }
1203  
1204  // Ported from second half of ICU4J SelectFormat.format(String).
1205  UnicodeString &
appendSubMessageWithoutSkipSyntax(const MessagePattern & msgPattern,int32_t msgStart,UnicodeString & result)1206  MessageImpl::appendSubMessageWithoutSkipSyntax(const MessagePattern &msgPattern,
1207                                                 int32_t msgStart,
1208                                                 UnicodeString &result) {
1209      const UnicodeString &msgString=msgPattern.getPatternString();
1210      int32_t prevIndex=msgPattern.getPart(msgStart).getLimit();
1211      for(int32_t i=msgStart;;) {
1212          const MessagePattern::Part &part=msgPattern.getPart(++i);
1213          UMessagePatternPartType type=part.getType();
1214          int32_t index=part.getIndex();
1215          if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) {
1216              return result.append(msgString, prevIndex, index-prevIndex);
1217          } else if(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX) {
1218              result.append(msgString, prevIndex, index-prevIndex);
1219              prevIndex=part.getLimit();
1220          } else if(type==UMSGPAT_PART_TYPE_ARG_START) {
1221              result.append(msgString, prevIndex, index-prevIndex);
1222              prevIndex=index;
1223              i=msgPattern.getLimitPartIndex(i);
1224              index=msgPattern.getPart(i).getLimit();
1225              appendReducedApostrophes(msgString, prevIndex, index, result);
1226              prevIndex=index;
1227          }
1228      }
1229  }
1230  
1231  U_NAMESPACE_END
1232  
1233  #endif  // !UCONFIG_NO_FORMATTING
1234