tor-browser

numparse_scientific.cpp (5637B)

---

// © 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_scientific.h"
#include "static_unicode_sets.h"
#include "string_segment.h"

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


namespace {

inline const UnicodeSet& minusSignSet() {
   return *unisets::get(unisets::MINUS_SIGN);
}

inline const UnicodeSet& plusSignSet() {
   return *unisets::get(unisets::PLUS_SIGN);
}

} // namespace


ScientificMatcher::ScientificMatcher(const DecimalFormatSymbols& dfs, const Grouper& grouper)
       : fExponentSeparatorString(dfs.getConstSymbol(DecimalFormatSymbols::kExponentialSymbol)),
         fExponentMatcher(dfs, grouper, PARSE_FLAG_INTEGER_ONLY | PARSE_FLAG_GROUPING_DISABLED),
         fIgnorablesMatcher(PARSE_FLAG_STRICT_IGNORABLES) {

   const UnicodeString& minusSign = dfs.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
   if (minusSignSet().contains(minusSign)) {
       fCustomMinusSign.setToBogus();
   } else {
       fCustomMinusSign = minusSign;
   }

   const UnicodeString& plusSign = dfs.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
   if (plusSignSet().contains(plusSign)) {
       fCustomPlusSign.setToBogus();
   } else {
       fCustomPlusSign = plusSign;
   }
}

bool ScientificMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
   // Only accept scientific notation after the mantissa.
   if (!result.seenNumber()) {
       return false;
   }

   // Only accept one exponent per string.
   if (0 != (result.flags & FLAG_HAS_EXPONENT)) {
       return false;
   }

   // First match the scientific separator, and then match another number after it.
   // NOTE: This is guarded by the smoke test; no need to check fExponentSeparatorString length again.
   int32_t initialOffset = segment.getOffset();
   int32_t overlap = segment.getCommonPrefixLength(fExponentSeparatorString);
   if (overlap == fExponentSeparatorString.length()) {
       // Full exponent separator match.

       // First attempt to get a code point, returning true if we can't get one.
       if (segment.length() == overlap) {
           return true;
       }
       segment.adjustOffset(overlap);

       // Allow ignorables before the sign.
       // Note: call site is guarded by the segment.length() check above.
       // Note: the ignorables matcher should not touch the result.
       fIgnorablesMatcher.match(segment, result, status);
       if (segment.length() == 0) {
           segment.setOffset(initialOffset);
           return true;
       }

       // Allow a sign, and then try to match digits.
       int8_t exponentSign = 1;
       if (segment.startsWith(minusSignSet())) {
           exponentSign = -1;
           segment.adjustOffsetByCodePoint();
       } else if (segment.startsWith(plusSignSet())) {
           segment.adjustOffsetByCodePoint();
       } else if (segment.startsWith(fCustomMinusSign)) {
           overlap = segment.getCommonPrefixLength(fCustomMinusSign);
           if (overlap != fCustomMinusSign.length()) {
               // Partial custom sign match
               segment.setOffset(initialOffset);
               return true;
           }
           exponentSign = -1;
           segment.adjustOffset(overlap);
       } else if (segment.startsWith(fCustomPlusSign)) {
           overlap = segment.getCommonPrefixLength(fCustomPlusSign);
           if (overlap != fCustomPlusSign.length()) {
               // Partial custom sign match
               segment.setOffset(initialOffset);
               return true;
           }
           segment.adjustOffset(overlap);
       }

       // Return true if the segment is empty.
       if (segment.length() == 0) {
           segment.setOffset(initialOffset);
           return true;
       }

       // Allow ignorables after the sign.
       // Note: call site is guarded by the segment.length() check above.
       // Note: the ignorables matcher should not touch the result.
       fIgnorablesMatcher.match(segment, result, status);
       if (segment.length() == 0) {
           segment.setOffset(initialOffset);
           return true;
       }

       // We are supposed to accept E0 after NaN, so we need to make sure result.quantity is available.
       bool wasBogus = result.quantity.bogus;
       result.quantity.bogus = false;
       int digitsOffset = segment.getOffset();
       bool digitsReturnValue = fExponentMatcher.match(segment, result, exponentSign, status);
       result.quantity.bogus = wasBogus;

       if (segment.getOffset() != digitsOffset) {
           // At least one exponent digit was matched.
           result.flags |= FLAG_HAS_EXPONENT;
       } else {
           // No exponent digits were matched
           segment.setOffset(initialOffset);
       }
       return digitsReturnValue;

   } else if (overlap == segment.length()) {
       // Partial exponent separator match
       return true;
   }

   // No match
   return false;
}

bool ScientificMatcher::smokeTest(const StringSegment& segment) const {
   return segment.startsWith(fExponentSeparatorString);
}

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


#endif /* #if !UCONFIG_NO_FORMATTING */