1 // 2017 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 #include "number_affixutils.h" 9 #include "unicode/utf16.h" 10 #include "unicode/uniset.h" 11 12 using namespace icu; 13 using namespace icu::number; 14 using namespace icu::number::impl; 15 16 TokenConsumer::~TokenConsumer() = default; 17 SymbolProvider::~SymbolProvider() = default; 18 19 int32_t AffixUtils::estimateLength(const UnicodeString &patternString, UErrorCode &status) { 20 AffixPatternState state = STATE_BASE; 21 int32_t offset = 0; 22 int32_t length = 0; 23 for (; offset < patternString.length();) { 24 UChar32 cp = patternString.char32At(offset); 25 26 switch (state) { 27 case STATE_BASE: 28 if (cp == u'\'') { 29 // First quote 30 state = STATE_FIRST_QUOTE; 31 } else { 32 // Unquoted symbol 33 length++; 34 } 35 break; 36 case STATE_FIRST_QUOTE: 37 if (cp == u'\'') { 38 // Repeated quote 39 length++; 40 state = STATE_BASE; 41 } else { 42 // Quoted code point 43 length++; 44 state = STATE_INSIDE_QUOTE; 45 } 46 break; 47 case STATE_INSIDE_QUOTE: 48 if (cp == u'\'') { 49 // End of quoted sequence 50 state = STATE_AFTER_QUOTE; 51 } else { 52 // Quoted code point 53 length++; 54 } 55 break; 56 case STATE_AFTER_QUOTE: 57 if (cp == u'\'') { 58 // Double quote inside of quoted sequence 59 length++; 60 state = STATE_INSIDE_QUOTE; 61 } else { 62 // Unquoted symbol 63 length++; 64 } 65 break; 66 default: 67 U_ASSERT(false); 68 } 69 70 offset += U16_LENGTH(cp); 71 } 72 73 switch (state) { 74 case STATE_FIRST_QUOTE: 75 case STATE_INSIDE_QUOTE: 76 status = U_ILLEGAL_ARGUMENT_ERROR; 77 break; 78 default: 79 break; 80 } 81 82 return length; 83 } 84 85 UnicodeString AffixUtils::escape(const UnicodeString &input) { 86 AffixPatternState state = STATE_BASE; 87 int32_t offset = 0; 88 UnicodeString output; 89 for (; offset < input.length();) { 90 UChar32 cp = input.char32At(offset); 91 92 switch (cp) { 93 case u'\'': 94 output.append(u"''", -1); 95 break; 96 97 case u'-': 98 case u'+': 99 case u'%': 100 case u'': 101 case u'': 102 if (state == STATE_BASE) { 103 output.append(u'\''); 104 output.append(cp); 105 state = STATE_INSIDE_QUOTE; 106 } else { 107 output.append(cp); 108 } 109 break; 110 111 default: 112 if (state == STATE_INSIDE_QUOTE) { 113 output.append(u'\''); 114 output.append(cp); 115 state = STATE_BASE; 116 } else { 117 output.append(cp); 118 } 119 break; 120 } 121 offset += U16_LENGTH(cp); 122 } 123 124 if (state == STATE_INSIDE_QUOTE) { 125 output.append(u'\''); 126 } 127 128 return output; 129 } 130 131 Field AffixUtils::getFieldForType(AffixPatternType type) { 132 switch (type) { 133 case TYPE_MINUS_SIGN: 134 return Field::UNUM_SIGN_FIELD; 135 case TYPE_PLUS_SIGN: 136 return Field::UNUM_SIGN_FIELD; 137 case TYPE_PERCENT: 138 return Field::UNUM_PERCENT_FIELD; 139 case TYPE_PERMILLE: 140 return Field::UNUM_PERMILL_FIELD; 141 case TYPE_CURRENCY_SINGLE: 142 return Field::UNUM_CURRENCY_FIELD; 143 case TYPE_CURRENCY_DOUBLE: 144 return Field::UNUM_CURRENCY_FIELD; 145 case TYPE_CURRENCY_TRIPLE: 146 return Field::UNUM_CURRENCY_FIELD; 147 case TYPE_CURRENCY_QUAD: 148 return Field::UNUM_CURRENCY_FIELD; 149 case TYPE_CURRENCY_QUINT: 150 return Field::UNUM_CURRENCY_FIELD; 151 case TYPE_CURRENCY_OVERFLOW: 152 return Field::UNUM_CURRENCY_FIELD; 153 default: 154 U_ASSERT(false); 155 return Field::UNUM_FIELD_COUNT; // suppress "control reaches end of non-void function" 156 } 157 } 158 159 int32_t 160 AffixUtils::unescape(const UnicodeString &affixPattern, NumberStringBuilder &output, int32_t position, 161 const SymbolProvider &provider, UErrorCode &status) { 162 int32_t length = 0; 163 AffixTag tag; 164 while (hasNext(tag, affixPattern)) { 165 tag = nextToken(tag, affixPattern, status); 166 if (U_FAILURE(status)) { return length; } 167 if (tag.type == TYPE_CURRENCY_OVERFLOW) { 168 // Don't go to the provider for this special case 169 length += output.insertCodePoint(position + length, 0xFFFD, UNUM_CURRENCY_FIELD, status); 170 } else if (tag.type < 0) { 171 length += output.insert( 172 position + length, provider.getSymbol(tag.type), getFieldForType(tag.type), status); 173 } else { 174 length += output.insertCodePoint(position + length, tag.codePoint, UNUM_FIELD_COUNT, status); 175 } 176 } 177 return length; 178 } 179 180 int32_t AffixUtils::unescapedCodePointCount(const UnicodeString &affixPattern, 181 const SymbolProvider &provider, UErrorCode &status) { 182 int32_t length = 0; 183 AffixTag tag; 184 while (hasNext(tag, affixPattern)) { 185 tag = nextToken(tag, affixPattern, status); 186 if (U_FAILURE(status)) { return length; } 187 if (tag.type == TYPE_CURRENCY_OVERFLOW) { 188 length += 1; 189 } else if (tag.type < 0) { 190 length += provider.getSymbol(tag.type).length(); 191 } else { 192 length += U16_LENGTH(tag.codePoint); 193 } 194 } 195 return length; 196 } 197 198 bool 199 AffixUtils::containsType(const UnicodeString &affixPattern, AffixPatternType type, UErrorCode &status) { 200 if (affixPattern.length() == 0) { 201 return false; 202 } 203 AffixTag tag; 204 while (hasNext(tag, affixPattern)) { 205 tag = nextToken(tag, affixPattern, status); 206 if (U_FAILURE(status)) { return false; } 207 if (tag.type == type) { 208 return true; 209 } 210 } 211 return false; 212 } 213 214 bool AffixUtils::hasCurrencySymbols(const UnicodeString &affixPattern, UErrorCode &status) { 215 if (affixPattern.length() == 0) { 216 return false; 217 } 218 AffixTag tag; 219 while (hasNext(tag, affixPattern)) { 220 tag = nextToken(tag, affixPattern, status); 221 if (U_FAILURE(status)) { return false; } 222 if (tag.type < 0 && getFieldForType(tag.type) == UNUM_CURRENCY_FIELD) { 223 return true; 224 } 225 } 226 return false; 227 } 228 229 UnicodeString AffixUtils::replaceType(const UnicodeString &affixPattern, AffixPatternType type, 230 char16_t replacementChar, UErrorCode &status) { 231 UnicodeString output(affixPattern); // copy 232 if (affixPattern.length() == 0) { 233 return output; 234 }; 235 AffixTag tag; 236 while (hasNext(tag, affixPattern)) { 237 tag = nextToken(tag, affixPattern, status); 238 if (U_FAILURE(status)) { return output; } 239 if (tag.type == type) { 240 output.replace(tag.offset - 1, 1, replacementChar); 241 } 242 } 243 return output; 244 } 245 246 bool AffixUtils::containsOnlySymbolsAndIgnorables(const UnicodeString& affixPattern, 247 const UnicodeSet& ignorables, UErrorCode& status) { 248 if (affixPattern.length() == 0) { 249 return true; 250 }; 251 AffixTag tag; 252 while (hasNext(tag, affixPattern)) { 253 tag = nextToken(tag, affixPattern, status); 254 if (U_FAILURE(status)) { return false; } 255 if (tag.type == TYPE_CODEPOINT && !ignorables.contains(tag.codePoint)) { 256 return false; 257 } 258 } 259 return true; 260 } 261 262 void AffixUtils::iterateWithConsumer(const UnicodeString& affixPattern, TokenConsumer& consumer, 263 UErrorCode& status) { 264 if (affixPattern.length() == 0) { 265 return; 266 }; 267 AffixTag tag; 268 while (hasNext(tag, affixPattern)) { 269 tag = nextToken(tag, affixPattern, status); 270 if (U_FAILURE(status)) { return; } 271 consumer.consumeToken(tag.type, tag.codePoint, status); 272 if (U_FAILURE(status)) { return; } 273 } 274 } 275 276 AffixTag AffixUtils::nextToken(AffixTag tag, const UnicodeString &patternString, UErrorCode &status) { 277 int32_t offset = tag.offset; 278 int32_t state = tag.state; 279 for (; offset < patternString.length();) { 280 UChar32 cp = patternString.char32At(offset); 281 int32_t count = U16_LENGTH(cp); 282 283 switch (state) { 284 case STATE_BASE: 285 switch (cp) { 286 case u'\'': 287 state = STATE_FIRST_QUOTE; 288 offset += count; 289 // continue to the next code point 290 break; 291 case u'-': 292 return makeTag(offset + count, TYPE_MINUS_SIGN, STATE_BASE, 0); 293 case u'+': 294 return makeTag(offset + count, TYPE_PLUS_SIGN, STATE_BASE, 0); 295 case u'%': 296 return makeTag(offset + count, TYPE_PERCENT, STATE_BASE, 0); 297 case u'': 298 return makeTag(offset + count, TYPE_PERMILLE, STATE_BASE, 0); 299 case u'': 300 state = STATE_FIRST_CURR; 301 offset += count; 302 // continue to the next code point 303 break; 304 default: 305 return makeTag(offset + count, TYPE_CODEPOINT, STATE_BASE, cp); 306 } 307 break; 308 case STATE_FIRST_QUOTE: 309 if (cp == u'\'') { 310 return makeTag(offset + count, TYPE_CODEPOINT, STATE_BASE, cp); 311 } else { 312 return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp); 313 } 314 case STATE_INSIDE_QUOTE: 315 if (cp == u'\'') { 316 state = STATE_AFTER_QUOTE; 317 offset += count; 318 // continue to the next code point 319 break; 320 } else { 321 return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp); 322 } 323 case STATE_AFTER_QUOTE: 324 if (cp == u'\'') { 325 return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp); 326 } else { 327 state = STATE_BASE; 328 // re-evaluate this code point 329 break; 330 } 331 case STATE_FIRST_CURR: 332 if (cp == u'') { 333 state = STATE_SECOND_CURR; 334 offset += count; 335 // continue to the next code point 336 break; 337 } else { 338 return makeTag(offset, TYPE_CURRENCY_SINGLE, STATE_BASE, 0); 339 } 340 case STATE_SECOND_CURR: 341 if (cp == u'') { 342 state = STATE_THIRD_CURR; 343 offset += count; 344 // continue to the next code point 345 break; 346 } else { 347 return makeTag(offset, TYPE_CURRENCY_DOUBLE, STATE_BASE, 0); 348 } 349 case STATE_THIRD_CURR: 350 if (cp == u'') { 351 state = STATE_FOURTH_CURR; 352 offset += count; 353 // continue to the next code point 354 break; 355 } else { 356 return makeTag(offset, TYPE_CURRENCY_TRIPLE, STATE_BASE, 0); 357 } 358 case STATE_FOURTH_CURR: 359 if (cp == u'') { 360 state = STATE_FIFTH_CURR; 361 offset += count; 362 // continue to the next code point 363 break; 364 } else { 365 return makeTag(offset, TYPE_CURRENCY_QUAD, STATE_BASE, 0); 366 } 367 case STATE_FIFTH_CURR: 368 if (cp == u'') { 369 state = STATE_OVERFLOW_CURR; 370 offset += count; 371 // continue to the next code point 372 break; 373 } else { 374 return makeTag(offset, TYPE_CURRENCY_QUINT, STATE_BASE, 0); 375 } 376 case STATE_OVERFLOW_CURR: 377 if (cp == u'') { 378 offset += count; 379 // continue to the next code point and loop back to this state 380 break; 381 } else { 382 return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0); 383 } 384 default: 385 U_ASSERT(false); 386 } 387 } 388 // End of string 389 switch (state) { 390 case STATE_BASE: 391 // No more tokens in string. 392 return {-1}; 393 case STATE_FIRST_QUOTE: 394 case STATE_INSIDE_QUOTE: 395 // For consistent behavior with the JDK and ICU 58, set an error here. 396 status = U_ILLEGAL_ARGUMENT_ERROR; 397 return {-1}; 398 case STATE_AFTER_QUOTE: 399 // No more tokens in string. 400 return {-1}; 401 case STATE_FIRST_CURR: 402 return makeTag(offset, TYPE_CURRENCY_SINGLE, STATE_BASE, 0); 403 case STATE_SECOND_CURR: 404 return makeTag(offset, TYPE_CURRENCY_DOUBLE, STATE_BASE, 0); 405 case STATE_THIRD_CURR: 406 return makeTag(offset, TYPE_CURRENCY_TRIPLE, STATE_BASE, 0); 407 case STATE_FOURTH_CURR: 408 return makeTag(offset, TYPE_CURRENCY_QUAD, STATE_BASE, 0); 409 case STATE_FIFTH_CURR: 410 return makeTag(offset, TYPE_CURRENCY_QUINT, STATE_BASE, 0); 411 case STATE_OVERFLOW_CURR: 412 return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0); 413 default: 414 U_ASSERT(false); 415 return {-1}; // suppress "control reaches end of non-void function" 416 } 417 } 418 419 bool AffixUtils::hasNext(const AffixTag &tag, const UnicodeString &string) { 420 // First check for the {-1} and default initializer syntax. 421 if (tag.offset < 0) { 422 return false; 423 } else if (tag.offset == 0) { 424 return string.length() > 0; 425 } 426 // The rest of the fields are safe to use now. 427 // Special case: the last character in string is an end quote. 428 if (tag.state == STATE_INSIDE_QUOTE && tag.offset == string.length() - 1 && 429 string.charAt(tag.offset) == u'\'') { 430 return false; 431 } else if (tag.state != STATE_BASE) { 432 return true; 433 } else { 434 return tag.offset < string.length(); 435 } 436 } 437 438 #endif /* #if !UCONFIG_NO_FORMATTING */ 439
