[apple/icu.git] / icuSources / i18n / number_affixutils.cpp

// © 2017 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "number_affixutils.h"
#include "unicode/utf16.h"
#include "unicode/uniset.h"

using namespace icu;
using namespace icu::number;
using namespace icu::number::impl;

TokenConsumer::~TokenConsumer() = default;
SymbolProvider::~SymbolProvider() = default;

int32_t AffixUtils::estimateLength(const UnicodeString &patternString, UErrorCode &status) {
    AffixPatternState state = STATE_BASE;
    int32_t offset = 0;
    int32_t length = 0;
    for (; offset < patternString.length();) {
        UChar32 cp = patternString.char32At(offset);

        switch (state) {
            case STATE_BASE:
                if (cp == u'\'') {
                    // First quote
                    state = STATE_FIRST_QUOTE;
                } else {
                    // Unquoted symbol
                    length++;
                }
                break;
            case STATE_FIRST_QUOTE:
                if (cp == u'\'') {
                    // Repeated quote
                    length++;
                    state = STATE_BASE;
                } else {
                    // Quoted code point
                    length++;
                    state = STATE_INSIDE_QUOTE;
                }
                break;
            case STATE_INSIDE_QUOTE:
                if (cp == u'\'') {
                    // End of quoted sequence
                    state = STATE_AFTER_QUOTE;
                } else {
                    // Quoted code point
                    length++;
                }
                break;
            case STATE_AFTER_QUOTE:
                if (cp == u'\'') {
                    // Double quote inside of quoted sequence
                    length++;
                    state = STATE_INSIDE_QUOTE;
                } else {
                    // Unquoted symbol
                    length++;
                }
                break;
            default:
                U_ASSERT(false);
        }

        offset += U16_LENGTH(cp);
    }

    switch (state) {
        case STATE_FIRST_QUOTE:
        case STATE_INSIDE_QUOTE:
            status = U_ILLEGAL_ARGUMENT_ERROR;
            break;
        default:
            break;
    }

    return length;
}

UnicodeString AffixUtils::escape(const UnicodeString &input) {
    AffixPatternState state = STATE_BASE;
    int32_t offset = 0;
    UnicodeString output;
    for (; offset < input.length();) {
        UChar32 cp = input.char32At(offset);

        switch (cp) {
            case u'\'':
                output.append(u"''", -1);
                break;

            case u'-':
            case u'+':
            case u'%':
            case u'‰':
            case u'¤':
                if (state == STATE_BASE) {
                    output.append(u'\'');
                    output.append(cp);
                    state = STATE_INSIDE_QUOTE;
                } else {
                    output.append(cp);
                }
                break;

            default:
                if (state == STATE_INSIDE_QUOTE) {
                    output.append(u'\'');
                    output.append(cp);
                    state = STATE_BASE;
                } else {
                    output.append(cp);
                }
                break;
        }
        offset += U16_LENGTH(cp);
    }

    if (state == STATE_INSIDE_QUOTE) {
        output.append(u'\'');
    }

    return output;
}

Field AffixUtils::getFieldForType(AffixPatternType type) {
    switch (type) {
        case TYPE_MINUS_SIGN:
            return Field::UNUM_SIGN_FIELD;
        case TYPE_PLUS_SIGN:
            return Field::UNUM_SIGN_FIELD;
        case TYPE_PERCENT:
            return Field::UNUM_PERCENT_FIELD;
        case TYPE_PERMILLE:
            return Field::UNUM_PERMILL_FIELD;
        case TYPE_CURRENCY_SINGLE:
            return Field::UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_DOUBLE:
            return Field::UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_TRIPLE:
            return Field::UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_QUAD:
            return Field::UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_QUINT:
            return Field::UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_OVERFLOW:
            return Field::UNUM_CURRENCY_FIELD;
        default:
            U_ASSERT(false);
            return Field::UNUM_FIELD_COUNT; // suppress "control reaches end of non-void function"
    }
}

