Coverage Report

Created: 2024-04-24 06:23

/src/icu/source/common/ustrcase.cpp
Line
Count
Source (jump to first uncovered line)
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) 2001-2015, International Business Machines
7
*   Corporation and others.  All Rights Reserved.
8
*
9
*******************************************************************************
10
*   file name:  ustrcase.cpp
11
*   encoding:   UTF-8
12
*   tab size:   8 (not used)
13
*   indentation:4
14
*
15
*   created on: 2002feb20
16
*   created by: Markus W. Scherer
17
*
18
*   Implementation file for string casing C API functions.
19
*   Uses functions from uchar.c for basic functionality that requires access
20
*   to the Unicode Character Database (uprops.dat).
21
*/
22
23
#include "unicode/utypes.h"
24
#include "unicode/brkiter.h"
25
#include "unicode/casemap.h"
26
#include "unicode/edits.h"
27
#include "unicode/stringoptions.h"
28
#include "unicode/ustring.h"
29
#include "unicode/ucasemap.h"
30
#include "unicode/ubrk.h"
31
#include "unicode/utf.h"
32
#include "unicode/utf16.h"
33
#include "cmemory.h"
34
#include "ucase.h"
35
#include "ucasemap_imp.h"
36
#include "ustr_imp.h"
37
#include "uassert.h"
38
39
/**
40
 * Code point for COMBINING ACUTE ACCENT
41
 * @internal
42
 */
43
0
#define ACUTE u'\u0301'
44
45
U_NAMESPACE_BEGIN
46
47
namespace {
48
49
int32_t checkOverflowAndEditsError(int32_t destIndex, int32_t destCapacity,
50
0
                                   Edits *edits, UErrorCode &errorCode) {
51
0
    if (U_SUCCESS(errorCode)) {
52
0
        if (destIndex > destCapacity) {
53
0
            errorCode = U_BUFFER_OVERFLOW_ERROR;
54
0
        } else if (edits != NULL) {
55
0
            edits->copyErrorTo(errorCode);
56
0
        }
57
0
    }
58
0
    return destIndex;
59
0
}
60
61
/* Appends a full case mapping result, see UCASE_MAX_STRING_LENGTH. */
62
inline int32_t
63
appendResult(UChar *dest, int32_t destIndex, int32_t destCapacity,
64
             int32_t result, const UChar *s,
65
0
             int32_t cpLength, uint32_t options, icu::Edits *edits) {
66
0
    UChar32 c;
67
0
    int32_t length;
68
69
    /* decode the result */
70
0
    if(result<0) {
71
        /* (not) original code point */
72
0
        if(edits!=NULL) {
73
0
            edits->addUnchanged(cpLength);
74
0
        }
75
0
        if(options & U_OMIT_UNCHANGED_TEXT) {
76
0
            return destIndex;
77
0
        }
78
0
        c=~result;
79
0
        if(destIndex<destCapacity && c<=0xffff) {  // BMP slightly-fastpath
80
0
            dest[destIndex++]=(UChar)c;
81
0
            return destIndex;
82
0
        }
83
0
        length=cpLength;
84
0
    } else {
85
0
        if(result<=UCASE_MAX_STRING_LENGTH) {
86
0
            c=U_SENTINEL;
87
0
            length=result;
88
0
        } else if(destIndex<destCapacity && result<=0xffff) {  // BMP slightly-fastpath
89
0
            dest[destIndex++]=(UChar)result;
90
0
            if(edits!=NULL) {
91
0
                edits->addReplace(cpLength, 1);
92
0
            }
93
0
            return destIndex;
94
0
        } else {
95
0
            c=result;
96
0
            length=U16_LENGTH(c);
97
0
        }
98
0
        if(edits!=NULL) {
99
0
            edits->addReplace(cpLength, length);
100
0
        }
101
0
    }
102
0
    if(length>(INT32_MAX-destIndex)) {
103
0
        return -1;  // integer overflow
104
0
    }
105
106
0
    if(destIndex<destCapacity) {
107
        /* append the result */
108
0
        if(c>=0) {
109
            /* code point */
110
0
            UBool isError=FALSE;
111
0
            U16_APPEND(dest, destIndex, destCapacity, c, isError);
112
0
            if(isError) {
113
                /* overflow, nothing written */
114
0
                destIndex+=length;
115
0
            }
116
0
        } else {
117
            /* string */
118
0
            if((destIndex+length)<=destCapacity) {
119
0
                while(length>0) {
120
0
                    dest[destIndex++]=*s++;
121
0
                    --length;
122
0
                }
123
0
            } else {
124
                /* overflow */
125
0
                destIndex+=length;
126
0
            }
127
0
        }
128
0
    } else {
129
        /* preflight */
130
0
        destIndex+=length;
131
0
    }
132
0
    return destIndex;
133
0
}
134
135
inline int32_t
136
0
appendUChar(UChar *dest, int32_t destIndex, int32_t destCapacity, UChar c) {
137
0
    if(destIndex<destCapacity) {
138
0
        dest[destIndex]=c;
139
0
    } else if(destIndex==INT32_MAX) {
140
0
        return -1;  // integer overflow
141
0
    }
142
0
    return destIndex+1;
143
0
}
144
145
int32_t
146
appendNonEmptyUnchanged(UChar *dest, int32_t destIndex, int32_t destCapacity,
147
0
                        const UChar *s, int32_t length, uint32_t options, icu::Edits *edits) {
148
0
    if(edits!=NULL) {
149
0
        edits->addUnchanged(length);
150
0
    }
151
0
    if(options & U_OMIT_UNCHANGED_TEXT) {
152
0
        return destIndex;
153
0
    }
154
0
    if(length>(INT32_MAX-destIndex)) {
155
0
        return -1;  // integer overflow
156
0
    }
157
0
    if((destIndex+length)<=destCapacity) {
158
0
        u_memcpy(dest+destIndex, s, length);
159
0
    }
160
0
    return destIndex + length;
161
0
}
162
163
inline int32_t
164
appendUnchanged(UChar *dest, int32_t destIndex, int32_t destCapacity,
165
0
                const UChar *s, int32_t length, uint32_t options, icu::Edits *edits) {
166
0
    if (length <= 0) {
167
0
        return destIndex;
168
0
    }
169
0
    return appendNonEmptyUnchanged(dest, destIndex, destCapacity, s, length, options, edits);
170
0
}
171
172
UChar32 U_CALLCONV
173
0
utf16_caseContextIterator(void *context, int8_t dir) {
174
0
    UCaseContext *csc=(UCaseContext *)context;
175
0
    UChar32 c;
176
177
0
    if(dir<0) {
178
        /* reset for backward iteration */
179
0
        csc->index=csc->cpStart;
180
0
        csc->dir=dir;
181
0
    } else if(dir>0) {
182
        /* reset for forward iteration */
183
0
        csc->index=csc->cpLimit;
184
0
        csc->dir=dir;
185
0
    } else {
186
        /* continue current iteration direction */
187
0
        dir=csc->dir;
188
0
    }
189
190
0
    if(dir<0) {
191
0
        if(csc->start<csc->index) {
192
0
            U16_PREV((const UChar *)csc->p, csc->start, csc->index, c);
193
0
            return c;
194
0
        }
195
0
    } else {
196
0
        if(csc->index<csc->limit) {
197
0
            U16_NEXT((const UChar *)csc->p, csc->index, csc->limit, c);
198
0
            return c;
199
0
        }
200
0
    }
201
0
    return U_SENTINEL;
202
0
}
203
204
/**
205
 * caseLocale >= 0: Lowercases [srcStart..srcLimit[ but takes context [0..srcLength[ into account.
206
 * caseLocale < 0: Case-folds [srcStart..srcLimit[.
207
 */
208
int32_t toLower(int32_t caseLocale, uint32_t options,
209
                UChar *dest, int32_t destCapacity,
210
                const UChar *src, UCaseContext *csc, int32_t srcStart, int32_t srcLimit,
211
0
                icu::Edits *edits, UErrorCode &errorCode) {
212
0
    const int8_t *latinToLower;
213
0
    if (caseLocale == UCASE_LOC_ROOT ||
214
0
            (caseLocale >= 0 ?
215
0
                !(caseLocale == UCASE_LOC_TURKISH || caseLocale == UCASE_LOC_LITHUANIAN) :
216
0
                (options & _FOLD_CASE_OPTIONS_MASK) == U_FOLD_CASE_DEFAULT)) {
217
0
        latinToLower = LatinCase::TO_LOWER_NORMAL;
218
0
    } else {
219
0
        latinToLower = LatinCase::TO_LOWER_TR_LT;
220
0
    }
221
0
    const UTrie2 *trie = ucase_getTrie();
222
0
    int32_t destIndex = 0;
223
0
    int32_t prev = srcStart;
224
0
    int32_t srcIndex = srcStart;
225
0
    for (;;) {
226
        // fast path for simple cases
227
0
        UChar lead = 0;
228
0
        while (srcIndex < srcLimit) {
229
0
            lead = src[srcIndex];
230
0
            int32_t delta;
231
0
            if (lead < LatinCase::LONG_S) {
232
0
                int8_t d = latinToLower[lead];
233
0
                if (d == LatinCase::EXC) { break; }
234
0
                ++srcIndex;
235
0
                if (d == 0) { continue; }
236
0
                delta = d;
237
0
            } else if (lead >= 0xd800) {
238
0
                break;  // surrogate or higher
239
0
            } else {
240
0
                uint16_t props = UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, lead);
241
0
                if (UCASE_HAS_EXCEPTION(props)) { break; }
242
0
                ++srcIndex;
243
0
                if (!UCASE_IS_UPPER_OR_TITLE(props) || (delta = UCASE_GET_DELTA(props)) == 0) {
244
0
                    continue;
245
0
                }
246
0
            }
247
0
            lead += static_cast<UChar>(delta);
248
0
            destIndex = appendUnchanged(dest, destIndex, destCapacity,
249
0
                                        src + prev, srcIndex - 1 - prev, options, edits);
250
0
            if (destIndex >= 0) {
251
0
                destIndex = appendUChar(dest, destIndex, destCapacity, lead);
252
0
                if (edits != nullptr) {
253
0
                    edits->addReplace(1, 1);
254
0
                }
255
0
            }
256
0
            if (destIndex < 0) {
257
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
258
0
                return 0;
259
0
            }
260
0
            prev = srcIndex;
261
0
        }
262
0
        if (srcIndex >= srcLimit) {
263
0
            break;
264
0
        }
265
        // slow path
266
0
        int32_t cpStart = srcIndex++;
267
0
        UChar trail;
268
0
        UChar32 c;
269
0
        if (U16_IS_LEAD(lead) && srcIndex < srcLimit && U16_IS_TRAIL(trail = src[srcIndex])) {
270
0
            c = U16_GET_SUPPLEMENTARY(lead, trail);
271
0
            ++srcIndex;
272
0
        } else {
273
0
            c = lead;
274
0
        }
275
0
        const UChar *s;
276
0
        if (caseLocale >= 0) {
277
0
            csc->cpStart = cpStart;
278
0
            csc->cpLimit = srcIndex;
279
0
            c = ucase_toFullLower(c, utf16_caseContextIterator, csc, &s, caseLocale);
280
0
        } else {
281
0
            c = ucase_toFullFolding(c, &s, options);
282
0
        }
283
0
        if (c >= 0) {
284
0
            destIndex = appendUnchanged(dest, destIndex, destCapacity,
285
0
                                        src + prev, cpStart - prev, options, edits);
286
0
            if (destIndex >= 0) {
287
0
                destIndex = appendResult(dest, destIndex, destCapacity, c, s,
288
0
                                         srcIndex - cpStart, options, edits);
289
0
            }
290
0
            if (destIndex < 0) {
291
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
292
0
                return 0;
293
0
            }
294
0
            prev = srcIndex;
295
0
        }
296
0
    }
297
0
    destIndex = appendUnchanged(dest, destIndex, destCapacity,
298
0
                                src + prev, srcIndex - prev, options, edits);
299
0
    if (destIndex < 0) {
300
0
        errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
301
0
        return 0;
302
0
    }
303
0
    return destIndex;
304
0
}
305
306
int32_t toUpper(int32_t caseLocale, uint32_t options,
307
                UChar *dest, int32_t destCapacity,
308
                const UChar *src, UCaseContext *csc, int32_t srcLength,
309
0
                icu::Edits *edits, UErrorCode &errorCode) {
310
0
    const int8_t *latinToUpper;
311
0
    if (caseLocale == UCASE_LOC_TURKISH) {
312
0
        latinToUpper = LatinCase::TO_UPPER_TR;
313
0
    } else {
314
0
        latinToUpper = LatinCase::TO_UPPER_NORMAL;
315
0
    }
316
0
    const UTrie2 *trie = ucase_getTrie();
317
0
    int32_t destIndex = 0;
318
0
    int32_t prev = 0;
319
0
    int32_t srcIndex = 0;
320
0
    for (;;) {
321
        // fast path for simple cases
322
0
        UChar lead = 0;
323
0
        while (srcIndex < srcLength) {
324
0
            lead = src[srcIndex];
325
0
            int32_t delta;
326
0
            if (lead < LatinCase::LONG_S) {
327
0
                int8_t d = latinToUpper[lead];
328
0
                if (d == LatinCase::EXC) { break; }
329
0
                ++srcIndex;
330
0
                if (d == 0) { continue; }
331
0
                delta = d;
332
0
            } else if (lead >= 0xd800) {
333
0
                break;  // surrogate or higher
334
0
            } else {
335
0
                uint16_t props = UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, lead);
336
0
                if (UCASE_HAS_EXCEPTION(props)) { break; }
337
0
                ++srcIndex;
338
0
                if (UCASE_GET_TYPE(props) != UCASE_LOWER || (delta = UCASE_GET_DELTA(props)) == 0) {
339
0
                    continue;
340
0
                }
341
0
            }
342
0
            lead += static_cast<UChar>(delta);
343
0
            destIndex = appendUnchanged(dest, destIndex, destCapacity,
344
0
                                        src + prev, srcIndex - 1 - prev, options, edits);
345
0
            if (destIndex >= 0) {
346
0
                destIndex = appendUChar(dest, destIndex, destCapacity, lead);
347
0
                if (edits != nullptr) {
348
0
                    edits->addReplace(1, 1);
349
0
                }
350
0
            }
351
0
            if (destIndex < 0) {
352
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
353
0
                return 0;
354
0
            }
355
0
            prev = srcIndex;
356
0
        }
357
0
        if (srcIndex >= srcLength) {
358
0
            break;
359
0
        }
360
        // slow path
361
0
        int32_t cpStart;
362
0
        csc->cpStart = cpStart = srcIndex++;
363
0
        UChar trail;
364
0
        UChar32 c;
365
0
        if (U16_IS_LEAD(lead) && srcIndex < srcLength && U16_IS_TRAIL(trail = src[srcIndex])) {
366
0
            c = U16_GET_SUPPLEMENTARY(lead, trail);
367
0
            ++srcIndex;
368
0
        } else {
369
0
            c = lead;
370
0
        }
371
0
        csc->cpLimit = srcIndex;
372
0
        const UChar *s;
373
0
        c = ucase_toFullUpper(c, utf16_caseContextIterator, csc, &s, caseLocale);
374
0
        if (c >= 0) {
375
0
            destIndex = appendUnchanged(dest, destIndex, destCapacity,
376
0
                                        src + prev, cpStart - prev, options, edits);
377
0
            if (destIndex >= 0) {
378
0
                destIndex = appendResult(dest, destIndex, destCapacity, c, s,
379
0
                                         srcIndex - cpStart, options, edits);
380
0
            }
381
0
            if (destIndex < 0) {
382
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
383
0
                return 0;
384
0
            }
385
0
            prev = srcIndex;
386
0
        }
387
0
    }
