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

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

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

// Allow implicit conversion from char16_t* to UnicodeString for this file:
// Helpful in toString methods and elsewhere.
#define UNISTR_FROM_STRING_EXPLICIT

#include <typeinfo>
#include <array>
#include "number_types.h"
#include "number_patternstring.h"
#include "numparse_types.h"
#include "numparse_impl.h"
#include "numparse_symbols.h"
#include "numparse_decimal.h"
#include "unicode/numberformatter.h"
#include "cstr.h"
#include "number_mapper.h"
#include "static_unicode_sets.h"

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


NumberParseMatcher::~NumberParseMatcher() = default;


NumberParserImpl*
NumberParserImpl::createSimpleParser(const Locale& locale, const UnicodeString& patternString,
                                     parse_flags_t parseFlags, UErrorCode& status) {

    LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));
    DecimalFormatSymbols symbols(locale, status);

    parser->fLocalMatchers.ignorables = {unisets::DEFAULT_IGNORABLES};
    IgnorablesMatcher& ignorables = parser->fLocalMatchers.ignorables;

    DecimalFormatSymbols dfs(locale, status);
    dfs.setSymbol(DecimalFormatSymbols::kCurrencySymbol, u"IU$");
    dfs.setSymbol(DecimalFormatSymbols::kIntlCurrencySymbol, u"ICU");
    CurrencySymbols currencySymbols({u"ICU", status}, locale, dfs, status);

    ParsedPatternInfo patternInfo;
    PatternParser::parseToPatternInfo(patternString, patternInfo, status);

    // The following statements set up the affix matchers.
    AffixTokenMatcherSetupData affixSetupData = {
            currencySymbols, symbols, ignorables, locale, parseFlags};
    parser->fLocalMatchers.affixTokenMatcherWarehouse = {&affixSetupData};
    parser->fLocalMatchers.affixMatcherWarehouse = {&parser->fLocalMatchers.affixTokenMatcherWarehouse};
    parser->fLocalMatchers.affixMatcherWarehouse.createAffixMatchers(
            patternInfo, *parser, ignorables, parseFlags, status);

    Grouper grouper = Grouper::forStrategy(UNUM_GROUPING_AUTO);
    grouper.setLocaleData(patternInfo, locale);

    parser->addMatcher(parser->fLocalMatchers.ignorables);
    parser->addMatcher(parser->fLocalMatchers.decimal = {symbols, grouper, parseFlags});
    parser->addMatcher(parser->fLocalMatchers.minusSign = {symbols, false});
    parser->addMatcher(parser->fLocalMatchers.plusSign = {symbols, false});
    parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
    parser->addMatcher(parser->fLocalMatchers.permille = {symbols});
    parser->addMatcher(parser->fLocalMatchers.nan = {symbols});
    parser->addMatcher(parser->fLocalMatchers.infinity = {symbols});
    parser->addMatcher(parser->fLocalMatchers.padding = {u"@"});
    parser->addMatcher(parser->fLocalMatchers.scientific = {symbols, grouper});
    parser->addMatcher(parser->fLocalMatchers.currency = {currencySymbols, symbols, parseFlags, status});
    parser->addMatcher(parser->fLocalValidators.number = {});

    parser->freeze();
    return parser.orphan();
}

