Coverage Report

Created: 2024-04-24 06:23

/src/icu/source/common/ucase.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) 2004-2014, International Business Machines
7
*   Corporation and others.  All Rights Reserved.
8
*
9
*******************************************************************************
10
*   file name:  ucase.cpp
11
*   encoding:   UTF-8
12
*   tab size:   8 (not used)
13
*   indentation:4
14
*
15
*   created on: 2004aug30
16
*   created by: Markus W. Scherer
17
*
18
*   Low-level Unicode character/string case mapping code.
19
*   Much code moved here (and modified) from uchar.c.
20
*/
21
22
#include "unicode/utypes.h"
23
#include "unicode/unistr.h"
24
#include "unicode/uset.h"
25
#include "unicode/utf16.h"
26
#include "cmemory.h"
27
#include "uassert.h"
28
#include "ucase.h"
29
#include "umutex.h"
30
#include "utrie2.h"
31
32
/* ucase_props_data.h is machine-generated by genprops/casepropsbuilder.cpp */
33
#define INCLUDED_FROM_UCASE_CPP
34
#include "ucase_props_data.h"
35
36
/* set of property starts for UnicodeSet ------------------------------------ */
37
38
static UBool U_CALLCONV
39
0
_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 /*end*/, uint32_t /*value*/) {
40
    /* add the start code point to the USet */
41
0
    const USetAdder *sa=(const USetAdder *)context;
42
0
    sa->add(sa->set, start);
43
0
    return TRUE;
44
0
}
45
46
U_CFUNC void U_EXPORT2
47
0
ucase_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) {
48
0
    if(U_FAILURE(*pErrorCode)) {
49
0
        return;
50
0
    }
51
52
    /* add the start code point of each same-value range of the trie */
53
0
    utrie2_enum(&ucase_props_singleton.trie, NULL, _enumPropertyStartsRange, sa);
54
55
    /* add code points with hardcoded properties, plus the ones following them */
56
57
    /* (none right now, see comment below) */
58
59
    /*
60
     * Omit code points with hardcoded specialcasing properties
61
     * because we do not build property UnicodeSets for them right now.
62
     */
63
0
}
64
65
/* data access primitives --------------------------------------------------- */
66
67
U_CAPI const struct UCaseProps * U_EXPORT2
68
0
ucase_getSingleton(int32_t *pExceptionsLength, int32_t *pUnfoldLength) {
69
0
    *pExceptionsLength = UPRV_LENGTHOF(ucase_props_exceptions);
70
0
    *pUnfoldLength = UPRV_LENGTHOF(ucase_props_unfold);
71
0
    return &ucase_props_singleton;
72
0
}
73
74
U_CFUNC const UTrie2 * U_EXPORT2
75
19.1k
ucase_getTrie() {
76
19.1k
    return &ucase_props_singleton.trie;
77
19.1k
}
78
79
0
#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT))
80
81
/* number of bits in an 8-bit integer value */
82
static const uint8_t flagsOffset[256]={
83
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
84
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
85
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
86
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
87
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
88
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
89
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
90
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
91
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
92
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
93
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
94
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
95
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
96
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
97
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
98
    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
99
};
100
101
0
#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx)))
102
0
#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)]
103
104
/*
105
 * Get the value of an optional-value slot where HAS_SLOT(excWord, idx).
106
 *
107
 * @param excWord (in) initial exceptions word
108
 * @param idx (in) desired slot index
109
 * @param pExc16 (in/out) const uint16_t * after excWord=*pExc16++;
110
 *               moved to the last uint16_t of the value, use +1 for beginning of next slot
111
 * @param value (out) int32_t or uint32_t output if hasSlot, otherwise not modified
112
 */
113
0
#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \
114
0
    if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \
115
0
        (pExc16)+=SLOT_OFFSET(excWord, idx); \
116
0
        (value)=*pExc16; \
117
0
    } else { \
118
0
        (pExc16)+=2*SLOT_OFFSET(excWord, idx); \
119
0
        (value)=*pExc16++; \
120
0
        (value)=((value)<<16)|*pExc16; \
121
0
    } \
122
0
} UPRV_BLOCK_MACRO_END
123
124
/* simple case mappings ----------------------------------------------------- */
125
126
U_CAPI UChar32 U_EXPORT2
127
0
ucase_tolower(UChar32 c) {
128
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
129
0
    if(!UCASE_HAS_EXCEPTION(props)) {
130
0
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
131
0
            c+=UCASE_GET_DELTA(props);
132
0
        }
133
0
    } else {
134
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
135
0
        uint16_t excWord=*pe++;
136
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
137
0
            int32_t delta;
138
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
139
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
140
0
        }
141
0
        if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
142
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe, c);
143
0
        }
144
0
    }
145
0
    return c;
146
0
}
147
148
U_CAPI UChar32 U_EXPORT2
149
0
ucase_toupper(UChar32 c) {
150
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
151
0
    if(!UCASE_HAS_EXCEPTION(props)) {
152
0
        if(UCASE_GET_TYPE(props)==UCASE_LOWER) {
153
0
            c+=UCASE_GET_DELTA(props);
154
0
        }
155
0
    } else {
156
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
157
0
        uint16_t excWord=*pe++;
158
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
159
0
            int32_t delta;
160
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
161
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
162
0
        }
163
0
        if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
164
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_UPPER, pe, c);
165
0
        }
166
0
    }
167
0
    return c;
168
0
}
169
170
U_CAPI UChar32 U_EXPORT2
171
0
ucase_totitle(UChar32 c) {
172
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
173
0
    if(!UCASE_HAS_EXCEPTION(props)) {
174
0
        if(UCASE_GET_TYPE(props)==UCASE_LOWER) {
175
0
            c+=UCASE_GET_DELTA(props);
176
0
        }
177
0
    } else {
178
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
179
0
        uint16_t excWord=*pe++;
180
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
181
0
            int32_t delta;
182
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
183
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
184
0
        }
185
0
        int32_t idx;
186
0
        if(HAS_SLOT(excWord, UCASE_EXC_TITLE)) {
187
0
            idx=UCASE_EXC_TITLE;
188
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
189
0
            idx=UCASE_EXC_UPPER;
190
0
        } else {
191
0
            return c;
192
0
        }
193
0
        GET_SLOT_VALUE(excWord, idx, pe, c);
194
0
    }
195
0
    return c;
196
0
}
197
198
static const UChar iDot[2] = { 0x69, 0x307 };
199
static const UChar jDot[2] = { 0x6a, 0x307 };
200
static const UChar iOgonekDot[3] = { 0x12f, 0x307 };
201
static const UChar iDotGrave[3] = { 0x69, 0x307, 0x300 };
202
static const UChar iDotAcute[3] = { 0x69, 0x307, 0x301 };
203
static const UChar iDotTilde[3] = { 0x69, 0x307, 0x303 };
204
205
206
U_CFUNC void U_EXPORT2
207
0
ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
208
0
    uint16_t props;
209
210
    /*
211
     * Hardcode the case closure of i and its relatives and ignore the
212
     * data file data for these characters.
213
     * The Turkic dotless i and dotted I with their case mapping conditions
214
     * and case folding option make the related characters behave specially.
215
     * This code matches their closure behavior to their case folding behavior.
216
     */
217
218
0
    switch(c) {
219
0
    case 0x49:
220
        /* regular i and I are in one equivalence class */
221
0
        sa->add(sa->set, 0x69);
222
0
        return;
223
0
    case 0x69:
224
0
        sa->add(sa->set, 0x49);
225
0
        return;
226
0
    case 0x130:
227
        /* dotted I is in a class with <0069 0307> (for canonical equivalence with <0049 0307>) */
228
0
        sa->addString(sa->set, iDot, 2);
229
0
        return;
230
0
    case 0x131:
231
        /* dotless i is in a class by itself */
232
0
        return;
233
0
    default:
234
        /* otherwise use the data file data */
235
0
        break;
236
0
    }
