]>
Commit | Line | Data |
---|---|---|
1 | // © 2016 and later: Unicode, Inc. and others. | |
2 | // License & terms of use: http://www.unicode.org/copyright.html | |
3 | /* | |
4 | ******************************************************************************* | |
5 | * Copyright (C) 2011-2012, International Business Machines | |
6 | * Corporation and others. All Rights Reserved. | |
7 | ******************************************************************************* | |
8 | * file name: messagepattern.cpp | |
9 | * encoding: UTF-8 | |
10 | * tab size: 8 (not used) | |
11 | * indentation:4 | |
12 | * | |
13 | * created on: 2011mar14 | |
14 | * created by: Markus W. Scherer | |
15 | */ | |
16 | ||
17 | #include "unicode/utypes.h" | |
18 | ||
19 | #if !UCONFIG_NO_FORMATTING | |
20 | ||
21 | #include "unicode/messagepattern.h" | |
22 | #include "unicode/unistr.h" | |
23 | #include "unicode/utf16.h" | |
24 | #include "cmemory.h" | |
25 | #include "cstring.h" | |
26 | #include "messageimpl.h" | |
27 | #include "patternprops.h" | |
28 | #include "putilimp.h" | |
29 | #include "uassert.h" | |
30 | ||
31 | U_NAMESPACE_BEGIN | |
32 | ||
33 | // Unicode character/code point constants ---------------------------------- *** | |
34 | ||
35 | static const UChar u_pound=0x23; | |
36 | static const UChar u_apos=0x27; | |
37 | static const UChar u_plus=0x2B; | |
38 | static const UChar u_comma=0x2C; | |
39 | static const UChar u_minus=0x2D; | |
40 | static const UChar u_dot=0x2E; | |
41 | static const UChar u_colon=0x3A; | |
42 | static const UChar u_lessThan=0x3C; | |
43 | static const UChar u_equal=0x3D; | |
44 | static const UChar u_A=0x41; | |
45 | static const UChar u_C=0x43; | |
46 | static const UChar u_D=0x44; | |
47 | static const UChar u_E=0x45; | |
48 | static const UChar u_H=0x48; | |
49 | static const UChar u_I=0x49; | |
50 | static const UChar u_L=0x4C; | |
51 | static const UChar u_N=0x4E; | |
52 | static const UChar u_O=0x4F; | |
53 | static const UChar u_P=0x50; | |
54 | static const UChar u_R=0x52; | |
55 | static const UChar u_S=0x53; | |
56 | static const UChar u_T=0x54; | |
57 | static const UChar u_U=0x55; | |
58 | static const UChar u_Z=0x5A; | |
59 | static const UChar u_a=0x61; | |
60 | static const UChar u_c=0x63; | |
61 | static const UChar u_d=0x64; | |
62 | static const UChar u_e=0x65; | |
63 | static const UChar u_f=0x66; | |
64 | static const UChar u_h=0x68; | |
65 | static const UChar u_i=0x69; | |
66 | static const UChar u_l=0x6C; | |
67 | static const UChar u_n=0x6E; | |
68 | static const UChar u_o=0x6F; | |
69 | static const UChar u_p=0x70; | |
70 | static const UChar u_r=0x72; | |
71 | static const UChar u_s=0x73; | |
72 | static const UChar u_t=0x74; | |
73 | static const UChar u_u=0x75; | |
74 | static const UChar u_z=0x7A; | |
75 | static const UChar u_leftCurlyBrace=0x7B; | |
76 | static const UChar u_pipe=0x7C; | |
77 | static const UChar u_rightCurlyBrace=0x7D; | |
78 | static const UChar u_lessOrEqual=0x2264; // U+2264 is <= | |
79 | ||
80 | static const UChar kOffsetColon[]={ // "offset:" | |
81 | u_o, u_f, u_f, u_s, u_e, u_t, u_colon | |
82 | }; | |
83 | ||
84 | static const UChar kOther[]={ // "other" | |
85 | u_o, u_t, u_h, u_e, u_r | |
86 | }; | |
87 | ||
88 | // MessagePatternList ------------------------------------------------------ *** | |
89 | ||
90 | template<typename T, int32_t stackCapacity> | |
91 | class MessagePatternList : public UMemory { | |
92 | public: | |
93 | MessagePatternList() {} | |
94 | void copyFrom(const MessagePatternList<T, stackCapacity> &other, | |
95 | int32_t length, | |
96 | UErrorCode &errorCode); | |
97 | UBool ensureCapacityForOneMore(int32_t oldLength, UErrorCode &errorCode); | |
98 | UBool equals(const MessagePatternList<T, stackCapacity> &other, int32_t length) const { | |
99 | for(int32_t i=0; i<length; ++i) { | |
100 | if(a[i]!=other.a[i]) { return FALSE; } | |
101 | } | |
102 | return TRUE; | |
103 | } | |
104 | ||
105 | MaybeStackArray<T, stackCapacity> a; | |
106 | }; | |
107 | ||
108 | template<typename T, int32_t stackCapacity> | |
109 | void | |
110 | MessagePatternList<T, stackCapacity>::copyFrom( | |
111 | const MessagePatternList<T, stackCapacity> &other, | |
112 | int32_t length, | |
113 | UErrorCode &errorCode) { | |
114 | if(U_SUCCESS(errorCode) && length>0) { | |
115 | if(length>a.getCapacity() && NULL==a.resize(length)) { | |
116 | errorCode=U_MEMORY_ALLOCATION_ERROR; | |
117 | return; | |
118 | } | |
119 | uprv_memcpy(a.getAlias(), other.a.getAlias(), (size_t)length*sizeof(T)); | |
120 | } | |
121 | } | |
122 | ||
123 | template<typename T, int32_t stackCapacity> | |
124 | UBool | |
125 | MessagePatternList<T, stackCapacity>::ensureCapacityForOneMore(int32_t oldLength, UErrorCode &errorCode) { | |
126 | if(U_FAILURE(errorCode)) { | |
127 | return FALSE; | |
128 | } | |
129 | if(a.getCapacity()>oldLength || a.resize(2*oldLength, oldLength)!=NULL) { | |
130 | return TRUE; | |
131 | } | |
132 | errorCode=U_MEMORY_ALLOCATION_ERROR; | |
133 | return FALSE; | |
134 | } | |
135 | ||
136 | // MessagePatternList specializations -------------------------------------- *** | |
137 | ||
138 | class MessagePatternDoubleList : public MessagePatternList<double, 8> { | |
139 | }; | |
140 | ||
141 | class MessagePatternPartsList : public MessagePatternList<MessagePattern::Part, 32> { | |
142 | }; | |
143 | ||
144 | // MessagePattern constructors etc. ---------------------------------------- *** | |
145 | ||
146 | MessagePattern::MessagePattern(UErrorCode &errorCode) | |
147 | : aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE), | |
148 | partsList(NULL), parts(NULL), partsLength(0), | |
149 | numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
150 | hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) { | |
151 | init(errorCode); | |
152 | } | |
153 | ||
154 | MessagePattern::MessagePattern(UMessagePatternApostropheMode mode, UErrorCode &errorCode) | |
155 | : aposMode(mode), | |
156 | partsList(NULL), parts(NULL), partsLength(0), | |
157 | numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
158 | hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) { | |
159 | init(errorCode); | |
160 | } | |
161 | ||
162 | MessagePattern::MessagePattern(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) | |
163 | : aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE), | |
164 | partsList(NULL), parts(NULL), partsLength(0), | |
165 | numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
166 | hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(FALSE) { | |
167 | if(init(errorCode)) { | |
168 | parse(pattern, parseError, errorCode); | |
169 | } | |
170 | } | |
171 | ||
172 | UBool | |
173 | MessagePattern::init(UErrorCode &errorCode) { | |
174 | if(U_FAILURE(errorCode)) { | |
175 | return FALSE; | |
176 | } | |
177 | partsList=new MessagePatternPartsList(); | |
178 | if(partsList==NULL) { | |
179 | errorCode=U_MEMORY_ALLOCATION_ERROR; | |
180 | return FALSE; | |
181 | } | |
182 | parts=partsList->a.getAlias(); | |
183 | return TRUE; | |
184 | } | |
185 | ||
186 | MessagePattern::MessagePattern(const MessagePattern &other) | |
187 | : UObject(other), aposMode(other.aposMode), msg(other.msg), | |
188 | partsList(NULL), parts(NULL), partsLength(0), | |
189 | numericValuesList(NULL), numericValues(NULL), numericValuesLength(0), | |
190 | hasArgNames(other.hasArgNames), hasArgNumbers(other.hasArgNumbers), | |
191 | needsAutoQuoting(other.needsAutoQuoting) { | |
192 | UErrorCode errorCode=U_ZERO_ERROR; | |
193 | if(!copyStorage(other, errorCode)) { | |
194 | clear(); | |
195 | } | |
196 | } | |
197 | ||
198 | MessagePattern & | |
199 | MessagePattern::operator=(const MessagePattern &other) { | |
200 | if(this==&other) { | |
201 | return *this; | |
202 | } | |
203 | aposMode=other.aposMode; | |
204 | msg=other.msg; | |
205 | hasArgNames=other.hasArgNames; | |
206 | hasArgNumbers=other.hasArgNumbers; | |
207 | needsAutoQuoting=other.needsAutoQuoting; | |
208 | UErrorCode errorCode=U_ZERO_ERROR; | |
209 | if(!copyStorage(other, errorCode)) { | |
210 | clear(); | |
211 | } | |
212 | return *this; | |
213 | } | |
214 | ||
215 | UBool | |
216 | MessagePattern::copyStorage(const MessagePattern &other, UErrorCode &errorCode) { | |
217 | if(U_FAILURE(errorCode)) { | |
218 | return FALSE; | |
219 | } | |
220 | parts=NULL; | |
221 | partsLength=0; | |
222 | numericValues=NULL; | |
223 | numericValuesLength=0; | |
224 | if(partsList==NULL) { | |
225 | partsList=new MessagePatternPartsList(); | |
226 | if(partsList==NULL) { | |
227 | errorCode=U_MEMORY_ALLOCATION_ERROR; | |
228 | return FALSE; | |
229 | } | |
230 | parts=partsList->a.getAlias(); | |
231 | } | |
232 | if(other.partsLength>0) { | |
233 | partsList->copyFrom(*other.partsList, other.partsLength, errorCode); | |
234 | if(U_FAILURE(errorCode)) { | |
235 | return FALSE; | |
236 | } | |
237 | parts=partsList->a.getAlias(); | |
238 | partsLength=other.partsLength; | |
239 | } | |
240 | if(other.numericValuesLength>0) { | |
241 | if(numericValuesList==NULL) { | |
242 | numericValuesList=new MessagePatternDoubleList(); | |
243 | if(numericValuesList==NULL) { | |
244 | errorCode=U_MEMORY_ALLOCATION_ERROR; | |
245 | return FALSE; | |
246 | } | |
247 | numericValues=numericValuesList->a.getAlias(); | |
248 | } | |
249 | numericValuesList->copyFrom( | |
250 | *other.numericValuesList, other.numericValuesLength, errorCode); | |
251 | if(U_FAILURE(errorCode)) { | |
252 | return FALSE; | |
253 | } | |
254 | numericValues=numericValuesList->a.getAlias(); | |
255 | numericValuesLength=other.numericValuesLength; | |
256 | } | |
257 | return TRUE; | |
258 | } | |
259 | ||
260 | MessagePattern::~MessagePattern() { | |
261 | delete partsList; | |
262 | delete numericValuesList; | |
263 | } | |
264 | ||
265 | // MessagePattern API ------------------------------------------------------ *** | |
266 | ||
267 | MessagePattern & | |
268 | MessagePattern::parse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) { | |
269 | preParse(pattern, parseError, errorCode); | |
270 | parseMessage(0, 0, 0, UMSGPAT_ARG_TYPE_NONE, parseError, errorCode); | |
271 | postParse(); | |
272 | return *this; | |
273 | } | |
274 | ||
275 | MessagePattern & | |
276 | MessagePattern::parseChoiceStyle(const UnicodeString &pattern, | |
277 | UParseError *parseError, UErrorCode &errorCode) { | |
278 | preParse(pattern, parseError, errorCode); | |
279 | parseChoiceStyle(0, 0, parseError, errorCode); | |
280 | postParse(); | |
281 | return *this; | |
282 | } | |
283 | ||
284 | MessagePattern & | |
285 | MessagePattern::parsePluralStyle(const UnicodeString &pattern, | |
286 | UParseError *parseError, UErrorCode &errorCode) { | |
287 | preParse(pattern, parseError, errorCode); | |
288 | parsePluralOrSelectStyle(UMSGPAT_ARG_TYPE_PLURAL, 0, 0, parseError, errorCode); | |
289 | postParse(); | |
290 | return *this; | |
291 | } | |
292 | ||
293 | MessagePattern & | |
294 | MessagePattern::parseSelectStyle(const UnicodeString &pattern, | |
295 | UParseError *parseError, UErrorCode &errorCode) { | |
296 | preParse(pattern, parseError, errorCode); | |
297 | parsePluralOrSelectStyle(UMSGPAT_ARG_TYPE_SELECT, 0, 0, parseError, errorCode); | |
298 | postParse(); | |
299 | return *this; | |
300 | } | |
301 | ||
302 | void | |
303 | MessagePattern::clear() { | |
304 | // Mostly the same as preParse(). | |
305 | msg.remove(); | |
306 | hasArgNames=hasArgNumbers=FALSE; | |
307 | needsAutoQuoting=FALSE; | |
308 | partsLength=0; | |
309 | numericValuesLength=0; | |
310 | } | |
311 | ||
312 | UBool | |
313 | MessagePattern::operator==(const MessagePattern &other) const { | |
314 | if(this==&other) { | |
315 | return TRUE; | |
316 | } | |
317 | return | |
318 | aposMode==other.aposMode && | |
319 | msg==other.msg && | |
320 | // parts.equals(o.parts) | |
321 | partsLength==other.partsLength && | |
322 | (partsLength==0 || partsList->equals(*other.partsList, partsLength)); | |
323 | // No need to compare numericValues if msg and parts are the same. | |
324 | } | |
325 | ||
326 | int32_t | |
327 | MessagePattern::hashCode() const { | |
328 | int32_t hash=(aposMode*37+msg.hashCode())*37+partsLength; | |
329 | for(int32_t i=0; i<partsLength; ++i) { | |
330 | hash=hash*37+parts[i].hashCode(); | |
331 | } | |
332 | return hash; | |
333 | } | |
334 | ||
335 | int32_t | |
336 | MessagePattern::validateArgumentName(const UnicodeString &name) { | |
337 | if(!PatternProps::isIdentifier(name.getBuffer(), name.length())) { | |
338 | return UMSGPAT_ARG_NAME_NOT_VALID; | |
339 | } | |
340 | return parseArgNumber(name, 0, name.length()); | |
341 | } | |
342 | ||
343 | UnicodeString | |
344 | MessagePattern::autoQuoteApostropheDeep() const { | |
345 | if(!needsAutoQuoting) { | |
346 | return msg; | |
347 | } | |
348 | UnicodeString modified(msg); | |
349 | // Iterate backward so that the insertion indexes do not change. | |
350 | int32_t count=countParts(); | |
351 | for(int32_t i=count; i>0;) { | |
352 | const Part &part=getPart(--i); | |
353 | if(part.getType()==UMSGPAT_PART_TYPE_INSERT_CHAR) { | |
354 | modified.insert(part.index, (UChar)part.value); | |
355 | } | |
356 | } | |
357 | return modified; | |
358 | } | |
359 | ||
360 | double | |
361 | MessagePattern::getNumericValue(const Part &part) const { | |
362 | UMessagePatternPartType type=part.type; | |
363 | if(type==UMSGPAT_PART_TYPE_ARG_INT) { | |
364 | return part.value; | |
365 | } else if(type==UMSGPAT_PART_TYPE_ARG_DOUBLE) { | |
366 | return numericValues[part.value]; | |
367 | } else { | |
368 | return UMSGPAT_NO_NUMERIC_VALUE; | |
369 | } | |
370 | } | |
371 | ||
372 | /** | |
373 | * Returns the "offset:" value of a PluralFormat argument, or 0 if none is specified. | |
374 | * @param pluralStart the index of the first PluralFormat argument style part. (0..countParts()-1) | |
375 | * @return the "offset:" value. | |
376 | * @draft ICU 4.8 | |
377 | */ | |
378 | double | |
379 | MessagePattern::getPluralOffset(int32_t pluralStart) const { | |
380 | const Part &part=getPart(pluralStart); | |
381 | if(Part::hasNumericValue(part.type)) { | |
382 | return getNumericValue(part); | |
383 | } else { | |
384 | return 0; | |
385 | } | |
386 | } | |
387 | ||
388 | // MessagePattern::Part ---------------------------------------------------- *** | |
389 | ||
390 | UBool | |
391 | MessagePattern::Part::operator==(const Part &other) const { | |
392 | if(this==&other) { | |
393 | return TRUE; | |
394 | } | |
395 | return | |
396 | type==other.type && | |
397 | index==other.index && | |
398 | length==other.length && | |
399 | value==other.value && | |
400 | limitPartIndex==other.limitPartIndex; | |
401 | } | |
402 | ||
403 | // MessagePattern parser --------------------------------------------------- *** | |
404 | ||
405 | void | |
406 | MessagePattern::preParse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) { | |
407 | if(U_FAILURE(errorCode)) { | |
408 | return; | |
409 | } | |
410 | if(parseError!=NULL) { | |
411 | parseError->line=0; | |
412 | parseError->offset=0; | |
413 | parseError->preContext[0]=0; | |
414 | parseError->postContext[0]=0; | |
415 | } | |
416 | msg=pattern; | |
417 | hasArgNames=hasArgNumbers=FALSE; | |
418 | needsAutoQuoting=FALSE; | |
419 | partsLength=0; | |
420 | numericValuesLength=0; | |
421 | } | |
422 | ||
423 | void | |
424 | MessagePattern::postParse() { | |
425 | if(partsList!=NULL) { | |
426 | parts=partsList->a.getAlias(); | |
427 | } | |
428 | if(numericValuesList!=NULL) { | |
429 | numericValues=numericValuesList->a.getAlias(); | |
430 | } | |
431 | } | |
432 | ||
433 | int32_t | |
434 | MessagePattern::parseMessage(int32_t index, int32_t msgStartLength, | |
435 | int32_t nestingLevel, UMessagePatternArgType parentType, | |
436 | UParseError *parseError, UErrorCode &errorCode) { | |
437 | if(U_FAILURE(errorCode)) { | |
438 | return 0; | |
439 | } | |
440 | if(nestingLevel>Part::MAX_VALUE) { | |
441 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
442 | return 0; | |
443 | } | |
444 | int32_t msgStart=partsLength; | |
445 | addPart(UMSGPAT_PART_TYPE_MSG_START, index, msgStartLength, nestingLevel, errorCode); | |
446 | index+=msgStartLength; | |
447 | for(;;) { // while(index<msg.length()) with U_FAILURE(errorCode) check | |
448 | if(U_FAILURE(errorCode)) { | |
449 | return 0; | |
450 | } | |
451 | if(index>=msg.length()) { | |
452 | break; | |
453 | } | |
454 | UChar c=msg.charAt(index++); | |
455 | if(c==u_apos) { | |
456 | if(index==msg.length()) { | |
457 | // The apostrophe is the last character in the pattern. | |
458 | // Add a Part for auto-quoting. | |
459 | addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0, | |
460 | u_apos, errorCode); // value=char to be inserted | |
461 | needsAutoQuoting=TRUE; | |
462 | } else { | |
463 | c=msg.charAt(index); | |
464 | if(c==u_apos) { | |
465 | // double apostrophe, skip the second one | |
466 | addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index++, 1, 0, errorCode); | |
467 | } else if( | |
468 | aposMode==UMSGPAT_APOS_DOUBLE_REQUIRED || | |
469 | c==u_leftCurlyBrace || c==u_rightCurlyBrace || | |
470 | (parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_pipe) || | |
471 | (UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(parentType) && c==u_pound) | |
472 | ) { | |
473 | // skip the quote-starting apostrophe | |
474 | addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index-1, 1, 0, errorCode); | |
475 | // find the end of the quoted literal text | |
476 | for(;;) { | |
477 | index=msg.indexOf(u_apos, index+1); | |
478 | if(index>=0) { | |
479 | if(/*(index+1)<msg.length() &&*/ msg.charAt(index+1)==u_apos) { | |
480 | // double apostrophe inside quoted literal text | |
481 | // still encodes a single apostrophe, skip the second one | |
482 | addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, ++index, 1, 0, errorCode); | |
483 | } else { | |
484 | // skip the quote-ending apostrophe | |
485 | addPart(UMSGPAT_PART_TYPE_SKIP_SYNTAX, index++, 1, 0, errorCode); | |
486 | break; | |
487 | } | |
488 | } else { | |
489 | // The quoted text reaches to the end of the of the message. | |
490 | index=msg.length(); | |
491 | // Add a Part for auto-quoting. | |
492 | addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0, | |
493 | u_apos, errorCode); // value=char to be inserted | |
494 | needsAutoQuoting=TRUE; | |
495 | break; | |
496 | } | |
497 | } | |
498 | } else { | |
499 | // Interpret the apostrophe as literal text. | |
500 | // Add a Part for auto-quoting. | |
501 | addPart(UMSGPAT_PART_TYPE_INSERT_CHAR, index, 0, | |
502 | u_apos, errorCode); // value=char to be inserted | |
503 | needsAutoQuoting=TRUE; | |
504 | } | |
505 | } | |
506 | } else if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(parentType) && c==u_pound) { | |
507 | // The unquoted # in a plural message fragment will be replaced | |
508 | // with the (number-offset). | |
509 | addPart(UMSGPAT_PART_TYPE_REPLACE_NUMBER, index-1, 1, 0, errorCode); | |
510 | } else if(c==u_leftCurlyBrace) { | |
511 | index=parseArg(index-1, 1, nestingLevel, parseError, errorCode); | |
512 | } else if((nestingLevel>0 && c==u_rightCurlyBrace) || | |
513 | (parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_pipe)) { | |
514 | // Finish the message before the terminator. | |
515 | // In a choice style, report the "}" substring only for the following ARG_LIMIT, | |
516 | // not for this MSG_LIMIT. | |
517 | int32_t limitLength=(parentType==UMSGPAT_ARG_TYPE_CHOICE && c==u_rightCurlyBrace) ? 0 : 1; | |
518 | addLimitPart(msgStart, UMSGPAT_PART_TYPE_MSG_LIMIT, index-1, limitLength, | |
519 | nestingLevel, errorCode); | |
520 | if(parentType==UMSGPAT_ARG_TYPE_CHOICE) { | |
521 | // Let the choice style parser see the '}' or '|'. | |
522 | return index-1; | |
523 | } else { | |
524 | // continue parsing after the '}' | |
525 | return index; | |
526 | } | |
527 | } // else: c is part of literal text | |
528 | } | |
529 | if(nestingLevel>0 && !inTopLevelChoiceMessage(nestingLevel, parentType)) { | |
530 | setParseError(parseError, 0); // Unmatched '{' braces in message. | |
531 | errorCode=U_UNMATCHED_BRACES; | |
532 | return 0; | |
533 | } | |
534 | addLimitPart(msgStart, UMSGPAT_PART_TYPE_MSG_LIMIT, index, 0, nestingLevel, errorCode); | |
535 | return index; | |
536 | } | |
537 | ||
538 | int32_t | |
539 | MessagePattern::parseArg(int32_t index, int32_t argStartLength, int32_t nestingLevel, | |
540 | UParseError *parseError, UErrorCode &errorCode) { | |
541 | int32_t argStart=partsLength; | |
542 | UMessagePatternArgType argType=UMSGPAT_ARG_TYPE_NONE; | |
543 | addPart(UMSGPAT_PART_TYPE_ARG_START, index, argStartLength, argType, errorCode); | |
544 | if(U_FAILURE(errorCode)) { | |
545 | return 0; | |
546 | } | |
547 | int32_t nameIndex=index=skipWhiteSpace(index+argStartLength); | |
548 | if(index==msg.length()) { | |
549 | setParseError(parseError, 0); // Unmatched '{' braces in message. | |
550 | errorCode=U_UNMATCHED_BRACES; | |
551 | return 0; | |
552 | } | |
553 | // parse argument name or number | |
554 | index=skipIdentifier(index); | |
555 | int32_t number=parseArgNumber(nameIndex, index); | |
556 | if(number>=0) { | |
557 | int32_t length=index-nameIndex; | |
558 | if(length>Part::MAX_LENGTH || number>Part::MAX_VALUE) { | |
559 | setParseError(parseError, nameIndex); // Argument number too large. | |
560 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
561 | return 0; | |
562 | } | |
563 | hasArgNumbers=TRUE; | |
564 | addPart(UMSGPAT_PART_TYPE_ARG_NUMBER, nameIndex, length, number, errorCode); | |
565 | } else if(number==UMSGPAT_ARG_NAME_NOT_NUMBER) { | |
566 | int32_t length=index-nameIndex; | |
567 | if(length>Part::MAX_LENGTH) { | |
568 | setParseError(parseError, nameIndex); // Argument name too long. | |
569 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
570 | return 0; | |
571 | } | |
572 | hasArgNames=TRUE; | |
573 | addPart(UMSGPAT_PART_TYPE_ARG_NAME, nameIndex, length, 0, errorCode); | |
574 | } else { // number<-1 (ARG_NAME_NOT_VALID) | |
575 | setParseError(parseError, nameIndex); // Bad argument syntax. | |
576 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
577 | return 0; | |
578 | } | |
579 | index=skipWhiteSpace(index); | |
580 | if(index==msg.length()) { | |
581 | setParseError(parseError, 0); // Unmatched '{' braces in message. | |
582 | errorCode=U_UNMATCHED_BRACES; | |
583 | return 0; | |
584 | } | |
585 | UChar c=msg.charAt(index); | |
586 | if(c==u_rightCurlyBrace) { | |
587 | // all done | |
588 | } else if(c!=u_comma) { | |
589 | setParseError(parseError, nameIndex); // Bad argument syntax. | |
590 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
591 | return 0; | |
592 | } else /* ',' */ { | |
593 | // parse argument type: case-sensitive a-zA-Z | |
594 | int32_t typeIndex=index=skipWhiteSpace(index+1); | |
595 | while(index<msg.length() && isArgTypeChar(msg.charAt(index))) { | |
596 | ++index; | |
597 | } | |
598 | int32_t length=index-typeIndex; | |
599 | index=skipWhiteSpace(index); | |
600 | if(index==msg.length()) { | |
601 | setParseError(parseError, 0); // Unmatched '{' braces in message. | |
602 | errorCode=U_UNMATCHED_BRACES; | |
603 | return 0; | |
604 | } | |
605 | if(length==0 || ((c=msg.charAt(index))!=u_comma && c!=u_rightCurlyBrace)) { | |
606 | setParseError(parseError, nameIndex); // Bad argument syntax. | |
607 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
608 | return 0; | |
609 | } | |
610 | if(length>Part::MAX_LENGTH) { | |
611 | setParseError(parseError, nameIndex); // Argument type name too long. | |
612 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
613 | return 0; | |
614 | } | |
615 | argType=UMSGPAT_ARG_TYPE_SIMPLE; | |
616 | if(length==6) { | |
617 | // case-insensitive comparisons for complex-type names | |
618 | if(isChoice(typeIndex)) { | |
619 | argType=UMSGPAT_ARG_TYPE_CHOICE; | |
620 | } else if(isPlural(typeIndex)) { | |
621 | argType=UMSGPAT_ARG_TYPE_PLURAL; | |
622 | } else if(isSelect(typeIndex)) { | |
623 | argType=UMSGPAT_ARG_TYPE_SELECT; | |
624 | } | |
625 | } else if(length==13) { | |
626 | if(isSelect(typeIndex) && isOrdinal(typeIndex+6)) { | |
627 | argType=UMSGPAT_ARG_TYPE_SELECTORDINAL; | |
628 | } | |
629 | } | |
630 | // change the ARG_START type from NONE to argType | |
631 | partsList->a[argStart].value=(int16_t)argType; | |
632 | if(argType==UMSGPAT_ARG_TYPE_SIMPLE) { | |
633 | addPart(UMSGPAT_PART_TYPE_ARG_TYPE, typeIndex, length, 0, errorCode); | |
634 | } | |
635 | // look for an argument style (pattern) | |
636 | if(c==u_rightCurlyBrace) { | |
637 | if(argType!=UMSGPAT_ARG_TYPE_SIMPLE) { | |
638 | setParseError(parseError, nameIndex); // No style field for complex argument. | |
639 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
640 | return 0; | |
641 | } | |
642 | } else /* ',' */ { | |
643 | ++index; | |
644 | if(argType==UMSGPAT_ARG_TYPE_SIMPLE) { | |
645 | index=parseSimpleStyle(index, parseError, errorCode); | |
646 | } else if(argType==UMSGPAT_ARG_TYPE_CHOICE) { | |
647 | index=parseChoiceStyle(index, nestingLevel, parseError, errorCode); | |
648 | } else { | |
649 | index=parsePluralOrSelectStyle(argType, index, nestingLevel, parseError, errorCode); | |
650 | } | |
651 | } | |
652 | } | |
653 | // Argument parsing stopped on the '}'. | |
654 | addLimitPart(argStart, UMSGPAT_PART_TYPE_ARG_LIMIT, index, 1, argType, errorCode); | |
655 | return index+1; | |
656 | } | |
657 | ||
658 | int32_t | |
659 | MessagePattern::parseSimpleStyle(int32_t index, UParseError *parseError, UErrorCode &errorCode) { | |
660 | if(U_FAILURE(errorCode)) { | |
661 | return 0; | |
662 | } | |
663 | int32_t start=index; | |
664 | int32_t nestedBraces=0; | |
665 | while(index<msg.length()) { | |
666 | UChar c=msg.charAt(index++); | |
667 | if(c==u_apos) { | |
668 | // Treat apostrophe as quoting but include it in the style part. | |
669 | // Find the end of the quoted literal text. | |
670 | index=msg.indexOf(u_apos, index); | |
671 | if(index<0) { | |
672 | // Quoted literal argument style text reaches to the end of the message. | |
673 | setParseError(parseError, start); | |
674 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
675 | return 0; | |
676 | } | |
677 | // skip the quote-ending apostrophe | |
678 | ++index; | |
679 | } else if(c==u_leftCurlyBrace) { | |
680 | ++nestedBraces; | |
681 | } else if(c==u_rightCurlyBrace) { | |
682 | if(nestedBraces>0) { | |
683 | --nestedBraces; | |
684 | } else { | |
685 | int32_t length=--index-start; | |
686 | if(length>Part::MAX_LENGTH) { | |
687 | setParseError(parseError, start); // Argument style text too long. | |
688 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
689 | return 0; | |
690 | } | |
691 | addPart(UMSGPAT_PART_TYPE_ARG_STYLE, start, length, 0, errorCode); | |
692 | return index; | |
693 | } | |
694 | } // c is part of literal text | |
695 | } | |
696 | setParseError(parseError, 0); // Unmatched '{' braces in message. | |
697 | errorCode=U_UNMATCHED_BRACES; | |
698 | return 0; | |
699 | } | |
700 | ||
701 | int32_t | |
702 | MessagePattern::parseChoiceStyle(int32_t index, int32_t nestingLevel, | |
703 | UParseError *parseError, UErrorCode &errorCode) { | |
704 | if(U_FAILURE(errorCode)) { | |
705 | return 0; | |
706 | } | |
707 | int32_t start=index; | |
708 | index=skipWhiteSpace(index); | |
709 | if(index==msg.length() || msg.charAt(index)==u_rightCurlyBrace) { | |
710 | setParseError(parseError, 0); // Missing choice argument pattern. | |
711 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
712 | return 0; | |
713 | } | |
714 | for(;;) { | |
715 | // The choice argument style contains |-separated (number, separator, message) triples. | |
716 | // Parse the number. | |
717 | int32_t numberIndex=index; | |
718 | index=skipDouble(index); | |
719 | int32_t length=index-numberIndex; | |
720 | if(length==0) { | |
721 | setParseError(parseError, start); // Bad choice pattern syntax. | |
722 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
723 | return 0; | |
724 | } | |
725 | if(length>Part::MAX_LENGTH) { | |
726 | setParseError(parseError, numberIndex); // Choice number too long. | |
727 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
728 | return 0; | |
729 | } | |
730 | parseDouble(numberIndex, index, TRUE, parseError, errorCode); // adds ARG_INT or ARG_DOUBLE | |
731 | if(U_FAILURE(errorCode)) { | |
732 | return 0; | |
733 | } | |
734 | // Parse the separator. | |
735 | index=skipWhiteSpace(index); | |
736 | if(index==msg.length()) { | |
737 | setParseError(parseError, start); // Bad choice pattern syntax. | |
738 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
739 | return 0; | |
740 | } | |
741 | UChar c=msg.charAt(index); | |
742 | if(!(c==u_pound || c==u_lessThan || c==u_lessOrEqual)) { // U+2264 is <= | |
743 | setParseError(parseError, start); // Expected choice separator (#<\u2264) instead of c. | |
744 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
745 | return 0; | |
746 | } | |
747 | addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, index, 1, 0, errorCode); | |
748 | // Parse the message fragment. | |
749 | index=parseMessage(++index, 0, nestingLevel+1, UMSGPAT_ARG_TYPE_CHOICE, parseError, errorCode); | |
750 | if(U_FAILURE(errorCode)) { | |
751 | return 0; | |
752 | } | |
753 | // parseMessage(..., CHOICE) returns the index of the terminator, or msg.length(). | |
754 | if(index==msg.length()) { | |
755 | return index; | |
756 | } | |
757 | if(msg.charAt(index)==u_rightCurlyBrace) { | |
758 | if(!inMessageFormatPattern(nestingLevel)) { | |
759 | setParseError(parseError, start); // Bad choice pattern syntax. | |
760 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
761 | return 0; | |
762 | } | |
763 | return index; | |
764 | } // else the terminator is '|' | |
765 | index=skipWhiteSpace(index+1); | |
766 | } | |
767 | } | |
768 | ||
769 | int32_t | |
770 | MessagePattern::parsePluralOrSelectStyle(UMessagePatternArgType argType, | |
771 | int32_t index, int32_t nestingLevel, | |
772 | UParseError *parseError, UErrorCode &errorCode) { | |
773 | if(U_FAILURE(errorCode)) { | |
774 | return 0; | |
775 | } | |
776 | int32_t start=index; | |
777 | UBool isEmpty=TRUE; | |
778 | UBool hasOther=FALSE; | |
779 | for(;;) { | |
780 | // First, collect the selector looking for a small set of terminators. | |
781 | // It would be a little faster to consider the syntax of each possible | |
782 | // token right here, but that makes the code too complicated. | |
783 | index=skipWhiteSpace(index); | |
784 | UBool eos=index==msg.length(); | |
785 | if(eos || msg.charAt(index)==u_rightCurlyBrace) { | |
786 | if(eos==inMessageFormatPattern(nestingLevel)) { | |
787 | setParseError(parseError, start); // Bad plural/select pattern syntax. | |
788 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
789 | return 0; | |
790 | } | |
791 | if(!hasOther) { | |
792 | setParseError(parseError, 0); // Missing 'other' keyword in plural/select pattern. | |
793 | errorCode=U_DEFAULT_KEYWORD_MISSING; | |
794 | return 0; | |
795 | } | |
796 | return index; | |
797 | } | |
798 | int32_t selectorIndex=index; | |
799 | if(UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) && msg.charAt(selectorIndex)==u_equal) { | |
800 | // explicit-value plural selector: =double | |
801 | index=skipDouble(index+1); | |
802 | int32_t length=index-selectorIndex; | |
803 | if(length==1) { | |
804 | setParseError(parseError, start); // Bad plural/select pattern syntax. | |
805 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
806 | return 0; | |
807 | } | |
808 | if(length>Part::MAX_LENGTH) { | |
809 | setParseError(parseError, selectorIndex); // Argument selector too long. | |
810 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
811 | return 0; | |
812 | } | |
813 | addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, selectorIndex, length, 0, errorCode); | |
814 | parseDouble(selectorIndex+1, index, FALSE, | |
815 | parseError, errorCode); // adds ARG_INT or ARG_DOUBLE | |
816 | } else { | |
817 | index=skipIdentifier(index); | |
818 | int32_t length=index-selectorIndex; | |
819 | if(length==0) { | |
820 | setParseError(parseError, start); // Bad plural/select pattern syntax. | |
821 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
822 | return 0; | |
823 | } | |
824 | // Note: The ':' in "offset:" is just beyond the skipIdentifier() range. | |
825 | if( UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE(argType) && length==6 && index<msg.length() && | |
826 | 0==msg.compare(selectorIndex, 7, kOffsetColon, 0, 7) | |
827 | ) { | |
828 | // plural offset, not a selector | |
829 | if(!isEmpty) { | |
830 | // Plural argument 'offset:' (if present) must precede key-message pairs. | |
831 | setParseError(parseError, start); | |
832 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
833 | return 0; | |
834 | } | |
835 | // allow whitespace between offset: and its value | |
836 | int32_t valueIndex=skipWhiteSpace(index+1); // The ':' is at index. | |
837 | index=skipDouble(valueIndex); | |
838 | if(index==valueIndex) { | |
839 | setParseError(parseError, start); // Missing value for plural 'offset:'. | |
840 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
841 | return 0; | |
842 | } | |
843 | if((index-valueIndex)>Part::MAX_LENGTH) { | |
844 | setParseError(parseError, valueIndex); // Plural offset value too long. | |
845 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
846 | return 0; | |
847 | } | |
848 | parseDouble(valueIndex, index, FALSE, | |
849 | parseError, errorCode); // adds ARG_INT or ARG_DOUBLE | |
850 | if(U_FAILURE(errorCode)) { | |
851 | return 0; | |
852 | } | |
853 | isEmpty=FALSE; | |
854 | continue; // no message fragment after the offset | |
855 | } else { | |
856 | // normal selector word | |
857 | if(length>Part::MAX_LENGTH) { | |
858 | setParseError(parseError, selectorIndex); // Argument selector too long. | |
859 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
860 | return 0; | |
861 | } | |
862 | addPart(UMSGPAT_PART_TYPE_ARG_SELECTOR, selectorIndex, length, 0, errorCode); | |
863 | if(0==msg.compare(selectorIndex, length, kOther, 0, 5)) { | |
864 | hasOther=TRUE; | |
865 | } | |
866 | } | |
867 | } | |
868 | if(U_FAILURE(errorCode)) { | |
869 | return 0; | |
870 | } | |
871 | ||
872 | // parse the message fragment following the selector | |
873 | index=skipWhiteSpace(index); | |
874 | if(index==msg.length() || msg.charAt(index)!=u_leftCurlyBrace) { | |
875 | setParseError(parseError, selectorIndex); // No message fragment after plural/select selector. | |
876 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
877 | return 0; | |
878 | } | |
879 | index=parseMessage(index, 1, nestingLevel+1, argType, parseError, errorCode); | |
880 | if(U_FAILURE(errorCode)) { | |
881 | return 0; | |
882 | } | |
883 | isEmpty=FALSE; | |
884 | } | |
885 | } | |
886 | ||
887 | int32_t | |
888 | MessagePattern::parseArgNumber(const UnicodeString &s, int32_t start, int32_t limit) { | |
889 | // If the identifier contains only ASCII digits, then it is an argument _number_ | |
890 | // and must not have leading zeros (except "0" itself). | |
891 | // Otherwise it is an argument _name_. | |
892 | if(start>=limit) { | |
893 | return UMSGPAT_ARG_NAME_NOT_VALID; | |
894 | } | |
895 | int32_t number; | |
896 | // Defer numeric errors until we know there are only digits. | |
897 | UBool badNumber; | |
898 | UChar c=s.charAt(start++); | |
899 | if(c==0x30) { | |
900 | if(start==limit) { | |
901 | return 0; | |
902 | } else { | |
903 | number=0; | |
904 | badNumber=TRUE; // leading zero | |
905 | } | |
906 | } else if(0x31<=c && c<=0x39) { | |
907 | number=c-0x30; | |
908 | badNumber=FALSE; | |
909 | } else { | |
910 | return UMSGPAT_ARG_NAME_NOT_NUMBER; | |
911 | } | |
912 | while(start<limit) { | |
913 | c=s.charAt(start++); | |
914 | if(0x30<=c && c<=0x39) { | |
915 | if(number>=INT32_MAX/10) { | |
916 | badNumber=TRUE; // overflow | |
917 | } | |
918 | number=number*10+(c-0x30); | |
919 | } else { | |
920 | return UMSGPAT_ARG_NAME_NOT_NUMBER; | |
921 | } | |
922 | } | |
923 | // There are only ASCII digits. | |
924 | if(badNumber) { | |
925 | return UMSGPAT_ARG_NAME_NOT_VALID; | |
926 | } else { | |
927 | return number; | |
928 | } | |
929 | } | |
930 | ||
931 | void | |
932 | MessagePattern::parseDouble(int32_t start, int32_t limit, UBool allowInfinity, | |
933 | UParseError *parseError, UErrorCode &errorCode) { | |
934 | if(U_FAILURE(errorCode)) { | |
935 | return; | |
936 | } | |
937 | U_ASSERT(start<limit); | |
938 | // fake loop for easy exit and single throw statement | |
939 | for(;;) { /*loop doesn't iterate*/ | |
940 | // fast path for small integers and infinity | |
941 | int32_t value=0; | |
942 | int32_t isNegative=0; // not boolean so that we can easily add it to value | |
943 | int32_t index=start; | |
944 | UChar c=msg.charAt(index++); | |
945 | if(c==u_minus) { | |
946 | isNegative=1; | |
947 | if(index==limit) { | |
948 | break; // no number | |
949 | } | |
950 | c=msg.charAt(index++); | |
951 | } else if(c==u_plus) { | |
952 | if(index==limit) { | |
953 | break; // no number | |
954 | } | |
955 | c=msg.charAt(index++); | |
956 | } | |
957 | if(c==0x221e) { // infinity | |
958 | if(allowInfinity && index==limit) { | |
959 | double infinity=uprv_getInfinity(); | |
960 | addArgDoublePart( | |
961 | isNegative!=0 ? -infinity : infinity, | |
962 | start, limit-start, errorCode); | |
963 | return; | |
964 | } else { | |
965 | break; | |
966 | } | |
967 | } | |
968 | // try to parse the number as a small integer but fall back to a double | |
969 | while('0'<=c && c<='9') { | |
970 | value=value*10+(c-'0'); | |
971 | if(value>(Part::MAX_VALUE+isNegative)) { | |
972 | break; // not a small-enough integer | |
973 | } | |
974 | if(index==limit) { | |
975 | addPart(UMSGPAT_PART_TYPE_ARG_INT, start, limit-start, | |
976 | isNegative!=0 ? -value : value, errorCode); | |
977 | return; | |
978 | } | |
979 | c=msg.charAt(index++); | |
980 | } | |
981 | // Let Double.parseDouble() throw a NumberFormatException. | |
982 | char numberChars[128]; | |
983 | int32_t capacity=(int32_t)sizeof(numberChars); | |
984 | int32_t length=limit-start; | |
985 | if(length>=capacity) { | |
986 | break; // number too long | |
987 | } | |
988 | msg.extract(start, length, numberChars, capacity, US_INV); | |
989 | if((int32_t)uprv_strlen(numberChars)<length) { | |
990 | break; // contains non-invariant character that was turned into NUL | |
991 | } | |
992 | char *end; | |
993 | double numericValue=uprv_strtod(numberChars, &end); | |
994 | if(end!=(numberChars+length)) { | |
995 | break; // parsing error | |
996 | } | |
997 | addArgDoublePart(numericValue, start, length, errorCode); | |
998 | return; | |
999 | } | |
1000 | setParseError(parseError, start /*, limit*/); // Bad syntax for numeric value. | |
1001 | errorCode=U_PATTERN_SYNTAX_ERROR; | |
1002 | return; | |
1003 | } | |
1004 | ||
1005 | int32_t | |
1006 | MessagePattern::skipWhiteSpace(int32_t index) { | |
1007 | const UChar *s=msg.getBuffer(); | |
1008 | int32_t msgLength=msg.length(); | |
1009 | const UChar *t=PatternProps::skipWhiteSpace(s+index, msgLength-index); | |
1010 | return (int32_t)(t-s); | |
1011 | } | |
1012 | ||
1013 | int32_t | |
1014 | MessagePattern::skipIdentifier(int32_t index) { | |
1015 | const UChar *s=msg.getBuffer(); | |
1016 | int32_t msgLength=msg.length(); | |
1017 | const UChar *t=PatternProps::skipIdentifier(s+index, msgLength-index); | |
1018 | return (int32_t)(t-s); | |
1019 | } | |
1020 | ||
1021 | int32_t | |
1022 | MessagePattern::skipDouble(int32_t index) { | |
1023 | int32_t msgLength=msg.length(); | |
1024 | while(index<msgLength) { | |
1025 | UChar c=msg.charAt(index); | |
1026 | // U+221E: Allow the infinity symbol, for ChoiceFormat patterns. | |
1027 | if((c<0x30 && c!=u_plus && c!=u_minus && c!=u_dot) || (c>0x39 && c!=u_e && c!=u_E && c!=0x221e)) { | |
1028 | break; | |
1029 | } | |
1030 | ++index; | |
1031 | } | |
1032 | return index; | |
1033 | } | |
1034 | ||
1035 | UBool | |
1036 | MessagePattern::isArgTypeChar(UChar32 c) { | |
1037 | return (u_a<=c && c<=u_z) || (u_A<=c && c<=u_Z); | |
1038 | } | |
1039 | ||
1040 | UBool | |
1041 | MessagePattern::isChoice(int32_t index) { | |
1042 | UChar c; | |
1043 | return | |
1044 | ((c=msg.charAt(index++))==u_c || c==u_C) && | |
1045 | ((c=msg.charAt(index++))==u_h || c==u_H) && | |
1046 | ((c=msg.charAt(index++))==u_o || c==u_O) && | |
1047 | ((c=msg.charAt(index++))==u_i || c==u_I) && | |
1048 | ((c=msg.charAt(index++))==u_c || c==u_C) && | |
1049 | ((c=msg.charAt(index))==u_e || c==u_E); | |
1050 | } | |
1051 | ||
1052 | UBool | |
1053 | MessagePattern::isPlural(int32_t index) { | |
1054 | UChar c; | |
1055 | return | |
1056 | ((c=msg.charAt(index++))==u_p || c==u_P) && | |
1057 | ((c=msg.charAt(index++))==u_l || c==u_L) && | |
1058 | ((c=msg.charAt(index++))==u_u || c==u_U) && | |
1059 | ((c=msg.charAt(index++))==u_r || c==u_R) && | |
1060 | ((c=msg.charAt(index++))==u_a || c==u_A) && | |
1061 | ((c=msg.charAt(index))==u_l || c==u_L); | |
1062 | } | |
1063 | ||
1064 | UBool | |
1065 | MessagePattern::isSelect(int32_t index) { | |
1066 | UChar c; | |
1067 | return | |
1068 | ((c=msg.charAt(index++))==u_s || c==u_S) && | |
1069 | ((c=msg.charAt(index++))==u_e || c==u_E) && | |
1070 | ((c=msg.charAt(index++))==u_l || c==u_L) && | |
1071 | ((c=msg.charAt(index++))==u_e || c==u_E) && | |
1072 | ((c=msg.charAt(index++))==u_c || c==u_C) && | |
1073 | ((c=msg.charAt(index))==u_t || c==u_T); | |
1074 | } | |
1075 | ||
1076 | UBool | |
1077 | MessagePattern::isOrdinal(int32_t index) { | |
1078 | UChar c; | |
1079 | return | |
1080 | ((c=msg.charAt(index++))==u_o || c==u_O) && | |
1081 | ((c=msg.charAt(index++))==u_r || c==u_R) && | |
1082 | ((c=msg.charAt(index++))==u_d || c==u_D) && | |
1083 | ((c=msg.charAt(index++))==u_i || c==u_I) && | |
1084 | ((c=msg.charAt(index++))==u_n || c==u_N) && | |
1085 | ((c=msg.charAt(index++))==u_a || c==u_A) && | |
1086 | ((c=msg.charAt(index))==u_l || c==u_L); | |
1087 | } | |
1088 | ||
1089 | UBool | |
1090 | MessagePattern::inMessageFormatPattern(int32_t nestingLevel) { | |
1091 | return nestingLevel>0 || partsList->a[0].type==UMSGPAT_PART_TYPE_MSG_START; | |
1092 | } | |
1093 | ||
1094 | UBool | |
1095 | MessagePattern::inTopLevelChoiceMessage(int32_t nestingLevel, UMessagePatternArgType parentType) { | |
1096 | return | |
1097 | nestingLevel==1 && | |
1098 | parentType==UMSGPAT_ARG_TYPE_CHOICE && | |
1099 | partsList->a[0].type!=UMSGPAT_PART_TYPE_MSG_START; | |
1100 | } | |
1101 | ||
1102 | void | |
1103 | MessagePattern::addPart(UMessagePatternPartType type, int32_t index, int32_t length, | |
1104 | int32_t value, UErrorCode &errorCode) { | |
1105 | if(partsList->ensureCapacityForOneMore(partsLength, errorCode)) { | |
1106 | Part &part=partsList->a[partsLength++]; | |
1107 | part.type=type; | |
1108 | part.index=index; | |
1109 | part.length=(uint16_t)length; | |
1110 | part.value=(int16_t)value; | |
1111 | part.limitPartIndex=0; | |
1112 | } | |
1113 | } | |
1114 | ||
1115 | void | |
1116 | MessagePattern::addLimitPart(int32_t start, | |
1117 | UMessagePatternPartType type, int32_t index, int32_t length, | |
1118 | int32_t value, UErrorCode &errorCode) { | |
1119 | partsList->a[start].limitPartIndex=partsLength; | |
1120 | addPart(type, index, length, value, errorCode); | |
1121 | } | |
1122 | ||
1123 | void | |
1124 | MessagePattern::addArgDoublePart(double numericValue, int32_t start, int32_t length, | |
1125 | UErrorCode &errorCode) { | |
1126 | if(U_FAILURE(errorCode)) { | |
1127 | return; | |
1128 | } | |
1129 | int32_t numericIndex=numericValuesLength; | |
1130 | if(numericValuesList==NULL) { | |
1131 | numericValuesList=new MessagePatternDoubleList(); | |
1132 | if(numericValuesList==NULL) { | |
1133 | errorCode=U_MEMORY_ALLOCATION_ERROR; | |
1134 | return; | |
1135 | } | |
1136 | } else if(!numericValuesList->ensureCapacityForOneMore(numericValuesLength, errorCode)) { | |
1137 | return; | |
1138 | } else { | |
1139 | if(numericIndex>Part::MAX_VALUE) { | |
1140 | errorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
1141 | return; | |
1142 | } | |
1143 | } | |
1144 | numericValuesList->a[numericValuesLength++]=numericValue; | |
1145 | addPart(UMSGPAT_PART_TYPE_ARG_DOUBLE, start, length, numericIndex, errorCode); | |
1146 | } | |
1147 | ||
1148 | void | |
1149 | MessagePattern::setParseError(UParseError *parseError, int32_t index) { | |
1150 | if(parseError==NULL) { | |
1151 | return; | |
1152 | } | |
1153 | parseError->offset=index; | |
1154 | ||
1155 | // Set preContext to some of msg before index. | |
1156 | // Avoid splitting a surrogate pair. | |
1157 | int32_t length=index; | |
1158 | if(length>=U_PARSE_CONTEXT_LEN) { | |
1159 | length=U_PARSE_CONTEXT_LEN-1; | |
1160 | if(length>0 && U16_IS_TRAIL(msg[index-length])) { | |
1161 | --length; | |
1162 | } | |
1163 | } | |
1164 | msg.extract(index-length, length, parseError->preContext); | |
1165 | parseError->preContext[length]=0; | |
1166 | ||
1167 | // Set postContext to some of msg starting at index. | |
1168 | length=msg.length()-index; | |
1169 | if(length>=U_PARSE_CONTEXT_LEN) { | |
1170 | length=U_PARSE_CONTEXT_LEN-1; | |
1171 | if(length>0 && U16_IS_LEAD(msg[index+length-1])) { | |
1172 | --length; | |
1173 | } | |
1174 | } | |
1175 | msg.extract(index, length, parseError->postContext); | |
1176 | parseError->postContext[length]=0; | |
1177 | } | |
1178 | ||
1179 | // MessageImpl ------------------------------------------------------------- *** | |
1180 | ||
1181 | void | |
1182 | MessageImpl::appendReducedApostrophes(const UnicodeString &s, int32_t start, int32_t limit, | |
1183 | UnicodeString &sb) { | |
1184 | int32_t doubleApos=-1; | |
1185 | for(;;) { | |
1186 | int32_t i=s.indexOf(u_apos, start); | |
1187 | if(i<0 || i>=limit) { | |
1188 | sb.append(s, start, limit-start); | |
1189 | break; | |
1190 | } | |
1191 | if(i==doubleApos) { | |
1192 | // Double apostrophe at start-1 and start==i, append one. | |
1193 | sb.append(u_apos); | |
1194 | ++start; | |
1195 | doubleApos=-1; | |
1196 | } else { | |
1197 | // Append text between apostrophes and skip this one. | |
1198 | sb.append(s, start, i-start); | |
1199 | doubleApos=start=i+1; | |
1200 | } | |
1201 | } | |
1202 | } | |
1203 | ||
1204 | // Ported from second half of ICU4J SelectFormat.format(String). | |
1205 | UnicodeString & | |
1206 | MessageImpl::appendSubMessageWithoutSkipSyntax(const MessagePattern &msgPattern, | |
1207 | int32_t msgStart, | |
1208 | UnicodeString &result) { | |
1209 | const UnicodeString &msgString=msgPattern.getPatternString(); | |
1210 | int32_t prevIndex=msgPattern.getPart(msgStart).getLimit(); | |
1211 | for(int32_t i=msgStart;;) { | |
1212 | const MessagePattern::Part &part=msgPattern.getPart(++i); | |
1213 | UMessagePatternPartType type=part.getType(); | |
1214 | int32_t index=part.getIndex(); | |
1215 | if(type==UMSGPAT_PART_TYPE_MSG_LIMIT) { | |
1216 | return result.append(msgString, prevIndex, index-prevIndex); | |
1217 | } else if(type==UMSGPAT_PART_TYPE_SKIP_SYNTAX) { | |
1218 | result.append(msgString, prevIndex, index-prevIndex); | |
1219 | prevIndex=part.getLimit(); | |
1220 | } else if(type==UMSGPAT_PART_TYPE_ARG_START) { | |
1221 | result.append(msgString, prevIndex, index-prevIndex); | |
1222 | prevIndex=index; | |
1223 | i=msgPattern.getLimitPartIndex(i); | |
1224 | index=msgPattern.getPart(i).getLimit(); | |
1225 | appendReducedApostrophes(msgString, prevIndex, index, result); | |
1226 | prevIndex=index; | |
1227 | } | |
1228 | } | |
1229 | } | |
1230 | ||
1231 | U_NAMESPACE_END | |
1232 | ||
1233 | #endif // !UCONFIG_NO_FORMATTING |