NumberParserImpl*
NumberParserImpl::createParserFromProperties(const number::impl::DecimalFormatProperties& properties,
                                             const DecimalFormatSymbols& symbols, bool parseCurrency,
                                             UErrorCode& status) {
    Locale locale = symbols.getLocale();
    PropertiesAffixPatternProvider localPAPP;
    CurrencyPluralInfoAffixProvider localCPIAP;
    AffixPatternProvider* affixProvider;
    if (properties.currencyPluralInfo.fPtr.isNull()) {
        localPAPP.setTo(properties, status);
        affixProvider = &localPAPP;
    } else {
        localCPIAP.setTo(*properties.currencyPluralInfo.fPtr, properties, status);
        affixProvider = &localCPIAP;
    }
    if (affixProvider == nullptr || U_FAILURE(status)) { return nullptr; }
    CurrencyUnit currency = resolveCurrency(properties, locale, status);
    CurrencySymbols currencySymbols(currency, locale, symbols, status);
    bool isStrict = properties.parseMode.getOrDefault(PARSE_MODE_STRICT) == PARSE_MODE_STRICT;
    Grouper grouper = Grouper::forProperties(properties);
    int parseFlags = 0;
    if (affixProvider == nullptr || U_FAILURE(status)) { return nullptr; }
    if (!properties.parseCaseSensitive) {
        parseFlags |= PARSE_FLAG_IGNORE_CASE;
    }
    if (properties.parseIntegerOnly) {
        parseFlags |= PARSE_FLAG_INTEGER_ONLY;
    }
    if (properties.signAlwaysShown) {
        parseFlags |= PARSE_FLAG_PLUS_SIGN_ALLOWED;
    }
    if (isStrict) {
        parseFlags |= PARSE_FLAG_STRICT_GROUPING_SIZE;
        parseFlags |= PARSE_FLAG_STRICT_SEPARATORS;
        parseFlags |= PARSE_FLAG_USE_FULL_AFFIXES;
        parseFlags |= PARSE_FLAG_EXACT_AFFIX;
    } else {
        parseFlags |= PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES;
    }
    if (grouper.getPrimary() <= 0) {
        parseFlags |= PARSE_FLAG_GROUPING_DISABLED;
    }
    if (parseCurrency || affixProvider->hasCurrencySign()) {
        parseFlags |= PARSE_FLAG_MONETARY_SEPARATORS;
        // Apple <rdar://problem/51938595> check for curr symbol in suffix; use affix API instead?
        if (properties.positiveSuffixPattern.indexOf(u'¤') >= 0) {
            parseFlags |= PARSE_FLAG_HAS_TRAIL_CURRENCY;
        }
    }
    if (!parseCurrency) {
        parseFlags |= PARSE_FLAG_NO_FOREIGN_CURRENCY;
    }

    LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));

    parser->fLocalMatchers.ignorables = {
            isStrict ? unisets::STRICT_IGNORABLES : unisets::DEFAULT_IGNORABLES};
    IgnorablesMatcher& ignorables = parser->fLocalMatchers.ignorables;

    //////////////////////
    /// AFFIX MATCHERS ///
    //////////////////////

    // The following statements set up the affix matchers.
    AffixTokenMatcherSetupData affixSetupData = {
            currencySymbols, symbols, ignorables, locale, parseFlags};
    parser->fLocalMatchers.affixTokenMatcherWarehouse = {&affixSetupData};
    parser->fLocalMatchers.affixMatcherWarehouse = {&parser->fLocalMatchers.affixTokenMatcherWarehouse};
    parser->fLocalMatchers.affixMatcherWarehouse.createAffixMatchers(
            *affixProvider, *parser, ignorables, parseFlags, status);

    ////////////////////////
    /// CURRENCY MATCHER ///
    ////////////////////////

    if (parseCurrency || affixProvider->hasCurrencySign()) {
        parser->addMatcher(parser->fLocalMatchers.currency = {currencySymbols, symbols, parseFlags, status});
    }

    ///////////////
    /// PERCENT ///
    ///////////////

    // ICU-TC meeting, April 11, 2018: accept percent/permille only if it is in the pattern,
    // and to maintain regressive behavior, divide by 100 even if no percent sign is present.
    if (!isStrict && affixProvider->containsSymbolType(AffixPatternType::TYPE_PERCENT, status)) {
        parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
    }
    if (!isStrict && affixProvider->containsSymbolType(AffixPatternType::TYPE_PERMILLE, status)) {
        parser->addMatcher(parser->fLocalMatchers.permille = {symbols});
    }

    ///////////////////////////////
    /// OTHER STANDARD MATCHERS ///
    ///////////////////////////////

    if (!isStrict) {
        parser->addMatcher(parser->fLocalMatchers.plusSign = {symbols, false});
        parser->addMatcher(parser->fLocalMatchers.minusSign = {symbols, false});
    }
    parser->addMatcher(parser->fLocalMatchers.nan = {symbols});
    parser->addMatcher(parser->fLocalMatchers.infinity = {symbols});
    UnicodeString padString = properties.padString;
    if (!padString.isBogus() && !ignorables.getSet()->contains(padString)) {
        parser->addMatcher(parser->fLocalMatchers.padding = {padString});
    }
    parser->addMatcher(parser->fLocalMatchers.ignorables);
    parser->addMatcher(parser->fLocalMatchers.decimal = {symbols, grouper, parseFlags});
    // NOTE: parseNoExponent doesn't disable scientific parsing if we have a scientific formatter
    if (!properties.parseNoExponent || properties.minimumExponentDigits > 0) {
        parser->addMatcher(parser->fLocalMatchers.scientific = {symbols, grouper});
    }

    //////////////////
    /// VALIDATORS ///
    //////////////////

    parser->addMatcher(parser->fLocalValidators.number = {});
    if (isStrict) {
        parser->addMatcher(parser->fLocalValidators.affix = {});
    }
    if (parseCurrency) {
        parser->addMatcher(parser->fLocalValidators.currency = {});
    }
    if (properties.decimalPatternMatchRequired) {
        bool patternHasDecimalSeparator =
                properties.decimalSeparatorAlwaysShown || properties.maximumFractionDigits != 0;
        parser->addMatcher(parser->fLocalValidators.decimalSeparator = {patternHasDecimalSeparator});
    }
    // The multiplier takes care of scaling percentages.
    Scale multiplier = scaleFromProperties(properties);
    if (multiplier.isValid()) {
        parser->addMatcher(parser->fLocalValidators.multiplier = {multiplier});
    }

    parser->freeze();
    return parser.orphan();
}