237
238
0
    props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
239
0
    if(!UCASE_HAS_EXCEPTION(props)) {
240
0
        if(UCASE_GET_TYPE(props)!=UCASE_NONE) {
241
            /* add the one simple case mapping, no matter what type it is */
242
0
            int32_t delta=UCASE_GET_DELTA(props);
243
0
            if(delta!=0) {
244
0
                sa->add(sa->set, c+delta);
245
0
            }
246
0
        }
247
0
    } else {
248
        /*
249
         * c has exceptions, so there may be multiple simple and/or
250
         * full case mappings. Add them all.
251
         */
252
0
        const uint16_t *pe0, *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
253
0
        const UChar *closure;
254
0
        uint16_t excWord=*pe++;
255
0
        int32_t idx, closureLength, fullLength, length;
256
257
0
        pe0=pe;
258
259
        /* add all simple case mappings */
260
0
        for(idx=UCASE_EXC_LOWER; idx<=UCASE_EXC_TITLE; ++idx) {
261
0
            if(HAS_SLOT(excWord, idx)) {
262
0
                pe=pe0;
263
0
                GET_SLOT_VALUE(excWord, idx, pe, c);
264
0
                sa->add(sa->set, c);
265
0
            }
266
0
        }
267
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA)) {
268
0
            pe=pe0;
269
0
            int32_t delta;
270
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
271
0
            sa->add(sa->set, (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta);
272
0
        }
273
274
        /* get the closure string pointer & length */
275
0
        if(HAS_SLOT(excWord, UCASE_EXC_CLOSURE)) {
276
0
            pe=pe0;
277
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_CLOSURE, pe, closureLength);
278
0
            closureLength&=UCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
279
0
            closure=(const UChar *)pe+1; /* behind this slot, unless there are full case mappings */
280
0
        } else {
281
0
            closureLength=0;
282
0
            closure=NULL;
283
0
        }
284
285
        /* add the full case folding */
286
0
        if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
287
0
            pe=pe0;
288
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, fullLength);
289
290
            /* start of full case mapping strings */
291
0
            ++pe;
292
293
0
            fullLength&=0xffff; /* bits 16 and higher are reserved */
294
295
            /* skip the lowercase result string */
296
0
            pe+=fullLength&UCASE_FULL_LOWER;
297
0
            fullLength>>=4;
298
299
            /* add the full case folding string */
300
0
            length=fullLength&0xf;
301
0
            if(length!=0) {
302
0
                sa->addString(sa->set, (const UChar *)pe, length);
303
0
                pe+=length;
304
0
            }
305
306
            /* skip the uppercase and titlecase strings */
307
0
            fullLength>>=4;
308
0
            pe+=fullLength&0xf;
309
0
            fullLength>>=4;
310
0
            pe+=fullLength;
311
312
0
            closure=(const UChar *)pe; /* behind full case mappings */
313
0
        }
314
315
        /* add each code point in the closure string */
316
0
        for(idx=0; idx<closureLength;) {
317
0
            U16_NEXT_UNSAFE(closure, idx, c);
318
0
            sa->add(sa->set, c);
319
0
        }
320
0
    }
321
0
}
322
323
/*
324
 * compare s, which has a length, with t, which has a maximum length or is NUL-terminated
325
 * must be length>0 and max>0 and length<=max
326
 */
327
static inline int32_t
328
0
strcmpMax(const UChar *s, int32_t length, const UChar *t, int32_t max) {
329
0
    int32_t c1, c2;
330
331
0
    max-=length; /* we require length<=max, so no need to decrement max in the loop */
332
0
    do {
333
0
        c1=*s++;
334
0
        c2=*t++;
335
0
        if(c2==0) {
336
0
            return 1; /* reached the end of t but not of s */
337
0
        }
338
0
        c1-=c2;
339
0
        if(c1!=0) {
340
0
            return c1; /* return difference result */
341
0
        }
342
0
    } while(--length>0);
343
    /* ends with length==0 */
344
345
0
    if(max==0 || *t==0) {
346
0
        return 0; /* equal to length of both strings */
347
0
    } else {
348
0
        return -max; /* return length difference */
349
0
    }
350
0
}
351
352
U_CFUNC UBool U_EXPORT2
353
0
ucase_addStringCaseClosure(const UChar *s, int32_t length, const USetAdder *sa) {
354
0
    int32_t i, start, limit, result, unfoldRows, unfoldRowWidth, unfoldStringWidth;
355
356
0
    if(ucase_props_singleton.unfold==NULL || s==NULL) {
357
0
        return FALSE; /* no reverse case folding data, or no string */
358
0
    }
359
0
    if(length<=1) {
360
        /* the string is too short to find any match */
361
        /*
362
         * more precise would be:
363
         * if(!u_strHasMoreChar32Than(s, length, 1))
364
         * but this does not make much practical difference because
365
         * a single supplementary code point would just not be found
366
         */
367
0
        return FALSE;
368
0
    }
369
370
0
    const uint16_t *unfold=ucase_props_singleton.unfold;
371
0
    unfoldRows=unfold[UCASE_UNFOLD_ROWS];
372
0
    unfoldRowWidth=unfold[UCASE_UNFOLD_ROW_WIDTH];
373
0
    unfoldStringWidth=unfold[UCASE_UNFOLD_STRING_WIDTH];
374
0
    unfold+=unfoldRowWidth;
375
376
0
    if(length>unfoldStringWidth) {
377
        /* the string is too long to find any match */
378
0
        return FALSE;
379
0
    }
380
381
    /* do a binary search for the string */
382
0
    start=0;
383
0
    limit=unfoldRows;
384
0
    while(start<limit) {
385
0
        i=(start+limit)/2;
386
0
        const UChar *p=reinterpret_cast<const UChar *>(unfold+(i*unfoldRowWidth));
387
0
        result=strcmpMax(s, length, p, unfoldStringWidth);
388
389
0
        if(result==0) {
390
            /* found the string: add each code point, and its case closure */
391
0
            UChar32 c;
392
393
0
            for(i=unfoldStringWidth; i<unfoldRowWidth && p[i]!=0;) {
394
0
                U16_NEXT_UNSAFE(p, i, c);
395
0
                sa->add(sa->set, c);
396
0
                ucase_addCaseClosure(c, sa);
397
0
            }
398
0
            return TRUE;
399
0
        } else if(result<0) {
400
0
            limit=i;
401
0
        } else /* result>0 */ {
402
0
            start=i+1;
403
0
        }
404
0
    }
405
406
0
    return FALSE; /* string not found */
407
0
}
408
409
U_NAMESPACE_BEGIN
410
411
FullCaseFoldingIterator::FullCaseFoldingIterator()
412
        : unfold(reinterpret_cast<const UChar *>(ucase_props_singleton.unfold)),
413
          unfoldRows(unfold[UCASE_UNFOLD_ROWS]),
414
          unfoldRowWidth(unfold[UCASE_UNFOLD_ROW_WIDTH]),
415
          unfoldStringWidth(unfold[UCASE_UNFOLD_STRING_WIDTH]),
416
          currentRow(0),
