Restoring authorship annotation for <mcheshkov@yandex-team.ru>. Commit 1 of 2.

1 files changed, 365 insertions, 365 deletions

diff --git a/contrib/libs/icu/i18n/numparse_impl.cpp b/contrib/libs/icu/i18n/numparse_impl.cpp
index 4b76da1c14..cb50a0858d 100644
--- a/contrib/libs/icu/i18n/numparse_impl.cpp
+++ b/contrib/libs/icu/i18n/numparse_impl.cpp
@@ -1,365 +1,365 @@
-// © 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 = {parseFlags};
-    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();
-    AutoAffixPatternProvider affixProvider(properties, status);
-    if (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 (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;
-        parseFlags |= PARSE_FLAG_STRICT_IGNORABLES;
-    } else {
-        parseFlags |= PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES;
-    }
-    if (grouper.getPrimary() <= 0) {
-        parseFlags |= PARSE_FLAG_GROUPING_DISABLED;
-    }
-    if (parseCurrency || affixProvider.get().hasCurrencySign()) {
-        parseFlags |= PARSE_FLAG_MONETARY_SEPARATORS;
-    }
-    if (!parseCurrency) {
-        parseFlags |= PARSE_FLAG_NO_FOREIGN_CURRENCY;
-    }
-
-    LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));
-
-    parser->fLocalMatchers.ignorables = {parseFlags};
-    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.get(), *parser, ignorables, parseFlags, status);
-
-    ////////////////////////
-    /// CURRENCY MATCHER ///
-    ////////////////////////
-
-    if (parseCurrency || affixProvider.get().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.get().containsSymbolType(AffixPatternType::TYPE_PERCENT, status)) {
-        parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
-    }
-    if (!isStrict && affixProvider.get().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.
-    for (int i = 0; i <fNumMatchers;) {
-        // Base Case
-        if (segment.length() == 0) {
-            return;
-        }
-        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) {
-            // 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 */
+// © 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 = {parseFlags}; 
+    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(); 
+    AutoAffixPatternProvider affixProvider(properties, status); 
+    if (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 (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; 
+        parseFlags |= PARSE_FLAG_STRICT_IGNORABLES; 
+    } else { 
+        parseFlags |= PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES; 
+    } 
+    if (grouper.getPrimary() <= 0) { 
+        parseFlags |= PARSE_FLAG_GROUPING_DISABLED; 
+    } 
+    if (parseCurrency || affixProvider.get().hasCurrencySign()) { 
+        parseFlags |= PARSE_FLAG_MONETARY_SEPARATORS; 
+    } 
+    if (!parseCurrency) { 
+        parseFlags |= PARSE_FLAG_NO_FOREIGN_CURRENCY; 
+    } 
+ 
+    LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags)); 
+ 
+    parser->fLocalMatchers.ignorables = {parseFlags}; 
+    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.get(), *parser, ignorables, parseFlags, status); 
+ 
+    //////////////////////// 
+    /// CURRENCY MATCHER /// 
+    //////////////////////// 
+ 
+    if (parseCurrency || affixProvider.get().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.get().containsSymbolType(AffixPatternType::TYPE_PERCENT, status)) { 
+        parser->addMatcher(parser->fLocalMatchers.percent = {symbols}); 
+    } 
+    if (!isStrict && affixProvider.get().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. 
+    for (int i = 0; i <fNumMatchers;) { 
+        // Base Case 
+        if (segment.length() == 0) { 
+            return; 
+        } 
+        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) { 
+            // 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 */