NumberParserImpl::NumberParserImpl(parse_flags_t parseFlags)
        : fParseFlags(parseFlags) {
}

NumberParserImpl::~NumberParserImpl() {
    fNumMatchers = 0;
}

void NumberParserImpl::addMatcher(NumberParseMatcher& matcher) {
    if (fNumMatchers + 1 > fMatchers.getCapacity()) {
        fMatchers.resize(fNumMatchers * 2, fNumMatchers);
    }
    fMatchers[fNumMatchers] = &matcher;
    fNumMatchers++;
}

void NumberParserImpl::freeze() {
    fFrozen = true;
}

parse_flags_t NumberParserImpl::getParseFlags() const {
    return fParseFlags;
}

void NumberParserImpl::parse(const UnicodeString& input, bool greedy, ParsedNumber& result,
                             UErrorCode& status) const {
    return parse(input, 0, greedy, result, status);
}

void NumberParserImpl::parse(const UnicodeString& input, int32_t start, bool greedy, ParsedNumber& result,
                             UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return;
    }
    U_ASSERT(fFrozen);
    // TODO: Check start >= 0 and start < input.length()
    StringSegment segment(input, 0 != (fParseFlags & PARSE_FLAG_IGNORE_CASE));
    segment.adjustOffset(start);
    if (greedy) {
        parseGreedy(segment, result, status);
    } else if (0 != (fParseFlags & PARSE_FLAG_ALLOW_INFINITE_RECURSION)) {
        // Start at 1 so that recursionLevels never gets to 0
        parseLongestRecursive(segment, result, 1, status);
    } else {
        // Arbitrary recursion safety limit: 100 levels.
        parseLongestRecursive(segment, result, -100, status);
    }
    for (int32_t i = 0; i < fNumMatchers; i++) {
        fMatchers[i]->postProcess(result);
    }
    result.postProcess();
}

void NumberParserImpl::parseGreedy(StringSegment& segment, ParsedNumber& result,
                                            UErrorCode& status) const {
    // Note: this method is not recursive in order to avoid stack overflow.
    bool extraLoop = FALSE;
    for (int i = 0; i <fNumMatchers;) {
        // Base Case
        if (segment.length() == 0) {
            if ((extraLoop && i==0) || (fParseFlags & PARSE_FLAG_HAS_TRAIL_CURRENCY) == 0 || result.currencyCode[0] != 0) { // Apple <rdar://problem/51938595>
                return;
            }
            // If we are parsing for currency expected at the end but have not found it yet,
            // allow one more loop to see if we are matching an empty currency symbol
            if (extraLoop) {
                extraLoop = TRUE; // Apple <rdar://problem/51938595>
            }
        }
        const NumberParseMatcher* matcher = fMatchers[i];
        if (!matcher->smokeTest(segment)) {
            // Matcher failed smoke test: try the next one
            i++;
            continue;
        }
        int32_t initialOffset = segment.getOffset();
        matcher->match(segment, result, status);
        if (U_FAILURE(status)) {
            return;
        }
        if (segment.getOffset() != initialOffset ||
                (extraLoop && result.currencyCode[0] != 0)) { // Apple <rdar://problem/51938595>
            // Greedy heuristic: accept the match and loop back
            i = 0;
            continue;
        } else {
            // Matcher did not match: try the next one
            i++;
            continue;
        }
        UPRV_UNREACHABLE;
    }

    // NOTE: If we get here, the greedy parse completed without consuming the entire string.
}