388
0
    destIndex = appendUnchanged(dest, destIndex, destCapacity,
389
0
                                src + prev, srcIndex - prev, options, edits);
390
0
    if (destIndex < 0) {
391
0
        errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
392
0
        return 0;
393
0
    }
394
0
    return destIndex;
395
0
}
396
397
}  // namespace
398
399
U_NAMESPACE_END
400
401
U_NAMESPACE_USE
402
403
#if !UCONFIG_NO_BREAK_ITERATION
404
405
namespace {
406
407
/**
408
 * Input: c is a letter I with or without acute accent.
409
 * start is the index in src after c, and is less than segmentLimit.
410
 * If a plain i/I is followed by a plain j/J,
411
 * or an i/I with acute (precomposed or decomposed) is followed by a j/J with acute,
412
 * then we output accordingly.
413
 *
414
 * @return the src index after the titlecased sequence, or the start index if no Dutch IJ
415
 */
416
int32_t maybeTitleDutchIJ(const UChar *src, UChar32 c, int32_t start, int32_t segmentLimit,
417
                          UChar *dest, int32_t &destIndex, int32_t destCapacity, uint32_t options,
418
0
                          icu::Edits *edits) {
419
0
    U_ASSERT(start < segmentLimit);
420
421
0
    int32_t index = start;
422
0
    bool withAcute = false;
423
424
    // If the conditions are met, then the following variables tell us what to output.
425
0
    int32_t unchanged1 = 0;  // code units before the j, or the whole sequence (0..3)
426
0
    bool doTitleJ = false;  // true if the j needs to be titlecased
427
0
    int32_t unchanged2 = 0;  // after the j (0 or 1)
428
429
    // next character after the first letter
430
0
    UChar c2 = src[index++];
431
432
    // Is the first letter an i/I with accent?
433
0
    if (c == u'I') {
434
0
        if (c2 == ACUTE) {
435
0
            withAcute = true;
436
0
            unchanged1 = 1;
437
0
            if (index == segmentLimit) { return start; }
438
0
            c2 = src[index++];
439
0
        }
440
0
    } else {  // Í
441
0
        withAcute = true;
442
0
    }
443
444
    // Is the next character a j/J?
445
0
    if (c2 == u'j') {
446
0
        doTitleJ = true;
447
0
    } else if (c2 == u'J') {
448
0
        ++unchanged1;
449
0
    } else {
450
0
        return start;
451
0
    }
452
453
    // A plain i/I must be followed by a plain j/J.
454
    // An i/I with acute must be followed by a j/J with acute.
455
0
    if (withAcute) {
456
0
        if (index == segmentLimit || src[index++] != ACUTE) { return start; }
457
0
        if (doTitleJ) {
458
0
            unchanged2 = 1;
459
0
        } else {
460
0
            ++unchanged1;
461
0
        }
462
0
    }
463
464
    // There must not be another combining mark.
465
0
    if (index < segmentLimit) {
466
0
        int32_t cp;
467
0
        int32_t i = index;
468
0
        U16_NEXT(src, i, segmentLimit, cp);
469
0
        uint32_t typeMask = U_GET_GC_MASK(cp);
470
0
        if ((typeMask & U_GC_M_MASK) != 0) {
471
0
            return start;
472
0
        }
473
0
    }
474
475
    // Output the rest of the Dutch IJ.
476
0
    destIndex = appendUnchanged(dest, destIndex, destCapacity, src + start, unchanged1, options, edits);
477
0
    start += unchanged1;
478
0
    if (doTitleJ) {
479
0
        destIndex = appendUChar(dest, destIndex, destCapacity, u'J');
480
0
        if (edits != nullptr) {
481
0
            edits->addReplace(1, 1);
482
0
        }
483
0
        ++start;
484
0
    }
485
0
    destIndex = appendUnchanged(dest, destIndex, destCapacity, src + start, unchanged2, options, edits);
486
487
0
    U_ASSERT(start + unchanged2 == index);
488
0
    return index;
489
0
}
490
491
}  // namespace
492
493
U_CFUNC int32_t U_CALLCONV
494
ustrcase_internalToTitle(int32_t caseLocale, uint32_t options, BreakIterator *iter,
495
                         UChar *dest, int32_t destCapacity,
496
                         const UChar *src, int32_t srcLength,
497
                         icu::Edits *edits,
498
0
                         UErrorCode &errorCode) {
499
0
    if (!ustrcase_checkTitleAdjustmentOptions(options, errorCode)) {
500
0
        return 0;
501
0
    }
502
503
    /* set up local variables */
504
0
    UCaseContext csc=UCASECONTEXT_INITIALIZER;
505
0
    csc.p=(void *)src;
506
0
    csc.limit=srcLength;
507
0
    int32_t destIndex=0;
508
0
    int32_t prev=0;
509
0
    bool isFirstIndex=true;
510
511
    /* titlecasing loop */
512
0
    while(prev<srcLength) {
513
        /* find next index where to titlecase */
514
0
        int32_t index;
515
0
        if(isFirstIndex) {
516
0
            isFirstIndex=false;
517
0
            index=iter->first();
518
0
        } else {
519
0
            index=iter->next();
520
0
        }
521
0
        if(index==UBRK_DONE || index>srcLength) {
522
0
            index=srcLength;
523
0
        }
524
525
        /*
526
         * Segment [prev..index[ into 3 parts:
527
         * a) skipped characters (copy as-is) [prev..titleStart[
528
         * b) first letter (titlecase)              [titleStart..titleLimit[
529
         * c) subsequent characters (lowercase)                 [titleLimit..index[
530
         */
531
0
        if(prev<index) {
532
            // Find and copy skipped characters [prev..titleStart[
533
0
            int32_t titleStart=prev;
534
0
            int32_t titleLimit=prev;
535
0
            UChar32 c;
536
0
            U16_NEXT(src, titleLimit, index, c);
537
0
            if ((options&U_TITLECASE_NO_BREAK_ADJUSTMENT)==0) {
538
                // Adjust the titlecasing index to the next cased character,
539
                // or to the next letter/number/symbol/private use.
540
                // Stop with titleStart<titleLimit<=index
541
                // if there is a character to be titlecased,
542
                // or else stop with titleStart==titleLimit==index.
543
0
                bool toCased = (options&U_TITLECASE_ADJUST_TO_CASED) != 0;
544
0
                while (toCased ? UCASE_NONE==ucase_getType(c) : !ustrcase_isLNS(c)) {
545
0
                    titleStart=titleLimit;
546
0
                    if(titleLimit==index) {
547
0
                        break;
548
0
                    }
549
0
                    U16_NEXT(src, titleLimit, index, c);
550
0
                }
551
0
                if (prev < titleStart) {
552
0
                    destIndex=appendUnchanged(dest, destIndex, destCapacity,
553
0
                                              src+prev, titleStart-prev, options, edits);
554
0
                    if(destIndex<0) {
555
0
                        errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
556
0
                        return 0;
557
0
                    }
558
0
                }
559
0
            }
560
561
0
            if(titleStart<titleLimit) {
562
                /* titlecase c which is from [titleStart..titleLimit[ */
563
0
                csc.cpStart=titleStart;
564
0
                csc.cpLimit=titleLimit;
565
0
                const UChar *s;
566
0
                c=ucase_toFullTitle(c, utf16_caseContextIterator, &csc, &s, caseLocale);
567
0
                destIndex=appendResult(dest, destIndex, destCapacity, c, s,
568
0
                                       titleLimit-titleStart, options, edits);
569
0
                if(destIndex<0) {
570
0
                    errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
571
0
                    return 0;
572
0
                }
573
574
                /* Special case Dutch IJ titlecasing */
575
0
                if (titleStart+1 < index &&
576
0
                        caseLocale == UCASE_LOC_DUTCH) {
577
0
                    if (c < 0) {
578
0
                        c = ~c;
579
0
                    }
580
581
0
                    if (c == u'I' || c == u'Í') {
582
0
                        titleLimit = maybeTitleDutchIJ(src, c, titleStart + 1, index, 
583
0
                                                       dest, destIndex, destCapacity, options, 
584
0
                                                       edits);
585
0
                    }
586
0
                }
587
588
                /* lowercase [titleLimit..index[ */
589
0
                if(titleLimit<index) {
590
0
                    if((options&U_TITLECASE_NO_LOWERCASE)==0) {
591
                        /* Normal operation: Lowercase the rest of the word. */
592
0
                        destIndex+=
593
0
                            toLower(
594
0
                                caseLocale, options,
595
0
                                dest+destIndex, destCapacity-destIndex,
596
0
                                src, &csc, titleLimit, index,
597
0
                                edits, errorCode);
598
0
                        if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
599
0
                            errorCode=U_ZERO_ERROR;
600
0
                        }
601
0
                        if(U_FAILURE(errorCode)) {
602
0
                            return destIndex;
603
0
                        }
604
0
                    } else {
605
                        /* Optionally just copy the rest of the word unchanged. */
606
0
                        destIndex=appendUnchanged(dest, destIndex, destCapacity,
607
0
                                                  src+titleLimit, index-titleLimit, options, edits);
608
0
                        if(destIndex<0) {
609
0
                            errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
610
0
                            return 0;
611
0
                        }
612
0
                    }
613
0
                }
614
0
            }
615
0
        }
616
617
0
        prev=index;
618
0
    }