417
0
          rowCpIndex(unfoldStringWidth) {
418
0
    unfold+=unfoldRowWidth;
419
0
}
420
421
UChar32
422
0
FullCaseFoldingIterator::next(UnicodeString &full) {
423
    // Advance past the last-delivered code point.
424
0
    const UChar *p=unfold+(currentRow*unfoldRowWidth);
425
0
    if(rowCpIndex>=unfoldRowWidth || p[rowCpIndex]==0) {
426
0
        ++currentRow;
427
0
        p+=unfoldRowWidth;
428
0
        rowCpIndex=unfoldStringWidth;
429
0
    }
430
0
    if(currentRow>=unfoldRows) { return U_SENTINEL; }
431
    // Set "full" to the NUL-terminated string in the first unfold column.
432
0
    int32_t length=unfoldStringWidth;
433
0
    while(length>0 && p[length-1]==0) { --length; }
434
0
    full.setTo(FALSE, p, length);
435
    // Return the code point.
436
0
    UChar32 c;
437
0
    U16_NEXT_UNSAFE(p, rowCpIndex, c);
438
0
    return c;
439
0
}
440
441
namespace LatinCase {
442
443
const int8_t TO_LOWER_NORMAL[LIMIT] = {
444
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
445
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
446
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
447
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
448
449
    0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
450
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0,
451
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
452
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
453
454
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
455
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
456
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
457
    0, 0, 0, 0, 0, EXC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
458
459
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
460
    32, 32, 32, 32, 32, 32, 32, 0, 32, 32, 32, 32, 32, 32, 32, EXC,
461
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
462
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
463
464
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
465
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
466
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
467
    EXC, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,
468
469
    0, 1, 0, 1, 0, 1, 0, 1, 0, EXC, 1, 0, 1, 0, 1, 0,
470
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
471
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
472
    1, 0, 1, 0, 1, 0, 1, 0, -121, 1, 0, 1, 0, 1, 0, EXC
473
};
474
475
const int8_t TO_LOWER_TR_LT[LIMIT] = {
476
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
477
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
478
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
479
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
480
481
    0, 32, 32, 32, 32, 32, 32, 32, 32, EXC, EXC, 32, 32, 32, 32, 32,
482
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0,
483
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
484
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
485
486
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
487
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
488
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
489
    0, 0, 0, 0, 0, EXC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
490
491
    32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, EXC, EXC, 32, 32,
492
    32, 32, 32, 32, 32, 32, 32, 0, 32, 32, 32, 32, 32, 32, 32, EXC,
493
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
494
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
495
496
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
497
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
498
    1, 0, 1, 0, 1, 0, 1, 0, EXC, 0, 1, 0, 1, 0, EXC, 0,
499
    EXC, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,
500
501
    0, 1, 0, 1, 0, 1, 0, 1, 0, EXC, 1, 0, 1, 0, 1, 0,
502
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
503
    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
504
    1, 0, 1, 0, 1, 0, 1, 0, -121, 1, 0, 1, 0, 1, 0, EXC
505
};
506
507
const int8_t TO_UPPER_NORMAL[LIMIT] = {
508
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
509
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
510
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
511
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
512
513
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
514
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
515
    0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,
516
    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, 0, 0, 0, 0,
517
518
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
519
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
520
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
521
    0, 0, 0, 0, 0, EXC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
522
523
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
524
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EXC,
525
    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,
526
    -32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32, -32, 121,
527
528
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
529
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
530
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
531
    0, EXC, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0,
532
533
    -1, 0, -1, 0, -1, 0, -1, 0, -1, EXC, 0, -1, 0, -1, 0, -1,
534
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
535
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
536
    0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, EXC
537
};
538
539
const int8_t TO_UPPER_TR[LIMIT] = {
540
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
541
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
542
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
543
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
544
545
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
546
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
547
    0, -32, -32, -32, -32, -32, -32, -32, -32, EXC, -32, -32, -32, -32, -32, -32,
548
    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, 0, 0, 0, 0,
549
550
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
551
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
552
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
553
    0, 0, 0, 0, 0, EXC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
554
555
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
556
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EXC,
557
    -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32,
558
    -32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32, -32, 121,
559
560
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
561
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
562
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
563
    0, EXC, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0,
564
565
    -1, 0, -1, 0, -1, 0, -1, 0, -1, EXC, 0, -1, 0, -1, 0, -1,
566
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
567
    0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1,
568
    0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, EXC
569
};
570
571
}  // namespace LatinCase
572
573
U_NAMESPACE_END
574
575
/** @return UCASE_NONE, UCASE_LOWER, UCASE_UPPER, UCASE_TITLE */
576
U_CAPI int32_t U_EXPORT2
577
0
ucase_getType(UChar32 c) {
578
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
579
0
    return UCASE_GET_TYPE(props);
580
0
}
581
582
/** @return same as ucase_getType() and set bit 2 if c is case-ignorable */
583
U_CAPI int32_t U_EXPORT2
584
0
ucase_getTypeOrIgnorable(UChar32 c) {
585
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
586
0
    return UCASE_GET_TYPE_AND_IGNORABLE(props);
587
0
}
588
589
/** @return UCASE_NO_DOT, UCASE_SOFT_DOTTED, UCASE_ABOVE, UCASE_OTHER_ACCENT */
590
static inline int32_t
591
0
getDotType(UChar32 c) {
592
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
593
0
    if(!UCASE_HAS_EXCEPTION(props)) {
594
0
        return props&UCASE_DOT_MASK;
595
0
    } else {
596
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
597
0
        return (*pe>>UCASE_EXC_DOT_SHIFT)&UCASE_DOT_MASK;
598
0
    }
599
0
}
600
601
U_CAPI UBool U_EXPORT2
602
0
ucase_isSoftDotted(UChar32 c) {
603
0
    return (UBool)(getDotType(c)==UCASE_SOFT_DOTTED);
604
0
}
605
606
U_CAPI UBool U_EXPORT2
607
0
ucase_isCaseSensitive(UChar32 c) {
608
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
609
0
    if(!UCASE_HAS_EXCEPTION(props)) {
610
0
        return (UBool)((props&UCASE_SENSITIVE)!=0);
611
0
    } else {
612
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
613
0
        return (UBool)((*pe&UCASE_EXC_SENSITIVE)!=0);
614
0
    }
615
0
}
616
617
/* string casing ------------------------------------------------------------ */
618
619
/*
620
 * These internal functions form the core of string case mappings.
621
 * They map single code points to result code points or strings and take
622
 * all necessary conditions (context, locale ID, options) into account.
623
 *
624
 * They do not iterate over the source or write to the destination
625
 * so that the same functions are useful for non-standard string storage,
626
 * such as in a Replaceable (for Transliterator) or UTF-8/32 strings etc.
627
 * For the same reason, the "surrounding text" context is passed in as a
628
 * UCaseContextIterator which does not make any assumptions about
629
 * the underlying storage.
630
 *
631
 * This section contains helper functions that check for conditions
632
 * in the input text surrounding the current code point
633
 * according to SpecialCasing.txt.
634
 *
635
 * Each helper function gets the index
636
 * - after the current code point if it looks at following text
637
 * - before the current code point if it looks at preceding text
638
 *
639
 * Unicode 3.2 UAX 21 "Case Mappings" defines the conditions as follows:
640
 *
641
 * Final_Sigma
642
 *   C is preceded by a sequence consisting of
643
 *     a cased letter and a case-ignorable sequence,
644
 *   and C is not followed by a sequence consisting of
645
 *     an ignorable sequence and then a cased letter.
646
 *
647
 * More_Above
648
 *   C is followed by one or more characters of combining class 230 (ABOVE)
649
 *   in the combining character sequence.
650
 *
651
 * After_Soft_Dotted
652
 *   The last preceding character with combining class of zero before C
653
 *   was Soft_Dotted,
654
 *   and there is no intervening combining character class 230 (ABOVE).
655
 *
656
 * Before_Dot
657
 *   C is followed by combining dot above (U+0307).
658
 *   Any sequence of characters with a combining class that is neither 0 nor 230
659
 *   may intervene between the current character and the combining dot above.
660
 *
661
 * The erratum from 2002-10-31 adds the condition
662
 *
663
 * After_I
664
 *   The last preceding base character was an uppercase I, and there is no
665
 *   intervening combining character class 230 (ABOVE).
666
 *
667
 *   (See Jitterbug 2344 and the comments on After_I below.)
668
 *
669
 * Helper definitions in Unicode 3.2 UAX 21:
670
 *
671
 * D1. A character C is defined to be cased
672
 *     if it meets any of the following criteria:
673
 *
674
 *   - The general category of C is Titlecase Letter (Lt)
675
 *   - In [CoreProps], C has one of the properties Uppercase, or Lowercase
676
 *   - Given D = NFD(C), then it is not the case that:
677
 *     D = UCD_lower(D) = UCD_upper(D) = UCD_title(D)
678
 *     (This third criterion does not add any characters to the list
679
 *      for Unicode 3.2. Ignored.)
680
 *
681
 * D2. A character C is defined to be case-ignorable
682
 *     if it meets either of the following criteria:
683
 *
684
 *   - The general category of C is
685
 *     Nonspacing Mark (Mn), or Enclosing Mark (Me), or Format Control (Cf), or
686
 *     Letter Modifier (Lm), or Symbol Modifier (Sk)
687
 *   - C is one of the following characters
688
 *     U+0027 APOSTROPHE
689
 *     U+00AD SOFT HYPHEN (SHY)
690
 *     U+2019 RIGHT SINGLE QUOTATION MARK
691
 *            (the preferred character for apostrophe)
692
 *
693
 * D3. A case-ignorable sequence is a sequence of
694
 *     zero or more case-ignorable characters.
695
 */
