Coverage Report

Created: 2025-06-13 06:34

/src/icu/icu4c/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
1.93k
                                   Edits *edits, UErrorCode &errorCode) {
51
1.93k
    if (U_SUCCESS(errorCode)) {
52
1.93k
        if (destIndex > destCapacity) {
53
0
            errorCode = U_BUFFER_OVERFLOW_ERROR;
54
1.93k
        } else if (edits != nullptr) {
55
0
            edits->copyErrorTo(errorCode);
56
0
        }
57
1.93k
    }
58
1.93k
    return destIndex;
59
1.93k
}
60
61
/* Appends a full case mapping result, see UCASE_MAX_STRING_LENGTH. */
62
inline int32_t
63
appendResult(char16_t *dest, int32_t destIndex, int32_t destCapacity,
64
             int32_t result, const char16_t *s,
65
140
             int32_t cpLength, uint32_t options, icu::Edits *edits) {
66
140
    UChar32 c;
67
140
    int32_t length;
68
69
    /* decode the result */
70
140
    if(result<0) {
71
        /* (not) original code point */
72
0
        if(edits!=nullptr) {
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++] = static_cast<char16_t>(c);
81
0
            return destIndex;
82
0
        }
83
0
        length=cpLength;
84
140
    } else {
85
140
        if(result<=UCASE_MAX_STRING_LENGTH) {
86
0
            c=U_SENTINEL;
87
0
            length=result;
88
140
        } else if(destIndex<destCapacity && result<=0xffff) {  // BMP slightly-fastpath
89
140
            dest[destIndex++] = static_cast<char16_t>(result);
90
140
            if(edits!=nullptr) {
91
0
                edits->addReplace(cpLength, 1);
92
0
            }
93
140
            return destIndex;
94
140
        } else {
95
0
            c=result;
96
0
            length=U16_LENGTH(c);
97
0
        }
98
0
        if(edits!=nullptr) {
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
348
appendUChar(char16_t *dest, int32_t destIndex, int32_t destCapacity, char16_t c) {
137
348
    if(destIndex<destCapacity) {
138
348
        dest[destIndex]=c;
139
348
    } else if(destIndex==INT32_MAX) {
140
0
        return -1;  // integer overflow
141
0
    }
142
348
    return destIndex+1;
143
348
}
144
145
int32_t
146
appendNonEmptyUnchanged(char16_t *dest, int32_t destIndex, int32_t destCapacity,
147
1.92k
                        const char16_t *s, int32_t length, uint32_t options, icu::Edits *edits) {
148
1.92k
    if(edits!=nullptr) {
149
0
        edits->addUnchanged(length);
150
0
    }
151
1.92k
    if(options & U_OMIT_UNCHANGED_TEXT) {
152
0
        return destIndex;
153
0
    }
154
1.92k
    if(length>(INT32_MAX-destIndex)) {
155
0
        return -1;  // integer overflow
156
0
    }
157
1.92k
    if((destIndex+length)<=destCapacity) {
158
1.92k
        u_memcpy(dest+destIndex, s, length);
159
1.92k
    }
160
1.92k
    return destIndex + length;
161
1.92k
}
162
163
inline int32_t
164
appendUnchanged(char16_t *dest, int32_t destIndex, int32_t destCapacity,
165
2.42k
                const char16_t *s, int32_t length, uint32_t options, icu::Edits *edits) {
166
2.42k
    if (length <= 0) {
167
495
        return destIndex;
168
495
    }
169
1.92k
    return appendNonEmptyUnchanged(dest, destIndex, destCapacity, s, length, options, edits);
170
2.42k
}
171
172
UChar32 U_CALLCONV
173
0
utf16_caseContextIterator(void *context, int8_t dir) {
174
0
    UCaseContext* csc = static_cast<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 char16_t *)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 char16_t *)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
                char16_t *dest, int32_t destCapacity,
210
                const char16_t *src, UCaseContext *csc, int32_t srcStart, int32_t srcLimit,
211
1.93k
                icu::Edits *edits, UErrorCode &errorCode) {
212
1.93k
    const int8_t *latinToLower;
213
1.93k
    if (caseLocale == UCASE_LOC_ROOT ||
214
1.93k
            (caseLocale >= 0 ?
215
0
                !(caseLocale == UCASE_LOC_TURKISH || caseLocale == UCASE_LOC_LITHUANIAN) :
216
1.93k
                (options & _FOLD_CASE_OPTIONS_MASK) == U_FOLD_CASE_DEFAULT)) {
217
1.93k
        latinToLower = LatinCase::TO_LOWER_NORMAL;
218
1.93k
    } else {
219
0
        latinToLower = LatinCase::TO_LOWER_TR_LT;
220
0
    }
221
1.93k
    const UTrie2 *trie = ucase_getTrie();
222
1.93k
    int32_t destIndex = 0;
223
1.93k
    int32_t prev = srcStart;
224
1.93k
    int32_t srcIndex = srcStart;
225
2.32k
    for (;;) {
226
        // fast path for simple cases
227
2.32k
        char16_t lead = 0;
228
6.54k
        while (srcIndex < srcLimit) {
229
4.61k
            lead = src[srcIndex];
230
4.61k
            int32_t delta;
231
4.61k
            if (lead < LatinCase::LONG_S) {
232
516
                int8_t d = latinToLower[lead];
233
516
                if (d == LatinCase::EXC) { break; }
234
516
                ++srcIndex;
235
516
                if (d == 0) { continue; }
236
254
                delta = d;
237
4.09k
            } else if (lead >= 0xd800) {
238
129
                break;  // surrogate or higher
239
3.96k
            } else {
240
3.96k
                uint16_t props = UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, lead);
241
3.96k
                if (UCASE_HAS_EXCEPTION(props)) { break; }
242
3.70k
                ++srcIndex;
243
3.70k
                if (!UCASE_IS_UPPER_OR_TITLE(props) || (delta = UCASE_GET_DELTA(props)) == 0) {
244
3.61k
                    continue;
245
3.61k
                }
246
3.70k
            }
247
348
            lead += static_cast<char16_t>(delta);
248
348
            destIndex = appendUnchanged(dest, destIndex, destCapacity,
249
348
                                        src + prev, srcIndex - 1 - prev, options, edits);
250
348
            if (destIndex >= 0) {
251
348
                destIndex = appendUChar(dest, destIndex, destCapacity, lead);
252
348
                if (edits != nullptr) {
253
0
                    edits->addReplace(1, 1);
254
0
                }
255
348
            }
256
348
            if (destIndex < 0) {
257
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
258
0
                return 0;
259
0
            }
260
348
            prev = srcIndex;
261
348
        }
262
2.32k
        if (srcIndex >= srcLimit) {
263
1.93k
            break;
264
1.93k
        }
265
        // slow path
266
388
        int32_t cpStart = srcIndex++;
267
388
        char16_t trail;
268
388
        UChar32 c;
269
388
        if (U16_IS_LEAD(lead) && srcIndex < srcLimit && U16_IS_TRAIL(trail = src[srcIndex])) {
270
129
            c = U16_GET_SUPPLEMENTARY(lead, trail);
271
129
            ++srcIndex;
272
259
        } else {
273
259
            c = lead;
274
259
        }
275
388
        const char16_t *s = nullptr;
276
388
        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
388
        } else {
281
388
            c = ucase_toFullFolding(c, &s, options);
282
388
        }