void NumberParserImpl::parseLongestRecursive(StringSegment& segment, ParsedNumber& result,
                                             int32_t recursionLevels,
                                             UErrorCode& status) const {
    // Base Case
    if (segment.length() == 0) {
        return;
    }

    // Safety against stack overflow
    if (recursionLevels == 0) {
        return;
    }

    // TODO: Give a nice way for the matcher to reset the ParsedNumber?
    ParsedNumber initial(result);
    ParsedNumber candidate;

    int initialOffset = segment.getOffset();
    for (int32_t i = 0; i < fNumMatchers; i++) {
        const NumberParseMatcher* matcher = fMatchers[i];
        if (!matcher->smokeTest(segment)) {
            continue;
        }

        // In a non-greedy parse, we attempt all possible matches and pick the best.
        for (int32_t charsToConsume = 0; charsToConsume < segment.length();) {
            charsToConsume += U16_LENGTH(segment.codePointAt(charsToConsume));

            // Run the matcher on a segment of the current length.
            candidate = initial;
            segment.setLength(charsToConsume);
            bool maybeMore = matcher->match(segment, candidate, status);
            segment.resetLength();
            if (U_FAILURE(status)) {
                return;
            }

            // If the entire segment was consumed, recurse.
            if (segment.getOffset() - initialOffset == charsToConsume) {
                parseLongestRecursive(segment, candidate, recursionLevels + 1, status);
                if (U_FAILURE(status)) {
                    return;
                }
                if (candidate.isBetterThan(result)) {
                    result = candidate;
                }
            }

            // Since the segment can be re-used, reset the offset.
            // This does not have an effect if the matcher did not consume any chars.
            segment.setOffset(initialOffset);

            // Unless the matcher wants to see the next char, continue to the next matcher.
            if (!maybeMore) {
                break;
            }
        }
    }
}

UnicodeString NumberParserImpl::toString() const {
    UnicodeString result(u"<NumberParserImpl matchers:[");
    for (int32_t i = 0; i < fNumMatchers; i++) {
        result.append(u' ');
        result.append(fMatchers[i]->toString());
    }
    result.append(u" ]>", -1);
    return result;
}


#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
0f5d89e8 A	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 <typeinfo>
	13	#include <array>
	14	#include "number_types.h"
	15	#include "number_patternstring.h"
	16	#include "numparse_types.h"
	17	#include "numparse_impl.h"
	18	#include "numparse_symbols.h"
	19	#include "numparse_decimal.h"
	20	#include "unicode/numberformatter.h"
	21	#include "cstr.h"
	22	#include "number_mapper.h"
	23	#include "static_unicode_sets.h"
	24
	25	using namespace icu;
	26	using namespace icu::number;
	27	using namespace icu::number::impl;
	28	using namespace icu::numparse;
	29	using namespace icu::numparse::impl;
	30
	31
	32	NumberParseMatcher::~NumberParseMatcher() = default;
	33
	34
	35	NumberParserImpl*
	36	NumberParserImpl::createSimpleParser(const Locale& locale, const UnicodeString& patternString,
	37	parse_flags_t parseFlags, UErrorCode& status) {
	38
	39	LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));
	40	DecimalFormatSymbols symbols(locale, status);
	41
	42	parser->fLocalMatchers.ignorables = {unisets::DEFAULT_IGNORABLES};
	43	IgnorablesMatcher& ignorables = parser->fLocalMatchers.ignorables;
	44
	45	DecimalFormatSymbols dfs(locale, status);
	46	dfs.setSymbol(DecimalFormatSymbols::kCurrencySymbol, u"IU$");
	47	dfs.setSymbol(DecimalFormatSymbols::kIntlCurrencySymbol, u"ICU");
	48	CurrencySymbols currencySymbols({u"ICU", status}, locale, dfs, status);
	49
	50	ParsedPatternInfo patternInfo;
	51	PatternParser::parseToPatternInfo(patternString, patternInfo, status);
	52
	53	// The following statements set up the affix matchers.
	54	AffixTokenMatcherSetupData affixSetupData = {
	55	currencySymbols, symbols, ignorables, locale, parseFlags};
	56	parser->fLocalMatchers.affixTokenMatcherWarehouse = {&affixSetupData};
	57	parser->fLocalMatchers.affixMatcherWarehouse = {&parser->fLocalMatchers.affixTokenMatcherWarehouse};
	58	parser->fLocalMatchers.affixMatcherWarehouse.createAffixMatchers(
	59	patternInfo, *parser, ignorables, parseFlags, status);
	60
	61	Grouper grouper = Grouper::forStrategy(UNUM_GROUPING_AUTO);
	62	grouper.setLocaleData(patternInfo, locale);
	63
	64	parser->addMatcher(parser->fLocalMatchers.ignorables);
