tor-browser

numparse_currency.cpp (7206B)

---

// © 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 "numparse_types.h"
#include "numparse_currency.h"
#include "ucurrimp.h"
#include "unicode/errorcode.h"
#include "numparse_utils.h"
#include "string_segment.h"

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


CombinedCurrencyMatcher::CombinedCurrencyMatcher(const CurrencySymbols& currencySymbols, const DecimalFormatSymbols& dfs,
                                                parse_flags_t parseFlags, UErrorCode& status)
       : fCurrency1(currencySymbols.getCurrencySymbol(status)),
         fCurrency2(currencySymbols.getIntlCurrencySymbol(status)),
         fUseFullCurrencyData(0 == (parseFlags & PARSE_FLAG_NO_FOREIGN_CURRENCY)),
         afterPrefixInsert(dfs.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, false, status)),
         beforeSuffixInsert(dfs.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, true, status)),
         fLocaleName(dfs.getLocale().getName(), -1, status) {
   utils::copyCurrencyCode(fCurrencyCode, currencySymbols.getIsoCode());

   // Pre-load the long names for the current locale and currency
   // if we are parsing without the full currency data.
   if (!fUseFullCurrencyData) {
       for (int32_t i=0; i<StandardPlural::COUNT; i++) {
           auto plural = static_cast<StandardPlural::Form>(i);
           fLocalLongNames[i] = currencySymbols.getPluralName(plural, status);
       }
   }

   // TODO: Figure out how to make this faster and re-enable.
   // Computing the "lead code points" set for fastpathing is too slow to use in production.
   // See https://unicode-org.atlassian.net/browse/ICU-13584
//    // Compute the full set of characters that could be the first in a currency to allow for
//    // efficient smoke test.
//    fLeadCodePoints.add(fCurrency1.char32At(0));
//    fLeadCodePoints.add(fCurrency2.char32At(0));
//    fLeadCodePoints.add(beforeSuffixInsert.char32At(0));
//    uprv_currencyLeads(fLocaleName.data(), fLeadCodePoints, status);
//    // Always apply case mapping closure for currencies
//    fLeadCodePoints.closeOver(USET_ADD_CASE_MAPPINGS);
//    fLeadCodePoints.freeze();
}

bool
CombinedCurrencyMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
   if (result.currencyCode[0] != 0) {
       return false;
   }

   // Try to match a currency spacing separator.
   int32_t initialOffset = segment.getOffset();
   bool maybeMore = false;
   if (result.seenNumber() && !beforeSuffixInsert.isEmpty()) {
       int32_t overlap = segment.getCommonPrefixLength(beforeSuffixInsert);
       if (overlap == beforeSuffixInsert.length()) {
           segment.adjustOffset(overlap);
           // Note: let currency spacing be a weak match. Don't update chars consumed.
       }
       maybeMore = maybeMore || overlap == segment.length();
   }

   // Match the currency string, and reset if we didn't find one.
   maybeMore = maybeMore || matchCurrency(segment, result, status);
   if (result.currencyCode[0] == 0) {
       segment.setOffset(initialOffset);
       return maybeMore;
   }

   // Try to match a currency spacing separator.
   if (!result.seenNumber() && !afterPrefixInsert.isEmpty()) {
       int32_t overlap = segment.getCommonPrefixLength(afterPrefixInsert);
       if (overlap == afterPrefixInsert.length()) {
           segment.adjustOffset(overlap);
           // Note: let currency spacing be a weak match. Don't update chars consumed.
       }
       maybeMore = maybeMore || overlap == segment.length();
   }

   return maybeMore;
}

bool CombinedCurrencyMatcher::matchCurrency(StringSegment& segment, ParsedNumber& result,
                                           UErrorCode& status) const {
   bool maybeMore = false;

   int32_t overlap1;
   if (!fCurrency1.isEmpty()) {
       overlap1 = segment.getCaseSensitivePrefixLength(fCurrency1);
   } else {
       overlap1 = -1;
   }
   maybeMore = maybeMore || overlap1 == segment.length();
   if (overlap1 == fCurrency1.length()) {
       utils::copyCurrencyCode(result.currencyCode, fCurrencyCode);
       segment.adjustOffset(overlap1);
       result.setCharsConsumed(segment);
       return maybeMore;
   }

   int32_t overlap2;
   if (!fCurrency2.isEmpty()) {
       // ISO codes should be accepted case-insensitive.
       // https://unicode-org.atlassian.net/browse/ICU-13696
       overlap2 = segment.getCommonPrefixLength(fCurrency2);
   } else {
       overlap2 = -1;
   }
   maybeMore = maybeMore || overlap2 == segment.length();
   if (overlap2 == fCurrency2.length()) {
       utils::copyCurrencyCode(result.currencyCode, fCurrencyCode);
       segment.adjustOffset(overlap2);
       result.setCharsConsumed(segment);
       return maybeMore;
   }

   if (fUseFullCurrencyData) {
       // Use the full currency data.
       // NOTE: This call site should be improved with #13584.
       const UnicodeString segmentString = segment.toTempUnicodeString();

       // Try to parse the currency
       ParsePosition ppos(0);
       int32_t partialMatchLen = 0;
       uprv_parseCurrency(
               fLocaleName.data(),
               segmentString,
               ppos,
               UCURR_SYMBOL_NAME, // checks for both UCURR_SYMBOL_NAME and UCURR_LONG_NAME
               &partialMatchLen,
               result.currencyCode,
               status);
       maybeMore = maybeMore || partialMatchLen == segment.length();

       if (U_SUCCESS(status) && ppos.getIndex() != 0) {
           // Complete match.
           // NOTE: The currency code should already be saved in the ParsedNumber.
           segment.adjustOffset(ppos.getIndex());
           result.setCharsConsumed(segment);
           return maybeMore;
       }

   } else {
       // Use the locale long names.
       int32_t longestFullMatch = 0;
       for (int32_t i=0; i<StandardPlural::COUNT; i++) {
           const UnicodeString& name = fLocalLongNames[i];
           int32_t overlap = segment.getCommonPrefixLength(name);
           if (overlap == name.length() && name.length() > longestFullMatch) {
               longestFullMatch = name.length();
           }
           maybeMore = maybeMore || overlap > 0;
       }
       if (longestFullMatch > 0) {
           utils::copyCurrencyCode(result.currencyCode, fCurrencyCode);
           segment.adjustOffset(longestFullMatch);
           result.setCharsConsumed(segment);
           return maybeMore;
       }
   }

   // No match found.
   return maybeMore;
}

bool CombinedCurrencyMatcher::smokeTest(const StringSegment&) const {
   // TODO: See constructor
   return true;
   //return segment.startsWith(fLeadCodePoints);
}

UnicodeString CombinedCurrencyMatcher::toString() const {
   return u"<CombinedCurrencyMatcher>";
}


#endif /* #if !UCONFIG_NO_FORMATTING */