283
388
        if (c >= 0) {
284
140
            destIndex = appendUnchanged(dest, destIndex, destCapacity,
285
140
                                        src + prev, cpStart - prev, options, edits);
286
140
            if (destIndex >= 0) {
287
140
                destIndex = appendResult(dest, destIndex, destCapacity, c, s,
288
140
                                         srcIndex - cpStart, options, edits);
289
140
            }
290
140
            if (destIndex < 0) {
291
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
292
0
                return 0;
293
0
            }
294
140
            prev = srcIndex;
295
140
        }
296
388
    }
297
1.93k
    destIndex = appendUnchanged(dest, destIndex, destCapacity,
298
1.93k
                                src + prev, srcIndex - prev, options, edits);
299
1.93k
    if (destIndex < 0) {
300
0
        errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
301
0
        return 0;
302
0
    }
303
1.93k
    return destIndex;
304
1.93k
}
305
306
int32_t toUpper(int32_t caseLocale, uint32_t options,
307
                char16_t *dest, int32_t destCapacity,
308
                const char16_t *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
        char16_t 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<char16_t>(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
        char16_t 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 char16_t *s = nullptr;
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 char16_t *src, UChar32 c, int32_t start, int32_t segmentLimit,
417
                          char16_t *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
    char16_t 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
                         char16_t *dest, int32_t destCapacity,
496
                         const char16_t *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 char16_t *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==nullptr) ? nullptr: 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 char16_t *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
                char16_t *dest, int32_t destCapacity,
1106
                const char16_t *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 &&
1134
0
                (state & (AFTER_VOWEL_WITH_PRECOMPOSED_ACCENT | AFTER_VOWEL_WITH_COMBINING_ACCENT)) !=
1135
0
                    0 &&
1136
0
                (upper == 0x399 || upper == 0x3A5)) {
1137
0
                data |= (state & AFTER_VOWEL_WITH_PRECOMPOSED_ACCENT) ? HAS_DIALYTIKA
1138
0
                                                                      : HAS_COMBINING_DIALYTIKA;
1139
0
            }
1140
0
            int32_t numYpogegrammeni = 0;  // Map each one to a trailing, spacing, capital iota.
1141
0
            if ((data & HAS_YPOGEGRAMMENI) != 0) {
1142
0
                numYpogegrammeni = 1;
1143
0
            }
1144
0
            const UBool hasPrecomposedAccent = (data & HAS_ACCENT) != 0;
1145
            // Skip combining diacritics after this Greek letter.
1146
0
            while (nextIndex < srcLength) {
1147
0
                uint32_t diacriticData = getDiacriticData(src[nextIndex]);
1148
0
                if (diacriticData != 0) {
1149
0
                    data |= diacriticData;
1150
0
                    if ((diacriticData & HAS_YPOGEGRAMMENI) != 0) {
1151
0
                        ++numYpogegrammeni;
1152
0
                    }
1153
0
                    ++nextIndex;
1154
0
                } else {
1155
0
                    break;  // not a Greek diacritic
1156
0
                }
1157
0
            }
1158
0
            if ((data & HAS_VOWEL_AND_ACCENT_AND_DIALYTIKA) == HAS_VOWEL_AND_ACCENT) {
1159
0
                nextState |= hasPrecomposedAccent ? AFTER_VOWEL_WITH_PRECOMPOSED_ACCENT
1160
0
                                                  : AFTER_VOWEL_WITH_COMBINING_ACCENT;
1161
0
            }