619
620
0
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
621
0
}
622
623
#endif  // !UCONFIG_NO_BREAK_ITERATION
624
625
U_NAMESPACE_BEGIN
626
namespace GreekUpper {
627
628
// Data generated by prototype code, see
629
// https://icu.unicode.org/design/case/greek-upper
630
// TODO: Move this data into ucase.icu.
631
static const uint16_t data0370[] = {
632
    // U+0370..03FF
633
    0x0370,
634
    0x0370,
635
    0x0372,
636
    0x0372,
637
    0,
638
    0,
639
    0x0376,
640
    0x0376,
641
    0,
642
    0,
643
    0x037A,
644
    0x03FD,
645
    0x03FE,
646
    0x03FF,
647
    0,
648
    0x037F,
649
    0,
650
    0,
651
    0,
652
    0,
653
    0,
654
    0,
655
    0x0391 | HAS_VOWEL | HAS_ACCENT,
656
    0,
657
    0x0395 | HAS_VOWEL | HAS_ACCENT,
658
    0x0397 | HAS_VOWEL | HAS_ACCENT,
659
    0x0399 | HAS_VOWEL | HAS_ACCENT,
660
    0,
661
    0x039F | HAS_VOWEL | HAS_ACCENT,
662
    0,
663
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
664
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
665
    0x0399 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
666
    0x0391 | HAS_VOWEL,
667
    0x0392,
668
    0x0393,
669
    0x0394,
670
    0x0395 | HAS_VOWEL,
671
    0x0396,
672
    0x0397 | HAS_VOWEL,
673
    0x0398,
674
    0x0399 | HAS_VOWEL,
675
    0x039A,
676
    0x039B,
677
    0x039C,
678
    0x039D,
679
    0x039E,
680
    0x039F | HAS_VOWEL,
681
    0x03A0,
682
    0x03A1,
683
    0,
684
    0x03A3,
685
    0x03A4,
686
    0x03A5 | HAS_VOWEL,
687
    0x03A6,
688
    0x03A7,
689
    0x03A8,
690
    0x03A9 | HAS_VOWEL,
691
    0x0399 | HAS_VOWEL | HAS_DIALYTIKA,
692
    0x03A5 | HAS_VOWEL | HAS_DIALYTIKA,
693
    0x0391 | HAS_VOWEL | HAS_ACCENT,
694
    0x0395 | HAS_VOWEL | HAS_ACCENT,
695
    0x0397 | HAS_VOWEL | HAS_ACCENT,
696
    0x0399 | HAS_VOWEL | HAS_ACCENT,
697
    0x03A5 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
698
    0x0391 | HAS_VOWEL,
699
    0x0392,
700
    0x0393,
701
    0x0394,
702
    0x0395 | HAS_VOWEL,
703
    0x0396,
704
    0x0397 | HAS_VOWEL,
705
    0x0398,
706
    0x0399 | HAS_VOWEL,
707
    0x039A,
708
    0x039B,
709
    0x039C,
710
    0x039D,
711
    0x039E,
712
    0x039F | HAS_VOWEL,
713
    0x03A0,
714
    0x03A1,
715
    0x03A3,
716
    0x03A3,
717
    0x03A4,
718
    0x03A5 | HAS_VOWEL,
719
    0x03A6,
720
    0x03A7,
721
    0x03A8,
722
    0x03A9 | HAS_VOWEL,
723
    0x0399 | HAS_VOWEL | HAS_DIALYTIKA,
724
    0x03A5 | HAS_VOWEL | HAS_DIALYTIKA,
725
    0x039F | HAS_VOWEL | HAS_ACCENT,
726
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
727
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
728
    0x03CF,
729
    0x0392,
730
    0x0398,
731
    0x03D2,
732
    0x03D2 | HAS_ACCENT,
733
    0x03D2 | HAS_DIALYTIKA,
734
    0x03A6,
735
    0x03A0,
736
    0x03CF,
737
    0x03D8,
738
    0x03D8,
739
    0x03DA,
740
    0x03DA,
741
    0x03DC,
742
    0x03DC,
743
    0x03DE,
744
    0x03DE,
745
    0x03E0,
746
    0x03E0,
747
    0,
748
    0,
749
    0,
750
    0,
751
    0,
752
    0,
753
    0,
754
    0,
755
    0,
756
    0,
757
    0,
758
    0,
759
    0,
760
    0,
761
    0x039A,
762
    0x03A1,
763
    0x03F9,
764
    0x037F,
765
    0x03F4,
766
    0x0395 | HAS_VOWEL,
767
    0,
768
    0x03F7,
769
    0x03F7,
770
    0x03F9,
771
    0x03FA,
772
    0x03FA,
773
    0x03FC,
774
    0x03FD,
775
    0x03FE,
776
    0x03FF,
777
};
778
779
static const uint16_t data1F00[] = {
780
    // U+1F00..1FFF
781
    0x0391 | HAS_VOWEL,
782
    0x0391 | HAS_VOWEL,
783
    0x0391 | HAS_VOWEL | HAS_ACCENT,
784
    0x0391 | HAS_VOWEL | HAS_ACCENT,
785
    0x0391 | HAS_VOWEL | HAS_ACCENT,
786
    0x0391 | HAS_VOWEL | HAS_ACCENT,
787
    0x0391 | HAS_VOWEL | HAS_ACCENT,
788
    0x0391 | HAS_VOWEL | HAS_ACCENT,
789
    0x0391 | HAS_VOWEL,
790
    0x0391 | HAS_VOWEL,
791
    0x0391 | HAS_VOWEL | HAS_ACCENT,
792
    0x0391 | HAS_VOWEL | HAS_ACCENT,
793
    0x0391 | HAS_VOWEL | HAS_ACCENT,
794
    0x0391 | HAS_VOWEL | HAS_ACCENT,
795
    0x0391 | HAS_VOWEL | HAS_ACCENT,
796
    0x0391 | HAS_VOWEL | HAS_ACCENT,
797
    0x0395 | HAS_VOWEL,
798
    0x0395 | HAS_VOWEL,
799
    0x0395 | HAS_VOWEL | HAS_ACCENT,
800
    0x0395 | HAS_VOWEL | HAS_ACCENT,
801
    0x0395 | HAS_VOWEL | HAS_ACCENT,
802
    0x0395 | HAS_VOWEL | HAS_ACCENT,
803
    0,
804
    0,
805
    0x0395 | HAS_VOWEL,
806
    0x0395 | HAS_VOWEL,
807
    0x0395 | HAS_VOWEL | HAS_ACCENT,
808
    0x0395 | HAS_VOWEL | HAS_ACCENT,
809
    0x0395 | HAS_VOWEL | HAS_ACCENT,
810
    0x0395 | HAS_VOWEL | HAS_ACCENT,
811
    0,
812
    0,
813
    0x0397 | HAS_VOWEL,
814
    0x0397 | HAS_VOWEL,
815
    0x0397 | HAS_VOWEL | HAS_ACCENT,
816
    0x0397 | HAS_VOWEL | HAS_ACCENT,
817
    0x0397 | HAS_VOWEL | HAS_ACCENT,
818
    0x0397 | HAS_VOWEL | HAS_ACCENT,
819
    0x0397 | HAS_VOWEL | HAS_ACCENT,
820
    0x0397 | HAS_VOWEL | HAS_ACCENT,
821
    0x0397 | HAS_VOWEL,
822
    0x0397 | HAS_VOWEL,
823
    0x0397 | HAS_VOWEL | HAS_ACCENT,
824
    0x0397 | HAS_VOWEL | HAS_ACCENT,
825
    0x0397 | HAS_VOWEL | HAS_ACCENT,
826
    0x0397 | HAS_VOWEL | HAS_ACCENT,
827
    0x0397 | HAS_VOWEL | HAS_ACCENT,
828
    0x0397 | HAS_VOWEL | HAS_ACCENT,
829
    0x0399 | HAS_VOWEL,
830
    0x0399 | HAS_VOWEL,
831
    0x0399 | HAS_VOWEL | HAS_ACCENT,
832
    0x0399 | HAS_VOWEL | HAS_ACCENT,
833
    0x0399 | HAS_VOWEL | HAS_ACCENT,
834
    0x0399 | HAS_VOWEL | HAS_ACCENT,
835
    0x0399 | HAS_VOWEL | HAS_ACCENT,
836
    0x0399 | HAS_VOWEL | HAS_ACCENT,
837
    0x0399 | HAS_VOWEL,
838
    0x0399 | HAS_VOWEL,
839
    0x0399 | HAS_VOWEL | HAS_ACCENT,
840
    0x0399 | HAS_VOWEL | HAS_ACCENT,
841
    0x0399 | HAS_VOWEL | HAS_ACCENT,
842
    0x0399 | HAS_VOWEL | HAS_ACCENT,
843
    0x0399 | HAS_VOWEL | HAS_ACCENT,
844
    0x0399 | HAS_VOWEL | HAS_ACCENT,
845
    0x039F | HAS_VOWEL,
846
    0x039F | HAS_VOWEL,
847
    0x039F | HAS_VOWEL | HAS_ACCENT,
848
    0x039F | HAS_VOWEL | HAS_ACCENT,
849
    0x039F | HAS_VOWEL | HAS_ACCENT,
850
    0x039F | HAS_VOWEL | HAS_ACCENT,
851
    0,
852
    0,
853
    0x039F | HAS_VOWEL,
854
    0x039F | HAS_VOWEL,
855
    0x039F | HAS_VOWEL | HAS_ACCENT,
856
    0x039F | HAS_VOWEL | HAS_ACCENT,
857
    0x039F | HAS_VOWEL | HAS_ACCENT,
858
    0x039F | HAS_VOWEL | HAS_ACCENT,
859
    0,
860
    0,
861
    0x03A5 | HAS_VOWEL,
862
    0x03A5 | HAS_VOWEL,
863
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
864
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
865
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
866
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
867
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
868
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
869
    0,
870
    0x03A5 | HAS_VOWEL,
871
    0,
872
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
873
    0,
874
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
875
    0,
876
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
877
    0x03A9 | HAS_VOWEL,
878
    0x03A9 | HAS_VOWEL,
879
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
880
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
881
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
882
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
883
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
884
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
885
    0x03A9 | HAS_VOWEL,
886
    0x03A9 | HAS_VOWEL,
887
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
888
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
889
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
890
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
891
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
892
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
893
    0x0391 | HAS_VOWEL | HAS_ACCENT,
894
    0x0391 | HAS_VOWEL | HAS_ACCENT,
895
    0x0395 | HAS_VOWEL | HAS_ACCENT,
896
    0x0395 | HAS_VOWEL | HAS_ACCENT,
897
    0x0397 | HAS_VOWEL | HAS_ACCENT,
898
    0x0397 | HAS_VOWEL | HAS_ACCENT,
899
    0x0399 | HAS_VOWEL | HAS_ACCENT,
900
    0x0399 | HAS_VOWEL | HAS_ACCENT,
901
    0x039F | HAS_VOWEL | HAS_ACCENT,
902
    0x039F | HAS_VOWEL | HAS_ACCENT,
903
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
904
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
905
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
906
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
907
    0,
908
    0,
909
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
910
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
911
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
912
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
913
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
914
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
915
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
916
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
917
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
918
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
919
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
920
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
921
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
922
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
923
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
924
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
925
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
926
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
927
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
928
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
929
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
930
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
931
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
932
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
933
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
934
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
935
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
936
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
937
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
938
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
939
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
940
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
941
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
942
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
943
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
944
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
945
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
946
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
947
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
948
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
949
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
950
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
951
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
952
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
953
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
954
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
955
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
956
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
957
    0x0391 | HAS_VOWEL,
958
    0x0391 | HAS_VOWEL,
959
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
960
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
961
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
962
    0,
963
    0x0391 | HAS_VOWEL | HAS_ACCENT,
964
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
965
    0x0391 | HAS_VOWEL,
966
    0x0391 | HAS_VOWEL,
967
    0x0391 | HAS_VOWEL | HAS_ACCENT,
968
    0x0391 | HAS_VOWEL | HAS_ACCENT,
969
    0x0391 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
970
    0,
971
    0x0399 | HAS_VOWEL,
972
    0,
973
    0,
974
    0,
975
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
976
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
977
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
978
    0,
979
    0x0397 | HAS_VOWEL | HAS_ACCENT,
980
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
981
    0x0395 | HAS_VOWEL | HAS_ACCENT,
982
    0x0395 | HAS_VOWEL | HAS_ACCENT,
983
    0x0397 | HAS_VOWEL | HAS_ACCENT,
984
    0x0397 | HAS_VOWEL | HAS_ACCENT,
985
    0x0397 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
986
    0,
987
    0,
988
    0,
989
    0x0399 | HAS_VOWEL,
990
    0x0399 | HAS_VOWEL,
991
    0x0399 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
992
    0x0399 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
993
    0,
994
    0,
995
    0x0399 | HAS_VOWEL | HAS_ACCENT,
996
    0x0399 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
997
    0x0399 | HAS_VOWEL,
998
    0x0399 | HAS_VOWEL,
999
    0x0399 | HAS_VOWEL | HAS_ACCENT,
1000
    0x0399 | HAS_VOWEL | HAS_ACCENT,
1001
    0,
1002
    0,
1003
    0,
1004
    0,
1005
    0x03A5 | HAS_VOWEL,
1006
    0x03A5 | HAS_VOWEL,
1007
    0x03A5 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
1008
    0x03A5 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
1009
    0x03A1,
1010
    0x03A1,
1011
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
1012
    0x03A5 | HAS_VOWEL | HAS_ACCENT | HAS_DIALYTIKA,
1013
    0x03A5 | HAS_VOWEL,
1014
    0x03A5 | HAS_VOWEL,
1015
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
1016
    0x03A5 | HAS_VOWEL | HAS_ACCENT,
1017
    0x03A1,
1018
    0,
1019
    0,
1020
    0,
1021
    0,
1022
    0,
1023
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
1024
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
1025
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
1026
    0,
1027
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
1028
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI | HAS_ACCENT,
1029
    0x039F | HAS_VOWEL | HAS_ACCENT,
1030
    0x039F | HAS_VOWEL | HAS_ACCENT,
1031
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
1032
    0x03A9 | HAS_VOWEL | HAS_ACCENT,
1033
    0x03A9 | HAS_VOWEL | HAS_YPOGEGRAMMENI,
1034
    0,
1035
    0,
1036
    0,
1037
};
1038
1039
// U+2126 Ohm sign
1040
static const uint16_t data2126 = 0x03A9 | HAS_VOWEL;
1041
1042
0
uint32_t getLetterData(UChar32 c) {
1043
0
    if (c < 0x370 || 0x2126 < c || (0x3ff < c && c < 0x1f00)) {
1044
0
        return 0;
1045
0
    } else if (c <= 0x3ff) {
1046
0
        return data0370[c - 0x370];
1047
0
    } else if (c <= 0x1fff) {
1048
0
        return data1F00[c - 0x1f00];
1049
0
    } else if (c == 0x2126) {
1050
0
        return data2126;
1051
0
    } else {
1052
0
        return 0;
1053
0
    }
1054
0
}
1055
1056
0
uint32_t getDiacriticData(UChar32 c) {
1057
0
    switch (c) {
1058
0
    case 0x0300:  // varia
1059
0
    case 0x0301:  // tonos = oxia
1060
0
    case 0x0342:  // perispomeni
1061
0
    case 0x0302:  // circumflex can look like perispomeni
1062
0
    case 0x0303:  // tilde can look like perispomeni
1063
0
    case 0x0311:  // inverted breve can look like perispomeni
1064
0
        return HAS_ACCENT;
1065
0
    case 0x0308:  // dialytika = diaeresis
1066
0
        return HAS_COMBINING_DIALYTIKA;
1067
0
    case 0x0344:  // dialytika tonos
1068
0
        return HAS_COMBINING_DIALYTIKA | HAS_ACCENT;
1069
0
    case 0x0345:  // ypogegrammeni = iota subscript
1070
0
        return HAS_YPOGEGRAMMENI;
1071
0
    case 0x0304:  // macron
1072
0
    case 0x0306:  // breve
1073
0
    case 0x0313:  // comma above
1074
0
    case 0x0314:  // reversed comma above
1075
0
    case 0x0343:  // koronis
1076
0
        return HAS_OTHER_GREEK_DIACRITIC;
1077
0
    default:
1078
0
        return 0;
1079
0
    }
1080
0
}
1081
1082
0
UBool isFollowedByCasedLetter(const UChar *s, int32_t i, int32_t length) {
1083
0
    while (i < length) {
1084
0
        UChar32 c;
1085
0
        U16_NEXT(s, i, length, c);
1086
0
        int32_t type = ucase_getTypeOrIgnorable(c);
1087
0
        if ((type & UCASE_IGNORABLE) != 0) {
1088
            // Case-ignorable, continue with the loop.
1089
0
        } else if (type != UCASE_NONE) {
1090
0
            return TRUE;  // Followed by cased letter.
1091
0
        } else {
1092
0
            return FALSE;  // Uncased and not case-ignorable.
1093
0
        }
1094
0
    }
1095
0
    return FALSE;  // Not followed by cased letter.
1096
0
}
1097
1098
/**
1099
 * Greek string uppercasing with a state machine.
1100
 * Probably simpler than a stateless function that has to figure out complex context-before
1101
 * for each character.
1102
 * TODO: Try to re-consolidate one way or another with the non-Greek function.
1103
 */
1104
int32_t toUpper(uint32_t options,
1105
                UChar *dest, int32_t destCapacity,
1106
                const UChar *src, int32_t srcLength,
1107
                Edits *edits,
1108
0
                UErrorCode &errorCode) {
1109
0
    int32_t destIndex=0;
1110
0
    uint32_t state = 0;
1111
0
    for (int32_t i = 0; i < srcLength;) {
1112
0
        int32_t nextIndex = i;
1113
0
        UChar32 c;
1114
0
        U16_NEXT(src, nextIndex, srcLength, c);
1115
0
        uint32_t nextState = 0;
1116
0
        int32_t type = ucase_getTypeOrIgnorable(c);
1117
0
        if ((type & UCASE_IGNORABLE) != 0) {
1118
            // c is case-ignorable
1119
0
            nextState |= (state & AFTER_CASED);
1120
0
        } else if (type != UCASE_NONE) {
1121
            // c is cased
1122
0
            nextState |= AFTER_CASED;
1123
0
        }
1124
0
        uint32_t data = getLetterData(c);
1125
0
        if (data > 0) {
1126
0
            uint32_t upper = data & UPPER_MASK;
1127
            // Add a dialytika to this iota or ypsilon vowel
1128
            // if we removed a tonos from the previous vowel,
1129
            // and that previous vowel did not also have (or gain) a dialytika.
1130
            // Adding one only to the final vowel in a longer sequence
1131
            // (which does not occur in normal writing) would require lookahead.
1132
            // Set the same flag as for preserving an existing dialytika.
1133
0
            if ((data & HAS_VOWEL) != 0 && (state & AFTER_VOWEL_WITH_ACCENT) != 0 &&
1134
0
                    (upper == 0x399 || upper == 0x3A5)) {
1135
0
                data |= HAS_DIALYTIKA;
1136
0
            }
1137
0
            int32_t numYpogegrammeni = 0;  // Map each one to a trailing, spacing, capital iota.
1138
0
            if ((data & HAS_YPOGEGRAMMENI) != 0) {
1139
0
                numYpogegrammeni = 1;
1140
0
            }
1141
            // Skip combining diacritics after this Greek letter.
1142
0
            while (nextIndex < srcLength) {
1143
0
                uint32_t diacriticData = getDiacriticData(src[nextIndex]);
1144
0
                if (diacriticData != 0) {
1145
0
                    data |= diacriticData;
1146
0
                    if ((diacriticData & HAS_YPOGEGRAMMENI) != 0) {
1147
0
                        ++numYpogegrammeni;
1148
0
                    }
1149
0
                    ++nextIndex;
1150
0
                } else {
1151
0
                    break;  // not a Greek diacritic
1152
0
                }
1153
0
            }
1154
0
            if ((data & HAS_VOWEL_AND_ACCENT_AND_DIALYTIKA) == HAS_VOWEL_AND_ACCENT) {
1155
0
                nextState |= AFTER_VOWEL_WITH_ACCENT;
1156
0
            }
1157
            // Map according to Greek rules.
1158
0
            UBool addTonos = FALSE;
1159
0
            if (upper == 0x397 &&
1160
0
                    (data & HAS_ACCENT) != 0 &&
1161
0
                    numYpogegrammeni == 0 &&
1162
0
                    (state & AFTER_CASED) == 0 &&
1163
0
                    !isFollowedByCasedLetter(src, nextIndex, srcLength)) {
1164
                // Keep disjunctive "or" with (only) a tonos.
1165
                // We use the same "word boundary" conditions as for the Final_Sigma test.
1166
0
                if (i == nextIndex) {
1167
0
                    upper = 0x389;  // Preserve the precomposed form.
1168
0
                } else {
1169
0
                    addTonos = TRUE;
1170
0
                }
1171
0
            } else if ((data & HAS_DIALYTIKA) != 0) {
1172
                // Preserve a vowel with dialytika in precomposed form if it exists.
1173
0
                if (upper == 0x399) {
1174
0
                    upper = 0x3AA;
1175
0
                    data &= ~HAS_EITHER_DIALYTIKA;
1176
0
                } else if (upper == 0x3A5) {
1177
0
                    upper = 0x3AB;
1178
0
                    data &= ~HAS_EITHER_DIALYTIKA;
1179
0
                }
1180
0
            }
1181
1182
0
            UBool change;
1183
0
            if (edits == nullptr && (options & U_OMIT_UNCHANGED_TEXT) == 0) {
1184
0
                change = TRUE;  // common, simple usage
1185
0
            } else {
1186
                // Find out first whether we are changing the text.
1187
0
                change = src[i] != upper || numYpogegrammeni > 0;
1188
0
                int32_t i2 = i + 1;
1189
0
                if ((data & HAS_EITHER_DIALYTIKA) != 0) {
1190
0
                    change |= i2 >= nextIndex || src[i2] != 0x308;
1191
0
                    ++i2;
1192
0
                }
1193
0
                if (addTonos) {
1194
0
                    change |= i2 >= nextIndex || src[i2] != 0x301;
1195
0
                    ++i2;
1196
0
                }
1197
0
                int32_t oldLength = nextIndex - i;
1198
0
                int32_t newLength = (i2 - i) + numYpogegrammeni;
1199
0
                change |= oldLength != newLength;
1200
0
                if (change) {
1201
0
                    if (edits != NULL) {
1202
0
                        edits->addReplace(oldLength, newLength);
1203
0
                    }
1204
0
                } else {
1205
0
                    if (edits != NULL) {
1206
0
                        edits->addUnchanged(oldLength);
1207
0
                    }
1208
                    // Write unchanged text?
1209
0
                    change = (options & U_OMIT_UNCHANGED_TEXT) == 0;
1210
0
                }
1211
0
            }
1212
1213
0
            if (change) {
1214
0
                destIndex=appendUChar(dest, destIndex, destCapacity, (UChar)upper);
1215
0
                if (destIndex >= 0 && (data & HAS_EITHER_DIALYTIKA) != 0) {
1216
0
                    destIndex=appendUChar(dest, destIndex, destCapacity, 0x308);  // restore or add a dialytika
1217
0
                }
1218
0
                if (destIndex >= 0 && addTonos) {
1219
0
                    destIndex=appendUChar(dest, destIndex, destCapacity, 0x301);
1220
0
                }
1221
0
                while (destIndex >= 0 && numYpogegrammeni > 0) {
1222
0
                    destIndex=appendUChar(dest, destIndex, destCapacity, 0x399);
1223
0
                    --numYpogegrammeni;
1224
0
                }
1225
0
                if(destIndex<0) {
1226
0
                    errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1227
0
                    return 0;
1228
0
                }
1229
0
            }
1230
0
        } else {
1231
0
            const UChar *s;
1232
0
            c=ucase_toFullUpper(c, NULL, NULL, &s, UCASE_LOC_GREEK);
1233
0
            destIndex = appendResult(dest, destIndex, destCapacity, c, s,
1234
0
                                     nextIndex - i, options, edits);
1235
0
            if (destIndex < 0) {
1236
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
1237
0
                return 0;
1238
0
            }
1239
0
        }
1240
0
        i = nextIndex;
1241
0
        state = nextState;
1242
0
    }
1243
1244
0
    return destIndex;
1245
0
}
1246
1247
}  // namespace GreekUpper
1248
U_NAMESPACE_END
1249
1250
/* functions available in the common library (for unistr_case.cpp) */
1251
1252
U_CFUNC int32_t U_CALLCONV
1253
ustrcase_internalToLower(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
1254
                         UChar *dest, int32_t destCapacity,
1255
                         const UChar *src, int32_t srcLength,
1256
                         icu::Edits *edits,
1257
0
                         UErrorCode &errorCode) {
1258
0
    UCaseContext csc=UCASECONTEXT_INITIALIZER;
1259
0
    csc.p=(void *)src;
1260
0
    csc.limit=srcLength;
1261
0
    int32_t destIndex = toLower(
1262
0
        caseLocale, options,
1263
0
        dest, destCapacity,
1264
0
        src, &csc, 0, srcLength,
1265
0
        edits, errorCode);
1266
0
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
1267
0
}
1268
1269
U_CFUNC int32_t U_CALLCONV
1270
ustrcase_internalToUpper(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
1271
                         UChar *dest, int32_t destCapacity,
1272
                         const UChar *src, int32_t srcLength,
1273
                         icu::Edits *edits,
1274
0
                         UErrorCode &errorCode) {
1275
0
    int32_t destIndex;
1276
0
    if (caseLocale == UCASE_LOC_GREEK) {
1277
0
        destIndex = GreekUpper::toUpper(options, dest, destCapacity,
1278
0
                                        src, srcLength, edits, errorCode);
1279
0
    } else {
1280
0
        UCaseContext csc=UCASECONTEXT_INITIALIZER;
1281
0
        csc.p=(void *)src;
1282
0
        csc.limit=srcLength;
1283
0
        destIndex = toUpper(
1284
0
            caseLocale, options,
1285
0
            dest, destCapacity,
1286
0
            src, &csc, srcLength,
1287
0
            edits, errorCode);
1288
0
    }
1289
0
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
1290
0
}
1291
1292
U_CFUNC int32_t U_CALLCONV
1293
ustrcase_internalFold(int32_t /* caseLocale */, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
1294
                      UChar *dest, int32_t destCapacity,
1295
                      const UChar *src, int32_t srcLength,
1296
                      icu::Edits *edits,
1297
0
                      UErrorCode &errorCode) {
1298
0
    int32_t destIndex = toLower(
1299
0
        -1, options,
1300
0
        dest, destCapacity,
1301
0
        src, nullptr, 0, srcLength,
1302
0
        edits, errorCode);
1303
0
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
1304
0
}
1305
1306
U_CFUNC int32_t
1307
ustrcase_map(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
1308
             UChar *dest, int32_t destCapacity,
1309
             const UChar *src, int32_t srcLength,
1310
             UStringCaseMapper *stringCaseMapper,
1311
             icu::Edits *edits,
1312
0
             UErrorCode &errorCode) {
1313
0
    int32_t destLength;
1314
1315
    /* check argument values */
1316
0
    if(U_FAILURE(errorCode)) {
1317
0
        return 0;
1318
0
    }
1319
0
    if( destCapacity<0 ||
1320
0
        (dest==NULL && destCapacity>0) ||
1321
0
        src==NULL ||
1322
0
        srcLength<-1
1323
0
    ) {
1324
0
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
1325
0
        return 0;
1326
0
    }
1327
1328
    /* get the string length */
1329
0
    if(srcLength==-1) {
1330
0
        srcLength=u_strlen(src);
1331
0
    }
1332
1333
    /* check for overlapping source and destination */
1334
0
    if( dest!=NULL &&
1335
0
        ((src>=dest && src<(dest+destCapacity)) ||
1336
0
         (dest>=src && dest<(src+srcLength)))
1337
0
    ) {
1338
0
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
1339
0
        return 0;
1340
0
    }
1341
1342
0
    if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
1343
0
        edits->reset();
1344
0
    }
