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 __SOURCE_NUMBER_SKELETONS_H__ 8 #define __SOURCE_NUMBER_SKELETONS_H__ 9 10 #include "number_types.h" 11 #include "numparse_types.h" 12 #include "unicode/ucharstrie.h" 13 #include "string_segment.h" 14 15 U_NAMESPACE_BEGIN 16 namespace number { 17 namespace impl { 18 19 // Forward-declaration 20 struct SeenMacroProps; 21 22 // namespace for enums and entrypoint functions 23 namespace skeleton { 24 25 /////////////////////////////////////////////////////////////////////////////////////// 26 // NOTE: For an example of how to add a new stem to the number skeleton parser, see: // 27 // http://bugs.icu-project.org/trac/changeset/41193 // 28 /////////////////////////////////////////////////////////////////////////////////////// 29 30 /** 31 * While parsing a skeleton, this enum records what type of option we expect to find next. 32 */ 33 enum ParseState { 34 35 // Section 0: We expect whitespace or a stem, but not an option: 36 37 STATE_NULL, 38 39 // Section 1: We might accept an option, but it is not required: 40 41 STATE_SCIENTIFIC, 42 STATE_FRACTION_PRECISION, 43 44 // Section 2: An option is required: 45 46 STATE_INCREMENT_PRECISION, 47 STATE_MEASURE_UNIT, 48 STATE_PER_MEASURE_UNIT, 49 STATE_CURRENCY_UNIT, 50 STATE_INTEGER_WIDTH, 51 STATE_NUMBERING_SYSTEM, 52 STATE_SCALE, 53 }; 54 55 /** 56 * All possible stem literals have an entry in the StemEnum. The enum name is the kebab case stem 57 * string literal written in upper snake case. 58 * 59 * @see StemToObject 60 * @see #SERIALIZED_STEM_TRIE 61 */ 62 enum StemEnum { 63 64 // Section 1: Stems that do not require an option: 65 66 STEM_COMPACT_SHORT, 67 STEM_COMPACT_LONG, 68 STEM_SCIENTIFIC, 69 STEM_ENGINEERING, 70 STEM_NOTATION_SIMPLE, 71 STEM_BASE_UNIT, 72 STEM_PERCENT, 73 STEM_PERMILLE, 74 STEM_PRECISION_INTEGER, 75 STEM_PRECISION_UNLIMITED, 76 STEM_PRECISION_CURRENCY_STANDARD, 77 STEM_PRECISION_CURRENCY_CASH, 78 STEM_ROUNDING_MODE_CEILING, 79 STEM_ROUNDING_MODE_FLOOR, 80 STEM_ROUNDING_MODE_DOWN, 81 STEM_ROUNDING_MODE_UP, 82 STEM_ROUNDING_MODE_HALF_EVEN, 83 STEM_ROUNDING_MODE_HALF_DOWN, 84 STEM_ROUNDING_MODE_HALF_UP, 85 STEM_ROUNDING_MODE_UNNECESSARY, 86 STEM_GROUP_OFF, 87 STEM_GROUP_MIN2, 88 STEM_GROUP_AUTO, 89 STEM_GROUP_ON_ALIGNED, 90 STEM_GROUP_THOUSANDS, 91 STEM_LATIN, 92 STEM_UNIT_WIDTH_NARROW, 93 STEM_UNIT_WIDTH_SHORT, 94 STEM_UNIT_WIDTH_FULL_NAME, 95 STEM_UNIT_WIDTH_ISO_CODE, 96 STEM_UNIT_WIDTH_HIDDEN, 97 STEM_SIGN_AUTO, 98 STEM_SIGN_ALWAYS, 99 STEM_SIGN_NEVER, 100 STEM_SIGN_ACCOUNTING, 101 STEM_SIGN_ACCOUNTING_ALWAYS, 102 STEM_SIGN_EXCEPT_ZERO, 103 STEM_SIGN_ACCOUNTING_EXCEPT_ZERO, 104 STEM_DECIMAL_AUTO, 105 STEM_DECIMAL_ALWAYS, 106 107 // Section 2: Stems that DO require an option: 108 109 STEM_PRECISION_INCREMENT, 110 STEM_MEASURE_UNIT, 111 STEM_PER_MEASURE_UNIT, 112 STEM_CURRENCY, 113 STEM_INTEGER_WIDTH, 114 STEM_NUMBERING_SYSTEM, 115 STEM_SCALE, 116 }; 117 118 /** 119 * Creates a NumberFormatter corresponding to the given skeleton string. 120 * 121 * @param skeletonString 122 * A number skeleton string, possibly not in its shortest form. 123 * @return An UnlocalizedNumberFormatter with behavior defined by the given skeleton string. 124 */ 125 UnlocalizedNumberFormatter create( 126 const UnicodeString& skeletonString, UParseError* perror, UErrorCode& status); 127 128 /** 129 * Create a skeleton string corresponding to the given NumberFormatter. 130 * 131 * @param macros 132 * The NumberFormatter options object. 133 * @return A skeleton string in normalized form. 134 */ 135 UnicodeString generate(const MacroProps& macros, UErrorCode& status); 136 137 /** 138 * Converts from a skeleton string to a MacroProps. This method contains the primary parse loop. 139 * 140 * Internal: use the create() endpoint instead of this function. 141 */ 142 MacroProps parseSkeleton(const UnicodeString& skeletonString, int32_t& errOffset, UErrorCode& status); 143 144 /** 145 * Given that the current segment represents a stem, parse it and save the result. 146 * 147 * @return The next state after parsing this stem, corresponding to what subset of options to expect. 148 */ 149 ParseState parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, SeenMacroProps& seen, 150 MacroProps& macros, UErrorCode& status); 151 152 /** 153 * Given that the current segment represents an option, parse it and save the result. 154 * 155 * @return The next state after parsing this option, corresponding to what subset of options to 156 * expect next. 157 */ 158 ParseState 159 parseOption(ParseState stem, const StringSegment& segment, MacroProps& macros, UErrorCode& status); 160 161 } // namespace skeleton 162 163 164 /** 165 * Namespace for utility methods that convert from StemEnum to corresponding objects or enums. This 166 * applies to only the "Section 1" stems, those that are well-defined without an option. 167 */ 168 namespace stem_to_object { 169 170 Notation notation(skeleton::StemEnum stem); 171 172 MeasureUnit unit(skeleton::StemEnum stem); 173 174 Precision precision(skeleton::StemEnum stem); 175 176 UNumberFormatRoundingMode roundingMode(skeleton::StemEnum stem); 177 178 UNumberGroupingStrategy groupingStrategy(skeleton::StemEnum stem); 179 180 UNumberUnitWidth unitWidth(skeleton::StemEnum stem); 181 182 UNumberSignDisplay signDisplay(skeleton::StemEnum stem); 183 184 UNumberDecimalSeparatorDisplay decimalSeparatorDisplay(skeleton::StemEnum stem); 185 186 } // namespace stem_to_object 187 188 /** 189 * Namespace for utility methods that convert from enums to stem strings. More complex object conversions 190 * take place in the object_to_stem_string namespace. 191 */ 192 namespace enum_to_stem_string { 193 194 void roundingMode(UNumberFormatRoundingMode value, UnicodeString& sb); 195 196 void groupingStrategy(UNumberGroupingStrategy value, UnicodeString& sb); 197 198 void unitWidth(UNumberUnitWidth value, UnicodeString& sb); 199 200 void signDisplay(UNumberSignDisplay value, UnicodeString& sb); 201 202 void decimalSeparatorDisplay(UNumberDecimalSeparatorDisplay value, UnicodeString& sb); 203 204 } // namespace enum_to_stem_string 205 206 /** 207 * Namespace for utility methods for processing stems and options that cannot be interpreted literally. 208 */ 209 namespace blueprint_helpers { 210 211 /** @return Whether we successfully found and parsed an exponent width option. */ 212 bool parseExponentWidthOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 213 214 void generateExponentWidthOption(int32_t minExponentDigits, UnicodeString& sb, UErrorCode& status); 215 216 /** @return Whether we successfully found and parsed an exponent sign option. */ 217 bool parseExponentSignOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 218 219 void parseCurrencyOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 220 221 void generateCurrencyOption(const CurrencyUnit& currency, UnicodeString& sb, UErrorCode& status); 222 223 void parseMeasureUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 224 225 void generateMeasureUnitOption(const MeasureUnit& measureUnit, UnicodeString& sb, UErrorCode& status); 226 227 void parseMeasurePerUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 228 229 void parseFractionStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 230 231 void generateFractionStem(int32_t minFrac, int32_t maxFrac, UnicodeString& sb, UErrorCode& status); 232 233 void parseDigitsStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 234 235 void generateDigitsStem(int32_t minSig, int32_t maxSig, UnicodeString& sb, UErrorCode& status); 236 237 /** @return Whether we successfully found and parsed a frac-sig option. */ 238 bool parseFracSigOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 239 240 void parseIncrementOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 241 242 void 243 generateIncrementOption(double increment, int32_t trailingZeros, UnicodeString& sb, UErrorCode& status); 244 245 void parseIntegerWidthOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 246 247 void generateIntegerWidthOption(int32_t minInt, int32_t maxInt, UnicodeString& sb, UErrorCode& status); 248 249 void parseNumberingSystemOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 250 251 void generateNumberingSystemOption(const NumberingSystem& ns, UnicodeString& sb, UErrorCode& status); 252 253 void parseScaleOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status); 254 255 void generateScaleOption(int32_t magnitude, const DecNum* arbitrary, UnicodeString& sb, 256 UErrorCode& status); 257 258 } // namespace blueprint_helpers 259 260 /** 261 * Class for utility methods for generating a token corresponding to each macro-prop. Each method 262 * returns whether or not a token was written to the string builder. 263 * 264 * This needs to be a class, not a namespace, so it can be friended. 265 */ 266 class GeneratorHelpers { 267 public: 268 /** 269 * Main skeleton generator function. Appends the normalized skeleton for the MacroProps to the given 270 * StringBuilder. 271 * 272 * Internal: use the create() endpoint instead of this function. 273 */ 274 static void generateSkeleton(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 275 276 private: 277 static bool notation(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 278 279 static bool unit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 280 281 static bool perUnit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 282 283 static bool precision(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 284 285 static bool roundingMode(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 286 287 static bool grouping(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 288 289 static bool integerWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 290 291 static bool symbols(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 292 293 static bool unitWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 294 295 static bool sign(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 296 297 static bool decimal(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 298 299 static bool scale(const MacroProps& macros, UnicodeString& sb, UErrorCode& status); 300 301 }; 302 303 /** 304 * Struct for null-checking. 305 * In Java, we can just check the object reference. In C++, we need a different method. 306 */ 307 struct SeenMacroProps { 308 bool notation = false; 309 bool unit = false; 310 bool perUnit = false; 311 bool precision = false; 312 bool roundingMode = false; 313 bool grouper = false; 314 bool padder = false; 315 bool integerWidth = false; 316 bool symbols = false; 317 bool unitWidth = false; 318 bool sign = false; 319 bool decimal = false; 320 bool scale = false; 321 }; 322 323 } // namespace impl 324 } // namespace number 325 U_NAMESPACE_END 326 327 #endif //__SOURCE_NUMBER_SKELETONS_H__ 328 #endif /* #if !UCONFIG_NO_FORMATTING */ 329