1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ******************************************************************************
5 * Copyright (C) 2014-2016, International Business Machines
6 * Corporation and others.  All Rights Reserved.
7 ******************************************************************************
8 * simpleformatter.cpp
9 */
10 
11 #include "unicode/utypes.h"
12 #include "unicode/simpleformatter.h"
13 #include "unicode/unistr.h"
14 #include "uassert.h"
15 
16 U_NAMESPACE_BEGIN
17 
18 namespace {
19 
20 /**
21  * Argument numbers must be smaller than this limit.
22  * Text segment lengths are offset by this much.
23  * This is currently the only unused char value in compiled patterns,
24  * except it is the maximum value of the first unit (max arg +1).
25  */
26 const int32_t ARG_NUM_LIMIT = 0x100;
27 /**
28  * Initial and maximum char/UChar value set for a text segment.
29  * Segment length char values are from ARG_NUM_LIMIT+1 to this value here.
30  * Normally 0xffff, but can be as small as ARG_NUM_LIMIT+1 for testing.
31  */
32 const UChar SEGMENT_LENGTH_PLACEHOLDER_CHAR = 0xffff;
33 /**
34  * Maximum length of a text segment. Longer segments are split into shorter ones.
35  */
36 const int32_t MAX_SEGMENT_LENGTH = SEGMENT_LENGTH_PLACEHOLDER_CHAR - ARG_NUM_LIMIT;
37 
38 enum {
39     APOS = 0x27,
40     DIGIT_ZERO = 0x30,
41     DIGIT_ONE = 0x31,
42     DIGIT_NINE = 0x39,
43     OPEN_BRACE = 0x7b,
44     CLOSE_BRACE = 0x7d
45 };
46 
isInvalidArray(const void * array,int32_t length)47 inline UBool isInvalidArray(const void *array, int32_t length) {
48    return (length < 0 || (array == NULL && length != 0));
49 }
50 
51 }  // namespace
52 
operator =(const SimpleFormatter & other)53 SimpleFormatter &SimpleFormatter::operator=(const SimpleFormatter& other) {
54     if (this == &other) {
55         return *this;
56     }
57     compiledPattern = other.compiledPattern;
58     return *this;
59 }
60 
~SimpleFormatter()61 SimpleFormatter::~SimpleFormatter() {}
62 
applyPatternMinMaxArguments(const UnicodeString & pattern,int32_t min,int32_t max,UErrorCode & errorCode)63 UBool SimpleFormatter::applyPatternMinMaxArguments(
64         const UnicodeString &pattern,
65         int32_t min, int32_t max,
66         UErrorCode &errorCode) {
67     if (U_FAILURE(errorCode)) {
68         return FALSE;
69     }
70     // Parse consistent with MessagePattern, but
71     // - support only simple numbered arguments
72     // - build a simple binary structure into the result string
73     const UChar *patternBuffer = pattern.getBuffer();
74     int32_t patternLength = pattern.length();
75     // Reserve the first char for the number of arguments.
76     compiledPattern.setTo((UChar)0);
77     int32_t textLength = 0;
78     int32_t maxArg = -1;
79     UBool inQuote = FALSE;
80     for (int32_t i = 0; i < patternLength;) {
81         UChar c = patternBuffer[i++];
82         if (c == APOS) {
83             if (i < patternLength && (c = patternBuffer[i]) == APOS) {
84                 // double apostrophe, skip the second one
85                 ++i;
86             } else if (inQuote) {
87                 // skip the quote-ending apostrophe
88                 inQuote = FALSE;
89                 continue;
90             } else if (c == OPEN_BRACE || c == CLOSE_BRACE) {
91                 // Skip the quote-starting apostrophe, find the end of the quoted literal text.
92                 ++i;
93                 inQuote = TRUE;
94             } else {
95                 // The apostrophe is part of literal text.
96                 c = APOS;
97             }
98         } else if (!inQuote && c == OPEN_BRACE) {
99             if (textLength > 0) {
100                 compiledPattern.setCharAt(compiledPattern.length() - textLength - 1,
101                                           (UChar)(ARG_NUM_LIMIT + textLength));
102                 textLength = 0;
103             }
104             int32_t argNumber;
105             if ((i + 1) < patternLength &&
106                     0 <= (argNumber = patternBuffer[i] - DIGIT_ZERO) && argNumber <= 9 &&
107                     patternBuffer[i + 1] == CLOSE_BRACE) {
108                 i += 2;
109             } else {
110                 // Multi-digit argument number (no leading zero) or syntax error.
111                 // MessagePattern permits PatternProps.skipWhiteSpace(pattern, index)
112                 // around the number, but this class does not.
113                 argNumber = -1;
114                 if (i < patternLength && DIGIT_ONE <= (c = patternBuffer[i++]) && c <= DIGIT_NINE) {
115                     argNumber = c - DIGIT_ZERO;
116                     while (i < patternLength &&
117                             DIGIT_ZERO <= (c = patternBuffer[i++]) && c <= DIGIT_NINE) {
118                         argNumber = argNumber * 10 + (c - DIGIT_ZERO);
119                         if (argNumber >= ARG_NUM_LIMIT) {
120                             break;
121                         }
122                     }
123                 }
124                 if (argNumber < 0 || c != CLOSE_BRACE) {
125                     errorCode = U_ILLEGAL_ARGUMENT_ERROR;
126                     return FALSE;
127                 }
128             }
129             if (argNumber > maxArg) {
130                 maxArg = argNumber;
131             }
132             compiledPattern.append((UChar)argNumber);
133             continue;
134         }  // else: c is part of literal text
135         // Append c and track the literal-text segment length.
136         if (textLength == 0) {
137             // Reserve a char for the length of a new text segment, preset the maximum length.
138             compiledPattern.append(SEGMENT_LENGTH_PLACEHOLDER_CHAR);
139         }
140         compiledPattern.append(c);
141         if (++textLength == MAX_SEGMENT_LENGTH) {
142             textLength = 0;
143         }
144     }
145     if (textLength > 0) {
146         compiledPattern.setCharAt(compiledPattern.length() - textLength - 1,
147                                   (UChar)(ARG_NUM_LIMIT + textLength));
148     }
149     int32_t argCount = maxArg + 1;
150     if (argCount < min || max < argCount) {
151         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
152         return FALSE;
153     }
154     compiledPattern.setCharAt(0, (UChar)argCount);
155     return TRUE;
156 }
157 
format(const UnicodeString & value0,UnicodeString & appendTo,UErrorCode & errorCode) const158 UnicodeString& SimpleFormatter::format(
159         const UnicodeString &value0,
160         UnicodeString &appendTo, UErrorCode &errorCode) const {
161     const UnicodeString *values[] = { &value0 };
162     return formatAndAppend(values, 1, appendTo, NULL, 0, errorCode);
163 }
164 
format(const UnicodeString & value0,const UnicodeString & value1,UnicodeString & appendTo,UErrorCode & errorCode) const165 UnicodeString& SimpleFormatter::format(
166         const UnicodeString &value0,
167         const UnicodeString &value1,
168         UnicodeString &appendTo, UErrorCode &errorCode) const {
169     const UnicodeString *values[] = { &value0, &value1 };
170     return formatAndAppend(values, 2, appendTo, NULL, 0, errorCode);
171 }
172 
format(const UnicodeString & value0,const UnicodeString & value1,const UnicodeString & value2,UnicodeString & appendTo,UErrorCode & errorCode) const173 UnicodeString& SimpleFormatter::format(
174         const UnicodeString &value0,
175         const UnicodeString &value1,
176         const UnicodeString &value2,
177         UnicodeString &appendTo, UErrorCode &errorCode) const {
178     const UnicodeString *values[] = { &value0, &value1, &value2 };
179     return formatAndAppend(values, 3, appendTo, NULL, 0, errorCode);
180 }
181 
formatAndAppend(const UnicodeString * const * values,int32_t valuesLength,UnicodeString & appendTo,int32_t * offsets,int32_t offsetsLength,UErrorCode & errorCode) const182 UnicodeString& SimpleFormatter::formatAndAppend(
183         const UnicodeString *const *values, int32_t valuesLength,
184         UnicodeString &appendTo,
185         int32_t *offsets, int32_t offsetsLength, UErrorCode &errorCode) const {
186     if (U_FAILURE(errorCode)) {
187         return appendTo;
188     }
189     if (isInvalidArray(values, valuesLength) || isInvalidArray(offsets, offsetsLength) ||
190             valuesLength < getArgumentLimit()) {
191         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
192         return appendTo;
193     }
194     return format(compiledPattern.getBuffer(), compiledPattern.length(), values,
195                   appendTo, NULL, TRUE,
196                   offsets, offsetsLength, errorCode);
197 }
198 
formatAndReplace(const UnicodeString * const * values,int32_t valuesLength,UnicodeString & result,int32_t * offsets,int32_t offsetsLength,UErrorCode & errorCode) const199 UnicodeString &SimpleFormatter::formatAndReplace(
200         const UnicodeString *const *values, int32_t valuesLength,
201         UnicodeString &result,
202         int32_t *offsets, int32_t offsetsLength, UErrorCode &errorCode) const {
203     if (U_FAILURE(errorCode)) {
204         return result;
205     }
206     if (isInvalidArray(values, valuesLength) || isInvalidArray(offsets, offsetsLength)) {
207         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
208         return result;
209     }
210     const UChar *cp = compiledPattern.getBuffer();
211     int32_t cpLength = compiledPattern.length();
212     if (valuesLength < getArgumentLimit(cp, cpLength)) {
213         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
214         return result;
215     }
216 
217     // If the pattern starts with an argument whose value is the same object
218     // as the result, then we keep the result contents and append to it.
219     // Otherwise we replace its contents.
220     int32_t firstArg = -1;
221     // If any non-initial argument value is the same object as the result,
222     // then we first copy its contents and use that instead while formatting.
223     UnicodeString resultCopy;
224     if (getArgumentLimit(cp, cpLength) > 0) {
225         for (int32_t i = 1; i < cpLength;) {
226             int32_t n = cp[i++];
227             if (n < ARG_NUM_LIMIT) {
228                 if (values[n] == &result) {
229                     if (i == 2) {
230                         firstArg = n;
231                     } else if (resultCopy.isEmpty() && !result.isEmpty()) {
232                         resultCopy = result;
233                     }
234                 }
235             } else {
236                 i += n - ARG_NUM_LIMIT;
237             }
238         }
239     }
240     if (firstArg < 0) {
241         result.remove();
242     }
243     return format(cp, cpLength, values,
244                   result, &resultCopy, FALSE,
245                   offsets, offsetsLength, errorCode);
246 }
247 
getTextWithNoArguments(const UChar * compiledPattern,int32_t compiledPatternLength)248 UnicodeString SimpleFormatter::getTextWithNoArguments(
249         const UChar *compiledPattern, int32_t compiledPatternLength) {
250     int32_t capacity = compiledPatternLength - 1 -
251             getArgumentLimit(compiledPattern, compiledPatternLength);
252     UnicodeString sb(capacity, 0, 0);  // Java: StringBuilder
253     for (int32_t i = 1; i < compiledPatternLength;) {
254         int32_t segmentLength = compiledPattern[i++] - ARG_NUM_LIMIT;
255         if (segmentLength > 0) {
256             sb.append(compiledPattern + i, segmentLength);
257             i += segmentLength;
258         }
259     }
260     return sb;
261 }
262 
format(const UChar * compiledPattern,int32_t compiledPatternLength,const UnicodeString * const * values,UnicodeString & result,const UnicodeString * resultCopy,UBool forbidResultAsValue,int32_t * offsets,int32_t offsetsLength,UErrorCode & errorCode)263 UnicodeString &SimpleFormatter::format(
264         const UChar *compiledPattern, int32_t compiledPatternLength,
265         const UnicodeString *const *values,
266         UnicodeString &result, const UnicodeString *resultCopy, UBool forbidResultAsValue,
267         int32_t *offsets, int32_t offsetsLength,
268         UErrorCode &errorCode) {
269     if (U_FAILURE(errorCode)) {
270         return result;
271     }
272     for (int32_t i = 0; i < offsetsLength; i++) {
273         offsets[i] = -1;
274     }
275     for (int32_t i = 1; i < compiledPatternLength;) {
276         int32_t n = compiledPattern[i++];
277         if (n < ARG_NUM_LIMIT) {
278             const UnicodeString *value = values[n];
279             if (value == NULL) {
280                 errorCode = U_ILLEGAL_ARGUMENT_ERROR;
281                 return result;
282             }
283             if (value == &result) {
284                 if (forbidResultAsValue) {
285                     errorCode = U_ILLEGAL_ARGUMENT_ERROR;
286                     return result;
287                 }
288                 if (i == 2) {
289                     // We are appending to result which is also the first value object.
290                     if (n < offsetsLength) {
291                         offsets[n] = 0;
292                     }
293                 } else {
294                     if (n < offsetsLength) {
295                         offsets[n] = result.length();
296                     }
297                     result.append(*resultCopy);
298                 }
299             } else {
300                 if (n < offsetsLength) {
301                     offsets[n] = result.length();
302                 }
303                 result.append(*value);
304             }
305         } else {
306             int32_t length = n - ARG_NUM_LIMIT;
307             result.append(compiledPattern + i, length);
308             i += length;
309         }
310     }
311     return result;
312 }
313 
314 U_NAMESPACE_END
315