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: 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); 98 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 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 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 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 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 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 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 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 & 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 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 260 MessagePattern::~MessagePattern() { 261 delete partsList; 262 delete numericValuesList; 263 } 264 265 // MessagePattern API ------------------------------------------------------ *** 266 267 MessagePattern & 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 & 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 & 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 & 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 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 313 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 327 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 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 344 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 361 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 379 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 391 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 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 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 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 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 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 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 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 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 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 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 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 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 1036 MessagePattern::isArgTypeChar(UChar32 c) { 1037 return (u_a<=c && c<=u_z) || (u_A<=c && c<=u_Z); 1038 } 1039 1040 UBool 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 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 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 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 1090 MessagePattern::inMessageFormatPattern(int32_t nestingLevel) { 1091 return nestingLevel>0 || partsList->a[0].type==UMSGPAT_PART_TYPE_MSG_START; 1092 } 1093 1094 UBool 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 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 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 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 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 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 & 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