1162
            // Map according to Greek rules.
1163
0
            UBool addTonos = false;
1164
0
            if (upper == 0x397 &&
1165
0
                    (data & HAS_ACCENT) != 0 &&
1166
0
                    numYpogegrammeni == 0 &&
1167
0
                    (state & AFTER_CASED) == 0 &&
1168
0
                    !isFollowedByCasedLetter(src, nextIndex, srcLength)) {
1169
                // Keep disjunctive "or" with (only) a tonos.
1170
                // We use the same "word boundary" conditions as for the Final_Sigma test.
1171
0
                if (hasPrecomposedAccent) {
1172
0
                    upper = 0x389;  // Preserve the precomposed form.
1173
0
                } else {
1174
0
                    addTonos = true;
1175
0
                }
1176
0
            } else if ((data & HAS_DIALYTIKA) != 0) {
1177
                // Preserve a vowel with dialytika in precomposed form if it exists.
1178
0
                if (upper == 0x399) {
1179
0
                    upper = 0x3AA;
1180
0
                    data &= ~HAS_EITHER_DIALYTIKA;
1181
0
                } else if (upper == 0x3A5) {
1182
0
                    upper = 0x3AB;
1183
0
                    data &= ~HAS_EITHER_DIALYTIKA;
1184
0
                }
1185
0
            }
1186
1187
0
            UBool change;
1188
0
            if (edits == nullptr && (options & U_OMIT_UNCHANGED_TEXT) == 0) {
1189
0
                change = true;  // common, simple usage
1190
0
            } else {
1191
                // Find out first whether we are changing the text.
1192
0
                change = src[i] != upper || numYpogegrammeni > 0;
1193
0
                int32_t i2 = i + 1;
1194
0
                if ((data & HAS_EITHER_DIALYTIKA) != 0) {
1195
0
                    change |= i2 >= nextIndex || src[i2] != 0x308;
1196
0
                    ++i2;
1197
0
                }
1198
0
                if (addTonos) {
1199
0
                    change |= i2 >= nextIndex || src[i2] != 0x301;
1200
0
                    ++i2;
1201
0
                }
1202
0
                int32_t oldLength = nextIndex - i;
1203
0
                int32_t newLength = (i2 - i) + numYpogegrammeni;
1204
0
                change |= oldLength != newLength;
1205
0
                if (change) {
1206
0
                    if (edits != nullptr) {
1207
0
                        edits->addReplace(oldLength, newLength);
1208
0
                    }
1209
0
                } else {
1210
0
                    if (edits != nullptr) {
1211
0
                        edits->addUnchanged(oldLength);
1212
0
                    }
1213
                    // Write unchanged text?
1214
0
                    change = (options & U_OMIT_UNCHANGED_TEXT) == 0;
1215
0
                }
1216
0
            }
1217
1218
0
            if (change) {
1219
0
                destIndex = appendUChar(dest, destIndex, destCapacity, static_cast<char16_t>(upper));
1220
0
                if (destIndex >= 0 && (data & HAS_EITHER_DIALYTIKA) != 0) {
1221
0
                    destIndex=appendUChar(dest, destIndex, destCapacity, 0x308);  // restore or add a dialytika
1222
0
                }
1223
0
                if (destIndex >= 0 && addTonos) {
1224
0
                    destIndex=appendUChar(dest, destIndex, destCapacity, 0x301);
1225
0
                }
1226
0
                while (destIndex >= 0 && numYpogegrammeni > 0) {
1227
0
                    destIndex=appendUChar(dest, destIndex, destCapacity, 0x399);
1228
0
                    --numYpogegrammeni;
1229
0
                }
1230
0
                if(destIndex<0) {
1231
0
                    errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
1232
0
                    return 0;
1233
0
                }
1234
0
            }
1235
0
        } else {
1236
0
            const char16_t *s;
1237
0
            c=ucase_toFullUpper(c, nullptr, nullptr, &s, UCASE_LOC_GREEK);
1238
0
            destIndex = appendResult(dest, destIndex, destCapacity, c, s,
1239
0
                                     nextIndex - i, options, edits);
1240
0
            if (destIndex < 0) {
1241
0
                errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
1242
0
                return 0;
1243
0
            }
1244
0
        }
1245
0
        i = nextIndex;
1246
0
        state = nextState;
1247
0
    }
1248
1249
0
    return destIndex;