1345
0
    destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
1346
0
                                dest, destCapacity, src, srcLength, edits, errorCode);
1347
0
    return u_terminateUChars(dest, destCapacity, destLength, &errorCode);
1348
0
}
1349
1350
U_CFUNC int32_t
1351
ustrcase_mapWithOverlap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
1352
                        UChar *dest, int32_t destCapacity,
1353
                        const UChar *src, int32_t srcLength,
1354
                        UStringCaseMapper *stringCaseMapper,
1355
0
                        UErrorCode &errorCode) {
1356
0
    UChar buffer[300];
1357
0
    UChar *temp;
1358
1359
0
    int32_t destLength;
1360
1361
    /* check argument values */
1362
0
    if(U_FAILURE(errorCode)) {
1363
0
        return 0;
1364
0
    }
1365
0
    if( destCapacity<0 ||
1366
0
        (dest==NULL && destCapacity>0) ||
1367
0
        src==NULL ||
1368
0
        srcLength<-1
1369
0
    ) {
1370
0
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
1371
0
        return 0;
1372
0
    }
1373
1374
    /* get the string length */
1375
0
    if(srcLength==-1) {
1376
0
        srcLength=u_strlen(src);
1377
0
    }
1378
1379
    /* check for overlapping source and destination */
1380
0
    if( dest!=NULL &&
1381
0
        ((src>=dest && src<(dest+destCapacity)) ||
1382
0
         (dest>=src && dest<(src+srcLength)))
1383
0
    ) {
1384
        /* overlap: provide a temporary destination buffer and later copy the result */
1385
0
        if(destCapacity<=UPRV_LENGTHOF(buffer)) {
1386
            /* the stack buffer is large enough */
1387
0
            temp=buffer;
1388
0
        } else {
1389
            /* allocate a buffer */
1390
0
            temp=(UChar *)uprv_malloc(destCapacity*U_SIZEOF_UCHAR);
1391
0
            if(temp==NULL) {
1392
0
                errorCode=U_MEMORY_ALLOCATION_ERROR;
1393
0
                return 0;
1394
0
            }
1395
0
        }
1396
0
    } else {
1397
0
        temp=dest;
1398
0
    }
1399
1400
0
    destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
1401
0
                                temp, destCapacity, src, srcLength, NULL, errorCode);
