1 // 2018 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 4 #include "unicode/utypes.h" 5 6 #if !UCONFIG_NO_FORMATTING 7 8 // Allow implicit conversion from char16_t* to UnicodeString for this file: 9 // Helpful in toString methods and elsewhere. 10 #define UNISTR_FROM_STRING_EXPLICIT 11 12 #include "number_decnum.h" 13 #include "number_skeletons.h" 14 #include "umutex.h" 15 #include "ucln_in.h" 16 #include "patternprops.h" 17 #include "unicode/ucharstriebuilder.h" 18 #include "number_utils.h" 19 #include "number_decimalquantity.h" 20 #include "unicode/numberformatter.h" 21 #include "uinvchar.h" 22 #include "charstr.h" 23 24 using namespace icu; 25 using namespace icu::number; 26 using namespace icu::number::impl; 27 using namespace icu::number::impl::skeleton; 28 29 namespace { 30 31 icu::UInitOnce gNumberSkeletonsInitOnce = U_INITONCE_INITIALIZER; 32 33 char16_t* kSerializedStemTrie = nullptr; 34 35 UBool U_CALLCONV cleanupNumberSkeletons() { 36 uprv_free(kSerializedStemTrie); 37 kSerializedStemTrie = nullptr; 38 gNumberSkeletonsInitOnce.reset(); 39 return TRUE; 40 } 41 42 void U_CALLCONV initNumberSkeletons(UErrorCode& status) { 43 ucln_i18n_registerCleanup(UCLN_I18N_NUMBER_SKELETONS, cleanupNumberSkeletons); 44 45 UCharsTrieBuilder b(status); 46 if (U_FAILURE(status)) { return; } 47 48 // Section 1: 49 b.add(u"compact-short", STEM_COMPACT_SHORT, status); 50 b.add(u"compact-long", STEM_COMPACT_LONG, status); 51 b.add(u"scientific", STEM_SCIENTIFIC, status); 52 b.add(u"engineering", STEM_ENGINEERING, status); 53 b.add(u"notation-simple", STEM_NOTATION_SIMPLE, status); 54 b.add(u"base-unit", STEM_BASE_UNIT, status); 55 b.add(u"percent", STEM_PERCENT, status); 56 b.add(u"permille", STEM_PERMILLE, status); 57 b.add(u"precision-integer", STEM_PRECISION_INTEGER, status); 58 b.add(u"precision-unlimited", STEM_PRECISION_UNLIMITED, status); 59 b.add(u"precision-currency-standard", STEM_PRECISION_CURRENCY_STANDARD, status); 60 b.add(u"precision-currency-cash", STEM_PRECISION_CURRENCY_CASH, status); 61 b.add(u"rounding-mode-ceiling", STEM_ROUNDING_MODE_CEILING, status); 62 b.add(u"rounding-mode-floor", STEM_ROUNDING_MODE_FLOOR, status); 63 b.add(u"rounding-mode-down", STEM_ROUNDING_MODE_DOWN, status); 64 b.add(u"rounding-mode-up", STEM_ROUNDING_MODE_UP, status); 65 b.add(u"rounding-mode-half-even", STEM_ROUNDING_MODE_HALF_EVEN, status); 66 b.add(u"rounding-mode-half-down", STEM_ROUNDING_MODE_HALF_DOWN, status); 67 b.add(u"rounding-mode-half-up", STEM_ROUNDING_MODE_HALF_UP, status); 68 b.add(u"rounding-mode-unnecessary", STEM_ROUNDING_MODE_UNNECESSARY, status); 69 b.add(u"group-off", STEM_GROUP_OFF, status); 70 b.add(u"group-min2", STEM_GROUP_MIN2, status); 71 b.add(u"group-auto", STEM_GROUP_AUTO, status); 72 b.add(u"group-on-aligned", STEM_GROUP_ON_ALIGNED, status); 73 b.add(u"group-thousands", STEM_GROUP_THOUSANDS, status); 74 b.add(u"latin", STEM_LATIN, status); 75 b.add(u"unit-width-narrow", STEM_UNIT_WIDTH_NARROW, status); 76 b.add(u"unit-width-short", STEM_UNIT_WIDTH_SHORT, status); 77 b.add(u"unit-width-full-name", STEM_UNIT_WIDTH_FULL_NAME, status); 78 b.add(u"unit-width-iso-code", STEM_UNIT_WIDTH_ISO_CODE, status); 79 b.add(u"unit-width-hidden", STEM_UNIT_WIDTH_HIDDEN, status); 80 b.add(u"sign-auto", STEM_SIGN_AUTO, status); 81 b.add(u"sign-always", STEM_SIGN_ALWAYS, status); 82 b.add(u"sign-never", STEM_SIGN_NEVER, status); 83 b.add(u"sign-accounting", STEM_SIGN_ACCOUNTING, status); 84 b.add(u"sign-accounting-always", STEM_SIGN_ACCOUNTING_ALWAYS, status); 85 b.add(u"sign-except-zero", STEM_SIGN_EXCEPT_ZERO, status); 86 b.add(u"sign-accounting-except-zero", STEM_SIGN_ACCOUNTING_EXCEPT_ZERO, status); 87 b.add(u"decimal-auto", STEM_DECIMAL_AUTO, status); 88 b.add(u"decimal-always", STEM_DECIMAL_ALWAYS, status); 89 if (U_FAILURE(status)) { return; } 90 91 // Section 2: 92 b.add(u"precision-increment", STEM_PRECISION_INCREMENT, status); 93 b.add(u"measure-unit", STEM_MEASURE_UNIT, status); 94 b.add(u"per-measure-unit", STEM_PER_MEASURE_UNIT, status); 95 b.add(u"currency", STEM_CURRENCY, status); 96 b.add(u"integer-width", STEM_INTEGER_WIDTH, status); 97 b.add(u"numbering-system", STEM_NUMBERING_SYSTEM, status); 98 b.add(u"scale", STEM_SCALE, status); 99 if (U_FAILURE(status)) { return; } 100 101 // Build the CharsTrie 102 // TODO: Use SLOW or FAST here? 103 UnicodeString result; 104 b.buildUnicodeString(USTRINGTRIE_BUILD_FAST, result, status); 105 if (U_FAILURE(status)) { return; } 106 107 // Copy the result into the global constant pointer 108 size_t numBytes = result.length() * sizeof(char16_t); 109 kSerializedStemTrie = static_cast<char16_t*>(uprv_malloc(numBytes)); 110 uprv_memcpy(kSerializedStemTrie, result.getBuffer(), numBytes); 111 } 112 113 114 inline void appendMultiple(UnicodeString& sb, UChar32 cp, int32_t count) { 115 for (int i = 0; i < count; i++) { 116 sb.append(cp); 117 } 118 } 119 120 121 #define CHECK_NULL(seen, field, status) (void)(seen); /* for auto-format line wrapping */ \ 122 { \ 123 if ((seen).field) { \ 124 (status) = U_NUMBER_SKELETON_SYNTAX_ERROR; \ 125 return STATE_NULL; \ 126 } \ 127 (seen).field = true; \ 128 } 129 130 131 #define SKELETON_UCHAR_TO_CHAR(dest, src, start, end, status) (void)(dest); \ 132 { \ 133 UErrorCode conversionStatus = U_ZERO_ERROR; \ 134 (dest).appendInvariantChars({FALSE, (src).getBuffer() + (start), (end) - (start)}, conversionStatus); \ 135 if (conversionStatus == U_INVARIANT_CONVERSION_ERROR) { \ 136 /* Don't propagate the invariant conversion error; it is a skeleton syntax error */ \ 137 (status) = U_NUMBER_SKELETON_SYNTAX_ERROR; \ 138 return; \ 139 } else if (U_FAILURE(conversionStatus)) { \ 140 (status) = conversionStatus; \ 141 return; \ 142 } \ 143 } 144 145 146 } // anonymous namespace 147 148 149 Notation stem_to_object::notation(skeleton::StemEnum stem) { 150 switch (stem) { 151 case STEM_COMPACT_SHORT: 152 return Notation::compactShort(); 153 case STEM_COMPACT_LONG: 154 return Notation::compactLong(); 155 case STEM_SCIENTIFIC: 156 return Notation::scientific(); 157 case STEM_ENGINEERING: 158 return Notation::engineering(); 159 case STEM_NOTATION_SIMPLE: 160 return Notation::simple(); 161 default: 162 U_ASSERT(false); 163 return Notation::simple(); // return a value: silence compiler warning 164 } 165 } 166 167 MeasureUnit stem_to_object::unit(skeleton::StemEnum stem) { 168 switch (stem) { 169 case STEM_BASE_UNIT: 170 // Slicing is okay 171 return NoUnit::base(); // NOLINT 172 case STEM_PERCENT: 173 // Slicing is okay 174 return NoUnit::percent(); // NOLINT 175 case STEM_PERMILLE: 176 // Slicing is okay 177 return NoUnit::permille(); // NOLINT 178 default: 179 U_ASSERT(false); 180 return {}; // return a value: silence compiler warning 181 } 182 } 183 184 Precision stem_to_object::precision(skeleton::StemEnum stem) { 185 switch (stem) { 186 case STEM_PRECISION_INTEGER: 187 return Precision::integer(); 188 case STEM_PRECISION_UNLIMITED: 189 return Precision::unlimited(); 190 case STEM_PRECISION_CURRENCY_STANDARD: 191 return Precision::currency(UCURR_USAGE_STANDARD); 192 case STEM_PRECISION_CURRENCY_CASH: 193 return Precision::currency(UCURR_USAGE_CASH); 194 default: 195 U_ASSERT(false); 196 return Precision::integer(); // return a value: silence compiler warning 197 } 198 } 199 200 UNumberFormatRoundingMode stem_to_object::roundingMode(skeleton::StemEnum stem) { 201 switch (stem) { 202 case STEM_ROUNDING_MODE_CEILING: 203 return UNUM_ROUND_CEILING; 204 case STEM_ROUNDING_MODE_FLOOR: 205 return UNUM_ROUND_FLOOR; 206 case STEM_ROUNDING_MODE_DOWN: 207 return UNUM_ROUND_DOWN; 208 case STEM_ROUNDING_MODE_UP: 209 return UNUM_ROUND_UP; 210 case STEM_ROUNDING_MODE_HALF_EVEN: 211 return UNUM_ROUND_HALFEVEN; 212 case STEM_ROUNDING_MODE_HALF_DOWN: 213 return UNUM_ROUND_HALFDOWN; 214 case STEM_ROUNDING_MODE_HALF_UP: 215 return UNUM_ROUND_HALFUP; 216 case STEM_ROUNDING_MODE_UNNECESSARY: 217 return UNUM_ROUND_UNNECESSARY; 218 default: 219 U_ASSERT(false); 220 return UNUM_ROUND_UNNECESSARY; 221 } 222 } 223 224 UGroupingStrategy stem_to_object::groupingStrategy(skeleton::StemEnum stem) { 225 switch (stem) { 226 case STEM_GROUP_OFF: 227 return UNUM_GROUPING_OFF; 228 case STEM_GROUP_MIN2: 229 return UNUM_GROUPING_MIN2; 230 case STEM_GROUP_AUTO: 231 return UNUM_GROUPING_AUTO; 232 case STEM_GROUP_ON_ALIGNED: 233 return UNUM_GROUPING_ON_ALIGNED; 234 case STEM_GROUP_THOUSANDS: 235 return UNUM_GROUPING_THOUSANDS; 236 default: 237 return UNUM_GROUPING_COUNT; // for objects, throw; for enums, return COUNT 238 } 239 } 240 241 UNumberUnitWidth stem_to_object::unitWidth(skeleton::StemEnum stem) { 242 switch (stem) { 243 case STEM_UNIT_WIDTH_NARROW: 244 return UNUM_UNIT_WIDTH_NARROW; 245 case STEM_UNIT_WIDTH_SHORT: 246 return UNUM_UNIT_WIDTH_SHORT; 247 case STEM_UNIT_WIDTH_FULL_NAME: 248 return UNUM_UNIT_WIDTH_FULL_NAME; 249 case STEM_UNIT_WIDTH_ISO_CODE: 250 return UNUM_UNIT_WIDTH_ISO_CODE; 251 case STEM_UNIT_WIDTH_HIDDEN: 252 return UNUM_UNIT_WIDTH_HIDDEN; 253 default: 254 return UNUM_UNIT_WIDTH_COUNT; // for objects, throw; for enums, return COUNT 255 } 256 } 257 258 UNumberSignDisplay stem_to_object::signDisplay(skeleton::StemEnum stem) { 259 switch (stem) { 260 case STEM_SIGN_AUTO: 261 return UNUM_SIGN_AUTO; 262 case STEM_SIGN_ALWAYS: 263 return UNUM_SIGN_ALWAYS; 264 case STEM_SIGN_NEVER: 265 return UNUM_SIGN_NEVER; 266 case STEM_SIGN_ACCOUNTING: 267 return UNUM_SIGN_ACCOUNTING; 268 case STEM_SIGN_ACCOUNTING_ALWAYS: 269 return UNUM_SIGN_ACCOUNTING_ALWAYS; 270 case STEM_SIGN_EXCEPT_ZERO: 271 return UNUM_SIGN_EXCEPT_ZERO; 272 case STEM_SIGN_ACCOUNTING_EXCEPT_ZERO: 273 return UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO; 274 default: 275 return UNUM_SIGN_COUNT; // for objects, throw; for enums, return COUNT 276 } 277 } 278 279 UNumberDecimalSeparatorDisplay stem_to_object::decimalSeparatorDisplay(skeleton::StemEnum stem) { 280 switch (stem) { 281 case STEM_DECIMAL_AUTO: 282 return UNUM_DECIMAL_SEPARATOR_AUTO; 283 case STEM_DECIMAL_ALWAYS: 284 return UNUM_DECIMAL_SEPARATOR_ALWAYS; 285 default: 286 return UNUM_DECIMAL_SEPARATOR_COUNT; // for objects, throw; for enums, return COUNT 287 } 288 } 289 290 291 void enum_to_stem_string::roundingMode(UNumberFormatRoundingMode value, UnicodeString& sb) { 292 switch (value) { 293 case UNUM_ROUND_CEILING: 294 sb.append(u"rounding-mode-ceiling", -1); 295 break; 296 case UNUM_ROUND_FLOOR: 297 sb.append(u"rounding-mode-floor", -1); 298 break; 299 case UNUM_ROUND_DOWN: 300 sb.append(u"rounding-mode-down", -1); 301 break; 302 case UNUM_ROUND_UP: 303 sb.append(u"rounding-mode-up", -1); 304 break; 305 case UNUM_ROUND_HALFEVEN: 306 sb.append(u"rounding-mode-half-even", -1); 307 break; 308 case UNUM_ROUND_HALFDOWN: 309 sb.append(u"rounding-mode-half-down", -1); 310 break; 311 case UNUM_ROUND_HALFUP: 312 sb.append(u"rounding-mode-half-up", -1); 313 break; 314 case UNUM_ROUND_UNNECESSARY: 315 sb.append(u"rounding-mode-unnecessary", -1); 316 break; 317 default: 318 U_ASSERT(false); 319 } 320 } 321 322 void enum_to_stem_string::groupingStrategy(UGroupingStrategy value, UnicodeString& sb) { 323 switch (value) { 324 case UNUM_GROUPING_OFF: 325 sb.append(u"group-off", -1); 326 break; 327 case UNUM_GROUPING_MIN2: 328 sb.append(u"group-min2", -1); 329 break; 330 case UNUM_GROUPING_AUTO: 331 sb.append(u"group-auto", -1); 332 break; 333 case UNUM_GROUPING_ON_ALIGNED: 334 sb.append(u"group-on-aligned", -1); 335 break; 336 case UNUM_GROUPING_THOUSANDS: 337 sb.append(u"group-thousands", -1); 338 break; 339 default: 340 U_ASSERT(false); 341 } 342 } 343 344 void enum_to_stem_string::unitWidth(UNumberUnitWidth value, UnicodeString& sb) { 345 switch (value) { 346 case UNUM_UNIT_WIDTH_NARROW: 347 sb.append(u"unit-width-narrow", -1); 348 break; 349 case UNUM_UNIT_WIDTH_SHORT: 350 sb.append(u"unit-width-short", -1); 351 break; 352 case UNUM_UNIT_WIDTH_FULL_NAME: 353 sb.append(u"unit-width-full-name", -1); 354 break; 355 case UNUM_UNIT_WIDTH_ISO_CODE: 356 sb.append(u"unit-width-iso-code", -1); 357 break; 358 case UNUM_UNIT_WIDTH_HIDDEN: 359 sb.append(u"unit-width-hidden", -1); 360 break; 361 default: 362 U_ASSERT(false); 363 } 364 } 365 366 void enum_to_stem_string::signDisplay(UNumberSignDisplay value, UnicodeString& sb) { 367 switch (value) { 368 case UNUM_SIGN_AUTO: 369 sb.append(u"sign-auto", -1); 370 break; 371 case UNUM_SIGN_ALWAYS: 372 sb.append(u"sign-always", -1); 373 break; 374 case UNUM_SIGN_NEVER: 375 sb.append(u"sign-never", -1); 376 break; 377 case UNUM_SIGN_ACCOUNTING: 378 sb.append(u"sign-accounting", -1); 379 break; 380 case UNUM_SIGN_ACCOUNTING_ALWAYS: 381 sb.append(u"sign-accounting-always", -1); 382 break; 383 case UNUM_SIGN_EXCEPT_ZERO: 384 sb.append(u"sign-except-zero", -1); 385 break; 386 case UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO: 387 sb.append(u"sign-accounting-except-zero", -1); 388 break; 389 default: 390 U_ASSERT(false); 391 } 392 } 393 394 void 395 enum_to_stem_string::decimalSeparatorDisplay(UNumberDecimalSeparatorDisplay value, UnicodeString& sb) { 396 switch (value) { 397 case UNUM_DECIMAL_SEPARATOR_AUTO: 398 sb.append(u"decimal-auto", -1); 399 break; 400 case UNUM_DECIMAL_SEPARATOR_ALWAYS: 401 sb.append(u"decimal-always", -1); 402 break; 403 default: 404 U_ASSERT(false); 405 } 406 } 407 408 409 UnlocalizedNumberFormatter skeleton::create(const UnicodeString& skeletonString, UErrorCode& status) { 410 umtx_initOnce(gNumberSkeletonsInitOnce, &initNumberSkeletons, status); 411 MacroProps macros = parseSkeleton(skeletonString, status); 412 return NumberFormatter::with().macros(macros); 413 } 414 415 UnicodeString skeleton::generate(const MacroProps& macros, UErrorCode& status) { 416 umtx_initOnce(gNumberSkeletonsInitOnce, &initNumberSkeletons, status); 417 UnicodeString sb; 418 GeneratorHelpers::generateSkeleton(macros, sb, status); 419 return sb; 420 } 421 422 MacroProps skeleton::parseSkeleton(const UnicodeString& skeletonString, UErrorCode& status) { 423 if (U_FAILURE(status)) { return MacroProps(); } 424 425 // Add a trailing whitespace to the end of the skeleton string to make code cleaner. 426 UnicodeString tempSkeletonString(skeletonString); 427 tempSkeletonString.append(u' '); 428 429 SeenMacroProps seen; 430 MacroProps macros; 431 StringSegment segment(tempSkeletonString, false); 432 UCharsTrie stemTrie(kSerializedStemTrie); 433 ParseState stem = STATE_NULL; 434 int32_t offset = 0; 435 436 // Primary skeleton parse loop: 437 while (offset < segment.length()) { 438 UChar32 cp = segment.codePointAt(offset); 439 bool isTokenSeparator = PatternProps::isWhiteSpace(cp); 440 bool isOptionSeparator = (cp == u'/'); 441 442 if (!isTokenSeparator && !isOptionSeparator) { 443 // Non-separator token; consume it. 444 offset += U16_LENGTH(cp); 445 if (stem == STATE_NULL) { 446 // We are currently consuming a stem. 447 // Go to the next state in the stem trie. 448 stemTrie.nextForCodePoint(cp); 449 } 450 continue; 451 } 452 453 // We are looking at a token or option separator. 454 // If the segment is nonempty, parse it and reset the segment. 455 // Otherwise, make sure it is a valid repeating separator. 456 if (offset != 0) { 457 segment.setLength(offset); 458 if (stem == STATE_NULL) { 459 // The first separator after the start of a token. Parse it as a stem. 460 stem = parseStem(segment, stemTrie, seen, macros, status); 461 stemTrie.reset(); 462 } else { 463 // A separator after the first separator of a token. Parse it as an option. 464 stem = parseOption(stem, segment, macros, status); 465 } 466 segment.resetLength(); 467 if (U_FAILURE(status)) { return macros; } 468 469 // Consume the segment: 470 segment.adjustOffset(offset); 471 offset = 0; 472 473 } else if (stem != STATE_NULL) { 474 // A separator ('/' or whitespace) following an option separator ('/') 475 // segment.setLength(U16_LENGTH(cp)); // for error message 476 // throw new SkeletonSyntaxException("Unexpected separator character", segment); 477 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 478 return macros; 479 480 } else { 481 // Two spaces in a row; this is OK. 482 } 483 484 // Does the current stem forbid options? 485 if (isOptionSeparator && stem == STATE_NULL) { 486 // segment.setLength(U16_LENGTH(cp)); // for error message 487 // throw new SkeletonSyntaxException("Unexpected option separator", segment); 488 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 489 return macros; 490 } 491 492 // Does the current stem require an option? 493 if (isTokenSeparator && stem != STATE_NULL) { 494 switch (stem) { 495 case STATE_INCREMENT_PRECISION: 496 case STATE_MEASURE_UNIT: 497 case STATE_PER_MEASURE_UNIT: 498 case STATE_CURRENCY_UNIT: 499 case STATE_INTEGER_WIDTH: 500 case STATE_NUMBERING_SYSTEM: 501 case STATE_SCALE: 502 // segment.setLength(U16_LENGTH(cp)); // for error message 503 // throw new SkeletonSyntaxException("Stem requires an option", segment); 504 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 505 return macros; 506 default: 507 break; 508 } 509 stem = STATE_NULL; 510 } 511 512 // Consume the separator: 513 segment.adjustOffset(U16_LENGTH(cp)); 514 } 515 U_ASSERT(stem == STATE_NULL); 516 return macros; 517 } 518 519 ParseState 520 skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, SeenMacroProps& seen, 521 MacroProps& macros, UErrorCode& status) { 522 // First check for "blueprint" stems, which start with a "signal char" 523 switch (segment.charAt(0)) { 524 case u'.': 525 CHECK_NULL(seen, precision, status); 526 blueprint_helpers::parseFractionStem(segment, macros, status); 527 return STATE_FRACTION_PRECISION; 528 case u'@': 529 CHECK_NULL(seen, precision, status); 530 blueprint_helpers::parseDigitsStem(segment, macros, status); 531 return STATE_NULL; 532 default: 533 break; 534 } 535 536 // Now look at the stemsTrie, which is already be pointing at our stem. 537 UStringTrieResult stemResult = stemTrie.current(); 538 539 if (stemResult != USTRINGTRIE_INTERMEDIATE_VALUE && stemResult != USTRINGTRIE_FINAL_VALUE) { 540 // throw new SkeletonSyntaxException("Unknown stem", segment); 541 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 542 return STATE_NULL; 543 } 544 545 auto stem = static_cast<StemEnum>(stemTrie.getValue()); 546 switch (stem) { 547 548 // Stems with meaning on their own, not requiring an option: 549 550 case STEM_COMPACT_SHORT: 551 case STEM_COMPACT_LONG: 552 case STEM_SCIENTIFIC: 553 case STEM_ENGINEERING: 554 case STEM_NOTATION_SIMPLE: 555 CHECK_NULL(seen, notation, status); 556 macros.notation = stem_to_object::notation(stem); 557 switch (stem) { 558 case STEM_SCIENTIFIC: 559 case STEM_ENGINEERING: 560 return STATE_SCIENTIFIC; // allows for scientific options 561 default: 562 return STATE_NULL; 563 } 564 565 case STEM_BASE_UNIT: 566 case STEM_PERCENT: 567 case STEM_PERMILLE: 568 CHECK_NULL(seen, unit, status); 569 macros.unit = stem_to_object::unit(stem); 570 return STATE_NULL; 571 572 case STEM_PRECISION_INTEGER: 573 case STEM_PRECISION_UNLIMITED: 574 case STEM_PRECISION_CURRENCY_STANDARD: 575 case STEM_PRECISION_CURRENCY_CASH: 576 CHECK_NULL(seen, precision, status); 577 macros.precision = stem_to_object::precision(stem); 578 switch (stem) { 579 case STEM_PRECISION_INTEGER: 580 return STATE_FRACTION_PRECISION; // allows for "precision-integer/@##" 581 default: 582 return STATE_NULL; 583 } 584 585 case STEM_ROUNDING_MODE_CEILING: 586 case STEM_ROUNDING_MODE_FLOOR: 587 case STEM_ROUNDING_MODE_DOWN: 588 case STEM_ROUNDING_MODE_UP: 589 case STEM_ROUNDING_MODE_HALF_EVEN: 590 case STEM_ROUNDING_MODE_HALF_DOWN: 591 case STEM_ROUNDING_MODE_HALF_UP: 592 case STEM_ROUNDING_MODE_UNNECESSARY: 593 CHECK_NULL(seen, roundingMode, status); 594 macros.roundingMode = stem_to_object::roundingMode(stem); 595 return STATE_NULL; 596 597 case STEM_GROUP_OFF: 598 case STEM_GROUP_MIN2: 599 case STEM_GROUP_AUTO: 600 case STEM_GROUP_ON_ALIGNED: 601 case STEM_GROUP_THOUSANDS: 602 CHECK_NULL(seen, grouper, status); 603 macros.grouper = Grouper::forStrategy(stem_to_object::groupingStrategy(stem)); 604 return STATE_NULL; 605 606 case STEM_LATIN: 607 CHECK_NULL(seen, symbols, status); 608 macros.symbols.setTo(NumberingSystem::createInstanceByName("latn", status)); 609 return STATE_NULL; 610 611 case STEM_UNIT_WIDTH_NARROW: 612 case STEM_UNIT_WIDTH_SHORT: 613 case STEM_UNIT_WIDTH_FULL_NAME: 614 case STEM_UNIT_WIDTH_ISO_CODE: 615 case STEM_UNIT_WIDTH_HIDDEN: 616 CHECK_NULL(seen, unitWidth, status); 617 macros.unitWidth = stem_to_object::unitWidth(stem); 618 return STATE_NULL; 619 620 case STEM_SIGN_AUTO: 621 case STEM_SIGN_ALWAYS: 622 case STEM_SIGN_NEVER: 623 case STEM_SIGN_ACCOUNTING: 624 case STEM_SIGN_ACCOUNTING_ALWAYS: 625 case STEM_SIGN_EXCEPT_ZERO: 626 case STEM_SIGN_ACCOUNTING_EXCEPT_ZERO: 627 CHECK_NULL(seen, sign, status); 628 macros.sign = stem_to_object::signDisplay(stem); 629 return STATE_NULL; 630 631 case STEM_DECIMAL_AUTO: 632 case STEM_DECIMAL_ALWAYS: 633 CHECK_NULL(seen, decimal, status); 634 macros.decimal = stem_to_object::decimalSeparatorDisplay(stem); 635 return STATE_NULL; 636 637 // Stems requiring an option: 638 639 case STEM_PRECISION_INCREMENT: 640 CHECK_NULL(seen, precision, status); 641 return STATE_INCREMENT_PRECISION; 642 643 case STEM_MEASURE_UNIT: 644 CHECK_NULL(seen, unit, status); 645 return STATE_MEASURE_UNIT; 646 647 case STEM_PER_MEASURE_UNIT: 648 CHECK_NULL(seen, perUnit, status); 649 return STATE_PER_MEASURE_UNIT; 650 651 case STEM_CURRENCY: 652 CHECK_NULL(seen, unit, status); 653 return STATE_CURRENCY_UNIT; 654 655 case STEM_INTEGER_WIDTH: 656 CHECK_NULL(seen, integerWidth, status); 657 return STATE_INTEGER_WIDTH; 658 659 case STEM_NUMBERING_SYSTEM: 660 CHECK_NULL(seen, symbols, status); 661 return STATE_NUMBERING_SYSTEM; 662 663 case STEM_SCALE: 664 CHECK_NULL(seen, scale, status); 665 return STATE_SCALE; 666 667 default: 668 U_ASSERT(false); 669 return STATE_NULL; // return a value: silence compiler warning 670 } 671 } 672 673 ParseState skeleton::parseOption(ParseState stem, const StringSegment& segment, MacroProps& macros, 674 UErrorCode& status) { 675 676 ///// Required options: ///// 677 678 switch (stem) { 679 case STATE_CURRENCY_UNIT: 680 blueprint_helpers::parseCurrencyOption(segment, macros, status); 681 return STATE_NULL; 682 case STATE_MEASURE_UNIT: 683 blueprint_helpers::parseMeasureUnitOption(segment, macros, status); 684 return STATE_NULL; 685 case STATE_PER_MEASURE_UNIT: 686 blueprint_helpers::parseMeasurePerUnitOption(segment, macros, status); 687 return STATE_NULL; 688 case STATE_INCREMENT_PRECISION: 689 blueprint_helpers::parseIncrementOption(segment, macros, status); 690 return STATE_NULL; 691 case STATE_INTEGER_WIDTH: 692 blueprint_helpers::parseIntegerWidthOption(segment, macros, status); 693 return STATE_NULL; 694 case STATE_NUMBERING_SYSTEM: 695 blueprint_helpers::parseNumberingSystemOption(segment, macros, status); 696 return STATE_NULL; 697 case STATE_SCALE: 698 blueprint_helpers::parseScaleOption(segment, macros, status); 699 return STATE_NULL; 700 default: 701 break; 702 } 703 704 ///// Non-required options: ///// 705 706 // Scientific options 707 switch (stem) { 708 case STATE_SCIENTIFIC: 709 if (blueprint_helpers::parseExponentWidthOption(segment, macros, status)) { 710 return STATE_SCIENTIFIC; 711 } 712 if (U_FAILURE(status)) { 713 return {}; 714 } 715 if (blueprint_helpers::parseExponentSignOption(segment, macros, status)) { 716 return STATE_SCIENTIFIC; 717 } 718 if (U_FAILURE(status)) { 719 return {}; 720 } 721 break; 722 default: 723 break; 724 } 725 726 // Frac-sig option 727 switch (stem) { 728 case STATE_FRACTION_PRECISION: 729 if (blueprint_helpers::parseFracSigOption(segment, macros, status)) { 730 return STATE_NULL; 731 } 732 if (U_FAILURE(status)) { 733 return {}; 734 } 735 break; 736 default: 737 break; 738 } 739 740 // Unknown option 741 // throw new SkeletonSyntaxException("Invalid option", segment); 742 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 743 return STATE_NULL; 744 } 745 746 void GeneratorHelpers::generateSkeleton(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 747 if (U_FAILURE(status)) { return; } 748 749 // Supported options 750 if (GeneratorHelpers::notation(macros, sb, status)) { 751 sb.append(u' '); 752 } 753 if (U_FAILURE(status)) { return; } 754 if (GeneratorHelpers::unit(macros, sb, status)) { 755 sb.append(u' '); 756 } 757 if (U_FAILURE(status)) { return; } 758 if (GeneratorHelpers::perUnit(macros, sb, status)) { 759 sb.append(u' '); 760 } 761 if (U_FAILURE(status)) { return; } 762 if (GeneratorHelpers::precision(macros, sb, status)) { 763 sb.append(u' '); 764 } 765 if (U_FAILURE(status)) { return; } 766 if (GeneratorHelpers::roundingMode(macros, sb, status)) { 767 sb.append(u' '); 768 } 769 if (U_FAILURE(status)) { return; } 770 if (GeneratorHelpers::grouping(macros, sb, status)) { 771 sb.append(u' '); 772 } 773 if (U_FAILURE(status)) { return; } 774 if (GeneratorHelpers::integerWidth(macros, sb, status)) { 775 sb.append(u' '); 776 } 777 if (U_FAILURE(status)) { return; } 778 if (GeneratorHelpers::symbols(macros, sb, status)) { 779 sb.append(u' '); 780 } 781 if (U_FAILURE(status)) { return; } 782 if (GeneratorHelpers::unitWidth(macros, sb, status)) { 783 sb.append(u' '); 784 } 785 if (U_FAILURE(status)) { return; } 786 if (GeneratorHelpers::sign(macros, sb, status)) { 787 sb.append(u' '); 788 } 789 if (U_FAILURE(status)) { return; } 790 if (GeneratorHelpers::decimal(macros, sb, status)) { 791 sb.append(u' '); 792 } 793 if (U_FAILURE(status)) { return; } 794 if (GeneratorHelpers::scale(macros, sb, status)) { 795 sb.append(u' '); 796 } 797 if (U_FAILURE(status)) { return; } 798 799 // Unsupported options 800 if (!macros.padder.isBogus()) { 801 status = U_UNSUPPORTED_ERROR; 802 return; 803 } 804 if (macros.affixProvider != nullptr) { 805 status = U_UNSUPPORTED_ERROR; 806 return; 807 } 808 if (macros.rules != nullptr) { 809 status = U_UNSUPPORTED_ERROR; 810 return; 811 } 812 if (macros.currencySymbols != nullptr) { 813 status = U_UNSUPPORTED_ERROR; 814 return; 815 } 816 817 // Remove the trailing space 818 if (sb.length() > 0) { 819 sb.truncate(sb.length() - 1); 820 } 821 } 822 823 824 bool blueprint_helpers::parseExponentWidthOption(const StringSegment& segment, MacroProps& macros, 825 UErrorCode&) { 826 if (segment.charAt(0) != u'+') { 827 return false; 828 } 829 int32_t offset = 1; 830 int32_t minExp = 0; 831 for (; offset < segment.length(); offset++) { 832 if (segment.charAt(offset) == u'e') { 833 minExp++; 834 } else { 835 break; 836 } 837 } 838 if (offset < segment.length()) { 839 return false; 840 } 841 // Use the public APIs to enforce bounds checking 842 macros.notation = static_cast<ScientificNotation&>(macros.notation).withMinExponentDigits(minExp); 843 return true; 844 } 845 846 void 847 blueprint_helpers::generateExponentWidthOption(int32_t minExponentDigits, UnicodeString& sb, UErrorCode&) { 848 sb.append(u'+'); 849 appendMultiple(sb, u'e', minExponentDigits); 850 } 851 852 bool 853 blueprint_helpers::parseExponentSignOption(const StringSegment& segment, MacroProps& macros, UErrorCode&) { 854 // Get the sign display type out of the CharsTrie data structure. 855 UCharsTrie tempStemTrie(kSerializedStemTrie); 856 UStringTrieResult result = tempStemTrie.next( 857 segment.toTempUnicodeString().getBuffer(), 858 segment.length()); 859 if (result != USTRINGTRIE_INTERMEDIATE_VALUE && result != USTRINGTRIE_FINAL_VALUE) { 860 return false; 861 } 862 auto sign = stem_to_object::signDisplay(static_cast<StemEnum>(tempStemTrie.getValue())); 863 if (sign == UNUM_SIGN_COUNT) { 864 return false; 865 } 866 macros.notation = static_cast<ScientificNotation&>(macros.notation).withExponentSignDisplay(sign); 867 return true; 868 } 869 870 void blueprint_helpers::parseCurrencyOption(const StringSegment& segment, MacroProps& macros, 871 UErrorCode& status) { 872 // Unlike ICU4J, have to check length manually because ICU4C CurrencyUnit does not check it for us 873 if (segment.length() != 3) { 874 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 875 return; 876 } 877 const UChar* currencyCode = segment.toTempUnicodeString().getBuffer(); 878 UErrorCode localStatus = U_ZERO_ERROR; 879 CurrencyUnit currency(currencyCode, localStatus); 880 if (U_FAILURE(localStatus)) { 881 // Not 3 ascii chars 882 // throw new SkeletonSyntaxException("Invalid currency", segment); 883 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 884 return; 885 } 886 // Slicing is OK 887 macros.unit = currency; // NOLINT 888 } 889 890 void 891 blueprint_helpers::generateCurrencyOption(const CurrencyUnit& currency, UnicodeString& sb, UErrorCode&) { 892 sb.append(currency.getISOCurrency(), -1); 893 } 894 895 void blueprint_helpers::parseMeasureUnitOption(const StringSegment& segment, MacroProps& macros, 896 UErrorCode& status) { 897 const UnicodeString stemString = segment.toTempUnicodeString(); 898 899 // NOTE: The category (type) of the unit is guaranteed to be a valid subtag (alphanumeric) 900 // http://unicode.org/reports/tr35/#Validity_Data 901 int firstHyphen = 0; 902 while (firstHyphen < stemString.length() && stemString.charAt(firstHyphen) != '-') { 903 firstHyphen++; 904 } 905 if (firstHyphen == stemString.length()) { 906 // throw new SkeletonSyntaxException("Invalid measure unit option", segment); 907 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 908 return; 909 } 910 911 // Need to do char <-> UChar conversion... 912 U_ASSERT(U_SUCCESS(status)); 913 CharString type; 914 SKELETON_UCHAR_TO_CHAR(type, stemString, 0, firstHyphen, status); 915 CharString subType; 916 SKELETON_UCHAR_TO_CHAR(subType, stemString, firstHyphen + 1, stemString.length(), status); 917 918 // Note: the largest type as of this writing (March 2018) is "volume", which has 24 units. 919 static constexpr int32_t CAPACITY = 30; 920 MeasureUnit units[CAPACITY]; 921 UErrorCode localStatus = U_ZERO_ERROR; 922 int32_t numUnits = MeasureUnit::getAvailable(type.data(), units, CAPACITY, localStatus); 923 if (U_FAILURE(localStatus)) { 924 // More than 30 units in this type? 925 status = U_INTERNAL_PROGRAM_ERROR; 926 return; 927 } 928 for (int32_t i = 0; i < numUnits; i++) { 929 auto& unit = units[i]; 930 if (uprv_strcmp(subType.data(), unit.getSubtype()) == 0) { 931 macros.unit = unit; 932 return; 933 } 934 } 935 936 // throw new SkeletonSyntaxException("Unknown measure unit", segment); 937 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 938 } 939 940 void blueprint_helpers::generateMeasureUnitOption(const MeasureUnit& measureUnit, UnicodeString& sb, 941 UErrorCode&) { 942 // Need to do char <-> UChar conversion... 943 sb.append(UnicodeString(measureUnit.getType(), -1, US_INV)); 944 sb.append(u'-'); 945 sb.append(UnicodeString(measureUnit.getSubtype(), -1, US_INV)); 946 } 947 948 void blueprint_helpers::parseMeasurePerUnitOption(const StringSegment& segment, MacroProps& macros, 949 UErrorCode& status) { 950 // A little bit of a hack: safe the current unit (numerator), call the main measure unit 951 // parsing code, put back the numerator unit, and put the new unit into per-unit. 952 MeasureUnit numerator = macros.unit; 953 parseMeasureUnitOption(segment, macros, status); 954 if (U_FAILURE(status)) { return; } 955 macros.perUnit = macros.unit; 956 macros.unit = numerator; 957 } 958 959 void blueprint_helpers::parseFractionStem(const StringSegment& segment, MacroProps& macros, 960 UErrorCode& status) { 961 U_ASSERT(segment.charAt(0) == u'.'); 962 int32_t offset = 1; 963 int32_t minFrac = 0; 964 int32_t maxFrac; 965 for (; offset < segment.length(); offset++) { 966 if (segment.charAt(offset) == u'0') { 967 minFrac++; 968 } else { 969 break; 970 } 971 } 972 if (offset < segment.length()) { 973 if (segment.charAt(offset) == u'+') { 974 maxFrac = -1; 975 offset++; 976 } else { 977 maxFrac = minFrac; 978 for (; offset < segment.length(); offset++) { 979 if (segment.charAt(offset) == u'#') { 980 maxFrac++; 981 } else { 982 break; 983 } 984 } 985 } 986 } else { 987 maxFrac = minFrac; 988 } 989 if (offset < segment.length()) { 990 // throw new SkeletonSyntaxException("Invalid fraction stem", segment); 991 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 992 return; 993 } 994 // Use the public APIs to enforce bounds checking 995 if (maxFrac == -1) { 996 macros.precision = Precision::minFraction(minFrac); 997 } else { 998 macros.precision = Precision::minMaxFraction(minFrac, maxFrac); 999 } 1000 } 1001 1002 void 1003 blueprint_helpers::generateFractionStem(int32_t minFrac, int32_t maxFrac, UnicodeString& sb, UErrorCode&) { 1004 if (minFrac == 0 && maxFrac == 0) { 1005 sb.append(u"precision-integer", -1); 1006 return; 1007 } 1008 sb.append(u'.'); 1009 appendMultiple(sb, u'0', minFrac); 1010 if (maxFrac == -1) { 1011 sb.append(u'+'); 1012 } else { 1013 appendMultiple(sb, u'#', maxFrac - minFrac); 1014 } 1015 } 1016 1017 void 1018 blueprint_helpers::parseDigitsStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status) { 1019 U_ASSERT(segment.charAt(0) == u'@'); 1020 int offset = 0; 1021 int minSig = 0; 1022 int maxSig; 1023 for (; offset < segment.length(); offset++) { 1024 if (segment.charAt(offset) == u'@') { 1025 minSig++; 1026 } else { 1027 break; 1028 } 1029 } 1030 if (offset < segment.length()) { 1031 if (segment.charAt(offset) == u'+') { 1032 maxSig = -1; 1033 offset++; 1034 } else { 1035 maxSig = minSig; 1036 for (; offset < segment.length(); offset++) { 1037 if (segment.charAt(offset) == u'#') { 1038 maxSig++; 1039 } else { 1040 break; 1041 } 1042 } 1043 } 1044 } else { 1045 maxSig = minSig; 1046 } 1047 if (offset < segment.length()) { 1048 // throw new SkeletonSyntaxException("Invalid significant digits stem", segment); 1049 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1050 return; 1051 } 1052 // Use the public APIs to enforce bounds checking 1053 if (maxSig == -1) { 1054 macros.precision = Precision::minSignificantDigits(minSig); 1055 } else { 1056 macros.precision = Precision::minMaxSignificantDigits(minSig, maxSig); 1057 } 1058 } 1059 1060 void 1061 blueprint_helpers::generateDigitsStem(int32_t minSig, int32_t maxSig, UnicodeString& sb, UErrorCode&) { 1062 appendMultiple(sb, u'@', minSig); 1063 if (maxSig == -1) { 1064 sb.append(u'+'); 1065 } else { 1066 appendMultiple(sb, u'#', maxSig - minSig); 1067 } 1068 } 1069 1070 bool blueprint_helpers::parseFracSigOption(const StringSegment& segment, MacroProps& macros, 1071 UErrorCode& status) { 1072 if (segment.charAt(0) != u'@') { 1073 return false; 1074 } 1075 int offset = 0; 1076 int minSig = 0; 1077 int maxSig; 1078 for (; offset < segment.length(); offset++) { 1079 if (segment.charAt(offset) == u'@') { 1080 minSig++; 1081 } else { 1082 break; 1083 } 1084 } 1085 // For the frac-sig option, there must be minSig or maxSig but not both. 1086 // Valid: @+, @@+, @@@+ 1087 // Valid: @#, @##, @### 1088 // Invalid: @, @@, @@@ 1089 // Invalid: @@#, @@##, @@@# 1090 if (offset < segment.length()) { 1091 if (segment.charAt(offset) == u'+') { 1092 maxSig = -1; 1093 offset++; 1094 } else if (minSig > 1) { 1095 // @@#, @@##, @@@# 1096 // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment); 1097 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1098 return false; 1099 } else { 1100 maxSig = minSig; 1101 for (; offset < segment.length(); offset++) { 1102 if (segment.charAt(offset) == u'#') { 1103 maxSig++; 1104 } else { 1105 break; 1106 } 1107 } 1108 } 1109 } else { 1110 // @, @@, @@@ 1111 // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment); 1112 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1113 return false; 1114 } 1115 if (offset < segment.length()) { 1116 // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment); 1117 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1118 return false; 1119 } 1120 1121 auto& oldPrecision = static_cast<const FractionPrecision&>(macros.precision); 1122 if (maxSig == -1) { 1123 macros.precision = oldPrecision.withMinDigits(minSig); 1124 } else { 1125 macros.precision = oldPrecision.withMaxDigits(maxSig); 1126 } 1127 return true; 1128 } 1129 1130 void blueprint_helpers::parseIncrementOption(const StringSegment& segment, MacroProps& macros, 1131 UErrorCode& status) { 1132 // Need to do char <-> UChar conversion... 1133 U_ASSERT(U_SUCCESS(status)); 1134 CharString buffer; 1135 SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status); 1136 1137 // Utilize DecimalQuantity/decNumber to parse this for us. 1138 DecimalQuantity dq; 1139 UErrorCode localStatus = U_ZERO_ERROR; 1140 dq.setToDecNumber({buffer.data(), buffer.length()}, localStatus); 1141 if (U_FAILURE(localStatus)) { 1142 // throw new SkeletonSyntaxException("Invalid rounding increment", segment, e); 1143 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1144 return; 1145 } 1146 double increment = dq.toDouble(); 1147 1148 // We also need to figure out how many digits. Do a brute force string operation. 1149 int decimalOffset = 0; 1150 while (decimalOffset < segment.length() && segment.charAt(decimalOffset) != '.') { 1151 decimalOffset++; 1152 } 1153 if (decimalOffset == segment.length()) { 1154 macros.precision = Precision::increment(increment); 1155 } else { 1156 int32_t fractionLength = segment.length() - decimalOffset - 1; 1157 macros.precision = Precision::increment(increment).withMinFraction(fractionLength); 1158 } 1159 } 1160 1161 void blueprint_helpers::generateIncrementOption(double increment, int32_t trailingZeros, UnicodeString& sb, 1162 UErrorCode&) { 1163 // Utilize DecimalQuantity/double_conversion to format this for us. 1164 DecimalQuantity dq; 1165 dq.setToDouble(increment); 1166 dq.roundToInfinity(); 1167 sb.append(dq.toPlainString()); 1168 1169 // We might need to append extra trailing zeros for min fraction... 1170 if (trailingZeros > 0) { 1171 appendMultiple(sb, u'0', trailingZeros); 1172 } 1173 } 1174 1175 void blueprint_helpers::parseIntegerWidthOption(const StringSegment& segment, MacroProps& macros, 1176 UErrorCode& status) { 1177 int32_t offset = 0; 1178 int32_t minInt = 0; 1179 int32_t maxInt; 1180 if (segment.charAt(0) == u'+') { 1181 maxInt = -1; 1182 offset++; 1183 } else { 1184 maxInt = 0; 1185 } 1186 for (; offset < segment.length(); offset++) { 1187 if (segment.charAt(offset) == u'#') { 1188 maxInt++; 1189 } else { 1190 break; 1191 } 1192 } 1193 if (offset < segment.length()) { 1194 for (; offset < segment.length(); offset++) { 1195 if (segment.charAt(offset) == u'0') { 1196 minInt++; 1197 } else { 1198 break; 1199 } 1200 } 1201 } 1202 if (maxInt != -1) { 1203 maxInt += minInt; 1204 } 1205 if (offset < segment.length()) { 1206 // throw new SkeletonSyntaxException("Invalid integer width stem", segment); 1207 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1208 return; 1209 } 1210 // Use the public APIs to enforce bounds checking 1211 if (maxInt == -1) { 1212 macros.integerWidth = IntegerWidth::zeroFillTo(minInt); 1213 } else { 1214 macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt); 1215 } 1216 } 1217 1218 void blueprint_helpers::generateIntegerWidthOption(int32_t minInt, int32_t maxInt, UnicodeString& sb, 1219 UErrorCode&) { 1220 if (maxInt == -1) { 1221 sb.append(u'+'); 1222 } else { 1223 appendMultiple(sb, u'#', maxInt - minInt); 1224 } 1225 appendMultiple(sb, u'0', minInt); 1226 } 1227 1228 void blueprint_helpers::parseNumberingSystemOption(const StringSegment& segment, MacroProps& macros, 1229 UErrorCode& status) { 1230 // Need to do char <-> UChar conversion... 1231 U_ASSERT(U_SUCCESS(status)); 1232 CharString buffer; 1233 SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status); 1234 1235 NumberingSystem* ns = NumberingSystem::createInstanceByName(buffer.data(), status); 1236 if (ns == nullptr || U_FAILURE(status)) { 1237 // This is a skeleton syntax error; don't bubble up the low-level NumberingSystem error 1238 // throw new SkeletonSyntaxException("Unknown numbering system", segment); 1239 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1240 return; 1241 } 1242 macros.symbols.setTo(ns); 1243 } 1244 1245 void blueprint_helpers::generateNumberingSystemOption(const NumberingSystem& ns, UnicodeString& sb, 1246 UErrorCode&) { 1247 // Need to do char <-> UChar conversion... 1248 sb.append(UnicodeString(ns.getName(), -1, US_INV)); 1249 } 1250 1251 void blueprint_helpers::parseScaleOption(const StringSegment& segment, MacroProps& macros, 1252 UErrorCode& status) { 1253 // Need to do char <-> UChar conversion... 1254 U_ASSERT(U_SUCCESS(status)); 1255 CharString buffer; 1256 SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status); 1257 1258 LocalPointer<DecNum> decnum(new DecNum(), status); 1259 if (U_FAILURE(status)) { return; } 1260 decnum->setTo({buffer.data(), buffer.length()}, status); 1261 if (U_FAILURE(status)) { 1262 // This is a skeleton syntax error; don't let the low-level decnum error bubble up 1263 status = U_NUMBER_SKELETON_SYNTAX_ERROR; 1264 return; 1265 } 1266 1267 // NOTE: The constructor will optimize the decnum for us if possible. 1268 macros.scale = {0, decnum.orphan()}; 1269 } 1270 1271 void blueprint_helpers::generateScaleOption(int32_t magnitude, const DecNum* arbitrary, UnicodeString& sb, 1272 UErrorCode& status) { 1273 // Utilize DecimalQuantity/double_conversion to format this for us. 1274 DecimalQuantity dq; 1275 if (arbitrary != nullptr) { 1276 dq.setToDecNum(*arbitrary, status); 1277 if (U_FAILURE(status)) { return; } 1278 } else { 1279 dq.setToInt(1); 1280 } 1281 dq.adjustMagnitude(magnitude); 1282 dq.roundToInfinity(); 1283 sb.append(dq.toPlainString()); 1284 } 1285 1286 1287 bool GeneratorHelpers::notation(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1288 if (macros.notation.fType == Notation::NTN_COMPACT) { 1289 UNumberCompactStyle style = macros.notation.fUnion.compactStyle; 1290 if (style == UNumberCompactStyle::UNUM_LONG) { 1291 sb.append(u"compact-long", -1); 1292 return true; 1293 } else if (style == UNumberCompactStyle::UNUM_SHORT) { 1294 sb.append(u"compact-short", -1); 1295 return true; 1296 } else { 1297 // Compact notation generated from custom data (not supported in skeleton) 1298 // The other compact notations are literals 1299 status = U_UNSUPPORTED_ERROR; 1300 return false; 1301 } 1302 } else if (macros.notation.fType == Notation::NTN_SCIENTIFIC) { 1303 const Notation::ScientificSettings& impl = macros.notation.fUnion.scientific; 1304 if (impl.fEngineeringInterval == 3) { 1305 sb.append(u"engineering", -1); 1306 } else { 1307 sb.append(u"scientific", -1); 1308 } 1309 if (impl.fMinExponentDigits > 1) { 1310 sb.append(u'/'); 1311 blueprint_helpers::generateExponentWidthOption(impl.fMinExponentDigits, sb, status); 1312 if (U_FAILURE(status)) { 1313 return false; 1314 } 1315 } 1316 if (impl.fExponentSignDisplay != UNUM_SIGN_AUTO) { 1317 sb.append(u'/'); 1318 enum_to_stem_string::signDisplay(impl.fExponentSignDisplay, sb); 1319 } 1320 return true; 1321 } else { 1322 // Default value is not shown in normalized form 1323 return false; 1324 } 1325 } 1326 1327 bool GeneratorHelpers::unit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1328 if (utils::unitIsCurrency(macros.unit)) { 1329 sb.append(u"currency/", -1); 1330 CurrencyUnit currency(macros.unit, status); 1331 if (U_FAILURE(status)) { 1332 return false; 1333 } 1334 blueprint_helpers::generateCurrencyOption(currency, sb, status); 1335 return true; 1336 } else if (utils::unitIsNoUnit(macros.unit)) { 1337 if (utils::unitIsPercent(macros.unit)) { 1338 sb.append(u"percent", -1); 1339 return true; 1340 } else if (utils::unitIsPermille(macros.unit)) { 1341 sb.append(u"permille", -1); 1342 return true; 1343 } else { 1344 // Default value is not shown in normalized form 1345 return false; 1346 } 1347 } else { 1348 sb.append(u"measure-unit/", -1); 1349 blueprint_helpers::generateMeasureUnitOption(macros.unit, sb, status); 1350 return true; 1351 } 1352 } 1353 1354 bool GeneratorHelpers::perUnit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1355 // Per-units are currently expected to be only MeasureUnits. 1356 if (utils::unitIsNoUnit(macros.perUnit)) { 1357 if (utils::unitIsPercent(macros.perUnit) || utils::unitIsPermille(macros.perUnit)) { 1358 status = U_UNSUPPORTED_ERROR; 1359 return false; 1360 } else { 1361 // Default value: ok to ignore 1362 return false; 1363 } 1364 } else if (utils::unitIsCurrency(macros.perUnit)) { 1365 status = U_UNSUPPORTED_ERROR; 1366 return false; 1367 } else { 1368 sb.append(u"per-measure-unit/", -1); 1369 blueprint_helpers::generateMeasureUnitOption(macros.perUnit, sb, status); 1370 return true; 1371 } 1372 } 1373 1374 bool GeneratorHelpers::precision(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1375 if (macros.precision.fType == Precision::RND_NONE) { 1376 sb.append(u"precision-unlimited", -1); 1377 } else if (macros.precision.fType == Precision::RND_FRACTION) { 1378 const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig; 1379 blueprint_helpers::generateFractionStem(impl.fMinFrac, impl.fMaxFrac, sb, status); 1380 } else if (macros.precision.fType == Precision::RND_SIGNIFICANT) { 1381 const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig; 1382 blueprint_helpers::generateDigitsStem(impl.fMinSig, impl.fMaxSig, sb, status); 1383 } else if (macros.precision.fType == Precision::RND_FRACTION_SIGNIFICANT) { 1384 const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig; 1385 blueprint_helpers::generateFractionStem(impl.fMinFrac, impl.fMaxFrac, sb, status); 1386 sb.append(u'/'); 1387 if (impl.fMinSig == -1) { 1388 blueprint_helpers::generateDigitsStem(1, impl.fMaxSig, sb, status); 1389 } else { 1390 blueprint_helpers::generateDigitsStem(impl.fMinSig, -1, sb, status); 1391 } 1392 } else if (macros.precision.fType == Precision::RND_INCREMENT) { 1393 const Precision::IncrementSettings& impl = macros.precision.fUnion.increment; 1394 sb.append(u"precision-increment/", -1); 1395 blueprint_helpers::generateIncrementOption( 1396 impl.fIncrement, 1397 impl.fMinFrac - impl.fMaxFrac, 1398 sb, 1399 status); 1400 } else if (macros.precision.fType == Precision::RND_CURRENCY) { 1401 UCurrencyUsage usage = macros.precision.fUnion.currencyUsage; 1402 if (usage == UCURR_USAGE_STANDARD) { 1403 sb.append(u"precision-currency-standard", -1); 1404 } else { 1405 sb.append(u"precision-currency-cash", -1); 1406 } 1407 } else { 1408 // Bogus or Error 1409 return false; 1410 } 1411 1412 // NOTE: Always return true for rounding because the default value depends on other options. 1413 return true; 1414 } 1415 1416 bool GeneratorHelpers::roundingMode(const MacroProps& macros, UnicodeString& sb, UErrorCode&) { 1417 if (macros.roundingMode == kDefaultMode) { 1418 return false; // Default 1419 } 1420 enum_to_stem_string::roundingMode(macros.roundingMode, sb); 1421 return true; 1422 } 1423 1424 bool GeneratorHelpers::grouping(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1425 if (macros.grouper.isBogus()) { 1426 return false; // No value 1427 } else if (macros.grouper.fStrategy == UNUM_GROUPING_COUNT) { 1428 status = U_UNSUPPORTED_ERROR; 1429 return false; 1430 } else if (macros.grouper.fStrategy == UNUM_GROUPING_AUTO) { 1431 return false; // Default value 1432 } else { 1433 enum_to_stem_string::groupingStrategy(macros.grouper.fStrategy, sb); 1434 return true; 1435 } 1436 } 1437 1438 bool GeneratorHelpers::integerWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1439 if (macros.integerWidth.fHasError || macros.integerWidth.isBogus() || 1440 macros.integerWidth == IntegerWidth::standard()) { 1441 // Error or Default 1442 return false; 1443 } 1444 sb.append(u"integer-width/", -1); 1445 blueprint_helpers::generateIntegerWidthOption( 1446 macros.integerWidth.fUnion.minMaxInt.fMinInt, 1447 macros.integerWidth.fUnion.minMaxInt.fMaxInt, 1448 sb, 1449 status); 1450 return true; 1451 } 1452 1453 bool GeneratorHelpers::symbols(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1454 if (macros.symbols.isNumberingSystem()) { 1455 const NumberingSystem& ns = *macros.symbols.getNumberingSystem(); 1456 if (uprv_strcmp(ns.getName(), "latn") == 0) { 1457 sb.append(u"latin", -1); 1458 } else { 1459 sb.append(u"numbering-system/", -1); 1460 blueprint_helpers::generateNumberingSystemOption(ns, sb, status); 1461 } 1462 return true; 1463 } else if (macros.symbols.isDecimalFormatSymbols()) { 1464 status = U_UNSUPPORTED_ERROR; 1465 return false; 1466 } else { 1467 // No custom symbols 1468 return false; 1469 } 1470 } 1471 1472 bool GeneratorHelpers::unitWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode&) { 1473 if (macros.unitWidth == UNUM_UNIT_WIDTH_SHORT || macros.unitWidth == UNUM_UNIT_WIDTH_COUNT) { 1474 return false; // Default or Bogus 1475 } 1476 enum_to_stem_string::unitWidth(macros.unitWidth, sb); 1477 return true; 1478 } 1479 1480 bool GeneratorHelpers::sign(const MacroProps& macros, UnicodeString& sb, UErrorCode&) { 1481 if (macros.sign == UNUM_SIGN_AUTO || macros.sign == UNUM_SIGN_COUNT) { 1482 return false; // Default or Bogus 1483 } 1484 enum_to_stem_string::signDisplay(macros.sign, sb); 1485 return true; 1486 } 1487 1488 bool GeneratorHelpers::decimal(const MacroProps& macros, UnicodeString& sb, UErrorCode&) { 1489 if (macros.decimal == UNUM_DECIMAL_SEPARATOR_AUTO || macros.decimal == UNUM_DECIMAL_SEPARATOR_COUNT) { 1490 return false; // Default or Bogus 1491 } 1492 enum_to_stem_string::decimalSeparatorDisplay(macros.decimal, sb); 1493 return true; 1494 } 1495 1496 bool GeneratorHelpers::scale(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) { 1497 if (!macros.scale.isValid()) { 1498 return false; // Default or Bogus 1499 } 1500 sb.append(u"scale/", -1); 1501 blueprint_helpers::generateScaleOption( 1502 macros.scale.fMagnitude, 1503 macros.scale.fArbitrary, 1504 sb, 1505 status); 1506 return true; 1507 } 1508 1509 1510 #endif /* #if !UCONFIG_NO_FORMATTING */ 1511