1250
0
}
1251
1252
}  // namespace GreekUpper
1253
U_NAMESPACE_END
1254
1255
/* functions available in the common library (for unistr_case.cpp) */
1256
1257
U_CFUNC int32_t U_CALLCONV
1258
ustrcase_internalToLower(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
1259
                         char16_t *dest, int32_t destCapacity,
1260
                         const char16_t *src, int32_t srcLength,
1261
                         icu::Edits *edits,
1262
0
                         UErrorCode &errorCode) {
1263
0
    UCaseContext csc=UCASECONTEXT_INITIALIZER;
1264
0
    csc.p=(void *)src;
1265
0
    csc.limit=srcLength;
1266
0
    int32_t destIndex = toLower(
1267
0
        caseLocale, options,
1268
0
        dest, destCapacity,
1269
0
        src, &csc, 0, srcLength,
1270
0
        edits, errorCode);
1271
0
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
1272
0
}
1273
1274
U_CFUNC int32_t U_CALLCONV
1275
ustrcase_internalToUpper(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
1276
                         char16_t *dest, int32_t destCapacity,
1277
                         const char16_t *src, int32_t srcLength,
1278
                         icu::Edits *edits,
1279
0
                         UErrorCode &errorCode) {
1280
0
    int32_t destIndex;
1281
0
    if (caseLocale == UCASE_LOC_GREEK) {
1282
0
        destIndex = GreekUpper::toUpper(options, dest, destCapacity,
1283
0
                                        src, srcLength, edits, errorCode);
1284
0
    } else {
1285
0
        UCaseContext csc=UCASECONTEXT_INITIALIZER;
1286
0
        csc.p=(void *)src;
1287
0
        csc.limit=srcLength;
1288
0
        destIndex = toUpper(
1289
0
            caseLocale, options,
1290
0
            dest, destCapacity,
1291
0
            src, &csc, srcLength,
1292
0
            edits, errorCode);
1293
0
    }
1294
0
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
1295
0
}
1296
1297
U_CFUNC int32_t U_CALLCONV
1298
ustrcase_internalFold(int32_t /* caseLocale */, uint32_t options, UCASEMAP_BREAK_ITERATOR_UNUSED
1299
                      char16_t *dest, int32_t destCapacity,
1300
                      const char16_t *src, int32_t srcLength,
1301
                      icu::Edits *edits,
1302
1.93k
                      UErrorCode &errorCode) {
1303
1.93k
    int32_t destIndex = toLower(
1304
1.93k
        -1, options,
1305
1.93k
        dest, destCapacity,
1306
1.93k
        src, nullptr, 0, srcLength,
1307
1.93k
        edits, errorCode);
1308
1.93k
    return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode);
1309
1.93k
}
1310
1311
U_CFUNC int32_t
1312
ustrcase_map(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
1313
             char16_t *dest, int32_t destCapacity,
1314
             const char16_t *src, int32_t srcLength,
1315
             UStringCaseMapper *stringCaseMapper,
1316
             icu::Edits *edits,
1317
0
             UErrorCode &errorCode) {
1318
0
    int32_t destLength;
1319
1320
    /* check argument values */
1321
0
    if(U_FAILURE(errorCode)) {
1322
0
        return 0;
1323
0
    }
1324
0
    if( destCapacity<0 ||
1325
0
        (dest==nullptr && destCapacity>0) ||
1326
0
        src==nullptr ||
1327
0
        srcLength<-1
1328
0
    ) {
1329
0
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
1330
0
        return 0;
1331
0
    }
1332
1333
    /* get the string length */
1334
0
    if(srcLength==-1) {
1335
0
        srcLength=u_strlen(src);
1336
0
    }
1337
1338
    /* check for overlapping source and destination */
1339
0
    if( dest!=nullptr &&
1340
0
        ((src>=dest && src<(dest+destCapacity)) ||
1341
0
         (dest>=src && dest<(src+srcLength)))
1342
0
    ) {
1343
0
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
1344
0
        return 0;
1345
0
    }
1346
1347
0
    if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
1348
0
        edits->reset();
1349
0
    }
1350
0
    destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
1351
0
                                dest, destCapacity, src, srcLength, edits, errorCode);
1352
0
    return u_terminateUChars(dest, destCapacity, destLength, &errorCode);
1353
0
}
1354
1355
U_CFUNC int32_t
1356
ustrcase_mapWithOverlap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
1357
                        char16_t *dest, int32_t destCapacity,
1358
                        const char16_t *src, int32_t srcLength,
1359
                        UStringCaseMapper *stringCaseMapper,
1360
1.93k
                        UErrorCode &errorCode) {
1361
1.93k
    char16_t buffer[300];
1362
1.93k
    char16_t *temp;
1363
1364
1.93k
    int32_t destLength;
1365
1366
    /* check argument values */
1367
1.93k
    if(U_FAILURE(errorCode)) {
1368
0
        return 0;
1369
0
    }
1370
1.93k
    if( destCapacity<0 ||
1371
1.93k
        (dest==nullptr && destCapacity>0) ||
1372
1.93k
        src==nullptr ||
1373
1.93k
        srcLength<-1
1374
1.93k
    ) {
1375
0
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
1376
0
        return 0;
1377
0
    }
1378
1379
    /* get the string length */
1380
1.93k
    if(srcLength==-1) {
1381
0
        srcLength=u_strlen(src);
1382
0
    }
1383
1384
    /* check for overlapping source and destination */
1385
1.93k
    if( dest!=nullptr &&
1386
1.93k
        ((src>=dest && src<(dest+destCapacity)) ||
1387
1.93k
         (dest>=src && dest<(src+srcLength)))
1388
1.93k
    ) {
1389
        /* overlap: provide a temporary destination buffer and later copy the result */
1390
0
        if(destCapacity<=UPRV_LENGTHOF(buffer)) {
1391
            /* the stack buffer is large enough */
1392
0
            temp=buffer;
1393
0
        } else {
1394
            /* allocate a buffer */
1395
0
            temp=(char16_t *)uprv_malloc(destCapacity*U_SIZEOF_UCHAR);
1396
0
            if(temp==nullptr) {
1397
0
                errorCode=U_MEMORY_ALLOCATION_ERROR;
1398
0
                return 0;
1399
0
            }
1400
0
        }
1401
1.93k
    } else {
1402
1.93k
        temp=dest;
1403
1.93k
    }
1404
1405
1.93k
    destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR
1406
1.93k
                                temp, destCapacity, src, srcLength, nullptr, errorCode);