65	parser->addMatcher(parser->fLocalMatchers.decimal = {symbols, grouper, parseFlags});
66	parser->addMatcher(parser->fLocalMatchers.minusSign = {symbols, false});
67	parser->addMatcher(parser->fLocalMatchers.plusSign = {symbols, false});
68	parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
69	parser->addMatcher(parser->fLocalMatchers.permille = {symbols});
70	parser->addMatcher(parser->fLocalMatchers.nan = {symbols});
71	parser->addMatcher(parser->fLocalMatchers.infinity = {symbols});
72	parser->addMatcher(parser->fLocalMatchers.padding = {u"@"});
73	parser->addMatcher(parser->fLocalMatchers.scientific = {symbols, grouper});
74	parser->addMatcher(parser->fLocalMatchers.currency = {currencySymbols, symbols, parseFlags, status});
3d1f044b	75	parser->addMatcher(parser->fLocalValidators.number = {});
0f5d89e8 A	76
	77	parser->freeze();
	78	return parser.orphan();
	79	}
	80
	81	NumberParserImpl*
	82	NumberParserImpl::createParserFromProperties(const number::impl::DecimalFormatProperties& properties,
	83	const DecimalFormatSymbols& symbols, bool parseCurrency,
	84	UErrorCode& status) {
	85	Locale locale = symbols.getLocale();
	86	PropertiesAffixPatternProvider localPAPP;
	87	CurrencyPluralInfoAffixProvider localCPIAP;
	88	AffixPatternProvider* affixProvider;
	89	if (properties.currencyPluralInfo.fPtr.isNull()) {
	90	localPAPP.setTo(properties, status);
	91	affixProvider = &localPAPP;
	92	} else {
	93	localCPIAP.setTo(*properties.currencyPluralInfo.fPtr, properties, status);
	94	affixProvider = &localCPIAP;
	95	}
	96	if (affixProvider == nullptr \|\| U_FAILURE(status)) { return nullptr; }
	97	CurrencyUnit currency = resolveCurrency(properties, locale, status);
	98	CurrencySymbols currencySymbols(currency, locale, symbols, status);
	99	bool isStrict = properties.parseMode.getOrDefault(PARSE_MODE_STRICT) == PARSE_MODE_STRICT;
	100	Grouper grouper = Grouper::forProperties(properties);
	101	int parseFlags = 0;
	102	if (affixProvider == nullptr \|\| U_FAILURE(status)) { return nullptr; }
	103	if (!properties.parseCaseSensitive) {
	104	parseFlags \|= PARSE_FLAG_IGNORE_CASE;
	105	}
	106	if (properties.parseIntegerOnly) {
	107	parseFlags \|= PARSE_FLAG_INTEGER_ONLY;
	108	}
	109	if (properties.signAlwaysShown) {
	110	parseFlags \|= PARSE_FLAG_PLUS_SIGN_ALLOWED;
	111	}
	112	if (isStrict) {
	113	parseFlags \|= PARSE_FLAG_STRICT_GROUPING_SIZE;
	114	parseFlags \|= PARSE_FLAG_STRICT_SEPARATORS;
	115	parseFlags \|= PARSE_FLAG_USE_FULL_AFFIXES;
	116	parseFlags \|= PARSE_FLAG_EXACT_AFFIX;
	117	} else {
	118	parseFlags \|= PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES;
	119	}
	120	if (grouper.getPrimary() <= 0) {
	121	parseFlags \|= PARSE_FLAG_GROUPING_DISABLED;
	122	}
	123	if (parseCurrency \|\| affixProvider->hasCurrencySign()) {
	124	parseFlags \|= PARSE_FLAG_MONETARY_SEPARATORS;
c5116b9f A	125	// Apple <rdar://problem/51938595> check for curr symbol in suffix; use affix API instead?
	126	if (properties.positiveSuffixPattern.indexOf(u'¤') >= 0) {
	127	parseFlags \|= PARSE_FLAG_HAS_TRAIL_CURRENCY;
	128	}
0f5d89e8 A	129	}
	130	if (!parseCurrency) {
	131	parseFlags \|= PARSE_FLAG_NO_FOREIGN_CURRENCY;
	132	}
	133
	134	LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));
	135
	136	parser->fLocalMatchers.ignorables = {
	137	isStrict ? unisets::STRICT_IGNORABLES : unisets::DEFAULT_IGNORABLES};
	138	IgnorablesMatcher& ignorables = parser->fLocalMatchers.ignorables;
	139
	140	//////////////////////
	141	/// AFFIX MATCHERS ///
	142	//////////////////////
	143
	144	// The following statements set up the affix matchers.
	145	AffixTokenMatcherSetupData affixSetupData = {
	146	currencySymbols, symbols, ignorables, locale, parseFlags};
	147	parser->fLocalMatchers.affixTokenMatcherWarehouse = {&affixSetupData};
	148	parser->fLocalMatchers.affixMatcherWarehouse = {&parser->fLocalMatchers.affixTokenMatcherWarehouse};
	149	parser->fLocalMatchers.affixMatcherWarehouse.createAffixMatchers(
	150	affixProvider, parser, ignorables, parseFlags, status);
	151
	152	////////////////////////
	153	/// CURRENCY MATCHER ///
	154	////////////////////////
	155
	156	if (parseCurrency \|\| affixProvider->hasCurrencySign()) {
	157	parser->addMatcher(parser->fLocalMatchers.currency = {currencySymbols, symbols, parseFlags, status});
	158	}
	159
	160	///////////////
	161	/// PERCENT ///
	162	///////////////
	163
	164	// ICU-TC meeting, April 11, 2018: accept percent/permille only if it is in the pattern,
	165	// and to maintain regressive behavior, divide by 100 even if no percent sign is present.
