• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // © 2017 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 __NUMBER_PATTERNSTRING_H__
8 #define __NUMBER_PATTERNSTRING_H__
9 
10 
11 #include <cstdint>
12 #include "unicode/unum.h"
13 #include "unicode/unistr.h"
14 #include "number_types.h"
15 #include "number_decimalquantity.h"
16 #include "number_decimfmtprops.h"
17 #include "number_affixutils.h"
18 
19 U_NAMESPACE_BEGIN namespace number {
20 namespace impl {
21 
22 // Forward declaration
23 class PatternParser;
24 
25 // Exported as U_I18N_API because it is a public member field of exported ParsedSubpatternInfo
26 struct U_I18N_API Endpoints {
27     int32_t start = 0;
28     int32_t end = 0;
29 };
30 
31 // Exported as U_I18N_API because it is a public member field of exported ParsedPatternInfo
32 struct U_I18N_API ParsedSubpatternInfo {
33     uint64_t groupingSizes = 0x0000ffffffff0000L;
34     int32_t integerLeadingHashSigns = 0;
35     int32_t integerTrailingHashSigns = 0;
36     int32_t integerNumerals = 0;
37     int32_t integerAtSigns = 0;
38     int32_t integerTotal = 0; // for convenience
39     int32_t fractionNumerals = 0;
40     int32_t fractionHashSigns = 0;
41     int32_t fractionTotal = 0; // for convenience
42     bool hasDecimal = false;
43     int32_t widthExceptAffixes = 0;
44     // Note: NullableValue causes issues here with std::move.
45     bool hasPadding = false;
46     UNumberFormatPadPosition paddingLocation = UNUM_PAD_BEFORE_PREFIX;
47     DecimalQuantity rounding;
48     bool exponentHasPlusSign = false;
49     int32_t exponentZeros = 0;
50     bool hasPercentSign = false;
51     bool hasPerMilleSign = false;
52     bool hasCurrencySign = false;
53     bool hasMinusSign = false;
54     bool hasPlusSign = false;
55 
56     Endpoints prefixEndpoints;
57     Endpoints suffixEndpoints;
58     Endpoints paddingEndpoints;
59 };
60 
61 // Exported as U_I18N_API because it is needed for the unit test PatternStringTest
62 struct U_I18N_API ParsedPatternInfo : public AffixPatternProvider, public UMemory {
63     UnicodeString pattern;
64     ParsedSubpatternInfo positive;
65     ParsedSubpatternInfo negative;
66 
ParsedPatternInfoParsedPatternInfo67     ParsedPatternInfo()
68             : state(this->pattern), currentSubpattern(nullptr) {}
69 
70     ~ParsedPatternInfo() U_OVERRIDE = default;
71 
72     // Need to declare this explicitly because of the destructor
73     ParsedPatternInfo& operator=(ParsedPatternInfo&& src) U_NOEXCEPT = default;
74 
75     static int32_t getLengthFromEndpoints(const Endpoints& endpoints);
76 
77     char16_t charAt(int32_t flags, int32_t index) const U_OVERRIDE;
78 
79     int32_t length(int32_t flags) const U_OVERRIDE;
80 
81     UnicodeString getString(int32_t flags) const U_OVERRIDE;
82 
83     bool positiveHasPlusSign() const U_OVERRIDE;
84 
85     bool hasNegativeSubpattern() const U_OVERRIDE;
86 
87     bool negativeHasMinusSign() const U_OVERRIDE;
88 
89     bool hasCurrencySign() const U_OVERRIDE;
90 
91     bool containsSymbolType(AffixPatternType type, UErrorCode& status) const U_OVERRIDE;
92 
93     bool hasBody() const U_OVERRIDE;
94 
95   private:
96     struct U_I18N_API ParserState {
97         const UnicodeString& pattern; // reference to the parent
98         int32_t offset = 0;
99 
ParserStateParsedPatternInfo::ParserState100         explicit ParserState(const UnicodeString& _pattern)
101                 : pattern(_pattern) {};
102 
103         ParserState& operator=(ParserState&& src) U_NOEXCEPT {
104             // Leave pattern reference alone; it will continue to point to the same place in memory,
105             // which gets overwritten by ParsedPatternInfo's implicit move assignment.
106             offset = src.offset;
107             return *this;
108         }
109 
110         UChar32 peek();
111 
112         UChar32 next();
113 
114         // TODO: We don't currently do anything with the message string.
115         // This method is here as a shell for Java compatibility.
toParseExceptionParsedPatternInfo::ParserState116         inline void toParseException(const char16_t* message) { (void) message; }
117     } state;
118 
119     // NOTE: In Java, these are written as pure functions.
120     // In C++, they're written as methods.
121     // The behavior is the same.
122 
123     // Mutable transient pointer:
124     ParsedSubpatternInfo* currentSubpattern;
125 
126     // In Java, "negative == null" tells us whether or not we had a negative subpattern.
127     // In C++, we need to remember in another boolean.
128     bool fHasNegativeSubpattern = false;
129 
130     const Endpoints& getEndpoints(int32_t flags) const;
131 
132     /** Run the recursive descent parser. */
133     void consumePattern(const UnicodeString& patternString, UErrorCode& status);
134 
135     void consumeSubpattern(UErrorCode& status);
136 
137     void consumePadding(PadPosition paddingLocation, UErrorCode& status);
138 
139     void consumeAffix(Endpoints& endpoints, UErrorCode& status);
140 
141     void consumeLiteral(UErrorCode& status);
142 
143     void consumeFormat(UErrorCode& status);
144 
145     void consumeIntegerFormat(UErrorCode& status);
146 
147     void consumeFractionFormat(UErrorCode& status);
148 
149     void consumeExponent(UErrorCode& status);
150 
151     friend class PatternParser;
152 };
153 
154 enum IgnoreRounding {
155     IGNORE_ROUNDING_NEVER = 0, IGNORE_ROUNDING_IF_CURRENCY = 1, IGNORE_ROUNDING_ALWAYS = 2
156 };
157 
158 class U_I18N_API PatternParser {
159   public:
160     /**
161      * Runs the recursive descent parser on the given pattern string, returning a data structure with raw information
162      * about the pattern string.
163      *
164      * <p>
165      * To obtain a more useful form of the data, consider using {@link #parseToProperties} instead.
166      *
167      * TODO: Change argument type to const char16_t* instead of UnicodeString?
168      *
169      * @param patternString
170      *            The LDML decimal format pattern (Excel-style pattern) to parse.
171      * @return The results of the parse.
172      */
173     static void parseToPatternInfo(const UnicodeString& patternString, ParsedPatternInfo& patternInfo,
174                                    UErrorCode& status);
175 
176     /**
177      * Parses a pattern string into a new property bag.
178      *
179      * @param pattern
180      *            The pattern string, like "#,##0.00"
181      * @param ignoreRounding
182      *            Whether to leave out rounding information (minFrac, maxFrac, and rounding increment) when parsing the
183      *            pattern. This may be desirable if a custom rounding mode, such as CurrencyUsage, is to be used
184      *            instead.
185      * @return A property bag object.
186      * @throws IllegalArgumentException
187      *             If there is a syntax error in the pattern string.
188      */
189     static DecimalFormatProperties parseToProperties(const UnicodeString& pattern,
190                                                      IgnoreRounding ignoreRounding, UErrorCode& status);
191 
192     static DecimalFormatProperties parseToProperties(const UnicodeString& pattern, UErrorCode& status);
193 
194     /**
195      * Parses a pattern string into an existing property bag. All properties that can be encoded into a pattern string
196      * will be overwritten with either their default value or with the value coming from the pattern string. Properties
197      * that cannot be encoded into a pattern string, such as rounding mode, are not modified.
198      *
199      * @param pattern
200      *            The pattern string, like "#,##0.00"
201      * @param properties
202      *            The property bag object to overwrite.
203      * @param ignoreRounding
204      *            See {@link #parseToProperties(String pattern, int ignoreRounding)}.
205      * @throws IllegalArgumentException
206      *             If there was a syntax error in the pattern string.
207      */
208     static void parseToExistingProperties(const UnicodeString& pattern,
209                                           DecimalFormatProperties& properties,
210                                           IgnoreRounding ignoreRounding, UErrorCode& status);
211 
212   private:
213     static void parseToExistingPropertiesImpl(const UnicodeString& pattern,
214                                               DecimalFormatProperties& properties,
215                                               IgnoreRounding ignoreRounding, UErrorCode& status);
216 
217     /** Finalizes the temporary data stored in the ParsedPatternInfo to the Properties. */
218     static void patternInfoToProperties(DecimalFormatProperties& properties,
219                                         ParsedPatternInfo& patternInfo, IgnoreRounding _ignoreRounding,
220                                         UErrorCode& status);
221 };
222 
223 class U_I18N_API PatternStringUtils {
224   public:
225     /**
226      * Creates a pattern string from a property bag.
227      *
228      * <p>
229      * Since pattern strings support only a subset of the functionality available in a property bag, a new property bag
230      * created from the string returned by this function may not be the same as the original property bag.
231      *
232      * @param properties
233      *            The property bag to serialize.
234      * @return A pattern string approximately serializing the property bag.
235      */
236     static UnicodeString propertiesToPatternString(const DecimalFormatProperties& properties,
237                                                    UErrorCode& status);
238 
239 
240     /**
241      * Converts a pattern between standard notation and localized notation. Localized notation means that instead of
242      * using generic placeholders in the pattern, you use the corresponding locale-specific characters instead. For
243      * example, in locale <em>fr-FR</em>, the period in the pattern "0.000" means "decimal" in standard notation (as it
244      * does in every other locale), but it means "grouping" in localized notation.
245      *
246      * <p>
247      * A greedy string-substitution strategy is used to substitute locale symbols. If two symbols are ambiguous or have
248      * the same prefix, the result is not well-defined.
249      *
250      * <p>
251      * Locale symbols are not allowed to contain the ASCII quote character.
252      *
253      * <p>
254      * This method is provided for backwards compatibility and should not be used in any new code.
255      *
256      * TODO(C++): This method is not yet implemented.
257      *
258      * @param input
259      *            The pattern to convert.
260      * @param symbols
261      *            The symbols corresponding to the localized pattern.
262      * @param toLocalized
263      *            true to convert from standard to localized notation; false to convert from localized to standard
264      *            notation.
265      * @return The pattern expressed in the other notation.
266      */
267     static UnicodeString convertLocalized(const UnicodeString& input, const DecimalFormatSymbols& symbols,
268                                           bool toLocalized, UErrorCode& status);
269 
270     /**
271      * This method contains the heart of the logic for rendering LDML affix strings. It handles
272      * sign-always-shown resolution, whether to use the positive or negative subpattern, permille
273      * substitution, and plural forms for CurrencyPluralInfo.
274      */
275     static void patternInfoToStringBuilder(const AffixPatternProvider& patternInfo, bool isPrefix,
276                                            int8_t signum, UNumberSignDisplay signDisplay,
277                                            StandardPlural::Form plural, bool perMilleReplacesPercent,
278                                            UnicodeString& output);
279 
280   private:
281     /** @return The number of chars inserted. */
282     static int escapePaddingString(UnicodeString input, UnicodeString& output, int startIndex,
283                                    UErrorCode& status);
284 };
285 
286 } // namespace impl
287 } // namespace number
288 U_NAMESPACE_END
289 
290 
291 #endif //__NUMBER_PATTERNSTRING_H__
292 
293 #endif /* #if !UCONFIG_NO_FORMATTING */
294