1407
1.93k
    if(temp!=dest) {
1408
        /* copy the result string to the destination buffer */
1409
0
        if (U_SUCCESS(errorCode) && 0 < destLength && destLength <= destCapacity) {
1410
0
            u_memmove(dest, temp, destLength);
1411
0
        }
1412
0
        if(temp!=buffer) {
1413
0
            uprv_free(temp);
1414
0
        }
1415
0
    }
1416
1417
1.93k
    return u_terminateUChars(dest, destCapacity, destLength, &errorCode);
1418
1.93k
}
1419
1420
/* public API functions */
1421
1422
U_CAPI int32_t U_EXPORT2
1423
u_strFoldCase(char16_t *dest, int32_t destCapacity,
1424
              const char16_t *src, int32_t srcLength,
1425
              uint32_t options,
1426
1.93k
              UErrorCode *pErrorCode) {
1427
1.93k
    return ustrcase_mapWithOverlap(
1428
1.93k
        UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL
1429
1.93k
        dest, destCapacity,
1430
1.93k
        src, srcLength,
1431
1.93k
        ustrcase_internalFold, *pErrorCode);
1432
1.93k
}
1433
1434
U_NAMESPACE_BEGIN
1435
1436
int32_t CaseMap::fold(
1437
        uint32_t options,
1438
        const char16_t *src, int32_t srcLength,
1439
        char16_t *dest, int32_t destCapacity, Edits *edits,
1440
0
        UErrorCode &errorCode) {
1441
0
    return ustrcase_map(
1442
0
        UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL
1443
0
        dest, destCapacity,
1444
0
        src, srcLength,
1445
0
        ustrcase_internalFold, edits, errorCode);
1446
0
}
1447
1448
U_NAMESPACE_END
1449
1450
/* case-insensitive string comparisons -------------------------------------- */
1451
1452
/*
1453
 * This function is a copy of unorm_cmpEquivFold() minus the parts for
1454
 * canonical equivalence.
1455
 * Keep the functions in sync, and see there for how this works.
1456
 * The duplication is for modularization:
1457
 * It makes caseless (but not canonical caseless) matches independent of
1458
 * the normalization code.
1459
 */
1460
1461
/* stack element for previous-level source/decomposition pointers */
1462
struct CmpEquivLevel {
1463
    const char16_t *start, *s, *limit;
1464
};
1465
typedef struct CmpEquivLevel CmpEquivLevel;
1466
1467
/**
1468
 * Internal implementation code comparing string with case fold.
1469
 * This function is called from u_strcmpFold() and u_caseInsensitivePrefixMatch().
1470
 *
1471
 * @param s1            input string 1
1472
 * @param length1       length of string 1, or -1 (NUL terminated)
1473
 * @param s2            input string 2
1474
 * @param length2       length of string 2, or -1 (NUL terminated)
1475
 * @param options       compare options
1476
 * @param matchLen1     (output) length of partial prefix match in s1
1477
 * @param matchLen2     (output) length of partial prefix match in s2
1478
 * @param pErrorCode    receives error status
1479
 * @return The result of comparison
1480
 */