int32_t
AffixUtils::unescape(const UnicodeString &affixPattern, NumberStringBuilder &output, int32_t position,
                     const SymbolProvider &provider, UErrorCode &status) {
    int32_t length = 0;
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return length; }
        if (tag.type == TYPE_CURRENCY_OVERFLOW) {
            // Don't go to the provider for this special case
            length += output.insertCodePoint(position + length, 0xFFFD, UNUM_CURRENCY_FIELD, status);
        } else if (tag.type < 0) {
            length += output.insert(
                    position + length, provider.getSymbol(tag.type), getFieldForType(tag.type), status);
        } else {
            length += output.insertCodePoint(position + length, tag.codePoint, UNUM_FIELD_COUNT, status);
        }
    }
    return length;
}

int32_t AffixUtils::unescapedCodePointCount(const UnicodeString &affixPattern,
                                            const SymbolProvider &provider, UErrorCode &status) {
    int32_t length = 0;
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return length; }
        if (tag.type == TYPE_CURRENCY_OVERFLOW) {
            length += 1;
        } else if (tag.type < 0) {
            length += provider.getSymbol(tag.type).length();
        } else {
            length += U16_LENGTH(tag.codePoint);
        }
    }
    return length;
}

bool
AffixUtils::containsType(const UnicodeString &affixPattern, AffixPatternType type, UErrorCode &status) {
    if (affixPattern.length() == 0) {
        return false;
    }
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return false; }
        if (tag.type == type) {
            return true;
        }
    }
    return false;
}

bool AffixUtils::hasCurrencySymbols(const UnicodeString &affixPattern, UErrorCode &status) {
    if (affixPattern.length() == 0) {
        return false;
    }
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return false; }
        if (tag.type < 0 && getFieldForType(tag.type) == UNUM_CURRENCY_FIELD) {
            return true;
        }
    }
    return false;
}

UnicodeString AffixUtils::replaceType(const UnicodeString &affixPattern, AffixPatternType type,
                                      char16_t replacementChar, UErrorCode &status) {
    UnicodeString output(affixPattern); // copy
    if (affixPattern.length() == 0) {
        return output;
    };
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return output; }
        if (tag.type == type) {
            output.replace(tag.offset - 1, 1, replacementChar);
        }
    }
    return output;
}

bool AffixUtils::containsOnlySymbolsAndIgnorables(const UnicodeString& affixPattern,
                                                  const UnicodeSet& ignorables, UErrorCode& status) {
    if (affixPattern.length() == 0) {
        return true;
    };
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return false; }
        if (tag.type == TYPE_CODEPOINT && !ignorables.contains(tag.codePoint)) {
            return false;
        }
    }
    return true;
}

void AffixUtils::iterateWithConsumer(const UnicodeString& affixPattern, TokenConsumer& consumer,
                                     UErrorCode& status) {
    if (affixPattern.length() == 0) {
        return;
    };
    AffixTag tag;
    while (hasNext(tag, affixPattern)) {
        tag = nextToken(tag, affixPattern, status);
        if (U_FAILURE(status)) { return; }
        consumer.consumeToken(tag.type, tag.codePoint, status);
        if (U_FAILURE(status)) { return; }
    }
}