696
697
0
#define is_d(c) ((c)=='d' || (c)=='D')
698
0
#define is_e(c) ((c)=='e' || (c)=='E')
699
0
#define is_i(c) ((c)=='i' || (c)=='I')
700
0
#define is_l(c) ((c)=='l' || (c)=='L')
701
0
#define is_r(c) ((c)=='r' || (c)=='R')
702
0
#define is_t(c) ((c)=='t' || (c)=='T')
703
0
#define is_u(c) ((c)=='u' || (c)=='U')
704
0
#define is_y(c) ((c)=='y' || (c)=='Y')
705
0
#define is_z(c) ((c)=='z' || (c)=='Z')
706
707
/* separator? */
708
0
#define is_sep(c) ((c)=='_' || (c)=='-' || (c)==0)
709
710
/**
711
 * Requires non-NULL locale ID but otherwise does the equivalent of
712
 * checking for language codes as if uloc_getLanguage() were called:
713
 * Accepts both 2- and 3-letter codes and accepts case variants.
714
 */
715
U_CFUNC int32_t
716
0
ucase_getCaseLocale(const char *locale) {
717
    /*
718
     * This function used to use uloc_getLanguage(), but the current code
719
     * removes the dependency of this low-level code on uloc implementation code
720
     * and is faster because not the whole locale ID has to be
721
     * examined and copied/transformed.
722
     *
723
     * Because this code does not want to depend on uloc, the caller must
724
     * pass in a non-NULL locale, i.e., may need to call uloc_getDefault().
725
     */
726
0
    char c=*locale++;
727
    // Fastpath for English "en" which is often used for default (=root locale) case mappings,
728
    // and for Chinese "zh": Very common but no special case mapping behavior.
729
    // Then check lowercase vs. uppercase to reduce the number of comparisons
730
    // for other locales without special behavior.
731
0
    if(c=='e') {
732
        /* el or ell? */
733
0
        c=*locale++;
734
0
        if(is_l(c)) {
735
0
            c=*locale++;
736
0
            if(is_l(c)) {
737
0
                c=*locale;
738
0
            }
739
0
            if(is_sep(c)) {
740
0
                return UCASE_LOC_GREEK;
741
0
            }
742
0
        }
743
        // en, es, ... -> root
744
0
    } else if(c=='z') {
745
0
        return UCASE_LOC_ROOT;
746
0
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
747
0
    } else if(c>='a') {  // ASCII a-z = 0x61..0x7a, after A-Z
748
#elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
749
    } else if(c<='z') {  // EBCDIC a-z = 0x81..0xa9 with two gaps, before A-Z
750
#else
751
#   error Unknown charset family!
752
#endif
753
        // lowercase c
754
0
        if(c=='t') {
755
            /* tr or tur? */
756
0
            c=*locale++;
757
0
            if(is_u(c)) {
758
0
                c=*locale++;
759
0
            }
760
0
            if(is_r(c)) {
761
0
                c=*locale;
762
0
                if(is_sep(c)) {
763
0
                    return UCASE_LOC_TURKISH;
764
0
                }
765
0
            }
766
0
        } else if(c=='a') {
767
            /* az or aze? */
768
0
            c=*locale++;
769
0
            if(is_z(c)) {
770
0
                c=*locale++;
771
0
                if(is_e(c)) {
772
0
                    c=*locale;
773
0
                }
774
0
                if(is_sep(c)) {
775
0
                    return UCASE_LOC_TURKISH;
776
0
                }
777
0
            }
778
0
        } else if(c=='l') {
779
            /* lt or lit? */
780
0
            c=*locale++;
781
0
            if(is_i(c)) {
782
0
                c=*locale++;
783
0
            }
784
0
            if(is_t(c)) {
785
0
                c=*locale;
786
0
                if(is_sep(c)) {
787
0
                    return UCASE_LOC_LITHUANIAN;
788
0
                }
789
0
            }
790
0
        } else if(c=='n') {
791
            /* nl or nld? */
792
0
            c=*locale++;
793
0
            if(is_l(c)) {
794
0
                c=*locale++;
795
0
                if(is_d(c)) {
796
0
                    c=*locale;
797
0
                }
798
0
                if(is_sep(c)) {
799
0
                    return UCASE_LOC_DUTCH;
800
0
                }
801
0
            }
802
0
        } else if(c=='h') {
803
            /* hy or hye? *not* hyw */
804
0
            c=*locale++;
805
0
            if(is_y(c)) {
806
0
                c=*locale++;
807
0
                if(is_e(c)) {
808
0
                    c=*locale;
809
0
                }
810
0
                if(is_sep(c)) {
811
0
                    return UCASE_LOC_ARMENIAN;
812
0
                }
813
0
            }
814
0
        }
815
0
    } else {
816
        // uppercase c
817
        // Same code as for lowercase c but also check for 'E'.
818
0
        if(c=='T') {
819
            /* tr or tur? */
820
0
            c=*locale++;
821
0
            if(is_u(c)) {
822
0
                c=*locale++;
823
0
            }
824
0
            if(is_r(c)) {
825
0
                c=*locale;
826
0
                if(is_sep(c)) {
827
0
                    return UCASE_LOC_TURKISH;
828
0
                }
829
0
            }
830
0
        } else if(c=='A') {
831
            /* az or aze? */
832
0
            c=*locale++;
833
0
            if(is_z(c)) {
834
0
                c=*locale++;
835
0
                if(is_e(c)) {
836
0
                    c=*locale;
837
0
                }
838
0
                if(is_sep(c)) {
839
0
                    return UCASE_LOC_TURKISH;
840
0
                }
841
0
            }
842
0
        } else if(c=='L') {
843
            /* lt or lit? */
844
0
            c=*locale++;
845
0
            if(is_i(c)) {
846
0
                c=*locale++;
847
0
            }
848
0
            if(is_t(c)) {
849
0
                c=*locale;
850
0
                if(is_sep(c)) {
851
0
                    return UCASE_LOC_LITHUANIAN;
852
0
                }
853
0
            }
854
0
        } else if(c=='E') {
855
            /* el or ell? */
856
0
            c=*locale++;
857
0
            if(is_l(c)) {
858
0
                c=*locale++;
859
0
                if(is_l(c)) {
860
0
                    c=*locale;
861
0
                }
862
0
                if(is_sep(c)) {
863
0
                    return UCASE_LOC_GREEK;
864
0
                }
865
0
            }
866
0
        } else if(c=='N') {
867
            /* nl or nld? */
868
0
            c=*locale++;
869
0
            if(is_l(c)) {
870
0
                c=*locale++;
871
0
                if(is_d(c)) {
872
0
                    c=*locale;
873
0
                }
874
0
                if(is_sep(c)) {
875
0
                    return UCASE_LOC_DUTCH;
876
0
                }
877
0
            }
878
0
        } else if(c=='H') {
879
            /* hy or hye? *not* hyw */
880
0
            c=*locale++;
881
0
            if(is_y(c)) {
882
0
                c=*locale++;
883
0
                if(is_e(c)) {
884
0
                    c=*locale;
885
0
                }
886
0
                if(is_sep(c)) {
887
0
                    return UCASE_LOC_ARMENIAN;
888
0
                }
889
0
            }
890
0
        }
891
0
    }
892
0
    return UCASE_LOC_ROOT;
893
0
}
894
895
/*
896
 * Is followed by
897
 *   {case-ignorable}* cased
898
 * ?
899
 * (dir determines looking forward/backward)
900
 * If a character is case-ignorable, it is skipped regardless of whether
901
 * it is also cased or not.
902
 */
