[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:
                UPRV_UNREACHABLE;
        }

        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 UNUM_SIGN_FIELD;
        case TYPE_PLUS_SIGN:
            return UNUM_SIGN_FIELD;
        case TYPE_PERCENT:
            return UNUM_PERCENT_FIELD;
        case TYPE_PERMILLE:
            return UNUM_PERMILL_FIELD;
        case TYPE_CURRENCY_SINGLE:
            return UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_DOUBLE:
            return UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_TRIPLE:
            return UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_QUAD:
            return UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_QUINT:
            return UNUM_CURRENCY_FIELD;
        case TYPE_CURRENCY_OVERFLOW:
            return UNUM_CURRENCY_FIELD;
        default:
            UPRV_UNREACHABLE;
    }
}

int32_t
AffixUtils::unescape(const UnicodeString &affixPattern, NumberStringBuilder &output, int32_t position,
                     const SymbolProvider &provider, Field field, 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, field, 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:
                UPRV_UNREACHABLE;
        }
    }
    // 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:
            UPRV_UNREACHABLE;
    }
}

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:
3d1f044b	67	UPRV_UNREACHABLE;
0f5d89e8 A	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:
3d1f044b	134	return UNUM_SIGN_FIELD;
0f5d89e8	135	case TYPE_PLUS_SIGN:
3d1f044b	136	return UNUM_SIGN_FIELD;
0f5d89e8	137	case TYPE_PERCENT:
3d1f044b	138	return UNUM_PERCENT_FIELD;
0f5d89e8	139	case TYPE_PERMILLE:
3d1f044b	140	return UNUM_PERMILL_FIELD;
0f5d89e8	141	case TYPE_CURRENCY_SINGLE:
3d1f044b	142	return UNUM_CURRENCY_FIELD;
0f5d89e8	143	case TYPE_CURRENCY_DOUBLE:
3d1f044b	144	return UNUM_CURRENCY_FIELD;
0f5d89e8	145	case TYPE_CURRENCY_TRIPLE:
3d1f044b	146	return UNUM_CURRENCY_FIELD;
0f5d89e8	147	case TYPE_CURRENCY_QUAD:
3d1f044b	148	return UNUM_CURRENCY_FIELD;
0f5d89e8	149	case TYPE_CURRENCY_QUINT:
3d1f044b	150	return UNUM_CURRENCY_FIELD;
0f5d89e8	151	case TYPE_CURRENCY_OVERFLOW:
3d1f044b	152	return UNUM_CURRENCY_FIELD;
0f5d89e8	153	default:
3d1f044b	154	UPRV_UNREACHABLE;
0f5d89e8 A	155	}
	156	}
	157
	158	int32_t
	159	AffixUtils::unescape(const UnicodeString &affixPattern, NumberStringBuilder &output, int32_t position,
3d1f044b	160	const SymbolProvider &provider, Field field, UErrorCode &status) {
0f5d89e8 A	161	int32_t length = 0;
	162	AffixTag tag;
	163	while (hasNext(tag, affixPattern)) {
	164	tag = nextToken(tag, affixPattern, status);
	165	if (U_FAILURE(status)) { return length; }
	166	if (tag.type == TYPE_CURRENCY_OVERFLOW) {
	167	// Don't go to the provider for this special case
	168	length += output.insertCodePoint(position + length, 0xFFFD, UNUM_CURRENCY_FIELD, status);
	169	} else if (tag.type < 0) {
	170	length += output.insert(
	171	position + length, provider.getSymbol(tag.type), getFieldForType(tag.type), status);
	172	} else {
3d1f044b	173	length += output.insertCodePoint(position + length, tag.codePoint, field, status);
0f5d89e8 A	174	}
	175	}
	176	return length;
	177	}
	178
	179	int32_t AffixUtils::unescapedCodePointCount(const UnicodeString &affixPattern,
	180	const SymbolProvider &provider, UErrorCode &status) {
	181	int32_t length = 0;
	182	AffixTag tag;
	183	while (hasNext(tag, affixPattern)) {
	184	tag = nextToken(tag, affixPattern, status);
	185	if (U_FAILURE(status)) { return length; }
	186	if (tag.type == TYPE_CURRENCY_OVERFLOW) {
	187	length += 1;
	188	} else if (tag.type < 0) {
	189	length += provider.getSymbol(tag.type).length();
	190	} else {
	191	length += U16_LENGTH(tag.codePoint);
	192	}
	193	}
	194	return length;
	195	}
	196
	197	bool
	198	AffixUtils::containsType(const UnicodeString &affixPattern, AffixPatternType type, UErrorCode &status) {
	199	if (affixPattern.length() == 0) {
	200	return false;
	201	}
	202	AffixTag tag;
	203	while (hasNext(tag, affixPattern)) {
	204	tag = nextToken(tag, affixPattern, status);
	205	if (U_FAILURE(status)) { return false; }
	206	if (tag.type == type) {
	207	return true;
	208	}
	209	}
	210	return false;
	211	}
	212
	213	bool AffixUtils::hasCurrencySymbols(const UnicodeString &affixPattern, UErrorCode &status) {
	214	if (affixPattern.length() == 0) {
	215	return false;
	216	}
	217	AffixTag tag;
	218	while (hasNext(tag, affixPattern)) {
	219	tag = nextToken(tag, affixPattern, status);
	220	if (U_FAILURE(status)) { return false; }
	221	if (tag.type < 0 && getFieldForType(tag.type) == UNUM_CURRENCY_FIELD) {
	222	return true;
	223	}
	224	}
	225	return false;
	226	}
	227
	228	UnicodeString AffixUtils::replaceType(const UnicodeString &affixPattern, AffixPatternType type,
	229	char16_t replacementChar, UErrorCode &status) {
	230	UnicodeString output(affixPattern); // copy
	231	if (affixPattern.length() == 0) {
	232	return output;
	233	};
	234	AffixTag tag;
	235	while (hasNext(tag, affixPattern)) {
	236	tag = nextToken(tag, affixPattern, status);
	237	if (U_FAILURE(status)) { return output; }
238	if (tag.type == type) {
239	output.replace(tag.offset - 1, 1, replacementChar);
240	}
241	}
242	return output;
243	}
244
245	bool AffixUtils::containsOnlySymbolsAndIgnorables(const UnicodeString& affixPattern,
246	const UnicodeSet& ignorables, UErrorCode& status) {
247	if (affixPattern.length() == 0) {
248	return true;
249	};
250	AffixTag tag;
251	while (hasNext(tag, affixPattern)) {
252	tag = nextToken(tag, affixPattern, status);
253	if (U_FAILURE(status)) { return false; }
254	if (tag.type == TYPE_CODEPOINT && !ignorables.contains(tag.codePoint)) {
255	return false;
256	}
257	}
258	return true;
259	}
260
261	void AffixUtils::iterateWithConsumer(const UnicodeString& affixPattern, TokenConsumer& consumer,
262	UErrorCode& status) {
263	if (affixPattern.length() == 0) {
264	return;
265	};
266	AffixTag tag;
267	while (hasNext(tag, affixPattern)) {
268	tag = nextToken(tag, affixPattern, status);
269	if (U_FAILURE(status)) { return; }
270	consumer.consumeToken(tag.type, tag.codePoint, status);
271	if (U_FAILURE(status)) { return; }
272	}
273	}
274
275	AffixTag AffixUtils::nextToken(AffixTag tag, const UnicodeString &patternString, UErrorCode &status) {
276	int32_t offset = tag.offset;
277	int32_t state = tag.state;
278	for (; offset < patternString.length();) {
279	UChar32 cp = patternString.char32At(offset);
280	int32_t count = U16_LENGTH(cp);
281
282	switch (state) {
283	case STATE_BASE:
284	switch (cp) {
285	case u'\'':
286	state = STATE_FIRST_QUOTE;
287	offset += count;
288	// continue to the next code point
289	break;
290	case u'-':
291	return makeTag(offset + count, TYPE_MINUS_SIGN, STATE_BASE, 0);
292	case u'+':
293	return makeTag(offset + count, TYPE_PLUS_SIGN, STATE_BASE, 0);
294	case u'%':
295	return makeTag(offset + count, TYPE_PERCENT, STATE_BASE, 0);
296	case u'‰':
297	return makeTag(offset + count, TYPE_PERMILLE, STATE_BASE, 0);
298	case u'¤':
299	state = STATE_FIRST_CURR;
300	offset += count;
301	// continue to the next code point
302	break;
303	default:
304	return makeTag(offset + count, TYPE_CODEPOINT, STATE_BASE, cp);
305	}
306	break;
307	case STATE_FIRST_QUOTE:
308	if (cp == u'\'') {
309	return makeTag(offset + count, TYPE_CODEPOINT, STATE_BASE, cp);
310	} else {
311	return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp);
312	}
313	case STATE_INSIDE_QUOTE:
314	if (cp == u'\'') {
315	state = STATE_AFTER_QUOTE;
316	offset += count;
317	// continue to the next code point
318	break;
319	} else {
320	return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp);
321	}
322	case STATE_AFTER_QUOTE:
323	if (cp == u'\'') {
324	return makeTag(offset + count, TYPE_CODEPOINT, STATE_INSIDE_QUOTE, cp);
325	} else {
326	state = STATE_BASE;
327	// re-evaluate this code point
328	break;
329	}
330	case STATE_FIRST_CURR:
331	if (cp == u'¤') {
332	state = STATE_SECOND_CURR;
333	offset += count;
334	// continue to the next code point
335	break;
336	} else {
337	return makeTag(offset, TYPE_CURRENCY_SINGLE, STATE_BASE, 0);
338	}
339	case STATE_SECOND_CURR:
340	if (cp == u'¤') {
341	state = STATE_THIRD_CURR;
342	offset += count;
343	// continue to the next code point
344	break;
345	} else {
346	return makeTag(offset, TYPE_CURRENCY_DOUBLE, STATE_BASE, 0);
347	}
348	case STATE_THIRD_CURR:
349	if (cp == u'¤') {
350	state = STATE_FOURTH_CURR;
351	offset += count;
352	// continue to the next code point
353	break;
354	} else {
355	return makeTag(offset, TYPE_CURRENCY_TRIPLE, STATE_BASE, 0);
356	}
357	case STATE_FOURTH_CURR:
358	if (cp == u'¤') {
359	state = STATE_FIFTH_CURR;
360	offset += count;
361	// continue to the next code point
362	break;
363	} else {
364	return makeTag(offset, TYPE_CURRENCY_QUAD, STATE_BASE, 0);
365	}
366	case STATE_FIFTH_CURR:
367	if (cp == u'¤') {
368	state = STATE_OVERFLOW_CURR;
369	offset += count;
370	// continue to the next code point
371	break;
372	} else {
373	return makeTag(offset, TYPE_CURRENCY_QUINT, STATE_BASE, 0);
374	}
375	case STATE_OVERFLOW_CURR:
376	if (cp == u'¤') {
377	offset += count;
378	// continue to the next code point and loop back to this state
379	break;
380	} else {
381	return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0);
382	}
383	default:
3d1f044b	384	UPRV_UNREACHABLE;
0f5d89e8 A	385	}
	386	}
	387	// End of string
	388	switch (state) {
	389	case STATE_BASE:
	390	// No more tokens in string.
	391	return {-1};
	392	case STATE_FIRST_QUOTE:
	393	case STATE_INSIDE_QUOTE:
	394	// For consistent behavior with the JDK and ICU 58, set an error here.
	395	status = U_ILLEGAL_ARGUMENT_ERROR;
	396	return {-1};
	397	case STATE_AFTER_QUOTE:
	398	// No more tokens in string.
	399	return {-1};
	400	case STATE_FIRST_CURR:
	401	return makeTag(offset, TYPE_CURRENCY_SINGLE, STATE_BASE, 0);
	402	case STATE_SECOND_CURR:
	403	return makeTag(offset, TYPE_CURRENCY_DOUBLE, STATE_BASE, 0);
	404	case STATE_THIRD_CURR:
	405	return makeTag(offset, TYPE_CURRENCY_TRIPLE, STATE_BASE, 0);
	406	case STATE_FOURTH_CURR:
	407	return makeTag(offset, TYPE_CURRENCY_QUAD, STATE_BASE, 0);
	408	case STATE_FIFTH_CURR:
	409	return makeTag(offset, TYPE_CURRENCY_QUINT, STATE_BASE, 0);
	410	case STATE_OVERFLOW_CURR:
	411	return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0);
	412	default:
3d1f044b	413	UPRV_UNREACHABLE;
0f5d89e8 A	414	}
	415	}
	416
	417	bool AffixUtils::hasNext(const AffixTag &tag, const UnicodeString &string) {
	418	// First check for the {-1} and default initializer syntax.
	419	if (tag.offset < 0) {
	420	return false;
	421	} else if (tag.offset == 0) {
	422	return string.length() > 0;
	423	}
	424	// The rest of the fields are safe to use now.
	425	// Special case: the last character in string is an end quote.
	426	if (tag.state == STATE_INSIDE_QUOTE && tag.offset == string.length() - 1 &&
	427	string.charAt(tag.offset) == u'\'') {
	428	return false;
	429	} else if (tag.state != STATE_BASE) {
	430	return true;
	431	} else {
	432	return tag.offset < string.length();
	433	}
	434	}
	435
	436	#endif /* #if !UCONFIG_NO_FORMATTING */