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 "umutex.h"
9#include "ucln_cmn.h"
10#include "ucln_in.h"
11#include "number_modifiers.h"
12
13using namespace icu;
14using namespace icu::number;
15using namespace icu::number::impl;
16
17namespace {
18
19// TODO: This is copied from simpleformatter.cpp
20const int32_t ARG_NUM_LIMIT = 0x100;
21
22// These are the default currency spacing UnicodeSets in CLDR.
23// Pre-compute them for performance.
24// The Java unit test testCurrencySpacingPatternStability() will start failing if these change in CLDR.
25icu::UInitOnce gDefaultCurrencySpacingInitOnce = U_INITONCE_INITIALIZER;
26
27UnicodeSet *UNISET_DIGIT = nullptr;
28UnicodeSet *UNISET_NOTS = nullptr;
29
30UBool U_CALLCONV cleanupDefaultCurrencySpacing() {
31 delete UNISET_DIGIT;
32 UNISET_DIGIT = nullptr;
33 delete UNISET_NOTS;
34 UNISET_NOTS = nullptr;
35 gDefaultCurrencySpacingInitOnce.reset();
36 return TRUE;
37}
38
39void U_CALLCONV initDefaultCurrencySpacing(UErrorCode &status) {
40 ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY_SPACING, cleanupDefaultCurrencySpacing);
41 UNISET_DIGIT = new UnicodeSet(UnicodeString(u"[:digit:]"), status);
42 UNISET_NOTS = new UnicodeSet(UnicodeString(u"[:^S:]"), status);
43 if (UNISET_DIGIT == nullptr || UNISET_NOTS == nullptr) {
44 status = U_MEMORY_ALLOCATION_ERROR;
45 return;
46 }
47 UNISET_DIGIT->freeze();
48 UNISET_NOTS->freeze();
49}
50
51} // namespace
52
53
54Modifier::~Modifier() = default;
55
56Modifier::Parameters::Parameters()
57 : obj(nullptr) {}
58
59Modifier::Parameters::Parameters(
60 const ModifierStore* _obj, Signum _signum, StandardPlural::Form _plural)
61 : obj(_obj), signum(_signum), plural(_plural) {}
62
63ModifierStore::~ModifierStore() = default;
64
65AdoptingModifierStore::~AdoptingModifierStore() {
66 for (const Modifier *mod : mods) {
67 delete mod;
68 }
69}
70
71
72int32_t ConstantAffixModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
73 UErrorCode &status) const {
74 // Insert the suffix first since inserting the prefix will change the rightIndex
75 int length = output.insert(rightIndex, fSuffix, fField, status);
76 length += output.insert(leftIndex, fPrefix, fField, status);
77 return length;
78}
79
80int32_t ConstantAffixModifier::getPrefixLength() const {
81 return fPrefix.length();
82}
83
84int32_t ConstantAffixModifier::getCodePointCount() const {
85 return fPrefix.countChar32() + fSuffix.countChar32();
86}
87
88bool ConstantAffixModifier::isStrong() const {
89 return fStrong;
90}
91
92bool ConstantAffixModifier::containsField(UNumberFormatFields field) const {
93 (void)field;
94 // This method is not currently used.
95 UPRV_UNREACHABLE;
96}
97
98void ConstantAffixModifier::getParameters(Parameters& output) const {
99 (void)output;
100 // This method is not currently used.
101 UPRV_UNREACHABLE;
102}
103
104bool ConstantAffixModifier::semanticallyEquivalent(const Modifier& other) const {
105 auto* _other = dynamic_cast<const ConstantAffixModifier*>(&other);
106 if (_other == nullptr) {
107 return false;
108 }
109 return fPrefix == _other->fPrefix
110 && fSuffix == _other->fSuffix
111 && fField == _other->fField
112 && fStrong == _other->fStrong;
113}
114
115
116SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong)
117 : SimpleModifier(simpleFormatter, field, strong, {}) {}
118
119SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong,
120 const Modifier::Parameters parameters)
121 : fCompiledPattern(simpleFormatter.compiledPattern), fField(field), fStrong(strong),
122 fParameters(parameters) {
123 int32_t argLimit = SimpleFormatter::getArgumentLimit(
124 fCompiledPattern.getBuffer(), fCompiledPattern.length());
125 if (argLimit == 0) {
126 // No arguments in compiled pattern
127 fPrefixLength = fCompiledPattern.charAt(1) - ARG_NUM_LIMIT;
128 U_ASSERT(2 + fPrefixLength == fCompiledPattern.length());
129 // Set suffixOffset = -1 to indicate no arguments in compiled pattern.
130 fSuffixOffset = -1;
131 fSuffixLength = 0;
132 } else {
133 U_ASSERT(argLimit == 1);
134 if (fCompiledPattern.charAt(1) != 0) {
135 // Found prefix
136 fPrefixLength = fCompiledPattern.charAt(1) - ARG_NUM_LIMIT;
137 fSuffixOffset = 3 + fPrefixLength;
138 } else {
139 // No prefix
140 fPrefixLength = 0;
141 fSuffixOffset = 2;
142 }
143 if (3 + fPrefixLength < fCompiledPattern.length()) {
144 // Found suffix
145 fSuffixLength = fCompiledPattern.charAt(fSuffixOffset) - ARG_NUM_LIMIT;
146 } else {
147 // No suffix
148 fSuffixLength = 0;
149 }
150 }
151}
152
153SimpleModifier::SimpleModifier()
154 : fField(UNUM_FIELD_COUNT), fStrong(false), fPrefixLength(0), fSuffixLength(0) {
155}
156
157int32_t SimpleModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
158 UErrorCode &status) const {
159 return formatAsPrefixSuffix(output, leftIndex, rightIndex, status);
160}
161
162int32_t SimpleModifier::getPrefixLength() const {
163 return fPrefixLength;
164}
165
166int32_t SimpleModifier::getCodePointCount() const {
167 int32_t count = 0;
168 if (fPrefixLength > 0) {
169 count += fCompiledPattern.countChar32(2, fPrefixLength);
170 }
171 if (fSuffixLength > 0) {
172 count += fCompiledPattern.countChar32(1 + fSuffixOffset, fSuffixLength);
173 }
174 return count;
175}
176
177bool SimpleModifier::isStrong() const {
178 return fStrong;
179}
180
181bool SimpleModifier::containsField(UNumberFormatFields field) const {
182 (void)field;
183 // This method is not currently used.
184 UPRV_UNREACHABLE;
185}
186
187void SimpleModifier::getParameters(Parameters& output) const {
188 output = fParameters;
189}
190
191bool SimpleModifier::semanticallyEquivalent(const Modifier& other) const {
192 auto* _other = dynamic_cast<const SimpleModifier*>(&other);
193 if (_other == nullptr) {
194 return false;
195 }
196 if (fParameters.obj != nullptr) {
197 return fParameters.obj == _other->fParameters.obj;
198 }
199 return fCompiledPattern == _other->fCompiledPattern
200 && fField == _other->fField
201 && fStrong == _other->fStrong;
202}
203
204
205int32_t
206SimpleModifier::formatAsPrefixSuffix(FormattedStringBuilder &result, int32_t startIndex, int32_t endIndex,
207 UErrorCode &status) const {
208 if (fSuffixOffset == -1 && fPrefixLength + fSuffixLength > 0) {
209 // There is no argument for the inner number; overwrite the entire segment with our string.
210 return result.splice(startIndex, endIndex, fCompiledPattern, 2, 2 + fPrefixLength, fField, status);
211 } else {
212 if (fPrefixLength > 0) {
213 result.insert(startIndex, fCompiledPattern, 2, 2 + fPrefixLength, fField, status);
214 }
215 if (fSuffixLength > 0) {
216 result.insert(
217 endIndex + fPrefixLength,
218 fCompiledPattern,
219 1 + fSuffixOffset,
220 1 + fSuffixOffset + fSuffixLength,
221 fField,
222 status);
223 }
224 return fPrefixLength + fSuffixLength;
225 }
226}
227
228
229int32_t
230SimpleModifier::formatTwoArgPattern(const SimpleFormatter& compiled, FormattedStringBuilder& result,
231 int32_t index, int32_t* outPrefixLength, int32_t* outSuffixLength,
232 Field field, UErrorCode& status) {
233 const UnicodeString& compiledPattern = compiled.compiledPattern;
234 int32_t argLimit = SimpleFormatter::getArgumentLimit(
235 compiledPattern.getBuffer(), compiledPattern.length());
236 if (argLimit != 2) {
237 status = U_INTERNAL_PROGRAM_ERROR;
238 return 0;
239 }
240 int32_t offset = 1; // offset into compiledPattern
241 int32_t length = 0; // chars added to result
242
243 int32_t prefixLength = compiledPattern.charAt(offset);
244 offset++;
245 if (prefixLength < ARG_NUM_LIMIT) {
246 // No prefix
247 prefixLength = 0;
248 } else {
249 prefixLength -= ARG_NUM_LIMIT;
250 result.insert(index + length, compiledPattern, offset, offset + prefixLength, field, status);
251 offset += prefixLength;
252 length += prefixLength;
253 offset++;
254 }
255
256 int32_t infixLength = compiledPattern.charAt(offset);
257 offset++;
258 if (infixLength < ARG_NUM_LIMIT) {
259 // No infix
260 infixLength = 0;
261 } else {
262 infixLength -= ARG_NUM_LIMIT;
263 result.insert(index + length, compiledPattern, offset, offset + infixLength, field, status);
264 offset += infixLength;
265 length += infixLength;
266 offset++;
267 }
268
269 int32_t suffixLength;
270 if (offset == compiledPattern.length()) {
271 // No suffix
272 suffixLength = 0;
273 } else {
274 suffixLength = compiledPattern.charAt(offset) - ARG_NUM_LIMIT;
275 offset++;
276 result.insert(index + length, compiledPattern, offset, offset + suffixLength, field, status);
277 length += suffixLength;
278 }
279
280 *outPrefixLength = prefixLength;
281 *outSuffixLength = suffixLength;
282
283 return length;
284}
285
286
287int32_t ConstantMultiFieldModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
288 UErrorCode &status) const {
289 int32_t length = output.insert(leftIndex, fPrefix, status);
290 if (fOverwrite) {
291 length += output.splice(
292 leftIndex + length,
293 rightIndex + length,
294 UnicodeString(), 0, 0,
295 UNUM_FIELD_COUNT, status);
296 }
297 length += output.insert(rightIndex + length, fSuffix, status);
298 return length;
299}
300
301int32_t ConstantMultiFieldModifier::getPrefixLength() const {
302 return fPrefix.length();
303}
304
305int32_t ConstantMultiFieldModifier::getCodePointCount() const {
306 return fPrefix.codePointCount() + fSuffix.codePointCount();
307}
308
309bool ConstantMultiFieldModifier::isStrong() const {
310 return fStrong;
311}
312
313bool ConstantMultiFieldModifier::containsField(UNumberFormatFields field) const {
314 return fPrefix.containsField(field) || fSuffix.containsField(field);
315}
316
317void ConstantMultiFieldModifier::getParameters(Parameters& output) const {
318 output = fParameters;
319}
320
321bool ConstantMultiFieldModifier::semanticallyEquivalent(const Modifier& other) const {
322 auto* _other = dynamic_cast<const ConstantMultiFieldModifier*>(&other);
323 if (_other == nullptr) {
324 return false;
325 }
326 if (fParameters.obj != nullptr) {
327 return fParameters.obj == _other->fParameters.obj;
328 }
329 return fPrefix.contentEquals(_other->fPrefix)
330 && fSuffix.contentEquals(_other->fSuffix)
331 && fOverwrite == _other->fOverwrite
332 && fStrong == _other->fStrong;
333}
334
335
336CurrencySpacingEnabledModifier::CurrencySpacingEnabledModifier(const FormattedStringBuilder &prefix,
337 const FormattedStringBuilder &suffix,
338 bool overwrite,
339 bool strong,
340 const DecimalFormatSymbols &symbols,
341 UErrorCode &status)
342 : ConstantMultiFieldModifier(prefix, suffix, overwrite, strong) {
343 // Check for currency spacing. Do not build the UnicodeSets unless there is
344 // a currency code point at a boundary.
345 if (prefix.length() > 0 && prefix.fieldAt(prefix.length() - 1) == UNUM_CURRENCY_FIELD) {
346 int prefixCp = prefix.getLastCodePoint();
347 UnicodeSet prefixUnicodeSet = getUnicodeSet(symbols, IN_CURRENCY, PREFIX, status);
348 if (prefixUnicodeSet.contains(prefixCp)) {
349 fAfterPrefixUnicodeSet = getUnicodeSet(symbols, IN_NUMBER, PREFIX, status);
350 fAfterPrefixUnicodeSet.freeze();
351 fAfterPrefixInsert = getInsertString(symbols, PREFIX, status);
352 } else {
353 fAfterPrefixUnicodeSet.setToBogus();
354 fAfterPrefixInsert.setToBogus();
355 }
356 } else {
357 fAfterPrefixUnicodeSet.setToBogus();
358 fAfterPrefixInsert.setToBogus();
359 }
360 if (suffix.length() > 0 && suffix.fieldAt(0) == UNUM_CURRENCY_FIELD) {
361 int suffixCp = suffix.getLastCodePoint();
362 UnicodeSet suffixUnicodeSet = getUnicodeSet(symbols, IN_CURRENCY, SUFFIX, status);
363 if (suffixUnicodeSet.contains(suffixCp)) {
364 fBeforeSuffixUnicodeSet = getUnicodeSet(symbols, IN_NUMBER, SUFFIX, status);
365 fBeforeSuffixUnicodeSet.freeze();
366 fBeforeSuffixInsert = getInsertString(symbols, SUFFIX, status);
367 } else {
368 fBeforeSuffixUnicodeSet.setToBogus();
369 fBeforeSuffixInsert.setToBogus();
370 }
371 } else {
372 fBeforeSuffixUnicodeSet.setToBogus();
373 fBeforeSuffixInsert.setToBogus();
374 }
375}
376
377int32_t CurrencySpacingEnabledModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
378 UErrorCode &status) const {
379 // Currency spacing logic
380 int length = 0;
381 if (rightIndex - leftIndex > 0 && !fAfterPrefixUnicodeSet.isBogus() &&
382 fAfterPrefixUnicodeSet.contains(output.codePointAt(leftIndex))) {
383 // TODO: Should we use the CURRENCY field here?
384 length += output.insert(leftIndex, fAfterPrefixInsert, UNUM_FIELD_COUNT, status);
385 }
386 if (rightIndex - leftIndex > 0 && !fBeforeSuffixUnicodeSet.isBogus() &&
387 fBeforeSuffixUnicodeSet.contains(output.codePointBefore(rightIndex))) {
388 // TODO: Should we use the CURRENCY field here?
389 length += output.insert(rightIndex + length, fBeforeSuffixInsert, UNUM_FIELD_COUNT, status);
390 }
391
392 // Call super for the remaining logic
393 length += ConstantMultiFieldModifier::apply(output, leftIndex, rightIndex + length, status);
394 return length;
395}
396
397int32_t
398CurrencySpacingEnabledModifier::applyCurrencySpacing(FormattedStringBuilder &output, int32_t prefixStart,
399 int32_t prefixLen, int32_t suffixStart,
400 int32_t suffixLen,
401 const DecimalFormatSymbols &symbols,
402 UErrorCode &status) {
403 int length = 0;
404 bool hasPrefix = (prefixLen > 0);
405 bool hasSuffix = (suffixLen > 0);
406 bool hasNumber = (suffixStart - prefixStart - prefixLen > 0); // could be empty string
407 if (hasPrefix && hasNumber) {
408 length += applyCurrencySpacingAffix(output, prefixStart + prefixLen, PREFIX, symbols, status);
409 }
410 if (hasSuffix && hasNumber) {
411 length += applyCurrencySpacingAffix(output, suffixStart + length, SUFFIX, symbols, status);
412 }
413 return length;
414}
415
416int32_t
417CurrencySpacingEnabledModifier::applyCurrencySpacingAffix(FormattedStringBuilder &output, int32_t index,
418 EAffix affix,
419 const DecimalFormatSymbols &symbols,
420 UErrorCode &status) {
421 // NOTE: For prefix, output.fieldAt(index-1) gets the last field type in the prefix.
422 // This works even if the last code point in the prefix is 2 code units because the
423 // field value gets populated to both indices in the field array.
424 Field affixField = (affix == PREFIX) ? output.fieldAt(index - 1) : output.fieldAt(index);
425 if (affixField != UNUM_CURRENCY_FIELD) {
426 return 0;
427 }
428 int affixCp = (affix == PREFIX) ? output.codePointBefore(index) : output.codePointAt(index);
429 UnicodeSet affixUniset = getUnicodeSet(symbols, IN_CURRENCY, affix, status);
430 if (!affixUniset.contains(affixCp)) {
431 return 0;
432 }
433 int numberCp = (affix == PREFIX) ? output.codePointAt(index) : output.codePointBefore(index);
434 UnicodeSet numberUniset = getUnicodeSet(symbols, IN_NUMBER, affix, status);
435 if (!numberUniset.contains(numberCp)) {
436 return 0;
437 }
438 UnicodeString spacingString = getInsertString(symbols, affix, status);
439
440 // NOTE: This next line *inserts* the spacing string, triggering an arraycopy.
441 // It would be more efficient if this could be done before affixes were attached,
442 // so that it could be prepended/appended instead of inserted.
443 // However, the build code path is more efficient, and this is the most natural
444 // place to put currency spacing in the non-build code path.
445 // TODO: Should we use the CURRENCY field here?
446 return output.insert(index, spacingString, UNUM_FIELD_COUNT, status);
447}
448
449UnicodeSet
450CurrencySpacingEnabledModifier::getUnicodeSet(const DecimalFormatSymbols &symbols, EPosition position,
451 EAffix affix, UErrorCode &status) {
452 // Ensure the static defaults are initialized:
453 umtx_initOnce(gDefaultCurrencySpacingInitOnce, &initDefaultCurrencySpacing, status);
454 if (U_FAILURE(status)) {
455 return UnicodeSet();
456 }
457
458 const UnicodeString& pattern = symbols.getPatternForCurrencySpacing(
459 position == IN_CURRENCY ? UNUM_CURRENCY_MATCH : UNUM_CURRENCY_SURROUNDING_MATCH,
460 affix == SUFFIX,
461 status);
462 if (pattern.compare(u"[:digit:]", -1) == 0) {
463 return *UNISET_DIGIT;
464 } else if (pattern.compare(u"[:^S:]", -1) == 0) {
465 return *UNISET_NOTS;
466 } else {
467 return UnicodeSet(pattern, status);
468 }
469}
470
471UnicodeString
472CurrencySpacingEnabledModifier::getInsertString(const DecimalFormatSymbols &symbols, EAffix affix,
473 UErrorCode &status) {
474 return symbols.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, affix == SUFFIX, status);
475}
476
477#endif /* #if !UCONFIG_NO_FORMATTING */
478