903
static UBool
904
0
isFollowedByCasedLetter(UCaseContextIterator *iter, void *context, int8_t dir) {
905
0
    UChar32 c;
906
907
0
    if(iter==NULL) {
908
0
        return FALSE;
909
0
    }
910
911
0
    for(/* dir!=0 sets direction */; (c=iter(context, dir))>=0; dir=0) {
912
0
        int32_t type=ucase_getTypeOrIgnorable(c);
913
0
        if(type&4) {
914
            /* case-ignorable, continue with the loop */
915
0
        } else if(type!=UCASE_NONE) {
916
0
            return TRUE; /* followed by cased letter */
917
0
        } else {
918
0
            return FALSE; /* uncased and not case-ignorable */
919
0
        }
920
0
    }
921
922
0
    return FALSE; /* not followed by cased letter */
923
0
}
924
925
/* Is preceded by Soft_Dotted character with no intervening cc=230 ? */
926
static UBool
927
0
isPrecededBySoftDotted(UCaseContextIterator *iter, void *context) {
928
0
    UChar32 c;
929
0
    int32_t dotType;
930
0
    int8_t dir;
931
932
0
    if(iter==NULL) {
933
0
        return FALSE;
934
0
    }
935
936
0
    for(dir=-1; (c=iter(context, dir))>=0; dir=0) {
937
0
        dotType=getDotType(c);
938
0
        if(dotType==UCASE_SOFT_DOTTED) {
939
0
            return TRUE; /* preceded by TYPE_i */
940
0
        } else if(dotType!=UCASE_OTHER_ACCENT) {
941
0
            return FALSE; /* preceded by different base character (not TYPE_i), or intervening cc==230 */
942
0
        }
943
0
    }
944
945
0
    return FALSE; /* not preceded by TYPE_i */
946
0
}
947
948
/*
949
 * See Jitterbug 2344:
950
 * The condition After_I for Turkic-lowercasing of U+0307 combining dot above
951
 * is checked in ICU 2.0, 2.1, 2.6 but was not in 2.2 & 2.4 because
952
 * we made those releases compatible with Unicode 3.2 which had not fixed
953
 * a related bug in SpecialCasing.txt.
954
 *
955
 * From the Jitterbug 2344 text:
956
 * ... this bug is listed as a Unicode erratum
957
 * from 2002-10-31 at http://www.unicode.org/uni2errata/UnicodeErrata.html
958
 * <quote>
959
 * There are two errors in SpecialCasing.txt.
960
 * 1. Missing semicolons on two lines. ... [irrelevant for ICU]
961
 * 2. An incorrect context definition. Correct as follows:
962
 * < 0307; ; 0307; 0307; tr After_Soft_Dotted; # COMBINING DOT ABOVE
963
 * < 0307; ; 0307; 0307; az After_Soft_Dotted; # COMBINING DOT ABOVE
964
 * ---
965
 * > 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
966
 * > 0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
967
 * where the context After_I is defined as:
968
 * The last preceding base character was an uppercase I, and there is no
969
 * intervening combining character class 230 (ABOVE).
970
 * </quote>
971
 *
972
 * Note that SpecialCasing.txt even in Unicode 3.2 described the condition as:
973
 *
974
 * # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
975
 * # This matches the behavior of the canonically equivalent I-dot_above
976
 *
977
 * See also the description in this place in older versions of uchar.c (revision 1.100).
978
 *
979
 * Markus W. Scherer 2003-feb-15
980
 */
