]> git.saurik.com Git - apple/icu.git/blob - icuSources/common/ucasemap.cpp
projects / apple / icu.git / blob
? search:


cc998c993d73dc277f1b9b40cf4656b3e6eabefa
[apple/icu.git] / icuSources / common / ucasemap.cpp
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 *
6 * Copyright (C) 2005-2016, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 *******************************************************************************
10 * file name: ucasemap.cpp
11 * encoding: UTF-8
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2005may06
16 * created by: Markus W. Scherer
17 *
18 * Case mapping service object and functions using it.
19 */
20
21 #include "unicode/utypes.h"
22 #include "unicode/brkiter.h"
23 #include "unicode/bytestream.h"
24 #include "unicode/casemap.h"
25 #include "unicode/edits.h"
26 #include "unicode/stringoptions.h"
27 #include "unicode/stringpiece.h"
28 #include "unicode/ubrk.h"
29 #include "unicode/uloc.h"
30 #include "unicode/ustring.h"
31 #include "unicode/ucasemap.h"
32 #if !UCONFIG_NO_BREAK_ITERATION
33 #include "unicode/utext.h"
34 #endif
35 #include "unicode/utf.h"
36 #include "unicode/utf8.h"
37 #include "unicode/utf16.h"
38 #include "bytesinkutil.h"
39 #include "cmemory.h"
40 #include "cstring.h"
41 #include "uassert.h"
42 #include "ucase.h"
43 #include "ucasemap_imp.h"
44 #include "ustr_imp.h"
45
46 U_NAMESPACE_USE
47
48 /* UCaseMap service object -------------------------------------------------- */
49
50 UCaseMap::UCaseMap(const char *localeID, uint32_t opts, UErrorCode *pErrorCode) :
51 #if !UCONFIG_NO_BREAK_ITERATION
52 iter(NULL),
53 #endif
54 caseLocale(UCASE_LOC_UNKNOWN), options(opts) {
55 ucasemap_setLocale(this, localeID, pErrorCode);
56 }
57
58 UCaseMap::~UCaseMap() {
59 #if !UCONFIG_NO_BREAK_ITERATION
60 delete iter;
61 #endif
62 }
63
64 U_CAPI UCaseMap * U_EXPORT2
65 ucasemap_open(const char *locale, uint32_t options, UErrorCode *pErrorCode) {
66 if(U_FAILURE(*pErrorCode)) {
67 return NULL;
68 }
69 UCaseMap *csm = new UCaseMap(locale, options, pErrorCode);
70 if(csm==NULL) {
71 *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
72 return NULL;
73 } else if (U_FAILURE(*pErrorCode)) {
74 delete csm;
75 return NULL;
76 }
77 return csm;
78 }
79
80 U_CAPI void U_EXPORT2
81 ucasemap_close(UCaseMap *csm) {
82 delete csm;
83 }
84
85 U_CAPI const char * U_EXPORT2
86 ucasemap_getLocale(const UCaseMap *csm) {
87 return csm->locale;
88 }
89
90 U_CAPI uint32_t U_EXPORT2
91 ucasemap_getOptions(const UCaseMap *csm) {
92 return csm->options;
93 }
94
95 U_CAPI void U_EXPORT2
96 ucasemap_setLocale(UCaseMap *csm, const char *locale, UErrorCode *pErrorCode) {
97 if(U_FAILURE(*pErrorCode)) {
98 return;
99 }
100 if (locale != NULL && *locale == 0) {
101 csm->locale[0] = 0;
102 csm->caseLocale = UCASE_LOC_ROOT;
103 return;
104 }
105
106 int32_t length=uloc_getName(locale, csm->locale, (int32_t)sizeof(csm->locale), pErrorCode);
107 if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR || length==sizeof(csm->locale)) {
108 *pErrorCode=U_ZERO_ERROR;
109 /* we only really need the language code for case mappings */
110 length=uloc_getLanguage(locale, csm->locale, (int32_t)sizeof(csm->locale), pErrorCode);
111 }
112 if(length==sizeof(csm->locale)) {
113 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
114 }
115 if(U_SUCCESS(*pErrorCode)) {
116 csm->caseLocale=UCASE_LOC_UNKNOWN;
117 csm->caseLocale = ucase_getCaseLocale(csm->locale);
118 } else {
119 csm->locale[0]=0;
120 csm->caseLocale = UCASE_LOC_ROOT;
121 }
122 }
123
124 U_CAPI void U_EXPORT2
125 ucasemap_setOptions(UCaseMap *csm, uint32_t options, UErrorCode *pErrorCode) {
126 if(U_FAILURE(*pErrorCode)) {
127 return;
128 }
129 csm->options=options;
130 }
131
132 /* UTF-8 string case mappings ----------------------------------------------- */
133
134 /* TODO(markus): Move to a new, separate utf8case.cpp file. */
135
136 namespace {
137
138 /* append a full case mapping result, see UCASE_MAX_STRING_LENGTH */
139 inline UBool
140 appendResult(int32_t cpLength, int32_t result, const UChar *s,
141 ByteSink &sink, uint32_t options, icu::Edits *edits, UErrorCode &errorCode) {
142 U_ASSERT(U_SUCCESS(errorCode));
143
144 /* decode the result */
145 if(result<0) {
146 /* (not) original code point */
147 if(edits!=NULL) {
148 edits->addUnchanged(cpLength);
149 }
150 if((options & U_OMIT_UNCHANGED_TEXT) == 0) {
151 ByteSinkUtil::appendCodePoint(cpLength, ~result, sink);
152 }
153 } else {
154 if(result<=UCASE_MAX_STRING_LENGTH) {
155 // string: "result" is the UTF-16 length
156 return ByteSinkUtil::appendChange(cpLength, s, result, sink, edits, errorCode);
157 } else {
158 ByteSinkUtil::appendCodePoint(cpLength, result, sink, edits);
159 }
160 }
161 return TRUE;
162 }
163
164 // See unicode/utf8.h U8_APPEND_UNSAFE().
165 inline uint8_t getTwoByteLead(UChar32 c) { return (uint8_t)((c >> 6) | 0xc0); }
166 inline uint8_t getTwoByteTrail(UChar32 c) { return (uint8_t)((c & 0x3f) | 0x80); }
167
168 UChar32 U_CALLCONV
169 utf8_caseContextIterator(void *context, int8_t dir) {
170 UCaseContext *csc=(UCaseContext *)context;
171 UChar32 c;
172
173 if(dir<0) {
174 /* reset for backward iteration */
175 csc->index=csc->cpStart;
176 csc->dir=dir;
177 } else if(dir>0) {
178 /* reset for forward iteration */
179 csc->index=csc->cpLimit;
180 csc->dir=dir;
181 } else {
182 /* continue current iteration direction */
183 dir=csc->dir;
184 }
185
186 if(dir<0) {
187 if(csc->start<csc->index) {
188 U8_PREV((const uint8_t *)csc->p, csc->start, csc->index, c);
189 return c;
190 }
191 } else {
192 if(csc->index<csc->limit) {
193 U8_NEXT((const uint8_t *)csc->p, csc->index, csc->limit, c);
194 return c;
195 }
196 }
197 return U_SENTINEL;
198 }
199
200 /**
201 * caseLocale >= 0: Lowercases [srcStart..srcLimit[ but takes context [0..srcLength[ into account.
202 * caseLocale < 0: Case-folds [srcStart..srcLimit[.
203 */
204 void toLower(int32_t caseLocale, uint32_t options,
205 const uint8_t *src, UCaseContext *csc, int32_t srcStart, int32_t srcLimit,
206 icu::ByteSink &sink, icu::Edits *edits, UErrorCode &errorCode) {
207 const int8_t *latinToLower;
208 if (caseLocale == UCASE_LOC_ROOT ||
209 (caseLocale >= 0 ?
210 !(caseLocale == UCASE_LOC_TURKISH || caseLocale == UCASE_LOC_LITHUANIAN) :
211 (options & _FOLD_CASE_OPTIONS_MASK) == U_FOLD_CASE_DEFAULT)) {
212 latinToLower = LatinCase::TO_LOWER_NORMAL;
213 } else {
214 latinToLower = LatinCase::TO_LOWER_TR_LT;
215 }
216 const UTrie2 *trie = ucase_getTrie();
217 int32_t prev = srcStart;
218 int32_t srcIndex = srcStart;
219 for (;;) {
220 // fast path for simple cases
221 int32_t cpStart;
222 UChar32 c;
223 for (;;) {
224 if (U_FAILURE(errorCode) || srcIndex >= srcLimit) {
225 c = U_SENTINEL;
226 break;
227 }
228 uint8_t lead = src[srcIndex++];
229 if (lead <= 0x7f) {
230 int8_t d = latinToLower[lead];
231 if (d == LatinCase::EXC) {
232 cpStart = srcIndex - 1;
233 c = lead;
234 break;
235 }
236 if (d == 0) { continue; }
237 ByteSinkUtil::appendUnchanged(src + prev, srcIndex - 1 - prev,
238 sink, options, edits, errorCode);
239 char ascii = (char)(lead + d);
240 sink.Append(&ascii, 1);
241 if (edits != nullptr) {
242 edits->addReplace(1, 1);
243 }
244 prev = srcIndex;
245 continue;
246 } else if (lead < 0xe3) {
247 uint8_t t;
248 if (0xc2 <= lead && lead <= 0xc5 && srcIndex < srcLimit &&
249 (t = src[srcIndex] - 0x80) <= 0x3f) {
250 // U+0080..U+017F
251 ++srcIndex;
252 c = ((lead - 0xc0) << 6) | t;
253 int8_t d = latinToLower[c];
254 if (d == LatinCase::EXC) {
255 cpStart = srcIndex - 2;
256 break;
257 }
258 if (d == 0) { continue; }
259 ByteSinkUtil::appendUnchanged(src + prev, srcIndex - 2 - prev,
260 sink, options, edits, errorCode);
261 ByteSinkUtil::appendTwoBytes(c + d, sink);
262 if (edits != nullptr) {
263 edits->addReplace(2, 2);
264 }
265 prev = srcIndex;
266 continue;
267 }
268 } else if ((lead <= 0xe9 || lead == 0xeb || lead == 0xec) &&
269 (srcIndex + 2) <= srcLimit &&
270 U8_IS_TRAIL(src[srcIndex]) && U8_IS_TRAIL(src[srcIndex + 1])) {
271 // most of CJK: no case mappings
272 srcIndex += 2;
273 continue;
274 }
275 cpStart = --srcIndex;
276 U8_NEXT(src, srcIndex, srcLimit, c);
277 if (c < 0) {
278 // ill-formed UTF-8
279 continue;
280 }
281 uint16_t props = UTRIE2_GET16(trie, c);
282 if (UCASE_HAS_EXCEPTION(props)) { break; }
283 int32_t delta;
284 if (!UCASE_IS_UPPER_OR_TITLE(props) || (delta = UCASE_GET_DELTA(props)) == 0) {
285 continue;
286 }
287 ByteSinkUtil::appendUnchanged(src + prev, cpStart - prev,
288 sink, options, edits, errorCode);
289 ByteSinkUtil::appendCodePoint(srcIndex - cpStart, c + delta, sink, edits);
290 prev = srcIndex;
291 }
292 if (c < 0) {
293 break;
294 }
295 // slow path
296 const UChar *s;
297 if (caseLocale >= 0) {
298 csc->cpStart = cpStart;
299 csc->cpLimit = srcIndex;
300 c = ucase_toFullLower(c, utf8_caseContextIterator, csc, &s, caseLocale);
301 } else {
302 c = ucase_toFullFolding(c, &s, options);
303 }
304 if (c >= 0) {
305 ByteSinkUtil::appendUnchanged(src + prev, cpStart - prev,
306 sink, options, edits, errorCode);
307 appendResult(srcIndex - cpStart, c, s, sink, options, edits, errorCode);
308 prev = srcIndex;
309 }
310 }
311 ByteSinkUtil::appendUnchanged(src + prev, srcIndex - prev,
312 sink, options, edits, errorCode);
313 }
314
315 void toUpper(int32_t caseLocale, uint32_t options,
316 const uint8_t *src, UCaseContext *csc, int32_t srcLength,
317 icu::ByteSink &sink, icu::Edits *edits, UErrorCode &errorCode) {
318 const int8_t *latinToUpper;
319 if (caseLocale == UCASE_LOC_TURKISH) {
320 latinToUpper = LatinCase::TO_UPPER_TR;
321 } else {
322 latinToUpper = LatinCase::TO_UPPER_NORMAL;
323 }
324 const UTrie2 *trie = ucase_getTrie();
325 int32_t prev = 0;
326 int32_t srcIndex = 0;
327 for (;;) {
328 // fast path for simple cases
329 int32_t cpStart;
330 UChar32 c;
331 for (;;) {
332 if (U_FAILURE(errorCode) || srcIndex >= srcLength) {
333 c = U_SENTINEL;
334 break;
335 }
336 uint8_t lead = src[srcIndex++];
337 if (lead <= 0x7f) {
338 int8_t d = latinToUpper[lead];
339 if (d == LatinCase::EXC) {
340 cpStart = srcIndex - 1;
341 c = lead;
342 break;
343 }
344 if (d == 0) { continue; }
345 ByteSinkUtil::appendUnchanged(src + prev, srcIndex - 1 - prev,
346 sink, options, edits, errorCode);
347 char ascii = (char)(lead + d);
348 sink.Append(&ascii, 1);
349 if (edits != nullptr) {
350 edits->addReplace(1, 1);
351 }
352 prev = srcIndex;
353 continue;
354 } else if (lead < 0xe3) {
355 uint8_t t;
356 if (0xc2 <= lead && lead <= 0xc5 && srcIndex < srcLength &&
357 (t = src[srcIndex] - 0x80) <= 0x3f) {
358 // U+0080..U+017F
359 ++srcIndex;
360 c = ((lead - 0xc0) << 6) | t;
361 int8_t d = latinToUpper[c];
362 if (d == LatinCase::EXC) {
363 cpStart = srcIndex - 2;
364 break;
365 }
366 if (d == 0) { continue; }
367 ByteSinkUtil::appendUnchanged(src + prev, srcIndex - 2 - prev,
368 sink, options, edits, errorCode);
369 ByteSinkUtil::appendTwoBytes(c + d, sink);
370 if (edits != nullptr) {
371 edits->addReplace(2, 2);
372 }
373 prev = srcIndex;
374 continue;
375 }
376 } else if ((lead <= 0xe9 || lead == 0xeb || lead == 0xec) &&
377 (srcIndex + 2) <= srcLength &&
378 U8_IS_TRAIL(src[srcIndex]) && U8_IS_TRAIL(src[srcIndex + 1])) {
379 // most of CJK: no case mappings
380 srcIndex += 2;
381 continue;
382 }
383 cpStart = --srcIndex;
384 U8_NEXT(src, srcIndex, srcLength, c);
385 if (c < 0) {
386 // ill-formed UTF-8
387 continue;
388 }
389 uint16_t props = UTRIE2_GET16(trie, c);
390 if (UCASE_HAS_EXCEPTION(props)) { break; }
391 int32_t delta;
392 if (UCASE_GET_TYPE(props) != UCASE_LOWER || (delta = UCASE_GET_DELTA(props)) == 0) {
393 continue;
394 }
395 ByteSinkUtil::appendUnchanged(src + prev, cpStart - prev,
396 sink, options, edits, errorCode);
397 ByteSinkUtil::appendCodePoint(srcIndex - cpStart, c + delta, sink, edits);
398 prev = srcIndex;
399 }
400 if (c < 0) {
401 break;
402 }
403 // slow path
404 csc->cpStart = cpStart;
405 csc->cpLimit = srcIndex;
406 const UChar *s;
407 c = ucase_toFullUpper(c, utf8_caseContextIterator, csc, &s, caseLocale);
408 if (c >= 0) {
409 ByteSinkUtil::appendUnchanged(src + prev, cpStart - prev,
410 sink, options, edits, errorCode);
411 appendResult(srcIndex - cpStart, c, s, sink, options, edits, errorCode);
412 prev = srcIndex;
413 }
414 }
415 ByteSinkUtil::appendUnchanged(src + prev, srcIndex - prev,
416 sink, options, edits, errorCode);
417 }
418
419 } // namespace
420
421 #if !UCONFIG_NO_BREAK_ITERATION
422
423 U_CFUNC void U_CALLCONV
424 ucasemap_internalUTF8ToTitle(
425 int32_t caseLocale, uint32_t options, BreakIterator *iter,
426 const uint8_t *src, int32_t srcLength,
427 ByteSink &sink, icu::Edits *edits,
428 UErrorCode &errorCode) {
429 if (!ustrcase_checkTitleAdjustmentOptions(options, errorCode)) {
430 return;
431 }
432
433 /* set up local variables */
434 UCaseContext csc=UCASECONTEXT_INITIALIZER;
435 csc.p=(void *)src;
436 csc.limit=srcLength;
437 int32_t prev=0;
438 UBool isFirstIndex=TRUE;
439
440 /* titlecasing loop */
441 while(prev<srcLength) {
442 /* find next index where to titlecase */
443 int32_t index;
444 if(isFirstIndex) {
445 isFirstIndex=FALSE;
446 index=iter->first();
447 } else {
448 index=iter->next();
449 }
450 if(index==UBRK_DONE || index>srcLength) {
451 index=srcLength;
452 }
453
454 /*
455 * Segment [prev..index[ into 3 parts:
456 * a) skipped characters (copy as-is) [prev..titleStart[
457 * b) first letter (titlecase) [titleStart..titleLimit[
458 * c) subsequent characters (lowercase) [titleLimit..index[
459 */
460 if(prev<index) {
461 /* find and copy skipped characters [prev..titleStart[ */
462 int32_t titleStart=prev;
463 int32_t titleLimit=prev;
464 UChar32 c;
465 U8_NEXT(src, titleLimit, index, c);
466 if ((options&U_TITLECASE_NO_BREAK_ADJUSTMENT)==0) {
467 // Adjust the titlecasing index to the next cased character,
468 // or to the next letter/number/symbol/private use.
469 // Stop with titleStart<titleLimit<=index
470 // if there is a character to be titlecased,
471 // or else stop with titleStart==titleLimit==index.
472 UBool toCased = (options&U_TITLECASE_ADJUST_TO_CASED) != 0;
473 while (toCased ? UCASE_NONE==ucase_getType(c) : !ustrcase_isLNS(c)) {
474 titleStart=titleLimit;
475 if(titleLimit==index) {
476 break;
477 }
478 U8_NEXT(src, titleLimit, index, c);
479 }
480 if (prev < titleStart) {
481 if (!ByteSinkUtil::appendUnchanged(src+prev, titleStart-prev,
482 sink, options, edits, errorCode)) {
483 return;
484 }
485 }
486 }
487
488 if(titleStart<titleLimit) {
489 /* titlecase c which is from [titleStart..titleLimit[ */
490 if(c>=0) {
491 csc.cpStart=titleStart;
492 csc.cpLimit=titleLimit;
493 const UChar *s;
494 c=ucase_toFullTitle(c, utf8_caseContextIterator, &csc, &s, caseLocale);
495 if (!appendResult(titleLimit-titleStart, c, s, sink, options, edits, errorCode)) {
496 return;
497 }
498 } else {
499 // Malformed UTF-8.
500 if (!ByteSinkUtil::appendUnchanged(src+titleStart, titleLimit-titleStart,
501 sink, options, edits, errorCode)) {
502 return;
503 }
504 }
505
506 /* Special case Dutch IJ titlecasing */
507 if (titleStart+1 < index &&
508 caseLocale == UCASE_LOC_DUTCH &&
509 (src[titleStart] == 0x0049 || src[titleStart] == 0x0069)) {
510 if (src[titleStart+1] == 0x006A) {
511 ByteSinkUtil::appendCodePoint(1, 0x004A, sink, edits);
512 titleLimit++;
513 } else if (src[titleStart+1] == 0x004A) {
514 // Keep the capital J from getting lowercased.
515 if (!ByteSinkUtil::appendUnchanged(src+titleStart+1, 1,
516 sink, options, edits, errorCode)) {
517 return;
518 }
519 titleLimit++;
520 }
521 }
522
523 /* lowercase [titleLimit..index[ */
524 if(titleLimit<index) {
525 if((options&U_TITLECASE_NO_LOWERCASE)==0) {
526 /* Normal operation: Lowercase the rest of the word. */
527 toLower(caseLocale, options,
528 src, &csc, titleLimit, index,
529 sink, edits, errorCode);
530 if(U_FAILURE(errorCode)) {
531 return;
532 }
533 } else {
534 /* Optionally just copy the rest of the word unchanged. */
535 if (!ByteSinkUtil::appendUnchanged(src+titleLimit, index-titleLimit,
536 sink, options, edits, errorCode)) {
537 return;
538 }
539 }
540 }
541 }
542 }
543
544 prev=index;
545 }
546 }
547
548 #endif
549
550 U_NAMESPACE_BEGIN
551 namespace GreekUpper {
552
553 UBool isFollowedByCasedLetter(const uint8_t *s, int32_t i, int32_t length) {
554 while (i < length) {
555 UChar32 c;
556 U8_NEXT(s, i, length, c);
557 int32_t type = ucase_getTypeOrIgnorable(c);
558 if ((type & UCASE_IGNORABLE) != 0) {
559 // Case-ignorable, continue with the loop.
560 } else if (type != UCASE_NONE) {
561 return TRUE; // Followed by cased letter.
562 } else {
563 return FALSE; // Uncased and not case-ignorable.
564 }
565 }
566 return FALSE; // Not followed by cased letter.
567 }
568
569 // Keep this consistent with the UTF-16 version in ustrcase.cpp and the Java version in CaseMap.java.
570 void toUpper(uint32_t options,
571 const uint8_t *src, int32_t srcLength,
572 ByteSink &sink, Edits *edits,
573 UErrorCode &errorCode) {
574 uint32_t state = 0;
575 for (int32_t i = 0; i < srcLength;) {
576 int32_t nextIndex = i;
577 UChar32 c;
578 U8_NEXT(src, nextIndex, srcLength, c);
579 uint32_t nextState = 0;
580 int32_t type = ucase_getTypeOrIgnorable(c);
581 if ((type & UCASE_IGNORABLE) != 0) {
582 // c is case-ignorable
583 nextState |= (state & AFTER_CASED);
584 } else if (type != UCASE_NONE) {
585 // c is cased
586 nextState |= AFTER_CASED;
587 }
588 uint32_t data = getLetterData(c);
589 if (data > 0) {
590 uint32_t upper = data & UPPER_MASK;
591 // Add a dialytika to this iota or ypsilon vowel
592 // if we removed a tonos from the previous vowel,
593 // and that previous vowel did not also have (or gain) a dialytika.
594 // Adding one only to the final vowel in a longer sequence
595 // (which does not occur in normal writing) would require lookahead.
596 // Set the same flag as for preserving an existing dialytika.
597 if ((data & HAS_VOWEL) != 0 && (state & AFTER_VOWEL_WITH_ACCENT) != 0 &&
598 (upper == 0x399 || upper == 0x3A5)) {
599 data |= HAS_DIALYTIKA;
600 }
601 int32_t numYpogegrammeni = 0; // Map each one to a trailing, spacing, capital iota.
602 if ((data & HAS_YPOGEGRAMMENI) != 0) {
603 numYpogegrammeni = 1;
604 }
605 // Skip combining diacritics after this Greek letter.
606 int32_t nextNextIndex = nextIndex;
607 while (nextIndex < srcLength) {
608 UChar32 c2;
609 U8_NEXT(src, nextNextIndex, srcLength, c2);
610 uint32_t diacriticData = getDiacriticData(c2);
611 if (diacriticData != 0) {
612 data |= diacriticData;
613 if ((diacriticData & HAS_YPOGEGRAMMENI) != 0) {
614 ++numYpogegrammeni;
615 }
616 nextIndex = nextNextIndex;
617 } else {
618 break; // not a Greek diacritic
619 }
620 }
621 if ((data & HAS_VOWEL_AND_ACCENT_AND_DIALYTIKA) == HAS_VOWEL_AND_ACCENT) {
622 nextState |= AFTER_VOWEL_WITH_ACCENT;
623 }
624 // Map according to Greek rules.
625 UBool addTonos = FALSE;
626 if (upper == 0x397 &&
627 (data & HAS_ACCENT) != 0 &&
628 numYpogegrammeni == 0 &&
629 (state & AFTER_CASED) == 0 &&
630 !isFollowedByCasedLetter(src, nextIndex, srcLength)) {
631 // Keep disjunctive "or" with (only) a tonos.
632 // We use the same "word boundary" conditions as for the Final_Sigma test.
633 if (i == nextIndex) {
634 upper = 0x389; // Preserve the precomposed form.
635 } else {
636 addTonos = TRUE;
637 }
638 } else if ((data & HAS_DIALYTIKA) != 0) {
639 // Preserve a vowel with dialytika in precomposed form if it exists.
640 if (upper == 0x399) {
641 upper = 0x3AA;
642 data &= ~HAS_EITHER_DIALYTIKA;
643 } else if (upper == 0x3A5) {
644 upper = 0x3AB;
645 data &= ~HAS_EITHER_DIALYTIKA;
646 }
647 }
648
649 UBool change;
650 if (edits == nullptr && (options & U_OMIT_UNCHANGED_TEXT) == 0) {
651 change = TRUE; // common, simple usage
652 } else {
653 // Find out first whether we are changing the text.
654 U_ASSERT(0x370 <= upper && upper <= 0x3ff); // 2-byte UTF-8, main Greek block
655 change = (i + 2) > nextIndex ||
656 src[i] != getTwoByteLead(upper) || src[i + 1] != getTwoByteTrail(upper) ||
657 numYpogegrammeni > 0;
658 int32_t i2 = i + 2;
659 if ((data & HAS_EITHER_DIALYTIKA) != 0) {
660 change |= (i2 + 2) > nextIndex ||
661 src[i2] != (uint8_t)u8"\u0308"[0] ||
662 src[i2 + 1] != (uint8_t)u8"\u0308"[1];
663 i2 += 2;
664 }
665 if (addTonos) {
666 change |= (i2 + 2) > nextIndex ||
667 src[i2] != (uint8_t)u8"\u0301"[0] ||
668 src[i2 + 1] != (uint8_t)u8"\u0301"[1];
669 i2 += 2;
670 }
671 int32_t oldLength = nextIndex - i;
672 int32_t newLength = (i2 - i) + numYpogegrammeni * 2; // 2 bytes per U+0399
673 change |= oldLength != newLength;
674 if (change) {
675 if (edits != NULL) {
676 edits->addReplace(oldLength, newLength);
677 }
678 } else {
679 if (edits != NULL) {
680 edits->addUnchanged(oldLength);
681 }
682 // Write unchanged text?
683 change = (options & U_OMIT_UNCHANGED_TEXT) == 0;
684 }
685 }
686
687 if (change) {
688 ByteSinkUtil::appendTwoBytes(upper, sink);
689 if ((data & HAS_EITHER_DIALYTIKA) != 0) {
690 sink.Append(reinterpret_cast<const char*>(u8"\u0308"), 2); // restore or add a dialytika
691 }
692 if (addTonos) {
693 sink.Append(reinterpret_cast<const char*>(u8"\u0301"), 2);
694 }
695 while (numYpogegrammeni > 0) {
696 sink.Append(reinterpret_cast<const char*>(u8"\u0399"), 2);
697 --numYpogegrammeni;
698 }
699 }
700 } else if(c>=0) {
701 const UChar *s;
702 c=ucase_toFullUpper(c, NULL, NULL, &s, UCASE_LOC_GREEK);
703 if (!appendResult(nextIndex - i, c, s, sink, options, edits, errorCode)) {
704 return;
705 }
706 } else {
707 // Malformed UTF-8.
708 if (!ByteSinkUtil::appendUnchanged(src+i, nextIndex-i,
709 sink, options, edits, errorCode)) {
710 return;
711 }
712 }
713 i = nextIndex;
714 state = nextState;
715 }
716 }
717
718 } // namespace GreekUpper
719 U_NAMESPACE_END
720
721 static void U_CALLCONV
722 ucasemap_internalUTF8ToLower(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
723 const uint8_t *src, int32_t srcLength,
724 icu::ByteSink &sink, icu::Edits *edits,
725 UErrorCode &errorCode) {
726 UCaseContext csc=UCASECONTEXT_INITIALIZER;
727 csc.p=(void *)src;
728 csc.limit=srcLength;
729 toLower(
730 caseLocale, options,
731 src, &csc, 0, srcLength,
732 sink, edits, errorCode);
733 }
734
735 static void U_CALLCONV
736 ucasemap_internalUTF8ToUpper(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
737 const uint8_t *src, int32_t srcLength,
738 icu::ByteSink &sink, icu::Edits *edits,
739 UErrorCode &errorCode) {
740 if (caseLocale == UCASE_LOC_GREEK) {
741 GreekUpper::toUpper(options, src, srcLength, sink, edits, errorCode);
742 } else {
743 UCaseContext csc=UCASECONTEXT_INITIALIZER;
744 csc.p=(void *)src;
745 csc.limit=srcLength;
746 toUpper(
747 caseLocale, options,
748 src, &csc, srcLength,
749 sink, edits, errorCode);
750 }
751 }
752
753 static void U_CALLCONV
754 ucasemap_internalUTF8Fold(int32_t /* caseLocale */, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
755 const uint8_t *src, int32_t srcLength,
756 icu::ByteSink &sink, icu::Edits *edits,
757 UErrorCode &errorCode) {
758 toLower(
759 -1, options,
760 src, nullptr, 0, srcLength,
761 sink, edits, errorCode);
762 }
763
764 void
765 ucasemap_mapUTF8(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
766 const char *src, int32_t srcLength,
767 UTF8CaseMapper *stringCaseMapper,
768 icu::ByteSink &sink, icu::Edits *edits,
769 UErrorCode &errorCode) {
770 /* check argument values */
771 if (U_FAILURE(errorCode)) {
772 return;
773 }
774 if ((src == nullptr && srcLength != 0) || srcLength < -1) {
775 errorCode = U_ILLEGAL_ARGUMENT_ERROR;
776 return;
777 }
778
779 // Get the string length.
780 if (srcLength == -1) {
781 srcLength = (int32_t)uprv_strlen((const char *)src);
782 }
783
784 if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
785 edits->reset();
786 }
787 stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
788 (const uint8_t *)src, srcLength, sink, edits, errorCode);
789 sink.Flush();
790 if (U_SUCCESS(errorCode)) {
791 if (edits != nullptr) {
792 edits->copyErrorTo(errorCode);
793 }
794 }
795 }
796
797 int32_t
798 ucasemap_mapUTF8(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
799 char *dest, int32_t destCapacity,
800 const char *src, int32_t srcLength,
801 UTF8CaseMapper *stringCaseMapper,
802 icu::Edits *edits,
803 UErrorCode &errorCode) {
804 /* check argument values */
805 if(U_FAILURE(errorCode)) {
806 return 0;
807 }
808 if( destCapacity<0 ||
809 (dest==NULL && destCapacity>0) ||
810 (src==NULL && srcLength!=0) || srcLength<-1
811 ) {
812 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
813 return 0;
814 }
815
816 /* get the string length */
817 if(srcLength==-1) {
818 srcLength=(int32_t)uprv_strlen((const char *)src);
819 }
820
821 /* check for overlapping source and destination */
822 if( dest!=NULL &&
823 ((src>=dest && src<(dest+destCapacity)) ||
824 (dest>=src && dest<(src+srcLength)))
825 ) {
826 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
827 return 0;
828 }
829
830 CheckedArrayByteSink sink(dest, destCapacity);
831 if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
832 edits->reset();
833 }
834 stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
835 (const uint8_t *)src, srcLength, sink, edits, errorCode);
836 sink.Flush();
837 if (U_SUCCESS(errorCode)) {
838 if (sink.Overflowed()) {
839 errorCode = U_BUFFER_OVERFLOW_ERROR;
840 } else if (edits != nullptr) {
841 edits->copyErrorTo(errorCode);
842 }
843 }
844 return u_terminateChars(dest, destCapacity, sink.NumberOfBytesAppended(), &errorCode);
845 }
846
847 /* public API functions */
848
849 U_CAPI int32_t U_EXPORT2
850 ucasemap_utf8ToLower(const UCaseMap *csm,
851 char *dest, int32_t destCapacity,
852 const char *src, int32_t srcLength,
853 UErrorCode *pErrorCode) {
854 return ucasemap_mapUTF8(
855 csm->caseLocale, csm->options, UCASEMAP_BREAK_ITERATOR_NULL
856 dest, destCapacity,
857 src, srcLength,
858 ucasemap_internalUTF8ToLower, NULL, *pErrorCode);
859 }
860
861 U_CAPI int32_t U_EXPORT2
862 ucasemap_utf8ToUpper(const UCaseMap *csm,
863 char *dest, int32_t destCapacity,
864 const char *src, int32_t srcLength,
865 UErrorCode *pErrorCode) {
866 return ucasemap_mapUTF8(
867 csm->caseLocale, csm->options, UCASEMAP_BREAK_ITERATOR_NULL
868 dest, destCapacity,
869 src, srcLength,
870 ucasemap_internalUTF8ToUpper, NULL, *pErrorCode);
871 }
872
873 U_CAPI int32_t U_EXPORT2
874 ucasemap_utf8FoldCase(const UCaseMap *csm,
875 char *dest, int32_t destCapacity,
876 const char *src, int32_t srcLength,
877 UErrorCode *pErrorCode) {
878 return ucasemap_mapUTF8(
879 UCASE_LOC_ROOT, csm->options, UCASEMAP_BREAK_ITERATOR_NULL
880 dest, destCapacity,
881 src, srcLength,
882 ucasemap_internalUTF8Fold, NULL, *pErrorCode);
883 }
884
885 U_NAMESPACE_BEGIN
886
887 void CaseMap::utf8ToLower(
888 const char *locale, uint32_t options,
889 StringPiece src, ByteSink &sink, Edits *edits,
890 UErrorCode &errorCode) {
891 ucasemap_mapUTF8(
892 ustrcase_getCaseLocale(locale), options, UCASEMAP_BREAK_ITERATOR_NULL
893 src.data(), src.length(),
894 ucasemap_internalUTF8ToLower, sink, edits, errorCode);
895 }
896
897 void CaseMap::utf8ToUpper(
898 const char *locale, uint32_t options,
899 StringPiece src, ByteSink &sink, Edits *edits,
900 UErrorCode &errorCode) {
901 ucasemap_mapUTF8(
902 ustrcase_getCaseLocale(locale), options, UCASEMAP_BREAK_ITERATOR_NULL
903 src.data(), src.length(),
904 ucasemap_internalUTF8ToUpper, sink, edits, errorCode);
905 }
906
907 void CaseMap::utf8Fold(
908 uint32_t options,
909 StringPiece src, ByteSink &sink, Edits *edits,
910 UErrorCode &errorCode) {
911 ucasemap_mapUTF8(
912 UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL
913 src.data(), src.length(),
914 ucasemap_internalUTF8Fold, sink, edits, errorCode);
915 }
916
917 int32_t CaseMap::utf8ToLower(
918 const char *locale, uint32_t options,
919 const char *src, int32_t srcLength,
920 char *dest, int32_t destCapacity, Edits *edits,
921 UErrorCode &errorCode) {
922 return ucasemap_mapUTF8(
923 ustrcase_getCaseLocale(locale), options, UCASEMAP_BREAK_ITERATOR_NULL
924 dest, destCapacity,
925 src, srcLength,
926 ucasemap_internalUTF8ToLower, edits, errorCode);
927 }
928
929 int32_t CaseMap::utf8ToUpper(
930 const char *locale, uint32_t options,
931 const char *src, int32_t srcLength,
932 char *dest, int32_t destCapacity, Edits *edits,
933 UErrorCode &errorCode) {
934 return ucasemap_mapUTF8(
935 ustrcase_getCaseLocale(locale), options, UCASEMAP_BREAK_ITERATOR_NULL
936 dest, destCapacity,
937 src, srcLength,
938 ucasemap_internalUTF8ToUpper, edits, errorCode);
939 }
940
941 int32_t CaseMap::utf8Fold(
942 uint32_t options,
943 const char *src, int32_t srcLength,
944 char *dest, int32_t destCapacity, Edits *edits,
945 UErrorCode &errorCode) {
946 return ucasemap_mapUTF8(
947 UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL
948 dest, destCapacity,
949 src, srcLength,
950 ucasemap_internalUTF8Fold, edits, errorCode);
951 }
952
953 U_NAMESPACE_END
mirror of ICU