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 #ifndef __NUMPARSE_TYPES_H__ 8 #define __NUMPARSE_TYPES_H__ 9 10 #include "unicode/uobject.h" 11 #include "number_decimalquantity.h" 12 #include "string_segment.h" 13 14 U_NAMESPACE_BEGIN 15 namespace numparse { 16 namespace impl { 17 18 // Forward-declarations 19 class ParsedNumber; 20 21 typedef int32_t result_flags_t; 22 typedef int32_t parse_flags_t; 23 24 /** Flags for the type result_flags_t */ 25 enum ResultFlags { 26 FLAG_NEGATIVE = 0x0001, 27 FLAG_PERCENT = 0x0002, 28 FLAG_PERMILLE = 0x0004, 29 FLAG_HAS_EXPONENT = 0x0008, 30 // FLAG_HAS_DEFAULT_CURRENCY = 0x0010, // no longer used 31 FLAG_HAS_DECIMAL_SEPARATOR = 0x0020, 32 FLAG_NAN = 0x0040, 33 FLAG_INFINITY = 0x0080, 34 FLAG_FAIL = 0x0100, 35 }; 36 37 /** Flags for the type parse_flags_t */ 38 enum ParseFlags { 39 PARSE_FLAG_IGNORE_CASE = 0x0001, 40 PARSE_FLAG_MONETARY_SEPARATORS = 0x0002, 41 PARSE_FLAG_STRICT_SEPARATORS = 0x0004, 42 PARSE_FLAG_STRICT_GROUPING_SIZE = 0x0008, 43 PARSE_FLAG_INTEGER_ONLY = 0x0010, 44 PARSE_FLAG_GROUPING_DISABLED = 0x0020, 45 // PARSE_FLAG_FRACTION_GROUPING_ENABLED = 0x0040, // see #10794 46 PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES = 0x0080, 47 PARSE_FLAG_USE_FULL_AFFIXES = 0x0100, 48 PARSE_FLAG_EXACT_AFFIX = 0x0200, 49 PARSE_FLAG_PLUS_SIGN_ALLOWED = 0x0400, 50 // PARSE_FLAG_OPTIMIZE = 0x0800, // no longer used 51 // PARSE_FLAG_FORCE_BIG_DECIMAL = 0x1000, // not used in ICU4C 52 PARSE_FLAG_NO_FOREIGN_CURRENCY = 0x2000, 53 PARSE_FLAG_ALLOW_INFINITE_RECURSION = 0x4000, 54 PARSE_FLAG_STRICT_IGNORABLES = 0x8000, 55 }; 56 57 58 // TODO: Is this class worthwhile? 59 template<int32_t stackCapacity> 60 class CompactUnicodeString { 61 public: CompactUnicodeString()62 CompactUnicodeString() { 63 static_assert(stackCapacity > 0, "cannot have zero space on stack"); 64 fBuffer[0] = 0; 65 } 66 CompactUnicodeString(const UnicodeString & text,UErrorCode & status)67 CompactUnicodeString(const UnicodeString& text, UErrorCode& status) 68 : fBuffer(text.length() + 1, status) { 69 if (U_FAILURE(status)) { return; } 70 uprv_memcpy(fBuffer.getAlias(), text.getBuffer(), sizeof(UChar) * text.length()); 71 fBuffer[text.length()] = 0; 72 } 73 toAliasedUnicodeString()74 inline UnicodeString toAliasedUnicodeString() const { 75 return UnicodeString(true, fBuffer.getAlias(), -1); 76 } 77 78 bool operator==(const CompactUnicodeString& other) const { 79 // Use the alias-only constructor and then call UnicodeString operator== 80 return toAliasedUnicodeString() == other.toAliasedUnicodeString(); 81 } 82 83 private: 84 MaybeStackArray<UChar, stackCapacity> fBuffer; 85 }; 86 87 88 /** 89 * Struct-like class to hold the results of a parsing routine. 90 * 91 * @author sffc 92 */ 93 // Exported as U_I18N_API for tests 94 class U_I18N_API ParsedNumber { 95 public: 96 97 /** 98 * The numerical value that was parsed. 99 */ 100 ::icu::number::impl::DecimalQuantity quantity; 101 102 /** 103 * The index of the last char consumed during parsing. If parsing started at index 0, this is equal 104 * to the number of chars consumed. This is NOT necessarily the same as the StringSegment offset; 105 * "weak" chars, like whitespace, change the offset, but the charsConsumed is not touched until a 106 * "strong" char is encountered. 107 */ 108 int32_t charEnd; 109 110 /** 111 * Boolean flags (see constants above). 112 */ 113 result_flags_t flags; 114 115 /** 116 * The pattern string corresponding to the prefix that got consumed. 117 */ 118 UnicodeString prefix; 119 120 /** 121 * The pattern string corresponding to the suffix that got consumed. 122 */ 123 UnicodeString suffix; 124 125 /** 126 * The currency that got consumed. 127 */ 128 UChar currencyCode[4]; 129 130 ParsedNumber(); 131 132 ParsedNumber(const ParsedNumber& other) = default; 133 134 ParsedNumber& operator=(const ParsedNumber& other) = default; 135 136 void clear(); 137 138 /** 139 * Call this method to register that a "strong" char was consumed. This should be done after calling 140 * {@link StringSegment#setOffset} or {@link StringSegment#adjustOffset} except when the char is 141 * "weak", like whitespace. 142 * 143 * <p> 144 * <strong>What is a strong versus weak char?</strong> The behavior of number parsing is to "stop" 145 * after reading the number, even if there is other content following the number. For example, after 146 * parsing the string "123 " (123 followed by a space), the cursor should be set to 3, not 4, even 147 * though there are matchers that accept whitespace. In this example, the digits are strong, whereas 148 * the whitespace is weak. Grouping separators are weak, whereas decimal separators are strong. Most 149 * other chars are strong. 150 * 151 * @param segment 152 * The current StringSegment, usually immediately following a call to setOffset. 153 */ 154 void setCharsConsumed(const StringSegment& segment); 155 156 /** Apply certain number-related flags to the DecimalQuantity. */ 157 void postProcess(); 158 159 /** 160 * Returns whether this the parse was successful. To be successful, at least one char must have been 161 * consumed, and the failure flag must not be set. 162 */ 163 bool success() const; 164 165 bool seenNumber() const; 166 167 double getDouble(UErrorCode& status) const; 168 169 void populateFormattable(Formattable& output, parse_flags_t parseFlags) const; 170 171 bool isBetterThan(const ParsedNumber& other); 172 }; 173 174 175 /** 176 * The core interface implemented by all matchers used for number parsing. 177 * 178 * Given a string, there should NOT be more than one way to consume the string with the same matcher 179 * applied multiple times. If there is, the non-greedy parsing algorithm will be unhappy and may enter an 180 * exponential-time loop. For example, consider the "A Matcher" that accepts "any number of As". Given 181 * the string "AAAA", there are 2^N = 8 ways to apply the A Matcher to this string: you could have the A 182 * Matcher apply 4 times to each character; you could have it apply just once to all the characters; you 183 * could have it apply to the first 2 characters and the second 2 characters; and so on. A better version 184 * of the "A Matcher" would be for it to accept exactly one A, and allow the algorithm to run it 185 * repeatedly to consume a string of multiple As. The A Matcher can implement the Flexible interface 186 * below to signal that it can be applied multiple times in a row. 187 * 188 * @author sffc 189 */ 190 // Exported as U_I18N_API for tests 191 class U_I18N_API NumberParseMatcher { 192 public: 193 virtual ~NumberParseMatcher(); 194 195 /** 196 * Matchers can override this method to return true to indicate that they are optional and can be run 197 * repeatedly. Used by SeriesMatcher, primarily in the context of IgnorablesMatcher. 198 */ isFlexible()199 virtual bool isFlexible() const { 200 return false; 201 } 202 203 /** 204 * Runs this matcher starting at the beginning of the given StringSegment. If this matcher finds 205 * something interesting in the StringSegment, it should update the offset of the StringSegment 206 * corresponding to how many chars were matched. 207 * 208 * This method is thread-safe. 209 * 210 * @param segment 211 * The StringSegment to match against. Matches always start at the beginning of the 212 * segment. The segment is guaranteed to contain at least one char. 213 * @param result 214 * The data structure to store results if the match succeeds. 215 * @return Whether this matcher thinks there may be more interesting chars beyond the end of the 216 * string segment. 217 */ 218 virtual bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const = 0; 219 220 /** 221 * Performs a fast "smoke check" for whether or not this matcher could possibly match against the 222 * given string segment. The test should be as fast as possible but also as restrictive as possible. 223 * For example, matchers can maintain a UnicodeSet of all code points that count possibly start a 224 * match. Matchers should use the {@link StringSegment#startsWith} method in order to correctly 225 * handle case folding. 226 * 227 * @param segment 228 * The segment to check against. 229 * @return true if the matcher might be able to match against this segment; false if it definitely 230 * will not be able to match. 231 */ 232 virtual bool smokeTest(const StringSegment& segment) const = 0; 233 234 /** 235 * Method called at the end of a parse, after all matchers have failed to consume any more chars. 236 * Allows a matcher to make final modifications to the result given the knowledge that no more 237 * matches are possible. 238 * 239 * @param result 240 * The data structure to store results. 241 */ postProcess(ParsedNumber &)242 virtual void postProcess(ParsedNumber&) const { 243 // Default implementation: no-op 244 } 245 246 // String for debugging 247 virtual UnicodeString toString() const = 0; 248 249 protected: 250 // No construction except by subclasses! 251 NumberParseMatcher() = default; 252 }; 253 254 255 /** 256 * Interface for use in arguments. 257 */ 258 // Exported as U_I18N_API for tests 259 class U_I18N_API MutableMatcherCollection { 260 public: 261 virtual ~MutableMatcherCollection() = default; 262 263 virtual void addMatcher(NumberParseMatcher& matcher) = 0; 264 }; 265 266 267 } // namespace impl 268 } // namespace numparse 269 U_NAMESPACE_END 270 271 #endif //__NUMPARSE_TYPES_H__ 272 #endif /* #if !UCONFIG_NO_FORMATTING */ 273