981
982
/* Is preceded by base character 'I' with no intervening cc=230 ? */
983
static UBool
984
0
isPrecededBy_I(UCaseContextIterator *iter, void *context) {
985
0
    UChar32 c;
986
0
    int32_t dotType;
987
0
    int8_t dir;
988
989
0
    if(iter==NULL) {
990
0
        return FALSE;
991
0
    }
992
993
0
    for(dir=-1; (c=iter(context, dir))>=0; dir=0) {
994
0
        if(c==0x49) {
995
0
            return TRUE; /* preceded by I */
996
0
        }
997
0
        dotType=getDotType(c);
998
0
        if(dotType!=UCASE_OTHER_ACCENT) {
999
0
            return FALSE; /* preceded by different base character (not I), or intervening cc==230 */
1000
0
        }
1001
0
    }
1002
1003
0
    return FALSE; /* not preceded by I */
1004
0
}
1005
1006
/* Is followed by one or more cc==230 ? */
1007
static UBool
1008
0
isFollowedByMoreAbove(UCaseContextIterator *iter, void *context) {
1009
0
    UChar32 c;
1010
0
    int32_t dotType;
1011
0
    int8_t dir;
1012
1013
0
    if(iter==NULL) {
1014
0
        return FALSE;
1015
0
    }
1016
1017
0
    for(dir=1; (c=iter(context, dir))>=0; dir=0) {
1018
0
        dotType=getDotType(c);
1019
0
        if(dotType==UCASE_ABOVE) {
1020
0
            return TRUE; /* at least one cc==230 following */
1021
0
        } else if(dotType!=UCASE_OTHER_ACCENT) {
1022
0
            return FALSE; /* next base character, no more cc==230 following */
1023
0
        }
1024
0
    }
1025
1026
0
    return FALSE; /* no more cc==230 following */
1027
0
}
1028
1029
/* Is followed by a dot above (without cc==230 in between) ? */
1030
static UBool
1031
0
isFollowedByDotAbove(UCaseContextIterator *iter, void *context) {
1032
0
    UChar32 c;
1033
0
    int32_t dotType;
1034
0
    int8_t dir;
1035
1036
0
    if(iter==NULL) {
1037
0
        return FALSE;
1038
0
    }
1039
1040
0
    for(dir=1; (c=iter(context, dir))>=0; dir=0) {
1041
0
        if(c==0x307) {
1042
0
            return TRUE;
1043
0
        }
1044
0
        dotType=getDotType(c);
1045
0
        if(dotType!=UCASE_OTHER_ACCENT) {
1046
0
            return FALSE; /* next base character or cc==230 in between */
1047
0
        }
1048
0
    }
1049
1050
0
    return FALSE; /* no dot above following */
1051
0
}
1052
1053
U_CAPI int32_t U_EXPORT2
1054
ucase_toFullLower(UChar32 c,
1055
                  UCaseContextIterator *iter, void *context,
1056
                  const UChar **pString,
1057
0
                  int32_t loc) {
1058
    // The sign of the result has meaning, input must be non-negative so that it can be returned as is.
1059
0
    U_ASSERT(c >= 0);
1060
0
    UChar32 result=c;
1061
    // Reset the output pointer in case it was uninitialized.
1062
0
    *pString=nullptr;
1063
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
1064
0
    if(!UCASE_HAS_EXCEPTION(props)) {
1065
0
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
1066
0
            result=c+UCASE_GET_DELTA(props);
1067
0
        }
1068
0
    } else {
1069
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2;
1070
0
        uint16_t excWord=*pe++;
1071
0
        int32_t full;
1072
1073
0
        pe2=pe;
1074
1075
0
        if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) {
1076
            /* use hardcoded conditions and mappings */
1077
1078
            /*
1079
             * Test for conditional mappings first
1080
             *   (otherwise the unconditional default mappings are always taken),
1081
             * then test for characters that have unconditional mappings in SpecialCasing.txt,
1082
             * then get the UnicodeData.txt mappings.
1083
             */
1084
0
            if( loc==UCASE_LOC_LITHUANIAN &&
1085
                    /* base characters, find accents above */
1086
0
                    (((c==0x49 || c==0x4a || c==0x12e) &&
1087
0
                        isFollowedByMoreAbove(iter, context)) ||
1088
                    /* precomposed with accent above, no need to find one */
1089
0
                    (c==0xcc || c==0xcd || c==0x128))
1090
0
            ) {
1091
                /*
1092
                    # Lithuanian
1093
1094
                    # Lithuanian retains the dot in a lowercase i when followed by accents.
1095
1096
                    # Introduce an explicit dot above when lowercasing capital I's and J's
1097
                    # whenever there are more accents above.
1098
                    # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
1099
1100
                    0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
1101
                    004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
1102
                    012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
1103
                    00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
1104
                    00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
1105
                    0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
1106
                 */
1107
0
                switch(c) {
1108
0
                case 0x49:  /* LATIN CAPITAL LETTER I */
1109
0
                    *pString=iDot;
1110
0
                    return 2;
1111
0
                case 0x4a:  /* LATIN CAPITAL LETTER J */
1112
0
                    *pString=jDot;
1113
0
                    return 2;
1114
0
                case 0x12e: /* LATIN CAPITAL LETTER I WITH OGONEK */
1115
0
                    *pString=iOgonekDot;
1116
0
                    return 2;
1117
0
                case 0xcc:  /* LATIN CAPITAL LETTER I WITH GRAVE */
1118
0
                    *pString=iDotGrave;
1119
0
                    return 3;
1120
0
                case 0xcd:  /* LATIN CAPITAL LETTER I WITH ACUTE */
1121
0
                    *pString=iDotAcute;
1122
0
                    return 3;
1123
0
                case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */
1124
0
                    *pString=iDotTilde;
1125
0
                    return 3;
1126
0
                default:
1127
0
                    return 0; /* will not occur */
1128
0
                }
1129
            /* # Turkish and Azeri */
1130
0
            } else if(loc==UCASE_LOC_TURKISH && c==0x130) {
1131
                /*
1132
                    # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
1133
                    # The following rules handle those cases.
1134
1135
                    0130; 0069; 0130; 0130; tr # LATIN CAPITAL LETTER I WITH DOT ABOVE
1136
                    0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE
1137
                 */
1138
0
                return 0x69;
1139
0
            } else if(loc==UCASE_LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, context)) {
1140
                /*
1141
                    # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
1142
                    # This matches the behavior of the canonically equivalent I-dot_above
1143
1144
                    0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
1145
                    0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
1146
                 */
1147
0
                return 0; /* remove the dot (continue without output) */
1148
0
            } else if(loc==UCASE_LOC_TURKISH && c==0x49 && !isFollowedByDotAbove(iter, context)) {
1149
                /*
1150
                    # When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
1151
1152
                    0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
1153
                    0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I
1154
                 */
1155
0
                return 0x131;
1156
0
            } else if(c==0x130) {
1157
                /*
1158
                    # Preserve canonical equivalence for I with dot. Turkic is handled below.
1159
1160
                    0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
1161
                 */
1162
0
                *pString=iDot;
1163
0
                return 2;
1164
0
            } else if(  c==0x3a3 &&
1165
0
                        !isFollowedByCasedLetter(iter, context, 1) &&
1166
0
                        isFollowedByCasedLetter(iter, context, -1) /* -1=preceded */
1167
0
            ) {
1168
                /* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */
1169
                /*
1170
                    # Special case for final form of sigma
1171
1172
                    03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
1173
                 */
1174
0
                return 0x3c2; /* greek small final sigma */
1175
0
            } else {
1176
                /* no known conditional special case mapping, use a normal mapping */
1177
0
            }
1178
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
1179
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full);
1180
0
            full&=UCASE_FULL_LOWER;
1181
0
            if(full!=0) {
1182
                /* set the output pointer to the lowercase mapping */
1183
0
                *pString=reinterpret_cast<const UChar *>(pe+1);
1184
1185
                /* return the string length */
1186
0
                return full;
1187
0
            }
1188
0
        }
1189
1190
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
1191
0
            int32_t delta;
1192
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta);
1193
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
1194
0
        }
1195
0
        if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
1196
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result);
1197
0
        }
1198
0
    }
1199
1200
0
    return (result==c) ? ~result : result;
1201
0
}
1202
1203
/* internal */
1204
static int32_t
1205
toUpperOrTitle(UChar32 c,
1206
               UCaseContextIterator *iter, void *context,
1207
               const UChar **pString,
1208
               int32_t loc,
1209
0
               UBool upperNotTitle) {
1210
    // The sign of the result has meaning, input must be non-negative so that it can be returned as is.
1211
0
    U_ASSERT(c >= 0);
1212
0
    UChar32 result=c;
1213
    // Reset the output pointer in case it was uninitialized.
1214
0
    *pString=nullptr;
1215
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
1216
0
    if(!UCASE_HAS_EXCEPTION(props)) {
1217
0
        if(UCASE_GET_TYPE(props)==UCASE_LOWER) {
1218
0
            result=c+UCASE_GET_DELTA(props);
1219
0
        }
1220
0
    } else {
1221
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2;
1222
0
        uint16_t excWord=*pe++;
1223
0
        int32_t full, idx;
1224
1225
0
        pe2=pe;
1226
1227
0
        if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) {
1228
            /* use hardcoded conditions and mappings */
1229
0
            if(loc==UCASE_LOC_TURKISH && c==0x69) {
1230
                /*
1231
                    # Turkish and Azeri
1232
1233
                    # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
1234
                    # The following rules handle those cases.
1235
1236
                    # When uppercasing, i turns into a dotted capital I
1237
1238
                    0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I
1239
                    0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I
1240
                */
1241
0
                return 0x130;
1242
0
            } else if(loc==UCASE_LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, context)) {
1243
                /*
1244
                    # Lithuanian
1245
1246
                    # Lithuanian retains the dot in a lowercase i when followed by accents.
1247
1248
                    # Remove DOT ABOVE after "i" with upper or titlecase
1249
1250
                    0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
1251
                 */
1252
0
                return 0; /* remove the dot (continue without output) */
1253
0
            } else if(c==0x0587) {
1254
                // See ICU-13416:
1255
                // և ligature ech-yiwn
1256
                // uppercases to ԵՒ=ech+yiwn by default and in Western Armenian,
1257
                // but to ԵՎ=ech+vew in Eastern Armenian.
1258
0
                if(loc==UCASE_LOC_ARMENIAN) {
1259
0
                    *pString=upperNotTitle ? u"ԵՎ" : u"Եվ";
1260
0
                } else {
1261
0
                    *pString=upperNotTitle ? u"ԵՒ" : u"Եւ";
1262
0
                }
1263
0
                return 2;
1264
0
            } else {
1265
                /* no known conditional special case mapping, use a normal mapping */
1266
0
            }
1267
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
1268
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full);
1269
1270
            /* start of full case mapping strings */