3d1f044b	166	if (!isStrict && affixProvider->containsSymbolType(AffixPatternType::TYPE_PERCENT, status)) {
0f5d89e8 A	167	parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
0f5d89e8 A	168	}
3d1f044b	169	if (!isStrict && affixProvider->containsSymbolType(AffixPatternType::TYPE_PERMILLE, status)) {
0f5d89e8 A	170	parser->addMatcher(parser->fLocalMatchers.permille = {symbols});
	171	}
	172
	173	///////////////////////////////
	174	/// OTHER STANDARD MATCHERS ///
	175	///////////////////////////////
	176
	177	if (!isStrict) {
	178	parser->addMatcher(parser->fLocalMatchers.plusSign = {symbols, false});
	179	parser->addMatcher(parser->fLocalMatchers.minusSign = {symbols, false});
	180	}
	181	parser->addMatcher(parser->fLocalMatchers.nan = {symbols});
	182	parser->addMatcher(parser->fLocalMatchers.infinity = {symbols});
	183	UnicodeString padString = properties.padString;
	184	if (!padString.isBogus() && !ignorables.getSet()->contains(padString)) {
	185	parser->addMatcher(parser->fLocalMatchers.padding = {padString});
	186	}
	187	parser->addMatcher(parser->fLocalMatchers.ignorables);
	188	parser->addMatcher(parser->fLocalMatchers.decimal = {symbols, grouper, parseFlags});
	189	// NOTE: parseNoExponent doesn't disable scientific parsing if we have a scientific formatter
	190	if (!properties.parseNoExponent \|\| properties.minimumExponentDigits > 0) {
	191	parser->addMatcher(parser->fLocalMatchers.scientific = {symbols, grouper});
	192	}
	193
	194	//////////////////
	195	/// VALIDATORS ///
	196	//////////////////
	197
	198	parser->addMatcher(parser->fLocalValidators.number = {});
	199	if (isStrict) {
	200	parser->addMatcher(parser->fLocalValidators.affix = {});
	201	}
	202	if (parseCurrency) {
	203	parser->addMatcher(parser->fLocalValidators.currency = {});
	204	}
	205	if (properties.decimalPatternMatchRequired) {
	206	bool patternHasDecimalSeparator =
	207	properties.decimalSeparatorAlwaysShown \|\| properties.maximumFractionDigits != 0;
	208	parser->addMatcher(parser->fLocalValidators.decimalSeparator = {patternHasDecimalSeparator});
	209	}
	210	// The multiplier takes care of scaling percentages.
	211	Scale multiplier = scaleFromProperties(properties);
	212	if (multiplier.isValid()) {
	213	parser->addMatcher(parser->fLocalValidators.multiplier = {multiplier});
	214	}
	215
	216	parser->freeze();
	217	return parser.orphan();
	218	}
	219
	220	NumberParserImpl::NumberParserImpl(parse_flags_t parseFlags)
	221	: fParseFlags(parseFlags) {
	222	}
	223
	224	NumberParserImpl::~NumberParserImpl() {
	225	fNumMatchers = 0;
	226	}
	227
	228	void NumberParserImpl::addMatcher(NumberParseMatcher& matcher) {
	229	if (fNumMatchers + 1 > fMatchers.getCapacity()) {
	230	fMatchers.resize(fNumMatchers * 2, fNumMatchers);
	231	}
	232	fMatchers[fNumMatchers] = &matcher;
	233	fNumMatchers++;
234	}
235
236	void NumberParserImpl::freeze() {
237	fFrozen = true;
238	}
239
240	parse_flags_t NumberParserImpl::getParseFlags() const {
241	return fParseFlags;
242	}
243
244	void NumberParserImpl::parse(const UnicodeString& input, bool greedy, ParsedNumber& result,
245	UErrorCode& status) const {
246	return parse(input, 0, greedy, result, status);
247	}
248
249	void NumberParserImpl::parse(const UnicodeString& input, int32_t start, bool greedy, ParsedNumber& result,
250	UErrorCode& status) const {
251	if (U_FAILURE(status)) {
252	return;
253	}
254	U_ASSERT(fFrozen);
255	// TODO: Check start >= 0 and start < input.length()
256	StringSegment segment(input, 0 != (fParseFlags & PARSE_FLAG_IGNORE_CASE));
257	segment.adjustOffset(start);
258	if (greedy) {
3d1f044b A	259	parseGreedy(segment, result, status);
	260	} else if (0 != (fParseFlags & PARSE_FLAG_ALLOW_INFINITE_RECURSION)) {
	261	// Start at 1 so that recursionLevels never gets to 0
	262	parseLongestRecursive(segment, result, 1, status);
0f5d89e8	263	} else {
3d1f044b A	264	// Arbitrary recursion safety limit: 100 levels.
3d1f044b A	265	parseLongestRecursive(segment, result, -100, status);
0f5d89e8 A	266	}
	267	for (int32_t i = 0; i < fNumMatchers; i++) {
	268	fMatchers[i]->postProcess(result);
	269	}
	270	result.postProcess();
	271	}
	272