1481
static int32_t _cmpFold(
1482
            const char16_t *s1, int32_t length1,
1483
            const char16_t *s2, int32_t length2,
1484
            uint32_t options,
1485
            int32_t *matchLen1, int32_t *matchLen2,
1486
0
            UErrorCode *pErrorCode) {
1487
0
    int32_t cmpRes = 0;
1488
1489
    /* current-level start/limit - s1/s2 as current */
1490
0
    const char16_t *start1, *start2, *limit1, *limit2;
1491
1492
    /* points to the original start address */
1493
0
    const char16_t *org1, *org2;
1494
1495
    /* points to the end of match + 1 */
1496
0
    const char16_t *m1, *m2;
1497
1498
    /* case folding variables */
1499
0
    const char16_t *p;
1500
0
    int32_t length;
1501
1502
    /* stacks of previous-level start/current/limit */
1503
0
    CmpEquivLevel stack1[2], stack2[2];
1504
1505
    /* case folding buffers, only use current-level start/limit */
1506
0
    char16_t fold1[UCASE_MAX_STRING_LENGTH+1], fold2[UCASE_MAX_STRING_LENGTH+1];
1507
1508
    /* track which is the current level per string */
1509
0
    int32_t level1, level2;
1510
1511
    /* current code units, and code points for lookups */
1512
0
    UChar32 c1, c2, cp1, cp2;
1513
1514
    /* no argument error checking because this itself is not an API */
1515
1516
    /*
1517
     * assume that at least the option U_COMPARE_IGNORE_CASE is set
1518
     * otherwise this function would have to behave exactly as uprv_strCompare()
1519
     */
1520
0
    if(U_FAILURE(*pErrorCode)) {
1521
0
        return 0;
1522
0
    }
1523
1524
    /* initialize */
1525
0
    if(matchLen1) {
1526
0
        U_ASSERT(matchLen2 !=nullptr);
1527
0
        *matchLen1=0;
1528
0
        *matchLen2=0;
1529
0
    }
1530
1531
0
    start1=m1=org1=s1;
1532
0
    if(length1==-1) {
1533
0
        limit1=nullptr;
1534
0
    } else {
1535
0
        limit1=s1+length1;
1536
0
    }
1537
1538
0
    start2=m2=org2=s2;
1539
0
    if(length2==-1) {
1540
0
        limit2=nullptr;
1541
0
    } else {
1542
0
        limit2=s2+length2;
1543
0
    }
1544
1545
0
    level1=level2=0;
1546
0
    c1=c2=-1;
1547
1548
    /* comparison loop */
1549
0
    for(;;) {
1550
        /*
1551
         * here a code unit value of -1 means "get another code unit"
1552
         * below it will mean "this source is finished"
1553
         */
1554
1555
0
        if(c1<0) {
1556
            /* get next code unit from string 1, post-increment */
1557
0
            for(;;) {
1558
0
                if(s1==limit1 || ((c1=*s1)==0 && (limit1==nullptr || (options&_STRNCMP_STYLE)))) {
1559
0
                    if(level1==0) {
1560
0
                        c1=-1;
1561
0
                        break;
1562
0
                    }
1563
0
                } else {
1564
0
                    ++s1;
1565
0
                    break;
1566
0
                }
1567
1568
                /* reached end of level buffer, pop one level */
1569
0
                do {
1570
0
                    --level1;
1571
0
                    start1=stack1[level1].start;    /*Not uninitialized*/
1572
0
                } while(start1==nullptr);
1573
0
                s1=stack1[level1].s;                /*Not uninitialized*/
1574
0
                limit1=stack1[level1].limit;        /*Not uninitialized*/
1575
0
            }
1576
0
        }
1577
1578
0
        if(c2<0) {
1579
            /* get next code unit from string 2, post-increment */
1580
0
            for(;;) {
1581
0
                if(s2==limit2 || ((c2=*s2)==0 && (limit2==nullptr || (options&_STRNCMP_STYLE)))) {
1582
0
                    if(level2==0) {
1583
0
                        c2=-1;
1584
0
                        break;
1585
0
                    }
1586
0
                } else {
1587
0
                    ++s2;
1588
0
                    break;
1589
0
                }
1590
1591
                /* reached end of level buffer, pop one level */
1592
0
                do {
1593
0
                    --level2;
1594
0
                    start2=stack2[level2].start;    /*Not uninitialized*/
1595
0
                } while(start2==nullptr);
1596
0
                s2=stack2[level2].s;                /*Not uninitialized*/
1597
0
                limit2=stack2[level2].limit;        /*Not uninitialized*/
1598
0
            }
1599
0
        }
1600
1601
        /*
1602
         * compare c1 and c2
1603
         * either variable c1, c2 is -1 only if the corresponding string is finished
1604
         */
1605
0
        if(c1==c2) {
1606
0
            const char16_t *next1, *next2;
1607
1608
0
            if(c1<0) {
1609
0
                cmpRes=0;   /* c1==c2==-1 indicating end of strings */
1610
0
                break;
1611
0
            }
1612
1613
            /*
1614
             * Note: Move the match positions in both strings at the same time
1615
             *      only when corresponding code point(s) in the original strings
1616
             *      are fully consumed. For example, when comparing s1="Fust" and
1617
             *      s2="Fu\u00dfball", s2[2] is folded into "ss", and s1[2] matches
1618
             *      the first code point in the case-folded data. But the second "s"
1619
             *      has no matching code point in s1, so this implementation returns
1620
             *      2 as the prefix match length ("Fu").
1621
             */
1622
0
            next1=next2=nullptr;
1623
0
            if(level1==0) {
1624
0
                next1=s1;
1625
0
            } else if(s1==limit1) {
1626
                /* Note: This implementation only use a single level of stack.
1627
                 *      If this code needs to be changed to use multiple levels
1628
                 *      of stacks, the code above should check if the current
1629
                 *      code is at the end of all stacks.
1630
                 */
1631
0
                U_ASSERT(level1==1);
1632
1633
                /* is s1 at the end of the current stack? */
1634
0
                next1=stack1[0].s;
1635
0
            }
1636
1637
0
            if (next1!=nullptr) {
1638
0
                if(level2==0) {
1639
0
                    next2=s2;
1640
0
                } else if(s2==limit2) {
1641
0
                    U_ASSERT(level2==1);
1642
1643
                    /* is s2 at the end of the current stack? */
1644
0
                    next2=stack2[0].s;
1645
0
                }
1646
0
                if(next2!=nullptr) {
1647
0
                    m1=next1;
1648
0
                    m2=next2;
1649
0
                }
1650
0
            }
1651
0
            c1=c2=-1;       /* make us fetch new code units */
1652
0
            continue;
1653
0
        } else if(c1<0) {
1654
0
            cmpRes=-1;      /* string 1 ends before string 2 */
1655
0
            break;
1656
0
        } else if(c2<0) {
1657
0
            cmpRes=1;       /* string 2 ends before string 1 */
1658
0
            break;
1659
0
        }
1660
        /* c1!=c2 && c1>=0 && c2>=0 */
1661
1662
        /* get complete code points for c1, c2 for lookups if either is a surrogate */
1663
0
        cp1=c1;
1664
0
        if(U_IS_SURROGATE(c1)) {
1665
0
            char16_t c;
1666
1667
0
            if(U_IS_SURROGATE_LEAD(c1)) {
1668
0
                if(s1!=limit1 && U16_IS_TRAIL(c=*s1)) {
1669
                    /* advance ++s1; only below if cp1 decomposes/case-folds */
1670
0
                    cp1=U16_GET_SUPPLEMENTARY(c1, c);
1671
0
                }
1672
0
            } else /* isTrail(c1) */ {
1673
0
                if(start1<=(s1-2) && U16_IS_LEAD(c=*(s1-2))) {
1674
0
                    cp1=U16_GET_SUPPLEMENTARY(c, c1);
1675
0
                }
1676
0
            }
1677
0
        }
1678
1679
0
        cp2=c2;
1680
0
        if(U_IS_SURROGATE(c2)) {
1681
0
            char16_t c;
1682
1683
0
            if(U_IS_SURROGATE_LEAD(c2)) {
1684
0
                if(s2!=limit2 && U16_IS_TRAIL(c=*s2)) {
1685
                    /* advance ++s2; only below if cp2 decomposes/case-folds */
1686
0
                    cp2=U16_GET_SUPPLEMENTARY(c2, c);
1687
0
                }
1688
0
            } else /* isTrail(c2) */ {
1689
0
                if(start2<=(s2-2) && U16_IS_LEAD(c=*(s2-2))) {
1690
0
                    cp2=U16_GET_SUPPLEMENTARY(c, c2);
1691
0
                }
1692
0
            }
1693
0
        }
1694
1695
        /*
1696
         * go down one level for each string
1697
         * continue with the main loop as soon as there is a real change
1698
         */
1699
1700
0
        if( level1==0 &&
1701
0
            (length = ucase_toFullFolding(cp1, &p, options)) >= 0
1702
0
        ) {
1703
            /* cp1 case-folds to the code point "length" or to p[length] */
1704
0
            if(U_IS_SURROGATE(c1)) {
1705
0
                if(U_IS_SURROGATE_LEAD(c1)) {
1706
                    /* advance beyond source surrogate pair if it case-folds */
1707
0
                    ++s1;
1708
0
                } else /* isTrail(c1) */ {
1709
                    /*
1710
                     * we got a supplementary code point when hitting its trail surrogate,
1711
                     * therefore the lead surrogate must have been the same as in the other string;
1712
                     * compare this decomposition with the lead surrogate in the other string
1713
                     * remember that this simulates bulk text replacement:
1714
                     * the decomposition would replace the entire code point
1715
                     */
1716
0
                    --s2;
1717
0
                    --m2;
1718
0
                    c2=*(s2-1);
1719
0
                }
1720
0
            }
1721
1722
            /* push current level pointers */
1723
0
            stack1[0].start=start1;
1724
0
            stack1[0].s=s1;
1725
0
            stack1[0].limit=limit1;
1726
0
            ++level1;
1727
1728
            /* copy the folding result to fold1[] */
1729
0
            if(length<=UCASE_MAX_STRING_LENGTH) {
1730
0
                u_memcpy(fold1, p, length);
1731
0
            } else {
1732
0
                int32_t i=0;
1733
0
                U16_APPEND_UNSAFE(fold1, i, length);
1734
0
                length=i;
1735
0
            }
1736
1737
            /* set next level pointers to case folding */
1738
0
            start1=s1=fold1;
1739
0
            limit1=fold1+length;
1740
1741
            /* get ready to read from decomposition, continue with loop */
1742
0
            c1=-1;
1743
0
            continue;
1744
0
        }
1745
1746
0
        if( level2==0 &&
1747
0
            (length = ucase_toFullFolding(cp2, &p, options)) >= 0
1748
0
        ) {
1749
            /* cp2 case-folds to the code point "length" or to p[length] */
1750
0
            if(U_IS_SURROGATE(c2)) {
1751
0
                if(U_IS_SURROGATE_LEAD(c2)) {
1752
                    /* advance beyond source surrogate pair if it case-folds */
1753
0
                    ++s2;
1754
0
                } else /* isTrail(c2) */ {
1755
                    /*
1756
                     * we got a supplementary code point when hitting its trail surrogate,
1757
                     * therefore the lead surrogate must have been the same as in the other string;
1758
                     * compare this decomposition with the lead surrogate in the other string
1759
                     * remember that this simulates bulk text replacement:
1760
                     * the decomposition would replace the entire code point
1761
                     */
1762
0
                    --s1;
1763
0
                    --m2;
1764
0
                    c1=*(s1-1);
1765
0
                }
1766
0
            }
1767
1768
            /* push current level pointers */
1769
0
            stack2[0].start=start2;
1770
0
            stack2[0].s=s2;
1771
0
            stack2[0].limit=limit2;
1772
0
            ++level2;
1773
1774
            /* copy the folding result to fold2[] */
1775
0
            if(length<=UCASE_MAX_STRING_LENGTH) {
1776
0
                u_memcpy(fold2, p, length);
1777
0
            } else {
1778
0
                int32_t i=0;
1779
0
                U16_APPEND_UNSAFE(fold2, i, length);
1780
0
                length=i;
1781
0
            }
1782
1783
            /* set next level pointers to case folding */
1784
0
            start2=s2=fold2;
1785
0
            limit2=fold2+length;
1786
1787
            /* get ready to read from decomposition, continue with loop */
1788
0
            c2=-1;
1789
0
            continue;
1790
0
        }
1791
1792
        /*
1793
         * no decomposition/case folding, max level for both sides:
1794
         * return difference result
1795
         *
1796
         * code point order comparison must not just return cp1-cp2
1797
         * because when single surrogates are present then the surrogate pairs
1798
         * that formed cp1 and cp2 may be from different string indexes
1799
         *
1800
         * example: { d800 d800 dc01 } vs. { d800 dc00 }, compare at second code units
1801
         * c1=d800 cp1=10001 c2=dc00 cp2=10000
1802
         * cp1-cp2>0 but c1-c2<0 and in fact in UTF-32 it is { d800 10001 } < { 10000 }
1803
         *
1804
         * therefore, use same fix-up as in ustring.c/uprv_strCompare()
1805
         * except: uprv_strCompare() fetches c=*s while this functions fetches c=*s++
1806
         * so we have slightly different pointer/start/limit comparisons here
1807
         */
1808
1809
0
        if(c1>=0xd800 && c2>=0xd800 && (options&U_COMPARE_CODE_POINT_ORDER)) {
1810
            /* subtract 0x2800 from BMP code points to make them smaller than supplementary ones */
1811
0
            if(
1812
0
                (c1<=0xdbff && s1!=limit1 && U16_IS_TRAIL(*s1)) ||
1813
0
                (U16_IS_TRAIL(c1) && start1!=(s1-1) && U16_IS_LEAD(*(s1-2)))
1814
0
            ) {
1815
                /* part of a surrogate pair, leave >=d800 */
1816
0
            } else {
1817
                /* BMP code point - may be surrogate code point - make <d800 */
1818
0
                c1-=0x2800;
1819
0
            }
1820
1821
0
            if(
1822
0
                (c2<=0xdbff && s2!=limit2 && U16_IS_TRAIL(*s2)) ||
1823
0
                (U16_IS_TRAIL(c2) && start2!=(s2-1) && U16_IS_LEAD(*(s2-2)))
1824
0
            ) {
1825
                /* part of a surrogate pair, leave >=d800 */
1826
0
            } else {
1827
                /* BMP code point - may be surrogate code point - make <d800 */
1828
0
                c2-=0x2800;
1829
0
            }
1830
0
        }
1831
1832
0
        cmpRes=c1-c2;
1833
0
        break;
1834
0
    }
1835
1836
0
    if(matchLen1) {
1837
0
        *matchLen1=static_cast<int32_t>(m1-org1);
1838
0
        *matchLen2=static_cast<int32_t>(m2-org2);
1839
0
    }
1840
0
    return cmpRes;
1841
0
}
1842
1843
/* internal function */
1844
U_CFUNC int32_t
1845
u_strcmpFold(const char16_t *s1, int32_t length1,
1846
             const char16_t *s2, int32_t length2,
1847
             uint32_t options,
1848
0
             UErrorCode *pErrorCode) {
1849
0
    return _cmpFold(s1, length1, s2, length2, options, nullptr, nullptr, pErrorCode);
1850
0
}
1851
1852
/* public API functions */
1853
1854
U_CAPI int32_t U_EXPORT2
1855
u_strCaseCompare(const char16_t *s1, int32_t length1,
1856
                 const char16_t *s2, int32_t length2,
1857
                 uint32_t options,
1858
0
                 UErrorCode *pErrorCode) {
1859
    /* argument checking */
1860
0
    if (pErrorCode == nullptr || U_FAILURE(*pErrorCode)) {
1861
0
        return 0;
1862
0
    }
1863
0
    if(s1==nullptr || length1<-1 || s2==nullptr || length2<-1) {
1864
0
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1865
0
        return 0;
1866
0
    }
1867
0
    return u_strcmpFold(s1, length1, s2, length2,
1868
0
                        options|U_COMPARE_IGNORE_CASE,
1869
0
                        pErrorCode);
1870
0
}
1871
1872
U_CAPI int32_t U_EXPORT2
1873
0
u_strcasecmp(const char16_t *s1, const char16_t *s2, uint32_t options) {
1874
0
    UErrorCode errorCode=U_ZERO_ERROR;
1875
0
    return u_strcmpFold(s1, -1, s2, -1,
1876
0
                        options|U_COMPARE_IGNORE_CASE,
1877
0
                        &errorCode);
1878
0
}
1879
1880
U_CAPI int32_t U_EXPORT2
1881
0
u_memcasecmp(const char16_t *s1, const char16_t *s2, int32_t length, uint32_t options) {
1882
0
    UErrorCode errorCode=U_ZERO_ERROR;
1883
0
    return u_strcmpFold(s1, length, s2, length,
1884
0
                        options|U_COMPARE_IGNORE_CASE,
1885
0
                        &errorCode);
1886
0
}
1887
1888
U_CAPI int32_t U_EXPORT2
1889
0
u_strncasecmp(const char16_t *s1, const char16_t *s2, int32_t n, uint32_t options) {
1890
0
    UErrorCode errorCode=U_ZERO_ERROR;
1891
0
    return u_strcmpFold(s1, n, s2, n,
1892
0
                        options|(U_COMPARE_IGNORE_CASE|_STRNCMP_STYLE),
1893
0
                        &errorCode);
1894
0
}
1895
1896
/* internal API - detect length of shared prefix */
1897
U_CAPI void
1898
u_caseInsensitivePrefixMatch(const char16_t *s1, int32_t length1,
1899
                             const char16_t *s2, int32_t length2,
1900
                             uint32_t options,
1901
                             int32_t *matchLen1, int32_t *matchLen2,
1902
0
                             UErrorCode *pErrorCode) {
1903
0
    _cmpFold(s1, length1, s2, length2, options,
1904
0
        matchLen1, matchLen2, pErrorCode);
1905
0
}