1271
0
            ++pe;
1272
1273
            /* skip the lowercase and case-folding result strings */
1274
0
            pe+=full&UCASE_FULL_LOWER;
1275
0
            full>>=4;
1276
0
            pe+=full&0xf;
1277
0
            full>>=4;
1278
1279
0
            if(upperNotTitle) {
1280
0
                full&=0xf;
1281
0
            } else {
1282
                /* skip the uppercase result string */
1283
0
                pe+=full&0xf;
1284
0
                full=(full>>4)&0xf;
1285
0
            }
1286
1287
0
            if(full!=0) {
1288
                /* set the output pointer to the result string */
1289
0
                *pString=reinterpret_cast<const UChar *>(pe);
1290
1291
                /* return the string length */
1292
0
                return full;
1293
0
            }
1294
0
        }
1295
1296
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
1297
0
            int32_t delta;
1298
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta);
1299
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
1300
0
        }
1301
0
        if(!upperNotTitle && HAS_SLOT(excWord, UCASE_EXC_TITLE)) {
1302
0
            idx=UCASE_EXC_TITLE;
1303
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
1304
            /* here, titlecase is same as uppercase */
1305
0
            idx=UCASE_EXC_UPPER;
1306
0
        } else {
1307
0
            return ~c;
1308
0
        }
1309
0
        GET_SLOT_VALUE(excWord, idx, pe2, result);
1310
0
    }
1311
1312
0
    return (result==c) ? ~result : result;
1313
0
}
1314
1315
U_CAPI int32_t U_EXPORT2
1316
ucase_toFullUpper(UChar32 c,
1317
                  UCaseContextIterator *iter, void *context,
1318
                  const UChar **pString,
1319
0
                  int32_t caseLocale) {
1320
0
    return toUpperOrTitle(c, iter, context, pString, caseLocale, TRUE);
1321
0
}
1322
1323
U_CAPI int32_t U_EXPORT2
1324
ucase_toFullTitle(UChar32 c,
1325
                  UCaseContextIterator *iter, void *context,
1326
                  const UChar **pString,
1327
0
                  int32_t caseLocale) {
1328
0
    return toUpperOrTitle(c, iter, context, pString, caseLocale, FALSE);
1329
0
}
1330
1331
/* case folding ------------------------------------------------------------- */
1332
1333
/*
1334
 * Case folding is similar to lowercasing.
1335
 * The result may be a simple mapping, i.e., a single code point, or
1336
 * a full mapping, i.e., a string.
1337
 * If the case folding for a code point is the same as its simple (1:1) lowercase mapping,
1338
 * then only the lowercase mapping is stored.
1339
 *
1340
 * Some special cases are hardcoded because their conditions cannot be
1341
 * parsed and processed from CaseFolding.txt.
1342
 *
1343
 * Unicode 3.2 CaseFolding.txt specifies for its status field:
1344
1345
# C: common case folding, common mappings shared by both simple and full mappings.
1346
# F: full case folding, mappings that cause strings to grow in length. Multiple characters are separated by spaces.
1347
# S: simple case folding, mappings to single characters where different from F.
1348
# T: special case for uppercase I and dotted uppercase I
1349
#    - For non-Turkic languages, this mapping is normally not used.
1350
#    - For Turkic languages (tr, az), this mapping can be used instead of the normal mapping for these characters.
1351
#
1352
# Usage:
1353
#  A. To do a simple case folding, use the mappings with status C + S.
1354
#  B. To do a full case folding, use the mappings with status C + F.
1355
#
1356
#    The mappings with status T can be used or omitted depending on the desired case-folding
1357
#    behavior. (The default option is to exclude them.)
1358
1359
 * Unicode 3.2 has 'T' mappings as follows:
1360
1361
0049; T; 0131; # LATIN CAPITAL LETTER I
1362
0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE
1363
1364
 * while the default mappings for these code points are:
1365
1366
0049; C; 0069; # LATIN CAPITAL LETTER I
1367
0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE
1368
1369
 * U+0130 has no simple case folding (simple-case-folds to itself).
1370
 */
1371
1372
/* return the simple case folding mapping for c */
1373
U_CAPI UChar32 U_EXPORT2
1374
0
ucase_fold(UChar32 c, uint32_t options) {
1375
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
1376
0
    if(!UCASE_HAS_EXCEPTION(props)) {
1377
0
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
1378
0
            c+=UCASE_GET_DELTA(props);
1379
0
        }
1380
0
    } else {
1381
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
1382
0
        uint16_t excWord=*pe++;
1383
0
        int32_t idx;
1384
0
        if(excWord&UCASE_EXC_CONDITIONAL_FOLD) {
1385
            /* special case folding mappings, hardcoded */
1386
0
            if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) {
1387
                /* default mappings */
1388
0
                if(c==0x49) {
1389
                    /* 0049; C; 0069; # LATIN CAPITAL LETTER I */
1390
0
                    return 0x69;
1391
0
                } else if(c==0x130) {
1392
                    /* no simple case folding for U+0130 */
1393
0
                    return c;
1394
0
                }
1395
0
            } else {
1396
                /* Turkic mappings */
1397
0
                if(c==0x49) {
1398
                    /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
1399
0
                    return 0x131;
1400
0
                } else if(c==0x130) {
1401
                    /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
1402
0
                    return 0x69;
1403
0
                }
1404
0
            }
1405
0
        }
1406
0
        if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) {
1407
0
            return c;
1408
0
        }
1409
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
1410
0
            int32_t delta;
1411
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
1412
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
1413
0
        }
1414
0
        if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) {
1415
0
            idx=UCASE_EXC_FOLD;
1416
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
1417
0
            idx=UCASE_EXC_LOWER;
1418
0
        } else {
1419
0
            return c;
1420
0
        }
1421
0
        GET_SLOT_VALUE(excWord, idx, pe, c);
1422
0
    }
1423
0
    return c;
1424
0
}
1425
1426
/*
1427
 * Issue for canonical caseless match (UAX #21):
1428
 * Turkic casefolding (using "T" mappings in CaseFolding.txt) does not preserve
1429
 * canonical equivalence, unlike default-option casefolding.
1430
 * For example, I-grave and I + grave fold to strings that are not canonically
1431
 * equivalent.
1432
 * For more details, see the comment in unorm_compare() in unorm.cpp
1433
 * and the intermediate prototype changes for Jitterbug 2021.
1434
 * (For example, revision 1.104 of uchar.c and 1.4 of CaseFolding.txt.)
1435
 *
1436
 * This did not get fixed because it appears that it is not possible to fix
1437
 * it for uppercase and lowercase characters (I-grave vs. i-grave)
1438
 * together in a way that they still fold to common result strings.
1439
 */