3d1f044b	273	void NumberParserImpl::parseGreedy(StringSegment& segment, ParsedNumber& result,
0f5d89e8	274	UErrorCode& status) const {
3d1f044b	275	// Note: this method is not recursive in order to avoid stack overflow.
c5116b9f	276	bool extraLoop = FALSE;
3d1f044b A	277	for (int i = 0; i <fNumMatchers;) {
	278	// Base Case
	279	if (segment.length() == 0) {
c5116b9f A	280	if ((extraLoop && i==0) \|\| (fParseFlags & PARSE_FLAG_HAS_TRAIL_CURRENCY) == 0 \|\| result.currencyCode[0] != 0) { // Apple <rdar://problem/51938595>
	281	return;
	282	}
	283	// If we are parsing for currency expected at the end but have not found it yet,
	284	// allow one more loop to see if we are matching an empty currency symbol
	285	if (extraLoop) {
	286	extraLoop = TRUE; // Apple <rdar://problem/51938595>
	287	}
3d1f044b	288	}
0f5d89e8 A	289	const NumberParseMatcher* matcher = fMatchers[i];
0f5d89e8 A	290	if (!matcher->smokeTest(segment)) {
3d1f044b A	291	// Matcher failed smoke test: try the next one
3d1f044b A	292	i++;
0f5d89e8 A	293	continue;
0f5d89e8 A	294	}
3d1f044b	295	int32_t initialOffset = segment.getOffset();
0f5d89e8 A	296	matcher->match(segment, result, status);
	297	if (U_FAILURE(status)) {
	298	return;
	299	}
c5116b9f A	300	if (segment.getOffset() != initialOffset \|\|
c5116b9f A	301	(extraLoop && result.currencyCode[0] != 0)) { // Apple <rdar://problem/51938595>
3d1f044b A	302	// Greedy heuristic: accept the match and loop back
	303	i = 0;
	304	continue;
	305	} else {
	306	// Matcher did not match: try the next one
	307	i++;
	308	continue;
0f5d89e8	309	}
3d1f044b	310	UPRV_UNREACHABLE;
0f5d89e8 A	311	}
	312
	313	// NOTE: If we get here, the greedy parse completed without consuming the entire string.
	314	}
	315
	316	void NumberParserImpl::parseLongestRecursive(StringSegment& segment, ParsedNumber& result,
3d1f044b	317	int32_t recursionLevels,
0f5d89e8 A	318	UErrorCode& status) const {
	319	// Base Case
	320	if (segment.length() == 0) {
	321	return;
	322	}
	323
3d1f044b A	324	// Safety against stack overflow
	325	if (recursionLevels == 0) {
	326	return;
	327	}
	328
0f5d89e8 A	329	// TODO: Give a nice way for the matcher to reset the ParsedNumber?
	330	ParsedNumber initial(result);
	331	ParsedNumber candidate;
	332
	333	int initialOffset = segment.getOffset();
	334	for (int32_t i = 0; i < fNumMatchers; i++) {
	335	const NumberParseMatcher* matcher = fMatchers[i];
	336	if (!matcher->smokeTest(segment)) {
	337	continue;
	338	}
	339
	340	// In a non-greedy parse, we attempt all possible matches and pick the best.
	341	for (int32_t charsToConsume = 0; charsToConsume < segment.length();) {
	342	charsToConsume += U16_LENGTH(segment.codePointAt(charsToConsume));
	343
	344	// Run the matcher on a segment of the current length.
	345	candidate = initial;
	346	segment.setLength(charsToConsume);
	347	bool maybeMore = matcher->match(segment, candidate, status);
	348	segment.resetLength();
	349	if (U_FAILURE(status)) {
	350	return;
	351	}
	352
	353	// If the entire segment was consumed, recurse.
	354	if (segment.getOffset() - initialOffset == charsToConsume) {
3d1f044b	355	parseLongestRecursive(segment, candidate, recursionLevels + 1, status);
0f5d89e8 A	356	if (U_FAILURE(status)) {
	357	return;
	358	}
	359	if (candidate.isBetterThan(result)) {
	360	result = candidate;
	361	}
	362	}
	363
	364	// Since the segment can be re-used, reset the offset.
	365	// This does not have an effect if the matcher did not consume any chars.
	366	segment.setOffset(initialOffset);
	367
	368	// Unless the matcher wants to see the next char, continue to the next matcher.
	369	if (!maybeMore) {
	370	break;
	371	}
	372	}
	373	}
	374	}
	375
	376	UnicodeString NumberParserImpl::toString() const {
	377	UnicodeString result(u"<NumberParserImpl matchers:[");
	378	for (int32_t i = 0; i < fNumMatchers; i++) {
	379	result.append(u' ');
	380	result.append(fMatchers[i]->toString());
	381	}
	382	result.append(u" ]>", -1);
	383	return result;
	384	}
	385
	386
	387	#endif /* #if !UCONFIG_NO_FORMATTING */