AffixTag AffixUtils::nextToken(AffixTag tag, const UnicodeString &patternString, UErrorCode &status) {
    int32_t offset = tag.offset;
    int32_t state = tag.state;
    for (; offset < patternString.length();) {
        UChar32 cp = patternString.char32At(offset);
        int32_t count = U16_LENGTH(cp);

        switch (state) {
            case STATE_BASE:
                switch (cp) {
                    case u'\'':
                        state = STATE_FIRST_QUOTE;
                        offset += count;
                        // continue to the next code point
                        break;
                    case u'-':
                        return makeTag(offset + count, TYPE_MINUS_SIGN, STATE_BASE, 0);
                    case u'+':
                        return makeTag(offset + count, TYPE_PLUS_SIGN, STATE_BASE, 0);
                    case u'%':
                        return makeTag(offset + count, TYPE_PERCENT, STATE_BASE, 0);
                    case u'‰':
                        return makeTag(offset + count, TYPE_PERMILLE, STATE_BASE, 0);
                    case u'¤':
                        state = STATE_FIRST_CURR;
                        offset += count;
                        // continue to the next code point
                        break;
                    default:
                        return makeTag(offset + count, TYPE_CODEPOINT, STATE_BASE, cp);
                }
                break;
            case STATE_FIRST_QUOTE:
                if (cp == u'\'') {
                    return makeTag(offset + count, TYPE_CODEPOINT, STATE_BASE, cp);
                } else {
                    return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp);
                }
            case STATE_INSIDE_QUOTE:
                if (cp == u'\'') {
                    state = STATE_AFTER_QUOTE;
                    offset += count;
                    // continue to the next code point
                    break;
                } else {
                    return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp);
                }
            case STATE_AFTER_QUOTE:
                if (cp == u'\'') {
                    return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp);
                } else {
                    state = STATE_BASE;
                    // re-evaluate this code point
                    break;
                }
            case STATE_FIRST_CURR:
                if (cp == u'¤') {
                    state = STATE_SECOND_CURR;
                    offset += count;
                    // continue to the next code point
                    break;
                } else {
                    return makeTag(offset, TYPE_CURRENCY_SINGLE, STATE_BASE, 0);
                }
            case STATE_SECOND_CURR:
                if (cp == u'¤') {
                    state = STATE_THIRD_CURR;
                    offset += count;
                    // continue to the next code point
                    break;
                } else {
                    return makeTag(offset, TYPE_CURRENCY_DOUBLE, STATE_BASE, 0);
                }
            case STATE_THIRD_CURR:
                if (cp == u'¤') {
                    state = STATE_FOURTH_CURR;
                    offset += count;
                    // continue to the next code point
                    break;
                } else {
                    return makeTag(offset, TYPE_CURRENCY_TRIPLE, STATE_BASE, 0);
                }
            case STATE_FOURTH_CURR:
                if (cp == u'¤') {
                    state = STATE_FIFTH_CURR;
                    offset += count;
                    // continue to the next code point
                    break;
                } else {
                    return makeTag(offset, TYPE_CURRENCY_QUAD, STATE_BASE, 0);
                }
            case STATE_FIFTH_CURR:
                if (cp == u'¤') {
                    state = STATE_OVERFLOW_CURR;
                    offset += count;
                    // continue to the next code point
                    break;
                } else {
                    return makeTag(offset, TYPE_CURRENCY_QUINT, STATE_BASE, 0);
                }
            case STATE_OVERFLOW_CURR:
                if (cp == u'¤') {
                    offset += count;
                    // continue to the next code point and loop back to this state
                    break;
                } else {
                    return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0);
                }
            default:
                U_ASSERT(false);
        }
    }
    // End of string
    switch (state) {
        case STATE_BASE:
            // No more tokens in string.
            return {-1};
        case STATE_FIRST_QUOTE:
        case STATE_INSIDE_QUOTE:
            // For consistent behavior with the JDK and ICU 58, set an error here.
            status = U_ILLEGAL_ARGUMENT_ERROR;
            return {-1};
        case STATE_AFTER_QUOTE:
            // No more tokens in string.
            return {-1};
        case STATE_FIRST_CURR:
            return makeTag(offset, TYPE_CURRENCY_SINGLE, STATE_BASE, 0);
        case STATE_SECOND_CURR:
            return makeTag(offset, TYPE_CURRENCY_DOUBLE, STATE_BASE, 0);
        case STATE_THIRD_CURR:
            return makeTag(offset, TYPE_CURRENCY_TRIPLE, STATE_BASE, 0);
        case STATE_FOURTH_CURR:
            return makeTag(offset, TYPE_CURRENCY_QUAD, STATE_BASE, 0);
        case STATE_FIFTH_CURR:
            return makeTag(offset, TYPE_CURRENCY_QUINT, STATE_BASE, 0);
        case STATE_OVERFLOW_CURR:
            return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0);
        default:
            U_ASSERT(false);
            return {-1}; // suppress "control reaches end of non-void function"
    }
}

bool AffixUtils::hasNext(const AffixTag &tag, const UnicodeString &string) {
    // First check for the {-1} and default initializer syntax.
    if (tag.offset < 0) {
        return false;
    } else if (tag.offset == 0) {
        return string.length() > 0;
    }
    // The rest of the fields are safe to use now.
    // Special case: the last character in string is an end quote.
    if (tag.state == STATE_INSIDE_QUOTE && tag.offset == string.length() - 1 &&
        string.charAt(tag.offset) == u'\'') {
        return false;
    } else if (tag.state != STATE_BASE) {
        return true;
    } else {
        return tag.offset < string.length();
    }
}

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
0f5d89e8 A	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 */