1402
0
    if(temp!=dest) {
1403
        /* copy the result string to the destination buffer */
1404
0
        if (U_SUCCESS(errorCode) && 0 < destLength && destLength <= destCapacity) {
1405
0
            u_memmove(dest, temp, destLength);
1406
0
        }
1407
0
        if(temp!=buffer) {
1408
0
            uprv_free(temp);
1409
0
        }
1410
0
    }
1411
1412
0
    return u_terminateUChars(dest, destCapacity, destLength, &errorCode);
1413
0
}
1414
1415
/* public API functions */
1416
1417
U_CAPI int32_t U_EXPORT2
1418
u_strFoldCase(UChar *dest, int32_t destCapacity,
1419
              const UChar *src, int32_t srcLength,
1420
              uint32_t options,
1421
0
              UErrorCode *pErrorCode) {
1422
0
    return ustrcase_mapWithOverlap(
1423
0
        UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL
1424
0
        dest, destCapacity,
1425
0
        src, srcLength,
1426
0
        ustrcase_internalFold, *pErrorCode);
1427
0
}
1428
1429
U_NAMESPACE_BEGIN
1430
1431
int32_t CaseMap::fold(
1432
        uint32_t options,
1433
        const UChar *src, int32_t srcLength,
1434
        UChar *dest, int32_t destCapacity, Edits *edits,
1435
0
        UErrorCode &errorCode) {
1436
0
    return ustrcase_map(
1437
0
        UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL
1438
0
        dest, destCapacity,
1439
0
        src, srcLength,
1440
0
        ustrcase_internalFold, edits, errorCode);
1441
0
}
1442
1443
U_NAMESPACE_END
1444
1445
/* case-insensitive string comparisons -------------------------------------- */
1446
1447
/*
1448
 * This function is a copy of unorm_cmpEquivFold() minus the parts for
1449
 * canonical equivalence.
1450
 * Keep the functions in sync, and see there for how this works.
1451
 * The duplication is for modularization:
1452
 * It makes caseless (but not canonical caseless) matches independent of
1453
 * the normalization code.
1454
 */