1440
1441
U_CAPI int32_t U_EXPORT2
1442
ucase_toFullFolding(UChar32 c,
1443
                    const UChar **pString,
1444
0
                    uint32_t options) {
1445
    // The sign of the result has meaning, input must be non-negative so that it can be returned as is.
1446
0
    U_ASSERT(c >= 0);
1447
0
    UChar32 result=c;
1448
    // Reset the output pointer in case it was uninitialized.
1449
0
    *pString=nullptr;
1450
0
    uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
1451
0
    if(!UCASE_HAS_EXCEPTION(props)) {
1452
0
        if(UCASE_IS_UPPER_OR_TITLE(props)) {
1453
0
            result=c+UCASE_GET_DELTA(props);
1454
0
        }
1455
0
    } else {
1456
0
        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2;
1457
0
        uint16_t excWord=*pe++;
1458
0
        int32_t full, idx;
1459
1460
0
        pe2=pe;
1461
1462
0
        if(excWord&UCASE_EXC_CONDITIONAL_FOLD) {
1463
            /* use hardcoded conditions and mappings */
1464
0
            if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) {
1465
                /* default mappings */
1466
0
                if(c==0x49) {
1467
                    /* 0049; C; 0069; # LATIN CAPITAL LETTER I */
1468
0
                    return 0x69;
1469
0
                } else if(c==0x130) {
1470
                    /* 0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
1471
0
                    *pString=iDot;
1472
0
                    return 2;
1473
0
                }
1474
0
            } else {
1475
                /* Turkic mappings */
1476
0
                if(c==0x49) {
1477
                    /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
1478
0
                    return 0x131;
1479
0
                } else if(c==0x130) {
1480
                    /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
1481
0
                    return 0x69;
1482
0
                }
1483
0
            }
1484
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) {
1485
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full);
1486
1487
            /* start of full case mapping strings */
1488
0
            ++pe;
1489
1490
            /* skip the lowercase result string */
1491
0
            pe+=full&UCASE_FULL_LOWER;
1492
0
            full=(full>>4)&0xf;
1493
1494
0
            if(full!=0) {
1495
                /* set the output pointer to the result string */
1496
0
                *pString=reinterpret_cast<const UChar *>(pe);
1497
1498
                /* return the string length */
1499
0
                return full;
1500
0
            }
1501
0
        }
1502
1503
0
        if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) {
1504
0
            return ~c;
1505
0
        }
1506
0
        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
1507
0
            int32_t delta;
1508
0
            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta);
1509
0
            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
1510
0
        }
1511
0
        if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) {
1512
0
            idx=UCASE_EXC_FOLD;
1513
0
        } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
1514
0
            idx=UCASE_EXC_LOWER;
1515
0
        } else {
1516
0
            return ~c;
1517
0
        }
1518
0
        GET_SLOT_VALUE(excWord, idx, pe2, result);
1519
0
    }
1520
1521
0
    return (result==c) ? ~result : result;
1522
0
}
1523
1524
/* case mapping properties API ---------------------------------------------- */
1525
1526
/* public API (see uchar.h) */
1527
1528
U_CAPI UBool U_EXPORT2
1529
0
u_isULowercase(UChar32 c) {
1530
0
    return (UBool)(UCASE_LOWER==ucase_getType(c));
1531
0
}
1532
1533
U_CAPI UBool U_EXPORT2
1534
0
u_isUUppercase(UChar32 c) {
1535
0
    return (UBool)(UCASE_UPPER==ucase_getType(c));
1536
0
}
1537
1538
/* Transforms the Unicode character to its lower case equivalent.*/
1539
U_CAPI UChar32 U_EXPORT2
1540
0
u_tolower(UChar32 c) {
1541
0
    return ucase_tolower(c);
1542
0
}
1543
1544
/* Transforms the Unicode character to its upper case equivalent.*/
1545
U_CAPI UChar32 U_EXPORT2
1546
0
u_toupper(UChar32 c) {
1547
0
    return ucase_toupper(c);
1548
0
}
1549
1550
/* Transforms the Unicode character to its title case equivalent.*/
1551
U_CAPI UChar32 U_EXPORT2
1552
0
u_totitle(UChar32 c) {
1553
0
    return ucase_totitle(c);
1554
0
}
1555
1556
/* return the simple case folding mapping for c */
1557
U_CAPI UChar32 U_EXPORT2
1558
0
u_foldCase(UChar32 c, uint32_t options) {
1559
0
    return ucase_fold(c, options);
1560
0
}
1561
1562
U_CFUNC int32_t U_EXPORT2
1563
0
ucase_hasBinaryProperty(UChar32 c, UProperty which) {
1564
    /* case mapping properties */
1565
0
    const UChar *resultString;
1566
0
    switch(which) {
1567
0
    case UCHAR_LOWERCASE:
1568
0
        return (UBool)(UCASE_LOWER==ucase_getType(c));
1569
0
    case UCHAR_UPPERCASE:
1570
0
        return (UBool)(UCASE_UPPER==ucase_getType(c));
1571
0
    case UCHAR_SOFT_DOTTED:
1572
0
        return ucase_isSoftDotted(c);
1573
0
    case UCHAR_CASE_SENSITIVE:
1574
0
        return ucase_isCaseSensitive(c);
1575
0
    case UCHAR_CASED:
1576
0
        return (UBool)(UCASE_NONE!=ucase_getType(c));
1577
0
    case UCHAR_CASE_IGNORABLE:
1578
0
        return (UBool)(ucase_getTypeOrIgnorable(c)>>2);
1579
    /*
1580
     * Note: The following Changes_When_Xyz are defined as testing whether
1581
     * the NFD form of the input changes when Xyz-case-mapped.
1582
     * However, this simpler implementation of these properties,
1583
     * ignoring NFD, passes the tests.
1584
     * The implementation needs to be changed if the tests start failing.
1585
     * When that happens, optimizations should be used to work with the
1586
     * per-single-code point ucase_toFullXyz() functions unless
1587
     * the NFD form has more than one code point,
1588
     * and the property starts set needs to be the union of the
1589
     * start sets for normalization and case mappings.
1590
     */
1591
0
    case UCHAR_CHANGES_WHEN_LOWERCASED:
1592
0
        return (UBool)(ucase_toFullLower(c, NULL, NULL, &resultString, UCASE_LOC_ROOT)>=0);
1593
0
    case UCHAR_CHANGES_WHEN_UPPERCASED:
1594
0
        return (UBool)(ucase_toFullUpper(c, NULL, NULL, &resultString, UCASE_LOC_ROOT)>=0);
1595
0
    case UCHAR_CHANGES_WHEN_TITLECASED:
1596
0
        return (UBool)(ucase_toFullTitle(c, NULL, NULL, &resultString, UCASE_LOC_ROOT)>=0);
1597
    /* case UCHAR_CHANGES_WHEN_CASEFOLDED: -- in uprops.c */
1598
0
    case UCHAR_CHANGES_WHEN_CASEMAPPED:
1599
0
        return (UBool)(
1600
0
            ucase_toFullLower(c, NULL, NULL, &resultString, UCASE_LOC_ROOT)>=0 ||
1601
0
            ucase_toFullUpper(c, NULL, NULL, &resultString, UCASE_LOC_ROOT)>=0 ||
1602
0
            ucase_toFullTitle(c, NULL, NULL, &resultString, UCASE_LOC_ROOT)>=0);
1603
0
    default:
1604
0
        return FALSE;
1605
0
    }
1606
0
}