1455
1456
/* stack element for previous-level source/decomposition pointers */
1457
struct CmpEquivLevel {
1458
    const UChar *start, *s, *limit;
1459
};
1460
typedef struct CmpEquivLevel CmpEquivLevel;
1461
1462
/**
1463
 * Internal implementation code comparing string with case fold.
1464
 * This function is called from u_strcmpFold() and u_caseInsensitivePrefixMatch().
1465
 *
1466
 * @param s1            input string 1
1467
 * @param length1       length of string 1, or -1 (NULL terminated)
1468
 * @param s2            input string 2
1469
 * @param length2       length of string 2, or -1 (NULL terminated)
1470
 * @param options       compare options
1471
 * @param matchLen1     (output) length of partial prefix match in s1
1472
 * @param matchLen2     (output) length of partial prefix match in s2
1473
 * @param pErrorCode    receives error status
1474
 * @return The result of comparison
1475
 */
1476
static int32_t _cmpFold(
1477
            const UChar *s1, int32_t length1,
1478
            const UChar *s2, int32_t length2,
1479
            uint32_t options,
1480
            int32_t *matchLen1, int32_t *matchLen2,
1481
0
            UErrorCode *pErrorCode) {
1482
0
    int32_t cmpRes = 0;
1483
1484
    /* current-level start/limit - s1/s2 as current */
1485
0
    const UChar *start1, *start2, *limit1, *limit2;
1486
1487
    /* points to the original start address */
1488
0
    const UChar *org1, *org2;
1489
1490
    /* points to the end of match + 1 */
1491
0
    const UChar *m1, *m2;
1492
1493
    /* case folding variables */
1494
0
    const UChar *p;
1495
0
    int32_t length;
1496
1497
    /* stacks of previous-level start/current/limit */
1498
0
    CmpEquivLevel stack1[2], stack2[2];
1499
1500
    /* case folding buffers, only use current-level start/limit */
1501
0
    UChar fold1[UCASE_MAX_STRING_LENGTH+1], fold2[UCASE_MAX_STRING_LENGTH+1];
1502
1503
    /* track which is the current level per string */
1504
0
    int32_t level1, level2;
1505
1506
    /* current code units, and code points for lookups */
1507
0
    UChar32 c1, c2, cp1, cp2;
1508
1509
    /* no argument error checking because this itself is not an API */
1510
1511
    /*
1512
     * assume that at least the option U_COMPARE_IGNORE_CASE is set
1513
     * otherwise this function would have to behave exactly as uprv_strCompare()
1514
     */
1515
0
    if(U_FAILURE(*pErrorCode)) {
1516
0
        return 0;
1517
0
    }
1518
1519
    /* initialize */
1520
0
    if(matchLen1) {
1521
0
        U_ASSERT(matchLen2 !=NULL);
1522
0
        *matchLen1=0;
1523
0
        *matchLen2=0;
1524
0
    }
1525
1526
0
    start1=m1=org1=s1;
1527
0
    if(length1==-1) {
1528
0
        limit1=NULL;
1529
0
    } else {
1530
0
        limit1=s1+length1;
1531
0
    }
1532
1533
0
    start2=m2=org2=s2;
1534
0
    if(length2==-1) {
1535
0
        limit2=NULL;
1536
0
    } else {
1537
0
        limit2=s2+length2;
1538
0
    }
1539
1540
0
    level1=level2=0;
1541
0
    c1=c2=-1;
1542
1543
    /* comparison loop */
1544
0
    for(;;) {
1545
        /*
1546
         * here a code unit value of -1 means "get another code unit"
1547
         * below it will mean "this source is finished"
1548
         */
1549
1550
0
        if(c1<0) {
1551
            /* get next code unit from string 1, post-increment */
1552
0
            for(;;) {
1553
0
                if(s1==limit1 || ((c1=*s1)==0 && (limit1==NULL || (options&_STRNCMP_STYLE)))) {
1554
0
                    if(level1==0) {
1555
0
                        c1=-1;
1556
0
                        break;
1557
0
                    }
1558
0
                } else {
1559
0
                    ++s1;
1560
0
                    break;
1561
0
                }
1562
1563
                /* reached end of level buffer, pop one level */
1564
0
                do {
1565
0
                    --level1;
1566
0
                    start1=stack1[level1].start;    /*Not uninitialized*/
1567
0
                } while(start1==NULL);
1568
0
                s1=stack1[level1].s;                /*Not uninitialized*/
1569
0
                limit1=stack1[level1].limit;        /*Not uninitialized*/
1570
0
            }
1571
0
        }
1572
1573
0
        if(c2<0) {
1574
            /* get next code unit from string 2, post-increment */
1575
0
            for(;;) {
1576
0
                if(s2==limit2 || ((c2=*s2)==0 && (limit2==NULL || (options&_STRNCMP_STYLE)))) {
1577
0
                    if(level2==0) {
1578
0
                        c2=-1;
1579
0
                        break;
1580
0
                    }
1581
0
                } else {
1582
0
                    ++s2;
1583
0
                    break;
1584
0
                }
1585
1586
                /* reached end of level buffer, pop one level */
1587
0
                do {
1588
0
                    --level2;
1589
0
                    start2=stack2[level2].start;    /*Not uninitialized*/
1590
0
                } while(start2==NULL);
1591
0
                s2=stack2[level2].s;                /*Not uninitialized*/
1592
0
                limit2=stack2[level2].limit;        /*Not uninitialized*/
1593
0
            }
1594
0
        }
1595
1596
        /*
1597
         * compare c1 and c2
1598
         * either variable c1, c2 is -1 only if the corresponding string is finished
1599
         */
1600
0
        if(c1==c2) {
1601
0
            const UChar *next1, *next2;
1602
1603
0
            if(c1<0) {
1604
0
                cmpRes=0;   /* c1==c2==-1 indicating end of strings */
1605
0
                break;
1606
0
            }
1607
1608
            /*
1609
             * Note: Move the match positions in both strings at the same time
1610
             *      only when corresponding code point(s) in the original strings
1611
             *      are fully consumed. For example, when comparing s1="Fust" and
1612
             *      s2="Fu\u00dfball", s2[2] is folded into "ss", and s1[2] matches
1613
             *      the first code point in the case-folded data. But the second "s"
1614
             *      has no matching code point in s1, so this implementation returns
1615
             *      2 as the prefix match length ("Fu").
1616
             */
1617
0
            next1=next2=NULL;
1618
0
            if(level1==0) {
1619
0
                next1=s1;
1620
0
            } else if(s1==limit1) {
1621
                /* Note: This implementation only use a single level of stack.
1622
                 *      If this code needs to be changed to use multiple levels
1623
                 *      of stacks, the code above should check if the current
1624
                 *      code is at the end of all stacks.
1625
                 */
1626
0
                U_ASSERT(level1==1);
1627
1628
                /* is s1 at the end of the current stack? */
1629
0
                next1=stack1[0].s;
1630
0
            }
1631
1632
0
            if (next1!=NULL) {
1633
0
                if(level2==0) {
1634
0
                    next2=s2;
1635
0
                } else if(s2==limit2) {
1636
0
                    U_ASSERT(level2==1);
1637
1638
                    /* is s2 at the end of the current stack? */
1639
0
                    next2=stack2[0].s;
1640
0
                }
1641
0
                if(next2!=NULL) {
1642
0
                    m1=next1;
1643
0
                    m2=next2;
1644
0
                }
1645
0
            }
1646
0
            c1=c2=-1;       /* make us fetch new code units */
1647
0
            continue;
1648
0
        } else if(c1<0) {
1649
0
            cmpRes=-1;      /* string 1 ends before string 2 */
1650
0
            break;
1651
0
        } else if(c2<0) {
1652
0
            cmpRes=1;       /* string 2 ends before string 1 */
1653
0
            break;
1654
0
        }
1655
        /* c1!=c2 && c1>=0 && c2>=0 */
1656
1657
        /* get complete code points for c1, c2 for lookups if either is a surrogate */
1658
0
        cp1=c1;
1659
0
        if(U_IS_SURROGATE(c1)) {
1660
0
            UChar c;
1661
1662
0
            if(U_IS_SURROGATE_LEAD(c1)) {
1663
0
                if(s1!=limit1 && U16_IS_TRAIL(c=*s1)) {
1664
                    /* advance ++s1; only below if cp1 decomposes/case-folds */
1665
0
                    cp1=U16_GET_SUPPLEMENTARY(c1, c);
1666
0
                }
1667
0
            } else /* isTrail(c1) */ {
1668
0
                if(start1<=(s1-2) && U16_IS_LEAD(c=*(s1-2))) {
1669
0
                    cp1=U16_GET_SUPPLEMENTARY(c, c1);
1670
0
                }
1671
0
            }
1672
0
        }
1673
1674
0
        cp2=c2;
1675
0
        if(U_IS_SURROGATE(c2)) {
1676
0
            UChar c;
1677
1678
0
            if(U_IS_SURROGATE_LEAD(c2)) {
1679
0
                if(s2!=limit2 && U16_IS_TRAIL(c=*s2)) {
1680
                    /* advance ++s2; only below if cp2 decomposes/case-folds */
1681
0
                    cp2=U16_GET_SUPPLEMENTARY(c2, c);
1682
0
                }
1683
0
            } else /* isTrail(c2) */ {
1684
0
                if(start2<=(s2-2) && U16_IS_LEAD(c=*(s2-2))) {
1685
0
                    cp2=U16_GET_SUPPLEMENTARY(c, c2);
1686
0
                }
1687
0
            }
1688
0
        }
1689
1690
        /*
1691
         * go down one level for each string
1692
         * continue with the main loop as soon as there is a real change
1693
         */
1694
1695
0
        if( level1==0 &&
1696
0
            (length=ucase_toFullFolding((UChar32)cp1, &p, options))>=0
1697
0
        ) {
1698
            /* cp1 case-folds to the code point "length" or to p[length] */
1699
0
            if(U_IS_SURROGATE(c1)) {
1700
0
                if(U_IS_SURROGATE_LEAD(c1)) {
1701
                    /* advance beyond source surrogate pair if it case-folds */
1702
0
                    ++s1;
1703
0
                } else /* isTrail(c1) */ {
1704
                    /*
1705
                     * we got a supplementary code point when hitting its trail surrogate,
1706
                     * therefore the lead surrogate must have been the same as in the other string;
1707
                     * compare this decomposition with the lead surrogate in the other string
1708
                     * remember that this simulates bulk text replacement:
1709
                     * the decomposition would replace the entire code point
1710
                     */
1711
0
                    --s2;
1712
0
                    --m2;
1713
0
                    c2=*(s2-1);
1714
0
                }
1715
0
            }
1716
1717
            /* push current level pointers */
1718
0
            stack1[0].start=start1;
1719
0
            stack1[0].s=s1;
1720
0
            stack1[0].limit=limit1;
1721
0
            ++level1;
1722
1723
            /* copy the folding result to fold1[] */
1724
0
            if(length<=UCASE_MAX_STRING_LENGTH) {
1725
0
                u_memcpy(fold1, p, length);
1726
0
            } else {
1727
0
                int32_t i=0;
1728
0
                U16_APPEND_UNSAFE(fold1, i, length);
1729
0
                length=i;
1730
0
            }
1731
1732
            /* set next level pointers to case folding */
1733
0
            start1=s1=fold1;
1734
0
            limit1=fold1+length;
1735
1736
            /* get ready to read from decomposition, continue with loop */
1737
0
            c1=-1;
1738
0
            continue;
1739
0
        }
1740
1741
0
        if( level2==0 &&
1742
0
            (length=ucase_toFullFolding((UChar32)cp2, &p, options))>=0
1743
0
        ) {
1744
            /* cp2 case-folds to the code point "length" or to p[length] */
1745
0
            if(U_IS_SURROGATE(c2)) {
1746
0
                if(U_IS_SURROGATE_LEAD(c2)) {
1747
                    /* advance beyond source surrogate pair if it case-folds */
1748
0
                    ++s2;
1749
0
                } else /* isTrail(c2) */ {
1750
                    /*
1751
                     * we got a supplementary code point when hitting its trail surrogate,
1752
                     * therefore the lead surrogate must have been the same as in the other string;
1753
                     * compare this decomposition with the lead surrogate in the other string
1754
                     * remember that this simulates bulk text replacement:
1755
                     * the decomposition would replace the entire code point
1756
                     */
1757
0
                    --s1;
1758
0
                    --m2;
1759
0
                    c1=*(s1-1);
1760
0
                }
1761
0
            }
1762
1763
            /* push current level pointers */
1764
0
            stack2[0].start=start2;
1765
0
            stack2[0].s=s2;
1766
0
            stack2[0].limit=limit2;
1767
0
            ++level2;
1768
1769
            /* copy the folding result to fold2[] */
1770
0
            if(length<=UCASE_MAX_STRING_LENGTH) {
1771
0
                u_memcpy(fold2, p, length);
1772
0
            } else {
1773
0
                int32_t i=0;
1774
0
                U16_APPEND_UNSAFE(fold2, i, length);
1775
0
                length=i;
1776
0
            }
1777
1778
            /* set next level pointers to case folding */
1779
0
            start2=s2=fold2;
1780
0
            limit2=fold2+length;
1781
1782
            /* get ready to read from decomposition, continue with loop */
1783
0
            c2=-1;
1784
0
            continue;
1785
0
        }
1786
1787
        /*
1788
         * no decomposition/case folding, max level for both sides:
1789
         * return difference result
1790
         *
1791
         * code point order comparison must not just return cp1-cp2
1792
         * because when single surrogates are present then the surrogate pairs
1793
         * that formed cp1 and cp2 may be from different string indexes
1794
         *
1795
         * example: { d800 d800 dc01 } vs. { d800 dc00 }, compare at second code units
1796
         * c1=d800 cp1=10001 c2=dc00 cp2=10000
1797
         * cp1-cp2>0 but c1-c2<0 and in fact in UTF-32 it is { d800 10001 } < { 10000 }
1798
         *
1799
         * therefore, use same fix-up as in ustring.c/uprv_strCompare()
1800
         * except: uprv_strCompare() fetches c=*s while this functions fetches c=*s++
1801
         * so we have slightly different pointer/start/limit comparisons here
1802
         */
1803
1804
0
        if(c1>=0xd800 && c2>=0xd800 && (options&U_COMPARE_CODE_POINT_ORDER)) {
1805
            /* subtract 0x2800 from BMP code points to make them smaller than supplementary ones */
1806
0
            if(
1807
0
                (c1<=0xdbff && s1!=limit1 && U16_IS_TRAIL(*s1)) ||
1808
0
                (U16_IS_TRAIL(c1) && start1!=(s1-1) && U16_IS_LEAD(*(s1-2)))
1809
0
            ) {
1810
                /* part of a surrogate pair, leave >=d800 */
1811
0
            } else {
1812
                /* BMP code point - may be surrogate code point - make <d800 */
1813
0
                c1-=0x2800;
1814
0
            }
1815
1816
0
            if(
1817
0
                (c2<=0xdbff && s2!=limit2 && U16_IS_TRAIL(*s2)) ||
1818
0
                (U16_IS_TRAIL(c2) && start2!=(s2-1) && U16_IS_LEAD(*(s2-2)))
1819
0
            ) {
1820
                /* part of a surrogate pair, leave >=d800 */
1821
0
            } else {
1822
                /* BMP code point - may be surrogate code point - make <d800 */
1823
0
                c2-=0x2800;
1824
0
            }
1825
0
        }
1826
1827
0
        cmpRes=c1-c2;
1828
0
        break;
1829
0
    }
1830
1831
0
    if(matchLen1) {
1832
0
        *matchLen1=static_cast<int32_t>(m1-org1);
1833
0
        *matchLen2=static_cast<int32_t>(m2-org2);
1834
0
    }
1835
0
    return cmpRes;
1836
0
}
1837
1838
/* internal function */
1839
U_CFUNC int32_t
1840
u_strcmpFold(const UChar *s1, int32_t length1,
1841
             const UChar *s2, int32_t length2,
1842
             uint32_t options,
1843
0
             UErrorCode *pErrorCode) {
1844
0
    return _cmpFold(s1, length1, s2, length2, options, NULL, NULL, pErrorCode);
1845
0
}
1846
1847
/* public API functions */
1848
1849
U_CAPI int32_t U_EXPORT2
1850
u_strCaseCompare(const UChar *s1, int32_t length1,
1851
                 const UChar *s2, int32_t length2,
1852
                 uint32_t options,
1853
0
                 UErrorCode *pErrorCode) {
1854
    /* argument checking */
1855
0
    if(pErrorCode==0 || U_FAILURE(*pErrorCode)) {
1856
0
        return 0;
1857
0
    }
1858
0
    if(s1==NULL || length1<-1 || s2==NULL || length2<-1) {
1859
0
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1860
0
        return 0;
1861
0
    }
1862
0
    return u_strcmpFold(s1, length1, s2, length2,
1863
0
                        options|U_COMPARE_IGNORE_CASE,
1864
0
                        pErrorCode);
1865
0
}
1866
1867
U_CAPI int32_t U_EXPORT2
1868
0
u_strcasecmp(const UChar *s1, const UChar *s2, uint32_t options) {
1869
0
    UErrorCode errorCode=U_ZERO_ERROR;
1870
0
    return u_strcmpFold(s1, -1, s2, -1,
1871
0
                        options|U_COMPARE_IGNORE_CASE,
1872
0
                        &errorCode);
1873
0
}
1874
1875
U_CAPI int32_t U_EXPORT2
1876
0
u_memcasecmp(const UChar *s1, const UChar *s2, int32_t length, uint32_t options) {
1877
0
    UErrorCode errorCode=U_ZERO_ERROR;
1878
0
    return u_strcmpFold(s1, length, s2, length,
1879
0
                        options|U_COMPARE_IGNORE_CASE,
1880
0
                        &errorCode);
1881
0
}
1882
1883
U_CAPI int32_t U_EXPORT2
1884
0
u_strncasecmp(const UChar *s1, const UChar *s2, int32_t n, uint32_t options) {
1885
0
    UErrorCode errorCode=U_ZERO_ERROR;
1886
0
    return u_strcmpFold(s1, n, s2, n,
1887
0
                        options|(U_COMPARE_IGNORE_CASE|_STRNCMP_STYLE),
1888
0
                        &errorCode);
1889
0
}
1890
1891
/* internal API - detect length of shared prefix */
1892
U_CAPI void
1893
u_caseInsensitivePrefixMatch(const UChar *s1, int32_t length1,
1894
                             const UChar *s2, int32_t length2,
1895
                             uint32_t options,
1896
                             int32_t *matchLen1, int32_t *matchLen2,
1897
0
                             UErrorCode *pErrorCode) {
1898
0
    _cmpFold(s1, length1, s2, length2, options,
1899
0
        matchLen1, matchLen2, pErrorCode);
1900
0
}