_ZN6icu_786BMPSetC2EPKii: 30| 3.93k| list(parentList), listLength(parentListLength) { 31| 3.93k| uprv_memset(latin1Contains, 0, sizeof(latin1Contains)); ------------------ | | 100| 3.93k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 3.93k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 32| 3.93k| uprv_memset(table7FF, 0, sizeof(table7FF)); ------------------ | | 100| 3.93k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 3.93k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 33| 3.93k| uprv_memset(bmpBlockBits, 0, sizeof(bmpBlockBits)); ------------------ | | 100| 3.93k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 3.93k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 34| | 35| | /* 36| | * Set the list indexes for binary searches for 37| | * U+0800, U+1000, U+2000, .., U+F000, U+10000. 38| | * U+0800 is the first 3-byte-UTF-8 code point. Lower code points are 39| | * looked up in the bit tables. 40| | * The last pair of indexes is for finding supplementary code points. 41| | */ 42| 3.93k| list4kStarts[0]=findCodePoint(0x800, 0, listLength-1); 43| 3.93k| int32_t i; 44| 66.9k| for(i=1; i<=0x10; ++i) { ------------------ | Branch (44:14): [True: 62.9k, False: 3.93k] ------------------ 45| 62.9k| list4kStarts[i]=findCodePoint(i<<12, list4kStarts[i-1], listLength-1); 46| 62.9k| } 47| 3.93k| list4kStarts[0x11]=listLength-1; 48| 3.93k| containsFFFD=containsSlow(0xfffd, list4kStarts[0xf], list4kStarts[0x10]); 49| | 50| 3.93k| initBits(); 51| 3.93k| overrideIllegal(); 52| 3.93k|} _ZN6icu_786BMPSetD2Ev: 63| 3.92k|BMPSet::~BMPSet() { 64| 3.92k|} _ZN6icu_786BMPSet8initBitsEv: 121| 3.93k|void BMPSet::initBits() { 122| 3.93k| UChar32 start, limit; 123| 3.93k| int32_t listIndex=0; 124| | 125| | // Set latin1Contains[]. 126| 22.0k| do { 127| 22.0k| start=list[listIndex++]; 128| 22.0k| if(listIndex=0x100) { ------------------ | Branch (133:12): [True: 3.88k, False: 18.1k] ------------------ 134| 3.88k| break; 135| 3.88k| } 136| 20.5k| do { 137| 20.5k| latin1Contains[start++]=1; 138| 20.5k| } while(start0x80) { ------------------ | Branch (150:12): [True: 3.93k, False: 12.5k] ------------------ 151| 3.93k| if(start<0x80) { ------------------ | Branch (151:16): [True: 4, False: 3.93k] ------------------ 152| 4| start=0x80; 153| 4| } 154| 3.93k| break; 155| 3.93k| } 156| 16.5k| } 157| | 158| | // Set table7FF[]. 159| 122k| while(start<0x800) { ------------------ | Branch (159:11): [True: 118k, False: 3.92k] ------------------ 160| 118k| set32x64Bits(table7FF, start, limit<=0x800 ? limit : 0x800); ------------------ | Branch (160:39): [True: 118k, False: 7] ------------------ 161| 118k| if(limit>0x800) { ------------------ | Branch (161:12): [True: 7, False: 118k] ------------------ 162| 7| start=0x800; 163| 7| break; 164| 7| } 165| | 166| 118k| start=list[listIndex++]; 167| 118k| if(listIndex0x10000) { ------------------ | Branch (177:12): [True: 0, False: 776k] ------------------ 178| 0| limit=0x10000; 179| 0| } 180| | 181| 776k| if(start>=6; 188| 303k| bmpBlockBits[start&0x3f]|=0x10001<<(start>>6); 189| 303k| start=(start+1)<<6; // Round up to the next block boundary. 190| 303k| minStart=start; // Ignore further ranges in this block. 191| 303k| } 192| 399k| if(start>6, limit>>6); 196| 3.93k| } 197| | 198| 96.1k| if(limit&0x3f) { ------------------ | Branch (198:20): [True: 92.2k, False: 3.92k] ------------------ 199| | // Mixed-value block of 64 code points. 200| 92.2k| limit>>=6; 201| 92.2k| bmpBlockBits[limit&0x3f]|=0x10001<<(limit>>6); 202| 92.2k| limit=(limit+1)<<6; // Round up to the next block boundary. 203| 92.2k| minStart=limit; // Ignore further ranges in this block. 204| 92.2k| } 205| 96.1k| } 206| 399k| } 207| | 208| 776k| if(limit==0x10000) { ------------------ | Branch (208:12): [True: 1, False: 776k] ------------------ 209| 1| break; 210| 1| } 211| | 212| 776k| start=list[listIndex++]; 213| 776k| if(listIndex(~(0x10001<<0xd)); // Lead byte 0xED. 245| 0| bits=1<<0xd; 246| 0| for(i=32; i<64; ++i) { // Second half of 4k block. ------------------ | Branch (246:19): [True: 0, False: 0] ------------------ 247| 0| bmpBlockBits[i]=(bmpBlockBits[i]&mask)|bits; 248| 0| } 249| 3.93k| } else { 250| 3.93k| mask= static_cast(~(0x10001<<0xd)); // Lead byte 0xED. 251| 129k| for(i=32; i<64; ++i) { // Second half of 4k block. ------------------ | Branch (251:19): [True: 125k, False: 3.93k] ------------------ 252| 125k| bmpBlockBits[i]&=mask; 253| 125k| } 254| 3.93k| } 255| 3.93k|} _ZNK6icu_786BMPSet13findCodePointEiii: 257| 70.8k|int32_t BMPSet::findCodePoint(UChar32 c, int32_t lo, int32_t hi) const { 258| | /* Examples: 259| | findCodePoint(c) 260| | set list[] c=0 1 3 4 7 8 261| | === ============== =========== 262| | [] [110000] 0 0 0 0 0 0 263| | [\u0000-\u0003] [0, 4, 110000] 1 1 1 2 2 2 264| | [\u0004-\u0007] [4, 8, 110000] 0 0 0 1 1 2 265| | [:Any:] [0, 110000] 1 1 1 1 1 1 266| | */ 267| | 268| | // Return the smallest i such that c < list[i]. Assume 269| | // list[len - 1] == HIGH and that c is legal (0..HIGH-1). 270| 70.8k| if (c < list[lo]) ------------------ | Branch (270:9): [True: 27.8k, False: 42.9k] ------------------ 271| 27.8k| return lo; 272| | // High runner test. c is often after the last range, so an 273| | // initial check for this condition pays off. 274| 42.9k| if (lo >= hi || c >= list[hi-1]) ------------------ | Branch (274:9): [True: 0, False: 42.9k] | Branch (274:21): [True: 5, False: 42.9k] ------------------ 275| 5| return hi; 276| | // invariant: c >= list[lo] 277| | // invariant: c < list[hi] 278| 396k| for (;;) { 279| 396k| int32_t i = (lo + hi) >> 1; 280| 396k| if (i == lo) { ------------------ | Branch (280:13): [True: 42.9k, False: 353k] ------------------ 281| 42.9k| break; // Found! 282| 353k| } else if (c < list[i]) { ------------------ | Branch (282:20): [True: 238k, False: 115k] ------------------ 283| 238k| hi = i; 284| 238k| } else { 285| 115k| lo = i; 286| 115k| } 287| 396k| } 288| 42.9k| return hi; 289| 42.9k|} bmpset.cpp:_ZN6icu_78L12set32x64BitsEPjii: 70| 122k|static void set32x64Bits(uint32_t table[64], int32_t start, int32_t limit) { 71| 122k| U_ASSERT(start>6; // Named for UTF-8 2-byte lead byte with upper 5 bits. 75| 122k| int32_t trail=start&0x3f; // Named for UTF-8 2-byte trail byte with lower 6 bits. 76| | 77| | // Set one bit indicating an all-one block. 78| 122k| uint32_t bits = static_cast(1) << lead; 79| 122k| if((start+1)==limit) { // Single-character shortcut. ------------------ | Branch (79:8): [True: 58.1k, False: 64.4k] ------------------ 80| 58.1k| table[trail]|=bits; 81| 58.1k| return; 82| 58.1k| } 83| | 84| 64.4k| int32_t limitLead=limit>>6; 85| 64.4k| int32_t limitTrail=limit&0x3f; 86| | 87| 64.4k| if(lead==limitLead) { ------------------ | Branch (87:8): [True: 52.5k, False: 11.8k] ------------------ 88| | // Partial vertical bit column. 89| 639k| while(trail0) { ------------------ | Branch (96:12): [True: 7.92k, False: 3.92k] ------------------ 97| 125k| do { 98| 125k| table[trail++]|=bits; 99| 125k| } while(trail<64); ------------------ | Branch (99:21): [True: 117k, False: 7.92k] ------------------ 100| 7.92k| ++lead; 101| 7.92k| } 102| 11.8k| if(lead(1) << lead) - 1); 104| 3.92k| if(limitLead<0x20) { ------------------ | Branch (104:16): [True: 3.92k, False: 0] ------------------ 105| 3.92k| bits &= (static_cast(1) << limitLead) - 1; 106| 3.92k| } 107| 255k| for(trail=0; trail<64; ++trail) { ------------------ | Branch (107:26): [True: 251k, False: 3.92k] ------------------ 108| 251k| table[trail]|=bits; 109| 251k| } 110| 3.92k| } 111| | // limit<=0x800. If limit==0x800 then limitLead=32 and limitTrail=0. 112| | // In that case, bits=1<(1) << ((limitLead == 0x20) ? (limitLead - 1) : limitLead); ------------------ | Branch (114:45): [True: 1, False: 11.8k] ------------------ 115| 114k| for(trail=0; trail (INT32_MAX - appended_)) { ------------------ | Branch (48:7): [True: 0, False: 5.81k] ------------------ 49| | // TODO: Report as integer overflow, not merely buffer overflow. 50| 0| appended_ = INT32_MAX; 51| 0| overflowed_ = true; 52| 0| return; 53| 0| } 54| 5.81k| appended_ += n; 55| 5.81k| int32_t available = capacity_ - size_; 56| 5.81k| if (n > available) { ------------------ | Branch (56:7): [True: 5.79k, False: 19] ------------------ 57| 5.79k| n = available; 58| 5.79k| overflowed_ = true; 59| 5.79k| } 60| 5.81k| if (n > 0 && bytes != (outbuf_ + size_)) { ------------------ | Branch (60:7): [True: 19, False: 5.79k] | Branch (60:16): [True: 19, False: 0] ------------------ 61| 19| uprv_memcpy(outbuf_ + size_, bytes, n); ------------------ | | 42| 19|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 19|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 19| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 19| _Pragma("clang diagnostic push") \ | | 45| 19| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 19| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 19|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 19| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 19|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 19| _Pragma("clang diagnostic pop") \ | | 49| 19| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 19|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 19|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 19|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 62| 19| } 63| 5.81k| size_ += n; 64| 5.81k|} _ZN6icu_7820CheckedArrayByteSink15GetAppendBufferEiiPciPi: 70| 3.37k| int32_t* result_capacity) { 71| 3.37k| if (min_capacity < 1 || scratch_capacity < min_capacity) { ------------------ | Branch (71:7): [True: 0, False: 3.37k] | Branch (71:27): [True: 0, False: 3.37k] ------------------ 72| 0| *result_capacity = 0; 73| 0| return nullptr; 74| 0| } 75| 3.37k| int32_t available = capacity_ - size_; 76| 3.37k| if (available >= min_capacity) { ------------------ | Branch (76:7): [True: 0, False: 3.37k] ------------------ 77| 0| *result_capacity = available; 78| 0| return outbuf_ + size_; 79| 3.37k| } else { 80| 3.37k| *result_capacity = scratch_capacity; 81| 3.37k| return scratch; 82| 3.37k| } 83| 3.37k|} _ZN6icu_789BytesTrieD2Ev: 26| 27.6k|BytesTrie::~BytesTrie() { 27| 27.6k| uprv_free(ownedArray_); ------------------ | | 1503| 27.6k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 27.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 27.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 27.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 28| 27.6k|} _ZN6icu_789BytesTrie9readValueEPKhi: 32| 25.0k|BytesTrie::readValue(const uint8_t *pos, int32_t leadByte) { 33| 25.0k| int32_t value; 34| 25.0k| if(leadBytekMaxBranchLinearSubNodeLength) { ------------------ | Branch (89:11): [True: 73.3k, False: 71.4k] ------------------ 90| 73.3k| if(inByte<*pos++) { ------------------ | Branch (90:12): [True: 41.0k, False: 32.3k] ------------------ 91| 41.0k| length>>=1; 92| 41.0k| pos=jumpByDelta(pos); 93| 41.0k| } else { 94| 32.3k| length=length-(length>>1); 95| 32.3k| pos=skipDelta(pos); 96| 32.3k| } 97| 73.3k| } 98| | // Drop down to linear search for the last few bytes. 99| | // length>=2 because the loop body above sees length>kMaxBranchLinearSubNodeLength>=3 100| | // and divides length by 2. 101| 112k| do { 102| 112k| if(inByte==*pos++) { ------------------ | Branch (102:12): [True: 46.9k, False: 65.7k] ------------------ 103| 46.9k| UStringTrieResult result; 104| 46.9k| int32_t node=*pos; 105| 46.9k| U_ASSERT(node>=kMinValueLead); ------------------ | | 35| 46.9k|# define U_ASSERT(exp) (void)0 ------------------ 106| 46.9k| if(node&kValueIsFinal) { ------------------ | Branch (106:16): [True: 8.86k, False: 38.1k] ------------------ 107| | // Leave the final value for getValue() to read. 108| 8.86k| result=USTRINGTRIE_FINAL_VALUE; 109| 38.1k| } else { 110| | // Use the non-final value as the jump delta. 111| 38.1k| ++pos; 112| | // int32_t delta=readValue(pos, node>>1); 113| 38.1k| node>>=1; 114| 38.1k| int32_t delta; 115| 38.1k| if(node=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (132:25): [True: 12.0k, False: 26.0k] ------------------ 133| 38.1k| } 134| 46.9k| pos_=pos; 135| 46.9k| return result; 136| 46.9k| } 137| 65.7k| --length; 138| 65.7k| pos=skipValue(pos); 139| 65.7k| } while(length>1); ------------------ | Branch (139:13): [True: 41.2k, False: 24.4k] ------------------ 140| 24.4k| if(inByte==*pos++) { ------------------ | Branch (140:8): [True: 22.3k, False: 2.12k] ------------------ 141| 22.3k| pos_=pos; 142| 22.3k| int32_t node=*pos; 143| 22.3k| return node>=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (143:16): [True: 5.30k, False: 17.0k] ------------------ 144| 22.3k| } else { 145| 2.12k| stop(); 146| 2.12k| return USTRINGTRIE_NO_MATCH; 147| 2.12k| } 148| 24.4k|} _ZN6icu_789BytesTrie8nextImplEPKhi: 151| 76.3k|BytesTrie::nextImpl(const uint8_t *pos, int32_t inByte) { 152| 81.8k| for(;;) { 153| 81.8k| int32_t node=*pos++; 154| 81.8k| if(node=kMinValueLead) ? ------------------ | Branch (162:25): [True: 2.51k, False: 2.29k] | Branch (162:37): [True: 2.06k, False: 453] ------------------ 163| 2.74k| valueResult(node) : USTRINGTRIE_NO_VALUE; 164| 4.81k| } else { 165| | // No match. 166| 124| break; 167| 124| } 168| 5.47k| } else if(node&kValueIsFinal) { ------------------ | Branch (168:19): [True: 0, False: 5.47k] ------------------ 169| | // No further matching bytes. 170| 0| break; 171| 5.47k| } else { 172| | // Skip intermediate value. 173| 5.47k| pos=skipValue(pos, node); 174| | // The next node must not also be a value node. 175| 5.47k| U_ASSERT(*pos=0) { ------------------ | Branch (192:8): [True: 2.29k, False: 76.3k] ------------------ 193| | // Remaining part of a linear-match node. 194| 2.29k| if(inByte==*pos++) { ------------------ | Branch (194:12): [True: 2.28k, False: 6] ------------------ 195| 2.28k| remainingMatchLength_=--length; 196| 2.28k| pos_=pos; 197| 2.28k| int32_t node; 198| 2.28k| return (length<0 && (node=*pos)>=kMinValueLead) ? ------------------ | Branch (198:21): [True: 2.28k, False: 5] | Branch (198:33): [True: 2.28k, False: 1] ------------------ 199| 2.28k| valueResult(node) : USTRINGTRIE_NO_VALUE; 200| 2.28k| } else { 201| 6| stop(); 202| 6| return USTRINGTRIE_NO_MATCH; 203| 6| } 204| 2.29k| } 205| 76.3k| return nextImpl(pos, inByte); 206| 78.6k|} _ZN6icu_7817CanonicalIteratorC2ERKNS_13UnicodeStringER10UErrorCode: 72| 6.76M| pieces(nullptr), 73| 6.76M| pieces_length(0), 74| 6.76M| pieces_lengths(nullptr), 75| 6.76M| current(nullptr), 76| 6.76M| current_length(0), 77| 6.76M| nfd(Normalizer2::getNFDInstance(status)), 78| 6.76M| nfcImpl(Normalizer2Factory::getNFCImpl(status)) 79| 6.76M|{ 80| 6.76M| if(U_SUCCESS(status) && nfcImpl->ensureCanonIterData(status)) { ------------------ | Branch (80:8): [True: 6.76M, False: 10] | Branch (80:29): [True: 6.76M, False: 0] ------------------ 81| 6.76M| setSource(sourceStr, status); 82| 6.76M| } 83| 6.76M|} _ZN6icu_7817CanonicalIteratorD2Ev: 85| 6.76M|CanonicalIterator::~CanonicalIterator() { 86| 6.76M| cleanPieces(); 87| 6.76M|} _ZN6icu_7817CanonicalIterator11cleanPiecesEv: 89| 13.5M|void CanonicalIterator::cleanPieces() { 90| 13.5M| int32_t i = 0; 91| 13.5M| if(pieces != nullptr) { ------------------ | Branch (91:8): [True: 6.76M, False: 6.76M] ------------------ 92| 13.8M| for(i = 0; i < pieces_length; i++) { ------------------ | Branch (92:20): [True: 7.07M, False: 6.76M] ------------------ 93| 7.07M| if(pieces[i] != nullptr) { ------------------ | Branch (93:16): [True: 7.06M, False: 9.06k] ------------------ 94| 7.06M| delete[] pieces[i]; 95| 7.06M| } 96| 7.07M| } 97| 6.76M| uprv_free(pieces); ------------------ | | 1503| 6.76M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 6.76M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.76M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.76M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 98| 6.76M| pieces = nullptr; 99| 6.76M| pieces_length = 0; 100| 6.76M| } 101| 13.5M| if(pieces_lengths != nullptr) { ------------------ | Branch (101:8): [True: 6.76M, False: 6.76M] ------------------ 102| 6.76M| uprv_free(pieces_lengths); ------------------ | | 1503| 6.76M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 6.76M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.76M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.76M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 103| 6.76M| pieces_lengths = nullptr; 104| 6.76M| } 105| 13.5M| if(current != nullptr) { ------------------ | Branch (105:8): [True: 6.76M, False: 6.76M] ------------------ 106| 6.76M| uprv_free(current); ------------------ | | 1503| 6.76M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 6.76M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.76M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.76M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 6.76M| current = nullptr; 108| 6.76M| current_length = 0; 109| 6.76M| } 110| 13.5M|} _ZN6icu_7817CanonicalIterator5resetEv: 122| 44.2k|void CanonicalIterator::reset() { 123| 44.2k| done = false; 124| 135k| for (int i = 0; i < current_length; ++i) { ------------------ | Branch (124:21): [True: 91.2k, False: 44.2k] ------------------ 125| 91.2k| current[i] = 0; 126| 91.2k| } 127| 44.2k|} _ZN6icu_7817CanonicalIterator4nextEv: 133| 16.5M|UnicodeString CanonicalIterator::next() { 134| 16.5M| int32_t i = 0; 135| | 136| 16.5M| if (done) { ------------------ | Branch (136:9): [True: 6.80M, False: 9.76M] ------------------ 137| 6.80M| buffer.setToBogus(); 138| 6.80M| return buffer; 139| 6.80M| } 140| | 141| | // delete old contents 142| 9.76M| buffer.remove(); 143| | 144| | // construct return value 145| | 146| 137M| for (i = 0; i < pieces_length; ++i) { ------------------ | Branch (146:17): [True: 128M, False: 9.76M] ------------------ 147| 128M| buffer.append(pieces[i][current[i]]); 148| 128M| } 149| | //String result = buffer.toString(); // not needed 150| | 151| | // find next value for next time 152| | 153| 23.6M| for (i = current_length - 1; ; --i) { 154| 23.6M| if (i < 0) { ------------------ | Branch (154:13): [True: 6.80M, False: 16.8M] ------------------ 155| 6.80M| done = true; 156| 6.80M| break; 157| 6.80M| } 158| 16.8M| current[i]++; 159| 16.8M| if (current[i] < pieces_lengths[i]) break; // got sequence ------------------ | Branch (159:13): [True: 2.96M, False: 13.8M] ------------------ 160| 13.8M| current[i] = 0; 161| 13.8M| } 162| 9.76M| return buffer; 163| 16.5M|} _ZN6icu_7817CanonicalIterator9setSourceERKNS_13UnicodeStringER10UErrorCode: 169| 6.76M|void CanonicalIterator::setSource(const UnicodeString &newSource, UErrorCode &status) { 170| 6.76M| int32_t list_length = 0; 171| 6.76M| UChar32 cp = 0; 172| 6.76M| int32_t start = 0; 173| 6.76M| int32_t i = 0; 174| 6.76M| UnicodeString *list = nullptr; 175| | 176| 6.76M| nfd->normalize(newSource, source, status); 177| 6.76M| if(U_FAILURE(status)) { ------------------ | Branch (177:8): [True: 0, False: 6.76M] ------------------ 178| 0| return; 179| 0| } 180| 6.76M| done = false; 181| | 182| 6.76M| cleanPieces(); 183| | 184| | // catch degenerate case 185| 6.76M| if (newSource.length() == 0) { ------------------ | Branch (185:9): [True: 0, False: 6.76M] ------------------ 186| 0| pieces = static_cast(uprv_malloc(sizeof(UnicodeString*))); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 187| 0| pieces_lengths = static_cast(uprv_malloc(1 * sizeof(int32_t))); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 188| 0| pieces_length = 1; 189| 0| current = static_cast(uprv_malloc(1 * sizeof(int32_t))); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 190| 0| current_length = 1; 191| 0| if (pieces == nullptr || pieces_lengths == nullptr || current == nullptr) { ------------------ | Branch (191:13): [True: 0, False: 0] | Branch (191:34): [True: 0, False: 0] | Branch (191:63): [True: 0, False: 0] ------------------ 192| 0| status = U_MEMORY_ALLOCATION_ERROR; 193| 0| goto CleanPartialInitialization; 194| 0| } 195| 0| current[0] = 0; 196| 0| pieces[0] = new UnicodeString[1]; 197| 0| pieces_lengths[0] = 1; 198| 0| if (pieces[0] == nullptr) { ------------------ | Branch (198:13): [True: 0, False: 0] ------------------ 199| 0| status = U_MEMORY_ALLOCATION_ERROR; 200| 0| goto CleanPartialInitialization; 201| 0| } 202| 0| return; 203| 0| } 204| | 205| | 206| 6.76M| list = new UnicodeString[source.length()]; 207| 6.76M| if (list == nullptr) { ------------------ | Branch (207:9): [True: 0, False: 6.76M] ------------------ 208| 0| status = U_MEMORY_ALLOCATION_ERROR; 209| 0| goto CleanPartialInitialization; 210| 0| } 211| | 212| | // i should initially be the number of code units at the 213| | // start of the string 214| 6.76M| i = U16_LENGTH(source.char32At(0)); ------------------ | | 141| 6.76M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 6.03M, False: 726k] | | ------------------ ------------------ 215| | // int32_t i = 1; 216| | // find the segments 217| | // This code iterates through the source string and 218| | // extracts segments that end up on a codepoint that 219| | // doesn't start any decompositions. (Analysis is done 220| | // on the NFD form - see above). 221| 8.20M| for (; i < source.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 1.44M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 1.43M, False: 2.96k] | | ------------------ ------------------ | Branch (221:12): [True: 1.44M, False: 6.76M] ------------------ 222| 1.44M| cp = source.char32At(i); 223| 1.44M| if (nfcImpl->isCanonSegmentStarter(cp)) { ------------------ | Branch (223:13): [True: 312k, False: 1.13M] ------------------ 224| 312k| source.extract(start, i-start, list[list_length++]); // add up to i 225| 312k| start = i; 226| 312k| } 227| 1.44M| } 228| 6.76M| source.extract(start, i-start, list[list_length++]); // add last one 229| | 230| | 231| | // allocate the arrays, and find the strings that are CE to each segment 232| 6.76M| pieces = static_cast(uprv_malloc(list_length * sizeof(UnicodeString*))); ------------------ | | 1524| 6.76M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 6.76M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.76M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.76M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 6.76M| pieces_length = list_length; 234| 6.76M| pieces_lengths = static_cast(uprv_malloc(list_length * sizeof(int32_t))); ------------------ | | 1524| 6.76M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 6.76M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.76M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.76M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 235| 6.76M| current = static_cast(uprv_malloc(list_length * sizeof(int32_t))); ------------------ | | 1524| 6.76M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 6.76M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.76M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.76M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 236| 6.76M| current_length = list_length; 237| 6.76M| if (pieces == nullptr || pieces_lengths == nullptr || current == nullptr) { ------------------ | Branch (237:9): [True: 0, False: 6.76M] | Branch (237:30): [True: 0, False: 6.76M] | Branch (237:59): [True: 0, False: 6.76M] ------------------ 238| 0| status = U_MEMORY_ALLOCATION_ERROR; 239| 0| goto CleanPartialInitialization; 240| 0| } 241| | 242| 13.8M| for (i = 0; i < current_length; i++) { ------------------ | Branch (242:17): [True: 7.07M, False: 6.76M] ------------------ 243| 7.07M| current[i] = 0; 244| 7.07M| } 245| | // for each segment, get all the combinations that can produce 246| | // it after NFD normalization 247| 13.8M| for (i = 0; i < pieces_length; ++i) { ------------------ | Branch (247:17): [True: 7.07M, False: 6.76M] ------------------ 248| | //if (PROGRESS) printf("SEGMENT\n"); 249| 7.07M| pieces[i] = getEquivalents(list[i], pieces_lengths[i], status); 250| 7.07M| } 251| | 252| 6.76M| delete[] list; 253| 6.76M| return; 254| |// Common section to cleanup all local variables and reset object variables. 255| 0|CleanPartialInitialization: 256| 0| delete[] list; 257| 0| cleanPieces(); 258| 0|} _ZN6icu_7817CanonicalIterator7permuteERNS_13UnicodeStringEaPNS_9HashtableER10UErrorCodei: 266| 22.3M|void U_EXPORT2 CanonicalIterator::permute(UnicodeString &source, UBool skipZeros, Hashtable *result, UErrorCode &status, int32_t depth) { 267| 22.3M| if(U_FAILURE(status)) { ------------------ | Branch (267:8): [True: 28.2k, False: 22.2M] ------------------ 268| 28.2k| return; 269| 28.2k| } 270| | // To avoid infinity loop caused by permute, we limit the depth of recursive 271| | // call to permute and return U_UNSUPPORTED_ERROR. 272| | // We know in some unit test we need at least 4. Set to 8 just in case some 273| | // unforseen use cases. 274| 22.2M| constexpr int32_t kPermuteDepthLimit = 8; 275| 22.2M| if (depth > kPermuteDepthLimit) { ------------------ | Branch (275:9): [True: 73, False: 22.2M] ------------------ 276| 73| status = U_UNSUPPORTED_ERROR; 277| 73| return; 278| 73| } 279| | //if (PROGRESS) printf("Permute: %s\n", UToS(Tr(source))); 280| 22.2M| int32_t i = 0; 281| | 282| | // optimization: 283| | // if zero or one character, just return a set with it 284| | // we check for length < 2 to keep from counting code points all the time 285| 22.2M| if (source.length() <= 2 && source.countChar32() <= 1) { ------------------ | Branch (285:9): [True: 20.5M, False: 1.69M] | Branch (285:33): [True: 16.0M, False: 4.52M] ------------------ 286| 16.0M| UnicodeString *toPut = new UnicodeString(source); 287| | /* test for nullptr */ 288| 16.0M| if (toPut == nullptr) { ------------------ | Branch (288:13): [True: 0, False: 16.0M] ------------------ 289| 0| status = U_MEMORY_ALLOCATION_ERROR; 290| 0| return; 291| 0| } 292| 16.0M| result->put(source, toPut, status); 293| 16.0M| return; 294| 16.0M| } 295| | 296| | // otherwise iterate through the string, and recursively permute all the other characters 297| 6.21M| UChar32 cp; 298| 6.21M| Hashtable subpermute(status); 299| 6.21M| if(U_FAILURE(status)) { ------------------ | Branch (299:8): [True: 0, False: 6.21M] ------------------ 300| 0| return; 301| 0| } 302| 6.21M| subpermute.setValueDeleter(uprv_deleteUObject); ------------------ | | 1489| 6.21M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 6.21M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.21M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.21M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 303| | 304| 20.7M| for (i = 0; i < source.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 14.5M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 14.3M, False: 120k] | | ------------------ ------------------ | Branch (304:17): [True: 14.5M, False: 6.21M] ------------------ 305| 14.5M| cp = source.char32At(i); 306| 14.5M| const UHashElement *ne = nullptr; 307| 14.5M| int32_t el = UHASH_FIRST; ------------------ | | 610| 14.5M|#define UHASH_FIRST (-1) ------------------ 308| 14.5M| UnicodeString subPermuteString = source; 309| | 310| | // optimization: 311| | // if the character is canonical combining class zero, 312| | // don't permute it 313| 14.5M| if (skipZeros && i != 0 && u_getCombiningClass(cp) == 0) { ------------------ | | 270| 8.29M|#define u_getCombiningClass U_ICU_ENTRY_POINT_RENAME(u_getCombiningClass) | | ------------------ | | | | 123| 8.29M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.29M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.29M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (313:13): [True: 14.5M, False: 0] | Branch (313:26): [True: 8.29M, False: 6.21M] | Branch (313:36): [True: 854k, False: 7.43M] ------------------ 314| | //System.out.println("Skipping " + Utility.hex(UTF16.valueOf(source, i))); 315| 854k| continue; 316| 854k| } 317| | 318| 13.6M| subpermute.removeAll(); 319| | 320| | // see what the permutations of the characters before and after this one are 321| | //Hashtable *subpermute = permute(source.substring(0,i) + source.substring(i + UTF16.getCharCount(cp))); 322| 13.6M| permute(subPermuteString.remove(i, U16_LENGTH(cp)), skipZeros, &subpermute, status, depth+1); ------------------ | | 141| 13.6M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 13.5M, False: 118k] | | ------------------ ------------------ 323| | /* Test for buffer overflows */ 324| 13.6M| if(U_FAILURE(status)) { ------------------ | Branch (324:12): [True: 657, False: 13.6M] ------------------ 325| 657| return; 326| 657| } 327| | // The upper remove is destructive. The question is do we have to make a copy, or we don't care about the contents 328| | // of source at this point. 329| | 330| | // prefix this character to all of them 331| 13.6M| ne = subpermute.nextElement(el); 332| 36.9M| while (ne != nullptr) { ------------------ | Branch (332:16): [True: 23.3M, False: 13.6M] ------------------ 333| 23.3M| UnicodeString* permRes = static_cast(ne->value.pointer); 334| 23.3M| UnicodeString *chStr = new UnicodeString(cp); 335| | //test for nullptr 336| 23.3M| if (chStr == nullptr) { ------------------ | Branch (336:17): [True: 0, False: 23.3M] ------------------ 337| 0| status = U_MEMORY_ALLOCATION_ERROR; 338| 0| return; 339| 0| } 340| 23.3M| chStr->append(*permRes); //*((UnicodeString *)(ne->value.pointer)); 341| | //if (PROGRESS) printf(" Piece: %s\n", UToS(*chStr)); 342| 23.3M| result->put(*chStr, chStr, status); 343| 23.3M| ne = subpermute.nextElement(el); 344| 23.3M| } 345| 13.6M| } 346| | //return result; 347| 6.21M|} _ZN6icu_7817CanonicalIterator14getEquivalentsERKNS_13UnicodeStringERiR10UErrorCode: 352| 7.07M|UnicodeString* CanonicalIterator::getEquivalents(const UnicodeString &segment, int32_t &result_len, UErrorCode &status) { 353| 7.07M| Hashtable result(status); 354| 7.07M| Hashtable permutations(status); 355| 7.07M| Hashtable basic(status); 356| 7.07M| if (U_FAILURE(status)) { ------------------ | Branch (356:9): [True: 8.91k, False: 7.06M] ------------------ 357| 8.91k| return nullptr; 358| 8.91k| } 359| 7.06M| result.setValueDeleter(uprv_deleteUObject); ------------------ | | 1489| 7.06M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 7.06M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.06M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.06M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 360| 7.06M| permutations.setValueDeleter(uprv_deleteUObject); ------------------ | | 1489| 7.06M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 7.06M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.06M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.06M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 361| 7.06M| basic.setValueDeleter(uprv_deleteUObject); ------------------ | | 1489| 7.06M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 7.06M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.06M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.06M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 362| | 363| 7.06M| char16_t USeg[256]; 364| 7.06M| int32_t segLen = segment.extract(USeg, 256, status); 365| 7.06M| getEquivalents2(&basic, USeg, segLen, status); 366| 7.06M| if (U_FAILURE(status)) { ------------------ | Branch (366:9): [True: 76, False: 7.06M] ------------------ 367| 76| return nullptr; 368| 76| } 369| | 370| | // now get all the permutations 371| | // add only the ones that are canonically equivalent 372| | // TODO: optimize by not permuting any class zero. 373| | 374| 7.06M| const UHashElement *ne = nullptr; 375| 7.06M| int32_t el = UHASH_FIRST; ------------------ | | 610| 7.06M|#define UHASH_FIRST (-1) ------------------ 376| | //Iterator it = basic.iterator(); 377| 7.06M| ne = basic.nextElement(el); 378| | //while (it.hasNext()) 379| 15.7M| while (ne != nullptr) { ------------------ | Branch (379:12): [True: 8.64M, False: 7.06M] ------------------ 380| | //String item = (String) it.next(); 381| 8.64M| UnicodeString item = *static_cast(ne->value.pointer); 382| | 383| 8.64M| permutations.removeAll(); 384| 8.64M| permute(item, CANITER_SKIP_ZEROES, &permutations, status); ------------------ | | 32| 8.64M|#define CANITER_SKIP_ZEROES true ------------------ 385| 8.64M| const UHashElement *ne2 = nullptr; 386| 8.64M| int32_t el2 = UHASH_FIRST; ------------------ | | 610| 8.64M|#define UHASH_FIRST (-1) ------------------ 387| | //Iterator it2 = permutations.iterator(); 388| 8.64M| ne2 = permutations.nextElement(el2); 389| | //while (it2.hasNext()) 390| 20.5M| while (ne2 != nullptr) { ------------------ | Branch (390:16): [True: 11.9M, False: 8.64M] ------------------ 391| | //String possible = (String) it2.next(); 392| | //UnicodeString *possible = new UnicodeString(*((UnicodeString *)(ne2->value.pointer))); 393| 11.9M| UnicodeString possible(*static_cast(ne2->value.pointer)); 394| 11.9M| UnicodeString attempt; 395| 11.9M| nfd->normalize(possible, attempt, status); 396| | 397| | // TODO: check if operator == is semanticaly the same as attempt.equals(segment) 398| 11.9M| if (attempt==segment) { ------------------ | Branch (398:17): [True: 8.85M, False: 3.07M] ------------------ 399| | //if (PROGRESS) printf("Adding Permutation: %s\n", UToS(Tr(*possible))); 400| | // TODO: use the hashtable just to catch duplicates - store strings directly (somehow). 401| 8.85M| result.put(possible, new UnicodeString(possible), status); //add(possible); 402| 8.85M| } else { 403| | //if (PROGRESS) printf("-Skipping Permutation: %s\n", UToS(Tr(*possible))); 404| 3.07M| } 405| | 406| 11.9M| ne2 = permutations.nextElement(el2); 407| 11.9M| } 408| 8.64M| ne = basic.nextElement(el); 409| 8.64M| } 410| | 411| | /* Test for buffer overflows */ 412| 7.06M| if(U_FAILURE(status)) { ------------------ | Branch (412:8): [True: 73, False: 7.06M] ------------------ 413| 73| return nullptr; 414| 73| } 415| | // convert into a String[] to clean up storage 416| | //String[] finalResult = new String[result.size()]; 417| 7.06M| UnicodeString *finalResult = nullptr; 418| 7.06M| int32_t resultCount; 419| 7.06M| if((resultCount = result.count()) != 0) { ------------------ | Branch (419:8): [True: 7.06M, False: 0] ------------------ 420| 7.06M| finalResult = new UnicodeString[resultCount]; 421| 7.06M| if (finalResult == nullptr) { ------------------ | Branch (421:13): [True: 0, False: 7.06M] ------------------ 422| 0| status = U_MEMORY_ALLOCATION_ERROR; 423| 0| return nullptr; 424| 0| } 425| 7.06M| } 426| 0| else { 427| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 428| 0| return nullptr; 429| 0| } 430| | //result.toArray(finalResult); 431| 7.06M| result_len = 0; 432| 7.06M| el = UHASH_FIRST; ------------------ | | 610| 7.06M|#define UHASH_FIRST (-1) ------------------ 433| 7.06M| ne = result.nextElement(el); 434| 15.8M| while(ne != nullptr) { ------------------ | Branch (434:11): [True: 8.81M, False: 7.06M] ------------------ 435| 8.81M| finalResult[result_len++] = *static_cast(ne->value.pointer); 436| 8.81M| ne = result.nextElement(el); 437| 8.81M| } 438| | 439| | 440| 7.06M| return finalResult; 441| 7.06M|} _ZN6icu_7817CanonicalIterator15getEquivalents2EPNS_9HashtableEPKDsiR10UErrorCode: 443| 7.66M|Hashtable *CanonicalIterator::getEquivalents2(Hashtable *fillinResult, const char16_t *segment, int32_t segLen, UErrorCode &status) { 444| | 445| 7.66M| if (U_FAILURE(status)) { ------------------ | Branch (445:9): [True: 23, False: 7.66M] ------------------ 446| 23| return nullptr; 447| 23| } 448| | 449| | //if (PROGRESS) printf("Adding: %s\n", UToS(Tr(segment))); 450| | 451| 7.66M| UnicodeString toPut(segment, segLen); 452| | 453| 7.66M| fillinResult->put(toPut, new UnicodeString(toPut), status); 454| | 455| 7.66M| UnicodeSet starts; 456| | 457| | // cycle through all the characters 458| 7.66M| UChar32 cp; 459| 20.6M| for (int32_t i = 0; i < segLen; i += U16_LENGTH(cp)) { ------------------ | | 141| 12.9M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 12.2M, False: 737k] | | ------------------ ------------------ | Branch (459:25): [True: 12.9M, False: 7.65M] ------------------ 460| | // see if any character is at the start of some decomposition 461| 12.9M| U16_GET(segment, 0, i, segLen, cp); ------------------ | | 201| 12.9M|#define U16_GET(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 12.9M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 202| 12.9M| (c)=(s)[i]; \ | | 203| 12.9M| if(U16_IS_SURROGATE(c)) { \ | | ------------------ | | | | 75| 12.9M|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | | | ------------------ | | | | | | 193| 12.9M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | | | ------------------ | | | | | | | Branch (193:27): [True: 737k, False: 12.2M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 204| 737k| uint16_t __c2; \ | | 205| 737k| if(U16_IS_SURROGATE_LEAD(c)) { \ | | ------------------ | | | | 84| 737k|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | | | ------------------ | | | | | Branch (84:34): [True: 737k, False: 0] | | | | ------------------ | | ------------------ | | 206| 737k| if((i)+1!=(length) && U16_IS_TRAIL(__c2=(s)[(i)+1])) { \ | | ------------------ | | | | 67| 737k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 737k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (206:16): [True: 737k, False: 0] | | ------------------ | | 207| 737k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 737k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 737k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 208| 737k| } \ | | 209| 737k| } else { \ | | 210| 0| if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \ | | ------------------ | | | | 59| 0|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (210:16): [True: 0, False: 0] | | ------------------ | | 211| 0| (c)=U16_GET_SUPPLEMENTARY(__c2, (c)); \ | | ------------------ | | | | 113| 0| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 0|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 212| 0| } \ | | 213| 0| } \ | | 214| 737k| } \ | | 215| 12.9M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 12.9M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 462| 12.9M| if (!nfcImpl->getCanonStartSet(cp, starts)) { ------------------ | Branch (462:13): [True: 10.6M, False: 2.32M] ------------------ 463| 10.6M| continue; 464| 10.6M| } 465| | // if so, see which decompositions match 466| 2.32M| UnicodeSetIterator iter(starts); 467| 31.8M| while (iter.next()) { ------------------ | Branch (467:16): [True: 29.5M, False: 2.31M] ------------------ 468| 29.5M| UChar32 cp2 = iter.getCodepoint(); 469| 29.5M| Hashtable remainder(status); 470| 29.5M| remainder.setValueDeleter(uprv_deleteUObject); ------------------ | | 1489| 29.5M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 29.5M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 29.5M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 29.5M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 471| 29.5M| if (extract(&remainder, cp2, segment, segLen, i, status) == nullptr) { ------------------ | Branch (471:17): [True: 27.7M, False: 1.82M] ------------------ 472| 27.7M| if (U_FAILURE(status)) { ------------------ | Branch (472:21): [True: 1.17k, False: 27.7M] ------------------ 473| 1.17k| return nullptr; 474| 1.17k| } 475| 27.7M| continue; 476| 27.7M| } 477| | 478| | // there were some matches, so add all the possibilities to the set. 479| 1.82M| UnicodeString prefix(segment, i); 480| 1.82M| prefix += cp2; 481| | 482| 1.82M| int32_t el = UHASH_FIRST; ------------------ | | 610| 1.82M|#define UHASH_FIRST (-1) ------------------ 483| 1.82M| const UHashElement *ne = remainder.nextElement(el); 484| 4.94M| while (ne != nullptr) { ------------------ | Branch (484:20): [True: 3.12M, False: 1.82M] ------------------ 485| 3.12M| UnicodeString item = *static_cast(ne->value.pointer); 486| 3.12M| UnicodeString *toAdd = new UnicodeString(prefix); 487| | /* test for nullptr */ 488| 3.12M| if (toAdd == nullptr) { ------------------ | Branch (488:21): [True: 0, False: 3.12M] ------------------ 489| 0| status = U_MEMORY_ALLOCATION_ERROR; 490| 0| return nullptr; 491| 0| } 492| 3.12M| *toAdd += item; 493| 3.12M| fillinResult->put(*toAdd, toAdd, status); 494| | 495| | //if (PROGRESS) printf("Adding: %s\n", UToS(Tr(*toAdd))); 496| | 497| 3.12M| ne = remainder.nextElement(el); 498| 3.12M| } 499| | // ICU-22642 Guards against strings that have so many permutations 500| | // that they would otherwise hang the function. 501| 1.82M| constexpr int32_t kResultLimit = 4096; 502| 1.82M| if (fillinResult->count() > kResultLimit) { ------------------ | Branch (502:17): [True: 53, False: 1.82M] ------------------ 503| 53| status = U_UNSUPPORTED_ERROR; 504| 53| return nullptr; 505| 53| } 506| 1.82M| } 507| 2.32M| } 508| | 509| | /* Test for buffer overflows */ 510| 7.65M| if(U_FAILURE(status)) { ------------------ | Branch (510:8): [True: 0, False: 7.65M] ------------------ 511| 0| return nullptr; 512| 0| } 513| 7.65M| return fillinResult; 514| 7.65M|} _ZN6icu_7817CanonicalIterator7extractEPNS_9HashtableEiPKDsiiR10UErrorCode: 521| 29.5M|Hashtable *CanonicalIterator::extract(Hashtable *fillinResult, UChar32 comp, const char16_t *segment, int32_t segLen, int32_t segmentPos, UErrorCode &status) { 522| |//Hashtable *CanonicalIterator::extract(UChar32 comp, const UnicodeString &segment, int32_t segLen, int32_t segmentPos, UErrorCode &status) { 523| | //if (PROGRESS) printf(" extract: %s, ", UToS(Tr(UnicodeString(comp)))); 524| | //if (PROGRESS) printf("%s, %i\n", UToS(Tr(segment)), segmentPos); 525| | 526| 29.5M| if (U_FAILURE(status)) { ------------------ | Branch (526:9): [True: 0, False: 29.5M] ------------------ 527| 0| return nullptr; 528| 0| } 529| | 530| 29.5M| UnicodeString temp(comp); 531| 29.5M| int32_t inputLen=temp.length(); 532| 29.5M| UnicodeString decompString; 533| 29.5M| nfd->normalize(temp, decompString, status); 534| 29.5M| if (U_FAILURE(status)) { ------------------ | Branch (534:9): [True: 0, False: 29.5M] ------------------ 535| 0| return nullptr; 536| 0| } 537| 29.5M| if (decompString.isBogus()) { ------------------ | Branch (537:9): [True: 0, False: 29.5M] ------------------ 538| 0| status = U_MEMORY_ALLOCATION_ERROR; 539| 0| return nullptr; 540| 0| } 541| 29.5M| const char16_t *decomp=decompString.getBuffer(); 542| 29.5M| int32_t decompLen=decompString.length(); 543| | 544| | // See if it matches the start of segment (at segmentPos) 545| 29.5M| UBool ok = false; 546| 29.5M| UChar32 cp; 547| 29.5M| int32_t decompPos = 0; 548| 29.5M| UChar32 decompCp; 549| 29.5M| U16_NEXT(decomp, decompPos, decompLen, decompCp); ------------------ | | 309| 29.5M|#define U16_NEXT(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 29.5M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 310| 29.5M| (c)=(s)[(i)++]; \ | | 311| 29.5M| if(U16_IS_LEAD(c)) { \ | | ------------------ | | | | 59| 29.5M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 14.4k, False: 29.5M] | | | | ------------------ | | ------------------ | | 312| 14.4k| uint16_t __c2; \ | | 313| 14.4k| if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \ | | ------------------ | | | | 67| 14.4k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 14.4k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (313:12): [True: 14.4k, False: 0] | | ------------------ | | 314| 14.4k| ++(i); \ | | 315| 14.4k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 14.4k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 14.4k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 316| 14.4k| } \ | | 317| 14.4k| } \ | | 318| 29.5M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 29.5M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 550| | 551| 29.5M| int32_t i = segmentPos; 552| 155M| while(i < segLen) { ------------------ | Branch (552:11): [True: 128M, False: 27.0M] ------------------ 553| 128M| U16_NEXT(segment, i, segLen, cp); ------------------ | | 309| 128M|#define U16_NEXT(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 128M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 310| 128M| (c)=(s)[(i)++]; \ | | 311| 128M| if(U16_IS_LEAD(c)) { \ | | ------------------ | | | | 59| 128M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 52.5k, False: 128M] | | | | ------------------ | | ------------------ | | 312| 52.5k| uint16_t __c2; \ | | 313| 52.5k| if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \ | | ------------------ | | | | 67| 52.5k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 52.5k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (313:12): [True: 52.5k, False: 0] | | ------------------ | | 314| 52.5k| ++(i); \ | | 315| 52.5k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 52.5k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 52.5k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 316| 52.5k| } \ | | 317| 52.5k| } \ | | 318| 128M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 128M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 554| | 555| 128M| if (cp == decompCp) { // if equal, eat another cp from decomp ------------------ | Branch (555:13): [True: 32.9M, False: 96.0M] ------------------ 556| | 557| | //if (PROGRESS) printf(" matches: %s\n", UToS(Tr(UnicodeString(cp)))); 558| | 559| 32.9M| if (decompPos == decompLen) { // done, have all decomp characters! ------------------ | Branch (559:17): [True: 2.51M, False: 30.4M] ------------------ 560| 2.51M| temp.append(segment+i, segLen-i); 561| 2.51M| ok = true; 562| 2.51M| break; 563| 2.51M| } 564| 32.9M| U16_NEXT(decomp, decompPos, decompLen, decompCp); ------------------ | | 309| 30.4M|#define U16_NEXT(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 30.4M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 310| 30.4M| (c)=(s)[(i)++]; \ | | 311| 30.4M| if(U16_IS_LEAD(c)) { \ | | ------------------ | | | | 59| 30.4M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 14.2k, False: 30.4M] | | | | ------------------ | | ------------------ | | 312| 14.2k| uint16_t __c2; \ | | 313| 14.2k| if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \ | | ------------------ | | | | 67| 14.2k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 14.2k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (313:12): [True: 14.2k, False: 0] | | ------------------ | | 314| 14.2k| ++(i); \ | | 315| 14.2k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 14.2k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 14.2k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 316| 14.2k| } \ | | 317| 14.2k| } \ | | 318| 32.9M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 32.9M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 565| 96.0M| } else { 566| | //if (PROGRESS) printf(" buffer: %s\n", UToS(Tr(UnicodeString(cp)))); 567| | 568| | // brute force approach 569| 96.0M| temp.append(cp); 570| | 571| | /* TODO: optimize 572| | // since we know that the classes are monotonically increasing, after zero 573| | // e.g. 0 5 7 9 0 3 574| | // we can do an optimization 575| | // there are only a few cases that work: zero, less, same, greater 576| | // if both classes are the same, we fail 577| | // if the decomp class < the segment class, we fail 578| | 579| | segClass = getClass(cp); 580| | if (decompClass <= segClass) return null; 581| | */ 582| 96.0M| } 583| 128M| } 584| 29.5M| if (!ok) ------------------ | Branch (584:9): [True: 27.0M, False: 2.51M] ------------------ 585| 27.0M| return nullptr; // we failed, characters left over 586| | 587| | //if (PROGRESS) printf("Matches\n"); 588| | 589| 2.51M| if (inputLen == temp.length()) { ------------------ | Branch (589:9): [True: 1.22M, False: 1.28M] ------------------ 590| 1.22M| fillinResult->put(UnicodeString(), new UnicodeString(), status); 591| 1.22M| return fillinResult; // succeed, but no remainder 592| 1.22M| } 593| | 594| | // brute force approach 595| | // check to make sure result is canonically equivalent 596| 1.28M| UnicodeString trial; 597| 1.28M| nfd->normalize(temp, trial, status); 598| 1.28M| if(U_FAILURE(status) || trial.compare(segment+segmentPos, segLen - segmentPos) != 0) { ------------------ | Branch (598:8): [True: 0, False: 1.28M] | Branch (598:8): [True: 688k, False: 594k] | Branch (598:29): [True: 688k, False: 594k] ------------------ 599| 688k| return nullptr; 600| 688k| } 601| | 602| 594k| return getEquivalents2(fillinResult, temp.getBuffer()+inputLen, temp.length()-inputLen, status); 603| 1.28M|} _ZN6icu_7819CharacterProperties24getInclusionsForPropertyE9UPropertyR10UErrorCode: 267| 10.2k| UProperty prop, UErrorCode &errorCode) { 268| 10.2k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (268:9): [True: 0, False: 10.2k] ------------------ 269| 10.2k| if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { ------------------ | Branch (269:9): [True: 10.2k, False: 8] | Branch (269:36): [True: 4.23k, False: 6.00k] ------------------ 270| 4.23k| int32_t inclIndex = UPROPS_SRC_COUNT + (prop - UCHAR_INT_START); 271| 4.23k| Inclusion &i = gInclusions[inclIndex]; 272| 4.23k| umtx_initOnce(i.fInitOnce, &initIntPropInclusion, prop, errorCode); 273| 4.23k| return i.fSet; 274| 6.00k| } else { 275| 6.00k| UPropertySource src = uprops_getSource(prop); ------------------ | | 1392| 6.00k|#define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource) | | ------------------ | | | | 123| 6.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 276| 6.00k| return getInclusionsForSource(src, errorCode); 277| 6.00k| } 278| 10.2k|} _ZN6icu_7819CharacterProperties20getBinaryPropertySetE9UPropertyR10UErrorCode: 394| 839|const UnicodeSet *CharacterProperties::getBinaryPropertySet(UProperty property, UErrorCode &errorCode) { 395| 839| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (395:9): [True: 0, False: 839] ------------------ 396| 839| if (property < 0 || UCHAR_BINARY_LIMIT <= property) { ------------------ | Branch (396:9): [True: 0, False: 839] | Branch (396:25): [True: 0, False: 839] ------------------ 397| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 398| 0| return nullptr; 399| 0| } 400| 839| Mutex m(&cpMutex); 401| 839| UnicodeSet *set = sets[property]; 402| 839| if (set == nullptr) { ------------------ | Branch (402:9): [True: 8, False: 831] ------------------ 403| 8| sets[property] = set = makeSet(property, errorCode); 404| 8| } 405| 839| return set; 406| 839|} u_getBinaryPropertySet_78: 413| 839|u_getBinaryPropertySet(UProperty property, UErrorCode *pErrorCode) { 414| 839| const UnicodeSet *set = CharacterProperties::getBinaryPropertySet(property, *pErrorCode); 415| 839| return U_SUCCESS(*pErrorCode) ? set->toUSet() : nullptr; ------------------ | Branch (415:12): [True: 839, False: 0] ------------------ 416| 839|} characterproperties.cpp:_ZN12_GLOBAL__N_120initIntPropInclusionE9UPropertyR10UErrorCode: 222| 2|void U_CALLCONV initIntPropInclusion(UProperty prop, UErrorCode &errorCode) { 223| | // This function is invoked only via umtx_initOnce(). 224| 2| U_ASSERT(UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT); ------------------ | | 35| 2|# define U_ASSERT(exp) (void)0 ------------------ 225| 2| int32_t inclIndex = UPROPS_SRC_COUNT + (prop - UCHAR_INT_START); 226| 2| U_ASSERT(gInclusions[inclIndex].fSet == nullptr); ------------------ | | 35| 2|# define U_ASSERT(exp) (void)0 ------------------ 227| 2| UPropertySource src = uprops_getSource(prop); ------------------ | | 1392| 2|#define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 228| 2| const UnicodeSet *incl = getInclusionsForSource(src, errorCode); 229| 2| if (U_FAILURE(errorCode)) { ------------------ | Branch (229:9): [True: 0, False: 2] ------------------ 230| 0| return; 231| 0| } 232| | 233| 2| LocalPointer intPropIncl(new UnicodeSet(0, 0)); 234| 2| if (intPropIncl.isNull()) { ------------------ | Branch (234:9): [True: 0, False: 2] ------------------ 235| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 236| 0| return; 237| 0| } 238| 2| int32_t numRanges = incl->getRangeCount(); 239| 2| int32_t prevValue = 0; 240| 3.99k| for (int32_t i = 0; i < numRanges; ++i) { ------------------ | Branch (240:25): [True: 3.99k, False: 2] ------------------ 241| 3.99k| UChar32 rangeEnd = incl->getRangeEnd(i); 242| 15.1k| for (UChar32 c = incl->getRangeStart(i); c <= rangeEnd; ++c) { ------------------ | Branch (242:50): [True: 11.1k, False: 3.99k] ------------------ 243| | // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch. 244| 11.1k| int32_t value = u_getIntPropertyValue(c, prop); ------------------ | | 280| 11.1k|#define u_getIntPropertyValue U_ICU_ENTRY_POINT_RENAME(u_getIntPropertyValue) | | ------------------ | | | | 123| 11.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 245| 11.1k| if (value != prevValue) { ------------------ | Branch (245:17): [True: 2.19k, False: 8.94k] ------------------ 246| 2.19k| intPropIncl->add(c); 247| 2.19k| prevValue = value; 248| 2.19k| } 249| 11.1k| } 250| 3.99k| } 251| | 252| 2| if (intPropIncl->isBogus()) { ------------------ | Branch (252:9): [True: 0, False: 2] ------------------ 253| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 254| 0| return; 255| 0| } 256| | // Compact for caching. 257| 2| intPropIncl->compact(); 258| 2| gInclusions[inclIndex].fSet = intPropIncl.orphan(); 259| 2| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); ------------------ | | 617| 2|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 260| 2|} characterproperties.cpp:_ZN12_GLOBAL__N_122getInclusionsForSourceE15UPropertySourceR10UErrorCode: 211| 6.01k|const UnicodeSet *getInclusionsForSource(UPropertySource src, UErrorCode &errorCode) { 212| 6.01k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (212:9): [True: 0, False: 6.01k] ------------------ 213| 6.01k| if (src < 0 || UPROPS_SRC_COUNT <= src) { ------------------ | Branch (213:9): [True: 0, False: 6.01k] | Branch (213:20): [True: 0, False: 6.01k] ------------------ 214| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 215| 0| return nullptr; 216| 0| } 217| 6.01k| Inclusion &i = gInclusions[src]; 218| 6.01k| umtx_initOnce(i.fInitOnce, &initInclusion, src, errorCode); 219| 6.01k| return i.fSet; 220| 6.01k|} characterproperties.cpp:_ZN12_GLOBAL__N_113initInclusionE15UPropertySourceR10UErrorCode: 91| 4|void U_CALLCONV initInclusion(UPropertySource src, UErrorCode &errorCode) { 92| | // This function is invoked only via umtx_initOnce(). 93| 4| U_ASSERT(0 <= src && src < UPROPS_SRC_COUNT); ------------------ | | 35| 4|# define U_ASSERT(exp) (void)0 ------------------ 94| 4| if (src == UPROPS_SRC_NONE) { ------------------ | Branch (94:9): [True: 0, False: 4] ------------------ 95| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 96| 0| return; 97| 0| } 98| 4| U_ASSERT(gInclusions[src].fSet == nullptr); ------------------ | | 35| 4|# define U_ASSERT(exp) (void)0 ------------------ 99| | 100| 4| LocalPointer incl(new UnicodeSet()); 101| 4| if (incl.isNull()) { ------------------ | Branch (101:9): [True: 0, False: 4] ------------------ 102| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 103| 0| return; 104| 0| } 105| 4| USetAdder sa = { 106| 4| reinterpret_cast(incl.getAlias()), 107| 4| _set_add, 108| 4| _set_addRange, 109| 4| _set_addString, 110| 4| nullptr, // don't need remove() 111| 4| nullptr // don't need removeRange() 112| 4| }; 113| | 114| 4| switch(src) { 115| 1| case UPROPS_SRC_CHAR: ------------------ | Branch (115:5): [True: 1, False: 3] ------------------ 116| 1| uchar_addPropertyStarts(&sa, &errorCode); ------------------ | | 614| 1|#define uchar_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uchar_addPropertyStarts) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 117| 1| break; 118| 1| case UPROPS_SRC_PROPSVEC: ------------------ | Branch (118:5): [True: 1, False: 3] ------------------ 119| 1| upropsvec_addPropertyStarts(&sa, &errorCode); ------------------ | | 1393| 1|#define upropsvec_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(upropsvec_addPropertyStarts) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 120| 1| break; 121| 0| case UPROPS_SRC_CHAR_AND_PROPSVEC: ------------------ | Branch (121:5): [True: 0, False: 4] ------------------ 122| 0| uchar_addPropertyStarts(&sa, &errorCode); ------------------ | | 614| 0|#define uchar_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uchar_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 123| 0| upropsvec_addPropertyStarts(&sa, &errorCode); ------------------ | | 1393| 0|#define upropsvec_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(upropsvec_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 124| 0| break; 125| 0|#if !UCONFIG_NO_NORMALIZATION 126| 0| case UPROPS_SRC_CASE_AND_NORM: { ------------------ | Branch (126:5): [True: 0, False: 4] ------------------ 127| 0| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 128| 0| if(U_SUCCESS(errorCode)) { ------------------ | Branch (128:12): [True: 0, False: 0] ------------------ 129| 0| impl->addPropertyStarts(&sa, errorCode); 130| 0| } 131| 0| ucase_addPropertyStarts(&sa, &errorCode); ------------------ | | 568| 0|#define ucase_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(ucase_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 132| 0| break; 133| 0| } 134| 1| case UPROPS_SRC_NFC: { ------------------ | Branch (134:5): [True: 1, False: 3] ------------------ 135| 1| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 136| 1| if(U_SUCCESS(errorCode)) { ------------------ | Branch (136:12): [True: 1, False: 0] ------------------ 137| 1| impl->addPropertyStarts(&sa, errorCode); 138| 1| } 139| 1| break; 140| 0| } 141| 0| case UPROPS_SRC_NFKC: { ------------------ | Branch (141:5): [True: 0, False: 4] ------------------ 142| 0| const Normalizer2Impl *impl=Normalizer2Factory::getNFKCImpl(errorCode); 143| 0| if(U_SUCCESS(errorCode)) { ------------------ | Branch (143:12): [True: 0, False: 0] ------------------ 144| 0| impl->addPropertyStarts(&sa, errorCode); 145| 0| } 146| 0| break; 147| 0| } 148| 0| case UPROPS_SRC_NFKC_CF: { ------------------ | Branch (148:5): [True: 0, False: 4] ------------------ 149| 0| const Normalizer2Impl *impl=Normalizer2Factory::getNFKC_CFImpl(errorCode); 150| 0| if(U_SUCCESS(errorCode)) { ------------------ | Branch (150:12): [True: 0, False: 0] ------------------ 151| 0| impl->addPropertyStarts(&sa, errorCode); 152| 0| } 153| 0| break; 154| 0| } 155| 0| case UPROPS_SRC_NFC_CANON_ITER: { ------------------ | Branch (155:5): [True: 0, False: 4] ------------------ 156| 0| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 157| 0| if(U_SUCCESS(errorCode)) { ------------------ | Branch (157:12): [True: 0, False: 0] ------------------ 158| 0| impl->addCanonIterPropertyStarts(&sa, errorCode); 159| 0| } 160| 0| break; 161| 0| } 162| 0|#endif 163| 1| case UPROPS_SRC_CASE: ------------------ | Branch (163:5): [True: 1, False: 3] ------------------ 164| 1| ucase_addPropertyStarts(&sa, &errorCode); ------------------ | | 568| 1|#define ucase_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(ucase_addPropertyStarts) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 165| 1| break; 166| 0| case UPROPS_SRC_BIDI: ------------------ | Branch (166:5): [True: 0, False: 4] ------------------ 167| 0| ubidi_addPropertyStarts(&sa, &errorCode); ------------------ | | 435| 0|#define ubidi_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(ubidi_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 168| 0| break; 169| 0| case UPROPS_SRC_INPC: ------------------ | Branch (169:5): [True: 0, False: 4] ------------------ 170| 0| case UPROPS_SRC_INSC: ------------------ | Branch (170:5): [True: 0, False: 4] ------------------ 171| 0| case UPROPS_SRC_VO: ------------------ | Branch (171:5): [True: 0, False: 4] ------------------ 172| 0| uprops_addPropertyStarts(src, &sa, &errorCode); ------------------ | | 1391| 0|#define uprops_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uprops_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 173| 0| break; 174| 0| case UPROPS_SRC_EMOJI: { ------------------ | Branch (174:5): [True: 0, False: 4] ------------------ 175| 0| const icu::EmojiProps *ep = icu::EmojiProps::getSingleton(errorCode); 176| 0| if (U_SUCCESS(errorCode)) { ------------------ | Branch (176:13): [True: 0, False: 0] ------------------ 177| 0| ep->addPropertyStarts(&sa, errorCode); 178| 0| } 179| 0| break; 180| 0| } 181| 0| case UPROPS_SRC_IDSU: ------------------ | Branch (181:5): [True: 0, False: 4] ------------------ 182| | // New in Unicode 15.1 for just two characters. 183| 0| sa.add(sa.set, 0x2FFE); 184| 0| sa.add(sa.set, 0x2FFF + 1); 185| 0| break; 186| 0| case UPROPS_SRC_ID_COMPAT_MATH: ------------------ | Branch (186:5): [True: 0, False: 4] ------------------ 187| 0| case UPROPS_SRC_MCM: ------------------ | Branch (187:5): [True: 0, False: 4] ------------------ 188| 0| uprops_addPropertyStarts(src, &sa, &errorCode); ------------------ | | 1391| 0|#define uprops_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uprops_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 189| 0| break; 190| 0| case UPROPS_SRC_BLOCK: ------------------ | Branch (190:5): [True: 0, False: 4] ------------------ 191| 0| ublock_addPropertyStarts(&sa, errorCode); ------------------ | | 493| 0|#define ublock_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(ublock_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 192| 0| break; 193| 0| default: ------------------ | Branch (193:5): [True: 0, False: 4] ------------------ 194| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 195| 0| break; 196| 4| } 197| | 198| 4| if (U_FAILURE(errorCode)) { ------------------ | Branch (198:9): [True: 0, False: 4] ------------------ 199| 0| return; 200| 0| } 201| 4| if (incl->isBogus()) { ------------------ | Branch (201:9): [True: 0, False: 4] ------------------ 202| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 203| 0| return; 204| 0| } 205| | // Compact for caching. 206| 4| incl->compact(); 207| 4| gInclusions[src].fSet = incl.orphan(); 208| 4| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); ------------------ | | 617| 4|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 4|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 209| 4|} characterproperties.cpp:_ZN12_GLOBAL__N_18_set_addEP4USeti: 60| 21.0k|_set_add(USet *set, UChar32 c) { 61| 21.0k| reinterpret_cast(set)->add(c); 62| 21.0k|} characterproperties.cpp:_ZN12_GLOBAL__N_17makeSetE9UPropertyR10UErrorCode: 284| 8|UnicodeSet *makeSet(UProperty property, UErrorCode &errorCode) { 285| 8| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (285:9): [True: 0, False: 8] ------------------ 286| 8| LocalPointer set(new UnicodeSet()); 287| 8| if (set.isNull()) { ------------------ | Branch (287:9): [True: 0, False: 8] ------------------ 288| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 289| 0| return nullptr; 290| 0| } 291| 8| if (UCHAR_BASIC_EMOJI <= property && property <= UCHAR_RGI_EMOJI) { ------------------ | Branch (291:9): [True: 0, False: 8] | Branch (291:42): [True: 0, False: 0] ------------------ 292| | // property of strings 293| 0| const icu::EmojiProps *ep = icu::EmojiProps::getSingleton(errorCode); 294| 0| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (294:13): [True: 0, False: 0] ------------------ 295| 0| USetAdder sa = { 296| 0| reinterpret_cast(set.getAlias()), 297| 0| _set_add, 298| 0| _set_addRange, 299| 0| _set_addString, 300| 0| nullptr, // don't need remove() 301| 0| nullptr // don't need removeRange() 302| 0| }; 303| 0| ep->addStrings(&sa, property, errorCode); 304| 0| if (property != UCHAR_BASIC_EMOJI && property != UCHAR_RGI_EMOJI) { ------------------ | Branch (304:13): [True: 0, False: 0] | Branch (304:46): [True: 0, False: 0] ------------------ 305| | // property of _only_ strings 306| 0| set->freeze(); 307| 0| return set.orphan(); 308| 0| } 309| 0| } 310| | 311| 8| const UnicodeSet *inclusions = 312| 8| icu::CharacterProperties::getInclusionsForProperty(property, errorCode); 313| 8| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (313:9): [True: 0, False: 8] ------------------ 314| 8| int32_t numRanges = inclusions->getRangeCount(); 315| 8| UChar32 startHasProperty = -1; 316| | 317| 16.3k| for (int32_t i = 0; i < numRanges; ++i) { ------------------ | Branch (317:25): [True: 16.3k, False: 8] ------------------ 318| 16.3k| UChar32 rangeEnd = inclusions->getRangeEnd(i); 319| 57.2k| for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) { ------------------ | Branch (319:56): [True: 40.9k, False: 16.3k] ------------------ 320| | // TODO: Get a UCharacterProperty.BinaryProperty to avoid the property dispatch. 321| 40.9k| if (u_hasBinaryProperty(c, property)) { ------------------ | | 292| 40.9k|#define u_hasBinaryProperty U_ICU_ENTRY_POINT_RENAME(u_hasBinaryProperty) | | ------------------ | | | | 123| 40.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 40.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 40.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (321:17): [True: 2.40k, False: 38.5k] ------------------ 322| 2.40k| if (startHasProperty < 0) { ------------------ | Branch (322:21): [True: 1.76k, False: 638] ------------------ 323| | // Transition from false to true. 324| 1.76k| startHasProperty = c; 325| 1.76k| } 326| 38.5k| } else if (startHasProperty >= 0) { ------------------ | Branch (326:24): [True: 1.76k, False: 36.7k] ------------------ 327| | // Transition from true to false. 328| 1.76k| set->add(startHasProperty, c - 1); 329| 1.76k| startHasProperty = -1; 330| 1.76k| } 331| 40.9k| } 332| 16.3k| } 333| 8| if (startHasProperty >= 0) { ------------------ | Branch (333:9): [True: 0, False: 8] ------------------ 334| 0| set->add(startHasProperty, 0x10FFFF); 335| 0| } 336| 8| set->freeze(); 337| 8| return set.orphan(); 338| 8|} _ZN6icu_7810CharStringC2EOS0_: 30| 4.87k| : buffer(std::move(src.buffer)), len(src.len) { 31| 4.87k| src.len = 0; // not strictly necessary because we make no guarantees on the source string 32| 4.87k|} _ZN6icu_7810CharString8copyFromENS_11StringPieceER10UErrorCode: 73| 119|CharString &CharString::copyFrom(StringPiece s, UErrorCode &errorCode) { 74| 119| if (U_FAILURE(errorCode)) { ------------------ | Branch (74:9): [True: 0, False: 119] ------------------ 75| 0| return *this; 76| 0| } 77| 119| len = 0; 78| 119| append(s, errorCode); 79| 119| return *this; 80| 119|} _ZN6icu_7810CharString6appendEcR10UErrorCode: 113| 52.4k|CharString &CharString::append(char c, UErrorCode &errorCode) { 114| 52.4k| if(ensureCapacity(len+2, 0, errorCode)) { ------------------ | Branch (114:8): [True: 52.4k, False: 0] ------------------ 115| 52.4k| buffer[len++]=c; 116| 52.4k| buffer[len]=0; 117| 52.4k| } 118| 52.4k| return *this; 119| 52.4k|} _ZN6icu_7810CharString6appendEPKciR10UErrorCode: 121| 91.9k|CharString &CharString::append(const char *s, int32_t sLength, UErrorCode &errorCode) { 122| 91.9k| if(U_FAILURE(errorCode)) { ------------------ | Branch (122:8): [True: 0, False: 91.9k] ------------------ 123| 0| return *this; 124| 0| } 125| 91.9k| if(sLength<-1 || (s==nullptr && sLength!=0)) { ------------------ | Branch (125:8): [True: 0, False: 91.9k] | Branch (125:23): [True: 0, False: 91.9k] | Branch (125:37): [True: 0, False: 0] ------------------ 126| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 127| 0| return *this; 128| 0| } 129| 91.9k| if(sLength<0) { ------------------ | Branch (129:8): [True: 0, False: 91.9k] ------------------ 130| 0| sLength= static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 131| 0| } 132| 91.9k| if(sLength>0) { ------------------ | Branch (132:8): [True: 76.2k, False: 15.6k] ------------------ 133| 76.2k| if(s==(buffer.getAlias()+len)) { ------------------ | Branch (133:12): [True: 16.6k, False: 59.6k] ------------------ 134| | // The caller wrote into the getAppendBuffer(). 135| 16.6k| if(sLength>=(buffer.getCapacity()-len)) { ------------------ | Branch (135:16): [True: 0, False: 16.6k] ------------------ 136| | // The caller wrote too much. 137| 0| errorCode=U_INTERNAL_PROGRAM_ERROR; 138| 16.6k| } else { 139| 16.6k| buffer[len+=sLength]=0; 140| 16.6k| } 141| 59.6k| } else if(buffer.getAlias()<=s && s<(buffer.getAlias()+len) && ------------------ | Branch (141:19): [True: 13.3k, False: 46.2k] | Branch (141:43): [True: 0, False: 13.3k] ------------------ 142| 59.6k| sLength>=(buffer.getCapacity()-len) ------------------ | Branch (142:19): [True: 0, False: 0] ------------------ 143| 59.6k| ) { 144| | // (Part of) this string is appended to itself which requires reallocation, 145| | // so we have to make a copy of the substring and append that. 146| 0| return append(CharString(s, sLength, errorCode), errorCode); 147| 59.6k| } else if(ensureCapacity(len+sLength+1, 0, errorCode)) { ------------------ | Branch (147:19): [True: 59.6k, False: 0] ------------------ 148| 59.6k| uprv_memcpy(buffer.getAlias()+len, s, sLength); ------------------ | | 42| 59.6k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 59.6k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 59.6k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 59.6k| _Pragma("clang diagnostic push") \ | | 45| 59.6k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 59.6k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 59.6k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 59.6k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 59.6k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 59.6k| _Pragma("clang diagnostic pop") \ | | 49| 59.6k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 59.6k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 59.6k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 59.6k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 149| 59.6k| buffer[len+=sLength]=0; 150| 59.6k| } 151| 76.2k| } 152| 91.9k| return *this; 153| 91.9k|} _ZN6icu_7810CharString15getAppendBufferEiiRiR10UErrorCode: 190| 16.8k| UErrorCode &errorCode) { 191| 16.8k| if(U_FAILURE(errorCode)) { ------------------ | Branch (191:8): [True: 0, False: 16.8k] ------------------ 192| 0| resultCapacity=0; 193| 0| return nullptr; 194| 0| } 195| 16.8k| int32_t appendCapacity=buffer.getCapacity()-len-1; // -1 for NUL 196| 16.8k| if(appendCapacity>=minCapacity) { ------------------ | Branch (196:8): [True: 16.7k, False: 90] ------------------ 197| 16.7k| resultCapacity=appendCapacity; 198| 16.7k| return buffer.getAlias()+len; 199| 16.7k| } 200| 90| if(ensureCapacity(len+minCapacity+1, len+desiredCapacityHint+1, errorCode)) { ------------------ | Branch (200:8): [True: 90, False: 0] ------------------ 201| 90| resultCapacity=buffer.getCapacity()-len-1; 202| 90| return buffer.getAlias()+len; 203| 90| } 204| 0| resultCapacity=0; 205| 0| return nullptr; 206| 90|} _ZN6icu_7810CharString20appendInvariantCharsERKNS_13UnicodeStringER10UErrorCode: 208| 39.5k|CharString &CharString::appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode) { 209| 39.5k| return appendInvariantChars(s.getBuffer(), s.length(), errorCode); 210| 39.5k|} _ZN6icu_7810CharString20appendInvariantCharsEPKDsiR10UErrorCode: 212| 39.5k|CharString &CharString::appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode &errorCode) { 213| 39.5k| if(U_FAILURE(errorCode)) { ------------------ | Branch (213:8): [True: 0, False: 39.5k] ------------------ 214| 0| return *this; 215| 0| } 216| 39.5k| if (!uprv_isInvariantUString(uchars, ucharsLen)) { ------------------ | | 1518| 39.5k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 39.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 39.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 39.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (216:9): [True: 13, False: 39.5k] ------------------ 217| 13| errorCode = U_INVARIANT_CONVERSION_ERROR; 218| 13| return *this; 219| 13| } 220| 39.5k| if(ensureCapacity(len+ucharsLen+1, 0, errorCode)) { ------------------ | Branch (220:8): [True: 39.5k, False: 0] ------------------ 221| 39.5k| u_UCharsToChars(uchars, buffer.getAlias()+len, ucharsLen); ------------------ | | 211| 39.5k|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 123| 39.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 39.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 39.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 222| 39.5k| len += ucharsLen; 223| 39.5k| buffer[len] = 0; 224| 39.5k| } 225| 39.5k| return *this; 226| 39.5k|} _ZN6icu_7810CharString14ensureCapacityEiiR10UErrorCode: 230| 151k| UErrorCode &errorCode) { 231| 151k| if(U_FAILURE(errorCode)) { ------------------ | Branch (231:8): [True: 0, False: 151k] ------------------ 232| 0| return false; 233| 0| } 234| 151k| if(capacity>buffer.getCapacity()) { ------------------ | Branch (234:8): [True: 1.62k, False: 150k] ------------------ 235| 1.62k| if(desiredCapacityHint==0) { ------------------ | Branch (235:12): [True: 1.53k, False: 90] ------------------ 236| 1.53k| desiredCapacityHint=capacity+buffer.getCapacity(); 237| 1.53k| } 238| 1.62k| if( (desiredCapacityHint<=capacity || buffer.resize(desiredCapacityHint, len+1)==nullptr) && ------------------ | Branch (238:14): [True: 90, False: 1.53k] | Branch (238:47): [True: 0, False: 1.53k] ------------------ 239| 1.62k| buffer.resize(capacity, len+1)==nullptr ------------------ | Branch (239:13): [True: 0, False: 90] ------------------ 240| 1.62k| ) { 241| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 242| 0| return false; 243| 0| } 244| 1.62k| } 245| 151k| return true; 246| 151k|} _ZN6icu_7810CharStringC2Ev: 43| 234k| CharString() : len(0) { buffer[0]=0; } _ZN6icu_7810CharString4dataEv: 85| 105k| char *data() { return buffer.getAlias(); } _ZNK6icu_7810CharString6lengthEv: 80| 66.3k| int32_t length() const { return len; } _ZNK6icu_7810CharStringixEi: 81| 4.75k| char operator[](int32_t index) const { return buffer[index]; } _ZN6icu_7810CharStringD2Ev: 56| 258k| ~CharString() {} _ZN6icu_7810CharStringC2ENS_11StringPieceER10UErrorCode: 44| 1.80k| CharString(StringPiece s, UErrorCode &errorCode) : len(0) { 45| 1.80k| buffer[0]=0; 46| 1.80k| append(s, errorCode); 47| 1.80k| } _ZN6icu_7810CharStringC2EPKciR10UErrorCode: 52| 18.2k| CharString(const char *s, int32_t sLength, UErrorCode &errorCode) : len(0) { 53| 18.2k| buffer[0]=0; 54| 18.2k| append(s, sLength, errorCode); 55| 18.2k| } _ZNK6icu_7810CharString7isEmptyEv: 79| 100k| UBool isEmpty() const { return len==0; } _ZNK6icu_7810CharString13toStringPieceEv: 82| 4.98k| StringPiece toStringPiece() const { return StringPiece(buffer.getAlias(), len); } _ZNK6icu_7810CharString4dataEv: 84| 10.6k| const char *data() const { return buffer.getAlias(); } _ZNK6icu_7810CharStringeqERKS0_: 108| 2.02k| bool operator==(const CharString& other) const { 109| 2.02k| return len == other.length() && (len == 0 || uprv_memcmp(data(), other.data(), len) == 0); ------------------ | | 101| 876|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 876|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (109:16): [True: 876, False: 1.14k] | Branch (109:42): [True: 0, False: 876] | Branch (109:54): [True: 549, False: 327] ------------------ 110| 2.02k| } _ZNK6icu_7810CharStringeqENS_11StringPieceE: 115| 10| bool operator==(StringPiece other) const { 116| 10| return len == other.length() && (len == 0 || uprv_memcmp(data(), other.data(), len) == 0); ------------------ | | 101| 3|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (116:16): [True: 3, False: 7] | Branch (116:42): [True: 0, False: 3] | Branch (116:54): [True: 0, False: 3] ------------------ 117| 10| } _ZN6icu_7810CharString5clearEv: 127| 9.54k| CharString &clear() { len=0; buffer[0]=0; return *this; } _ZN6icu_7810CharString6appendENS_11StringPieceER10UErrorCode: 131| 14.8k| CharString &append(StringPiece s, UErrorCode &errorCode) { 132| 14.8k| return append(s.data(), s.length(), errorCode); 133| 14.8k| } _ZN6icu_7810CharString6appendERKS0_R10UErrorCode: 134| 7.63k| CharString &append(const CharString &s, UErrorCode &errorCode) { 135| 7.63k| return append(s.data(), s.length(), errorCode); 136| 7.63k| } uprv_malloc_78: 45| 340M|uprv_malloc(size_t s) { 46| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 47| |#if 1 48| | putchar('>'); 49| | fflush(stdout); 50| |#else 51| | fprintf(stderr,"MALLOC\t#%d\t%ul bytes\t%ul total\n", ++n,s,(b+=s)); fflush(stderr); 52| |#endif 53| |#endif 54| 340M| if (s > 0) { ------------------ | Branch (54:9): [True: 340M, False: 0] ------------------ 55| 340M| if (pAlloc) { ------------------ | Branch (55:13): [True: 0, False: 340M] ------------------ 56| 0| return (*pAlloc)(pContext, s); 57| 340M| } else { 58| 340M| return uprv_default_malloc(s); ------------------ | | 615| 340M|# define uprv_default_malloc(x) malloc(x) ------------------ 59| 340M| } 60| 340M| } else { 61| 0| return (void *)zeroMem; 62| 0| } 63| 340M|} uprv_realloc_78: 66| 105k|uprv_realloc(void * buffer, size_t size) { 67| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 68| | putchar('~'); 69| | fflush(stdout); 70| |#endif 71| 105k| if (buffer == zeroMem) { ------------------ | Branch (71:9): [True: 0, False: 105k] ------------------ 72| 0| return uprv_malloc(size); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 73| 105k| } else if (size == 0) { ------------------ | Branch (73:16): [True: 0, False: 105k] ------------------ 74| 0| if (pFree) { ------------------ | Branch (74:13): [True: 0, False: 0] ------------------ 75| 0| (*pFree)(pContext, buffer); 76| 0| } else { 77| 0| uprv_default_free(buffer); ------------------ | | 617| 0|# define uprv_default_free(x) free(x) ------------------ 78| 0| } 79| 0| return (void *)zeroMem; 80| 105k| } else { 81| 105k| if (pRealloc) { ------------------ | Branch (81:13): [True: 0, False: 105k] ------------------ 82| 0| return (*pRealloc)(pContext, buffer, size); 83| 105k| } else { 84| 105k| return uprv_default_realloc(buffer, size); ------------------ | | 616| 105k|# define uprv_default_realloc(x,y) realloc(x,y) ------------------ 85| 105k| } 86| 105k| } 87| 105k|} uprv_free_78: 90| 358M|uprv_free(void *buffer) { 91| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 92| | putchar('<'); 93| | fflush(stdout); 94| |#endif 95| 358M| if (buffer != zeroMem) { ------------------ | Branch (95:9): [True: 358M, False: 0] ------------------ 96| 358M| if (pFree) { ------------------ | Branch (96:13): [True: 0, False: 358M] ------------------ 97| 0| (*pFree)(pContext, buffer); 98| 358M| } else { 99| 358M| uprv_default_free(buffer); ------------------ | | 617| 358M|# define uprv_default_free(x) free(x) ------------------ 100| 358M| } 101| 358M| } 102| 358M|} _ZN6icu_7815MaybeStackArrayIlLi40EEC2Ev: 344| 5.84M| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZNK6icu_7815MaybeStackArrayIlLi40EEixEl: 395| 78.5M| const T &operator[](ptrdiff_t i) const { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIlLi40EE12releaseArrayEv: 458| 5.84M| void releaseArray() { 459| 5.84M| if(needToRelease) { ------------------ | Branch (459:12): [True: 1.73k, False: 5.84M] ------------------ 460| 1.73k| uprv_free(ptr); ------------------ | | 1503| 1.73k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.73k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.73k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.73k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1.73k| } 462| 5.84M| } _ZN6icu_7815MaybeStackArrayIlLi40EEixEl: 402| 81.8M| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EEC2Ev: 344| 254k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7815MaybeStackArrayIcLi40EED2Ev: 363| 258k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayIcLi40EEC2EOS1_: 479| 4.87k| : ptr(src.ptr), capacity(src.capacity), needToRelease(src.needToRelease) { 480| 4.87k| if (src.ptr == src.stackArray) { ------------------ | Branch (480:9): [True: 4.87k, False: 0] ------------------ 481| 4.87k| ptr = stackArray; 482| 4.87k| uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity); ------------------ | | 42| 4.87k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.87k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 4.87k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 4.87k| _Pragma("clang diagnostic push") \ | | 45| 4.87k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 4.87k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4.87k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 4.87k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4.87k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 4.87k| _Pragma("clang diagnostic pop") \ | | 49| 4.87k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 4.87k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 4.87k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.87k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 483| 4.87k| } else { 484| 0| src.resetToStackArray(); // take ownership away from src 485| 0| } 486| 4.87k|} _ZNK6icu_7815MaybeStackArrayIcLi40EE11getCapacityEv: 376| 186k| int32_t getCapacity() const { return capacity; } _ZNK6icu_7815MaybeStackArrayIcLi40EE8getAliasEv: 381| 386k| T *getAlias() const { return ptr; } _ZNK6icu_7815MaybeStackArrayIcLi40EEixEl: 395| 4.75k| const T &operator[](ptrdiff_t i) const { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EEixEl: 402| 484k| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EE6resizeEii: 505| 1.62k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 1.62k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 1.62k, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 1.62k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 1.62k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.62k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.62k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.62k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 1.62k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 1.62k, False: 0] ------------------ 512| 1.62k| if(length>0) { ------------------ | Branch (512:16): [True: 1.62k, False: 0] ------------------ 513| 1.62k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 1.62k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 1.62k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 1.62k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 1.62k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 1.62k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.62k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.62k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.62k| _Pragma("clang diagnostic push") \ | | 45| 1.62k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.62k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.62k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.62k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.62k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.62k| _Pragma("clang diagnostic pop") \ | | 49| 1.62k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.62k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.62k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.62k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 1.62k| } 521| 1.62k| releaseArray(); 522| 1.62k| ptr=p; 523| 1.62k| capacity=newCapacity; 524| 1.62k| needToRelease=true; 525| 1.62k| } 526| 1.62k| return p; 527| 1.62k| } else { 528| 0| return nullptr; 529| 0| } 530| 1.62k|} _ZN6icu_7815MaybeStackArrayIcLi40EE12releaseArrayEv: 458| 259k| void releaseArray() { 459| 259k| if(needToRelease) { ------------------ | Branch (459:12): [True: 1.62k, False: 258k] ------------------ 460| 1.62k| uprv_free(ptr); ------------------ | | 1503| 1.62k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.62k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.62k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.62k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1.62k| } 462| 259k| } _ZN6icu_7815MaybeStackArrayIlLi40EED2Ev: 363| 5.84M| ~MaybeStackArray() { releaseArray(); } _ZNK6icu_7815MaybeStackArrayIlLi40EE11getCapacityEv: 376| 8.52M| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIlLi40EE6resizeEii: 505| 1.73k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 1.73k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 1.73k, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 1.73k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 1.73k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.73k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.73k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.73k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 1.73k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 1.73k, False: 0] ------------------ 512| 1.73k| if(length>0) { ------------------ | Branch (512:16): [True: 1.73k, False: 0] ------------------ 513| 1.73k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 1.73k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 1.73k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 1.73k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 1.73k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 1.73k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.73k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.73k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.73k| _Pragma("clang diagnostic push") \ | | 45| 1.73k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.73k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.73k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.73k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.73k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.73k| _Pragma("clang diagnostic pop") \ | | 49| 1.73k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.73k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.73k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.73k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 1.73k| } 521| 1.73k| releaseArray(); 522| 1.73k| ptr=p; 523| 1.73k| capacity=newCapacity; 524| 1.73k| needToRelease=true; 525| 1.73k| } 526| 1.73k| return p; 527| 1.73k| } else { 528| 0| return nullptr; 529| 0| } 530| 1.73k|} _ZN6icu_7815MaybeStackArrayIhLi40EEC2Ev: 344| 32.7k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZNK6icu_7815MaybeStackArrayIhLi40EE11getCapacityEv: 376| 2.32M| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIhLi40EE6resizeEii: 505| 4.84k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 4.84k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 4.84k, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 4.84k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 4.84k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4.84k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.84k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.84k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 4.84k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 4.84k, False: 0] ------------------ 512| 4.84k| if(length>0) { ------------------ | Branch (512:16): [True: 4.84k, False: 0] ------------------ 513| 4.84k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 4.84k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 4.84k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 4.84k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 4.84k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 4.84k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.84k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 4.84k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 4.84k| _Pragma("clang diagnostic push") \ | | 45| 4.84k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 4.84k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4.84k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 4.84k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4.84k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 4.84k| _Pragma("clang diagnostic pop") \ | | 49| 4.84k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 4.84k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 4.84k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.84k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 4.84k| } 521| 4.84k| releaseArray(); 522| 4.84k| ptr=p; 523| 4.84k| capacity=newCapacity; 524| 4.84k| needToRelease=true; 525| 4.84k| } 526| 4.84k| return p; 527| 4.84k| } else { 528| 0| return nullptr; 529| 0| } 530| 4.84k|} _ZN6icu_7815MaybeStackArrayIhLi40EE12releaseArrayEv: 458| 37.6k| void releaseArray() { 459| 37.6k| if(needToRelease) { ------------------ | Branch (459:12): [True: 4.84k, False: 32.7k] ------------------ 460| 4.84k| uprv_free(ptr); ------------------ | | 1503| 4.84k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 4.84k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.84k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.84k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 4.84k| } 462| 37.6k| } _ZN6icu_7815MaybeStackArrayIhLi40EEixEl: 402| 2.40M| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZNK6icu_7815MaybeStackArrayIhLi40EE8getAliasEv: 381| 17.1k| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayIhLi40EED2Ev: 363| 32.7k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayI11max_align_tLi7EEC2Ev: 344| 527k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZNK6icu_7815MaybeStackArrayI11max_align_tLi7EE11getCapacityEv: 376| 527k| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi7EE12releaseArrayEv: 458| 527k| void releaseArray() { 459| 527k| if(needToRelease) { ------------------ | Branch (459:12): [True: 0, False: 527k] ------------------ 460| 0| uprv_free(ptr); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 0| } 462| 527k| } _ZNK6icu_7815MaybeStackArrayI11max_align_tLi7EE8getAliasEv: 381| 527k| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi7EED2Ev: 363| 527k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayI11max_align_tLi14EEC2Ev: 344| 392k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZNK6icu_7815MaybeStackArrayI11max_align_tLi14EE11getCapacityEv: 376| 392k| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi14EE12releaseArrayEv: 458| 392k| void releaseArray() { 459| 392k| if(needToRelease) { ------------------ | Branch (459:12): [True: 0, False: 392k] ------------------ 460| 0| uprv_free(ptr); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 0| } 462| 392k| } _ZNK6icu_7815MaybeStackArrayI11max_align_tLi14EE8getAliasEv: 381| 785k| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi14EED2Ev: 363| 392k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EEixEl: 402| 37| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EE12releaseArrayEv: 458| 2| void releaseArray() { 459| 2| if(needToRelease) { ------------------ | Branch (459:12): [True: 1, False: 1] ------------------ 460| 1| uprv_free(ptr); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1| } 462| 2| } _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EEixEl: 402| 1.05k| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EE12releaseArrayEv: 458| 7| void releaseArray() { 459| 7| if(needToRelease) { ------------------ | Branch (459:12): [True: 6, False: 1] ------------------ 460| 6| uprv_free(ptr); ------------------ | | 1503| 6|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 6|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 6| } 462| 7| } _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EEixEl: 402| 178| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EE12releaseArrayEv: 458| 4| void releaseArray() { 459| 4| if(needToRelease) { ------------------ | Branch (459:12): [True: 3, False: 1] ------------------ 460| 3| uprv_free(ptr); ------------------ | | 1503| 3|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 3| } 462| 4| } _ZN6icu_7810MemoryPoolINS_10CharStringELi8EED2Ev: 762| 1.47k| ~MemoryPool() { 763| 4.36k| for (int32_t i = 0; i < fCount; ++i) { ------------------ | Branch (763:29): [True: 2.88k, False: 1.47k] ------------------ 764| 2.88k| delete fPool[i]; 765| 2.88k| } 766| 1.47k| } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EEixEl: 402| 6.83k| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EED2Ev: 363| 1.47k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EE12releaseArrayEv: 458| 1.56k| void releaseArray() { 459| 1.56k| if(needToRelease) { ------------------ | Branch (459:12): [True: 91, False: 1.47k] ------------------ 460| 91| uprv_free(ptr); ------------------ | | 1503| 91|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 91|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 91|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 91|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 91| } 462| 1.56k| } _ZN6icu_7810MemoryPoolINS_10CharStringELi8EEC2Ev: 760| 1.47k| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EEC2Ev: 344| 1.47k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolI13LocExtKeyDataLi8EEC2Ev: 760| 1| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EEC2Ev: 344| 1| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolI10LocExtTypeLi8EEC2Ev: 760| 1| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EEC2Ev: 344| 1| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolI9TypeAliasLi8EEC2Ev: 760| 1| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EEC2Ev: 344| 1| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolINS_10CharStringELi8EE6createIJEEEPS1_DpOT_: 796| 593| T* create(Args&&... args) { 797| 593| int32_t capacity = fPool.getCapacity(); 798| 593| if (fCount == capacity && ------------------ | Branch (798:13): [True: 5, False: 588] ------------------ 799| 593| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 5] | Branch (799:26): [True: 1, False: 4] ------------------ 800| 5| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 593| return fPool[fCount++] = new T(std::forward(args)...); 804| 593| } _ZNK6icu_7815MaybeStackArrayIPNS_10CharStringELi8EE11getCapacityEv: 376| 3.94k| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EE6resizeEii: 505| 92|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 92| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 92, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 92| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 92|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 92|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 92|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 92|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 92| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 92, False: 0] ------------------ 512| 92| if(length>0) { ------------------ | Branch (512:16): [True: 92, False: 0] ------------------ 513| 92| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 92] ------------------ 514| 0| length=capacity; 515| 0| } 516| 92| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 92] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 92| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 92|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 92|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 92| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 92| _Pragma("clang diagnostic push") \ | | 45| 92| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 92| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 92|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 92| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 92|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 92| _Pragma("clang diagnostic pop") \ | | 49| 92| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 92|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 92|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 92|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 92| } 521| 92| releaseArray(); 522| 92| ptr=p; 523| 92| capacity=newCapacity; 524| 92| needToRelease=true; 525| 92| } 526| 92| return p; 527| 92| } else { 528| 0| return nullptr; 529| 0| } 530| 92|} _ZN6icu_7810MemoryPoolINS_10CharStringELi8EE6createIJRPKcR10UErrorCodeEEEPS1_DpOT_: 796| 556| T* create(Args&&... args) { 797| 556| int32_t capacity = fPool.getCapacity(); 798| 556| if (fCount == capacity && ------------------ | Branch (798:13): [True: 2, False: 554] ------------------ 799| 556| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 2] | Branch (799:26): [True: 0, False: 2] ------------------ 800| 2| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 556| return fPool[fCount++] = new T(std::forward(args)...); 804| 556| } _ZN6icu_7810MemoryPoolI10LocExtTypeLi8EE6createIJEEEPS1_DpOT_: 796| 1.05k| T* create(Args&&... args) { 797| 1.05k| int32_t capacity = fPool.getCapacity(); 798| 1.05k| if (fCount == capacity && ------------------ | Branch (798:13): [True: 7, False: 1.04k] ------------------ 799| 1.05k| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 7] | Branch (799:26): [True: 1, False: 6] ------------------ 800| 7| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 1.05k| return fPool[fCount++] = new T(std::forward(args)...); 804| 1.05k| } _ZNK6icu_7815MaybeStackArrayIP10LocExtTypeLi8EE11getCapacityEv: 376| 1.05k| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EE6resizeEii: 505| 7|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 7| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 7, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 7| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 7|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 7| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 7, False: 0] ------------------ 512| 7| if(length>0) { ------------------ | Branch (512:16): [True: 7, False: 0] ------------------ 513| 7| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 7] ------------------ 514| 0| length=capacity; 515| 0| } 516| 7| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 7] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 7| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 7|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 7|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 7| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 7| _Pragma("clang diagnostic push") \ | | 45| 7| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 7| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 7|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 7| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 7|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 7| _Pragma("clang diagnostic pop") \ | | 49| 7| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 7|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 7|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 7| } 521| 7| releaseArray(); 522| 7| ptr=p; 523| 7| capacity=newCapacity; 524| 7| needToRelease=true; 525| 7| } 526| 7| return p; 527| 7| } else { 528| 0| return nullptr; 529| 0| } 530| 7|} _ZN6icu_7810MemoryPoolI9TypeAliasLi8EE6createIJS1_EEEPS1_DpOT_: 796| 178| T* create(Args&&... args) { 797| 178| int32_t capacity = fPool.getCapacity(); 798| 178| if (fCount == capacity && ------------------ | Branch (798:13): [True: 4, False: 174] ------------------ 799| 178| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 4] | Branch (799:26): [True: 1, False: 3] ------------------ 800| 4| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 178| return fPool[fCount++] = new T(std::forward(args)...); 804| 178| } _ZNK6icu_7815MaybeStackArrayIP9TypeAliasLi8EE11getCapacityEv: 376| 178| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EE6resizeEii: 505| 4|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 4| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 4, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 4| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 4|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 4| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 4, False: 0] ------------------ 512| 4| if(length>0) { ------------------ | Branch (512:16): [True: 4, False: 0] ------------------ 513| 4| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 4] ------------------ 514| 0| length=capacity; 515| 0| } 516| 4| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 4] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 4| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 4|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 4| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 4| _Pragma("clang diagnostic push") \ | | 45| 4| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 4| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 4| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 4| _Pragma("clang diagnostic pop") \ | | 49| 4| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 4|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 4| } 521| 4| releaseArray(); 522| 4| ptr=p; 523| 4| capacity=newCapacity; 524| 4| needToRelease=true; 525| 4| } 526| 4| return p; 527| 4| } else { 528| 0| return nullptr; 529| 0| } 530| 4|} _ZN6icu_7810MemoryPoolI13LocExtKeyDataLi8EE6createIJEEEPS1_DpOT_: 796| 37| T* create(Args&&... args) { 797| 37| int32_t capacity = fPool.getCapacity(); 798| 37| if (fCount == capacity && ------------------ | Branch (798:13): [True: 2, False: 35] ------------------ 799| 37| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 2] | Branch (799:26): [True: 1, False: 1] ------------------ 800| 2| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 37| return fPool[fCount++] = new T(std::forward(args)...); 804| 37| } _ZNK6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EE11getCapacityEv: 376| 37| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EE6resizeEii: 505| 2|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 2| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 2, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 2| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 2|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 2| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 2, False: 0] ------------------ 512| 2| if(length>0) { ------------------ | Branch (512:16): [True: 2, False: 0] ------------------ 513| 2| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 2] ------------------ 514| 0| length=capacity; 515| 0| } 516| 2| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 2] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 2| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 2|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2| _Pragma("clang diagnostic push") \ | | 45| 2| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2| _Pragma("clang diagnostic pop") \ | | 49| 2| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 2| } 521| 2| releaseArray(); 522| 2| ptr=p; 523| 2| capacity=newCapacity; 524| 2| needToRelease=true; 525| 2| } 526| 2| return p; 527| 2| } else { 528| 0| return nullptr; 529| 0| } 530| 2|} uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118AttributeListEntryELi8EEC2Ev: 760| 573| MemoryPool() : fCount(0), fPool() {} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EEC2Ev: 344| 573| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118ExtensionListEntryELi8EEC2Ev: 760| 902| MemoryPool() : fCount(0), fPool() {} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EEC2Ev: 344| 902| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118AttributeListEntryELi8EE6createIJEEEPS2_DpOT_: 796| 755| T* create(Args&&... args) { 797| 755| int32_t capacity = fPool.getCapacity(); 798| 755| if (fCount == capacity && ------------------ | Branch (798:13): [True: 30, False: 725] ------------------ 799| 755| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 30] | Branch (799:26): [True: 21, False: 9] ------------------ 800| 30| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 755| return fPool[fCount++] = new T(std::forward(args)...); 804| 755| } uloc_tag.cpp:_ZNK6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EE11getCapacityEv: 376| 755| int32_t getCapacity() const { return capacity; } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EE6resizeEii: 505| 30|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 30| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 30, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 30| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 30|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 30|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 30|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 30|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 30| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 30, False: 0] ------------------ 512| 30| if(length>0) { ------------------ | Branch (512:16): [True: 30, False: 0] ------------------ 513| 30| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 30] ------------------ 514| 0| length=capacity; 515| 0| } 516| 30| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 30] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 30| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 30|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 30|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 30| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 30| _Pragma("clang diagnostic push") \ | | 45| 30| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 30| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 30|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 30| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 30|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 30| _Pragma("clang diagnostic pop") \ | | 49| 30| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 30|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 30|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 30|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 30| } 521| 30| releaseArray(); 522| 30| ptr=p; 523| 30| capacity=newCapacity; 524| 30| needToRelease=true; 525| 30| } 526| 30| return p; 527| 30| } else { 528| 0| return nullptr; 529| 0| } 530| 30|} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EE12releaseArrayEv: 458| 603| void releaseArray() { 459| 603| if(needToRelease) { ------------------ | Branch (459:12): [True: 30, False: 573] ------------------ 460| 30| uprv_free(ptr); ------------------ | | 1503| 30|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 30|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 30|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 30|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 30| } 462| 603| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EEixEl: 402| 1.51k| T &operator[](ptrdiff_t i) { return ptr[i]; } uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118ExtensionListEntryELi8EE6createIJEEEPS2_DpOT_: 796| 2.99k| T* create(Args&&... args) { 797| 2.99k| int32_t capacity = fPool.getCapacity(); 798| 2.99k| if (fCount == capacity && ------------------ | Branch (798:13): [True: 71, False: 2.92k] ------------------ 799| 2.99k| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 71] | Branch (799:26): [True: 43, False: 28] ------------------ 800| 71| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 2.99k| return fPool[fCount++] = new T(std::forward(args)...); 804| 2.99k| } uloc_tag.cpp:_ZNK6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EE11getCapacityEv: 376| 2.99k| int32_t getCapacity() const { return capacity; } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EE6resizeEii: 505| 71|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 71| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 71, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 71| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 71|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 71|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 71|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 71|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 71| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 71, False: 0] ------------------ 512| 71| if(length>0) { ------------------ | Branch (512:16): [True: 71, False: 0] ------------------ 513| 71| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 71] ------------------ 514| 0| length=capacity; 515| 0| } 516| 71| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 71] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 71| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 71|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 71|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 71| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 71| _Pragma("clang diagnostic push") \ | | 45| 71| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 71| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 71|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 71| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 71|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 71| _Pragma("clang diagnostic pop") \ | | 49| 71| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 71|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 71|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 71|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 71| } 521| 71| releaseArray(); 522| 71| ptr=p; 523| 71| capacity=newCapacity; 524| 71| needToRelease=true; 525| 71| } 526| 71| return p; 527| 71| } else { 528| 0| return nullptr; 529| 0| } 530| 71|} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EE12releaseArrayEv: 458| 973| void releaseArray() { 459| 973| if(needToRelease) { ------------------ | Branch (459:12): [True: 71, False: 902] ------------------ 460| 71| uprv_free(ptr); ------------------ | | 1503| 71|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 71|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 71|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 71|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 71| } 462| 973| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EEixEl: 402| 5.98k| T &operator[](ptrdiff_t i) { return ptr[i]; } uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118ExtensionListEntryELi8EED2Ev: 762| 902| ~MemoryPool() { 763| 3.89k| for (int32_t i = 0; i < fCount; ++i) { ------------------ | Branch (763:29): [True: 2.99k, False: 902] ------------------ 764| 2.99k| delete fPool[i]; 765| 2.99k| } 766| 902| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EED2Ev: 363| 902| ~MaybeStackArray() { releaseArray(); } uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118AttributeListEntryELi8EED2Ev: 762| 573| ~MemoryPool() { 763| 1.32k| for (int32_t i = 0; i < fCount; ++i) { ------------------ | Branch (763:29): [True: 755, False: 573] ------------------ 764| 755| delete fPool[i]; 765| 755| } 766| 573| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EED2Ev: 363| 573| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7810MemoryPoolINS_10CharStringELi8EE6createIJRPKcRiR10UErrorCodeEEEPS1_DpOT_: 796| 2.79k| T* create(Args&&... args) { 797| 2.79k| int32_t capacity = fPool.getCapacity(); 798| 2.79k| if (fCount == capacity && ------------------ | Branch (798:13): [True: 85, False: 2.71k] ------------------ 799| 2.79k| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 85] | Branch (799:26): [True: 53, False: 32] ------------------ 800| 85| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 2.79k| return fPool[fCount++] = new T(std::forward(args)...); 804| 2.79k| } umutex.cpp:_ZZN6icu_78L9umtx_initEvENK3$_0clEv: 144| 1|#define STATIC_NEW(type) [] () { \ 145| 1| alignas(type) static char storage[sizeof(type)]; \ 146| 1| return new(storage) type();} () umutex.cpp:_ZZN6icu_78L9umtx_initEvENK3$_1clEv: 144| 1|#define STATIC_NEW(type) [] () { \ 145| 1| alignas(type) static char storage[sizeof(type)]; \ 146| 1| return new(storage) type();} () uprv_isASCIILetter_78: 52| 118k|uprv_isASCIILetter(char c) { 53| |#if U_CHARSET_FAMILY==U_EBCDIC_FAMILY 54| | return 55| | ('a'<=c && c<='i') || ('j'<=c && c<='r') || ('s'<=c && c<='z') || 56| | ('A'<=c && c<='I') || ('J'<=c && c<='R') || ('S'<=c && c<='Z'); 57| |#else 58| 118k| return ('a'<=c && c<='z') || ('A'<=c && c<='Z'); ------------------ | Branch (58:13): [True: 91.8k, False: 26.3k] | Branch (58:23): [True: 91.8k, False: 3] | Branch (58:35): [True: 19.7k, False: 6.57k] | Branch (58:45): [True: 19.7k, False: 5] ------------------ 59| 118k|#endif 60| 118k|} uprv_toupper_78: 63| 55.2k|uprv_toupper(char c) { 64| |#if U_CHARSET_FAMILY==U_EBCDIC_FAMILY 65| | if(('a'<=c && c<='i') || ('j'<=c && c<='r') || ('s'<=c && c<='z')) { 66| | c=(char)(c+('A'-'a')); 67| | } 68| |#else 69| 55.2k| if('a'<=c && c<='z') { ------------------ | Branch (69:8): [True: 7.23k, False: 48.0k] | Branch (69:18): [True: 7.14k, False: 90] ------------------ 70| 7.14k| c=(char)(c+('A'-'a')); 71| 7.14k| } 72| 55.2k|#endif 73| 55.2k| return c; 74| 55.2k|} uprv_asciitolower_78: 103| 706k|uprv_asciitolower(char c) { 104| 706k| if(0x41<=c && c<=0x5a) { ------------------ | Branch (104:8): [True: 678k, False: 27.1k] | Branch (104:19): [True: 179k, False: 499k] ------------------ 105| 179k| c=(char)(c+0x20); 106| 179k| } 107| 706k| return c; 108| 706k|} T_CString_toLowerCase_78: 124| 14.3k|{ 125| 14.3k| char* origPtr = str; 126| | 127| 14.3k| if (str) { ------------------ | Branch (127:9): [True: 14.3k, False: 0] ------------------ 128| 14.3k| do 129| 99.8k| *str = uprv_tolower(*str); ------------------ | | 68| 99.8k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 99.8k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 99.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 99.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 99.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 130| 99.8k| while (*(str++)); ------------------ | Branch (130:16): [True: 85.5k, False: 14.3k] ------------------ 131| 14.3k| } 132| | 133| 14.3k| return origPtr; 134| 14.3k|} T_CString_toUpperCase_78: 138| 1.58k|{ 139| 1.58k| char* origPtr = str; 140| | 141| 1.58k| if (str) { ------------------ | Branch (141:9): [True: 1.58k, False: 0] ------------------ 142| 1.58k| do 143| 8.50k| *str = uprv_toupper(*str); ------------------ | | 1547| 8.50k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 8.50k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.50k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.50k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 144| 8.50k| while (*(str++)); ------------------ | Branch (144:16): [True: 6.91k, False: 1.58k] ------------------ 145| 1.58k| } 146| | 147| 1.58k| return origPtr; 148| 1.58k|} uprv_stricmp_78: 235| 43.2k|uprv_stricmp(const char *str1, const char *str2) { 236| 43.2k| if(str1==nullptr) { ------------------ | Branch (236:8): [True: 0, False: 43.2k] ------------------ 237| 0| if(str2==nullptr) { ------------------ | Branch (237:12): [True: 0, False: 0] ------------------ 238| 0| return 0; 239| 0| } else { 240| 0| return -1; 241| 0| } 242| 43.2k| } else if(str2==nullptr) { ------------------ | Branch (242:15): [True: 0, False: 43.2k] ------------------ 243| 0| return 1; 244| 43.2k| } else { 245| | /* compare non-nullptr strings lexically with lowercase */ 246| 43.2k| int rc; 247| 43.2k| unsigned char c1, c2; 248| | 249| 45.3k| for(;;) { 250| 45.3k| c1=(unsigned char)*str1; 251| 45.3k| c2=(unsigned char)*str2; 252| 45.3k| if(c1==0) { ------------------ | Branch (252:16): [True: 0, False: 45.3k] ------------------ 253| 0| if(c2==0) { ------------------ | Branch (253:20): [True: 0, False: 0] ------------------ 254| 0| return 0; 255| 0| } else { 256| 0| return -1; 257| 0| } 258| 45.3k| } else if(c2==0) { ------------------ | Branch (258:23): [True: 0, False: 45.3k] ------------------ 259| 0| return 1; 260| 45.3k| } else { 261| | /* compare non-zero characters with lowercase */ 262| 45.3k| rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2); ------------------ | | 68| 45.3k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 45.3k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 45.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 45.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 45.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2); ------------------ | | 68| 45.3k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 45.3k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 45.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 45.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 45.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 263| 45.3k| if(rc!=0) { ------------------ | Branch (263:20): [True: 43.2k, False: 2.10k] ------------------ 264| 43.2k| return rc; 265| 43.2k| } 266| 45.3k| } 267| 2.10k| ++str1; 268| 2.10k| ++str2; 269| 2.10k| } 270| 43.2k| } 271| 43.2k|} uprv_strnicmp_78: 274| 143k|uprv_strnicmp(const char *str1, const char *str2, uint32_t n) { 275| 143k| if(str1==nullptr) { ------------------ | Branch (275:8): [True: 0, False: 143k] ------------------ 276| 0| if(str2==nullptr) { ------------------ | Branch (276:12): [True: 0, False: 0] ------------------ 277| 0| return 0; 278| 0| } else { 279| 0| return -1; 280| 0| } 281| 143k| } else if(str2==nullptr) { ------------------ | Branch (281:15): [True: 0, False: 143k] ------------------ 282| 0| return 1; 283| 143k| } else { 284| | /* compare non-nullptr strings lexically with lowercase */ 285| 143k| int rc; 286| 143k| unsigned char c1, c2; 287| | 288| 155k| for(; n--;) { ------------------ | Branch (288:15): [True: 155k, False: 144] ------------------ 289| 155k| c1=(unsigned char)*str1; 290| 155k| c2=(unsigned char)*str2; 291| 155k| if(c1==0) { ------------------ | Branch (291:16): [True: 0, False: 155k] ------------------ 292| 0| if(c2==0) { ------------------ | Branch (292:20): [True: 0, False: 0] ------------------ 293| 0| return 0; 294| 0| } else { 295| 0| return -1; 296| 0| } 297| 155k| } else if(c2==0) { ------------------ | Branch (297:23): [True: 565, False: 154k] ------------------ 298| 565| return 1; 299| 154k| } else { 300| | /* compare non-zero characters with lowercase */ 301| 154k| rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2); ------------------ | | 68| 154k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 154k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 154k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 154k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 154k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2); ------------------ | | 68| 154k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 154k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 154k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 154k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 154k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 302| 154k| if(rc!=0) { ------------------ | Branch (302:20): [True: 143k, False: 11.7k] ------------------ 303| 143k| return rc; 304| 143k| } 305| 154k| } 306| 11.7k| ++str1; 307| 11.7k| ++str2; 308| 11.7k| } 309| 143k| } 310| | 311| 144| return 0; 312| 143k|} uprv_strdup_78: 315| 706|uprv_strdup(const char *src) { 316| 706| size_t len = uprv_strlen(src) + 1; ------------------ | | 37| 706|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 706|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 317| 706| char *dup = (char *) uprv_malloc(len); ------------------ | | 1524| 706|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 706|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 706|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 706|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 318| | 319| 706| if (dup) { ------------------ | Branch (319:9): [True: 706, False: 0] ------------------ 320| 706| uprv_memcpy(dup, src, len); ------------------ | | 42| 706|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 706|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 706| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 706| _Pragma("clang diagnostic push") \ | | 45| 706| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 706| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 706|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 706| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 706|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 706| _Pragma("clang diagnostic pop") \ | | 49| 706| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 706|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 706|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 706|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 321| 706| } 322| | 323| 706| return dup; 324| 706|} _ZN6icu_789HashtableD2Ev: 190| 56.9M|inline Hashtable::~Hashtable() { 191| 56.9M| if (hash != nullptr) { ------------------ | Branch (191:9): [True: 56.9M, False: 26.7k] ------------------ 192| 56.9M| uhash_close(hash); ------------------ | | 991| 56.9M|#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 193| 56.9M| } 194| 56.9M|} _ZN6icu_789HashtableC2ER10UErrorCode: 178| 56.9M| : hash(nullptr) 179| 56.9M|{ 180| 56.9M| init(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, status); ------------------ | | 1017| 56.9M|#define uhash_hashUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hashUnicodeString) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ init(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, status); ------------------ | | 999| 56.9M|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 181| 56.9M|} _ZN6icu_789Hashtable4initEPFi8UElementEPFaS1_S1_ES5_R10UErrorCode: 127| 56.9M| UValueComparator *valueComp, UErrorCode& status) { 128| 56.9M| if (U_FAILURE(status)) { ------------------ | Branch (128:9): [True: 26.7k, False: 56.9M] ------------------ 129| 26.7k| return; 130| 26.7k| } 131| 56.9M| uhash_init(&hashObj, keyHash, keyComp, valueComp, &status); ------------------ | | 1022| 56.9M|#define uhash_init U_ICU_ENTRY_POINT_RENAME(uhash_init) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 132| 56.9M| if (U_SUCCESS(status)) { ------------------ | Branch (132:9): [True: 56.9M, False: 0] ------------------ 133| 56.9M| hash = &hashObj; 134| 56.9M| uhash_setKeyDeleter(hash, uprv_deleteUObject); ------------------ | | 1040| 56.9M|#define uhash_setKeyDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setKeyDeleter) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ uhash_setKeyDeleter(hash, uprv_deleteUObject); ------------------ | | 1489| 56.9M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 135| 56.9M| } 136| 56.9M|} _ZN6icu_789Hashtable3putERKNS_13UnicodeStringEPvR10UErrorCode: 204| 60.2M|inline void* Hashtable::put(const UnicodeString& key, void* value, UErrorCode& status) { 205| 60.2M| return uhash_put(hash, new UnicodeString(key), value, &status); ------------------ | | 1032| 60.2M|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 60.2M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 60.2M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 60.2M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 206| 60.2M|} _ZN6icu_789Hashtable15setValueDeleterEPFvPvE: 196| 56.9M|inline UObjectDeleter *Hashtable::setValueDeleter(UObjectDeleter *fn) { 197| 56.9M| return uhash_setValueDeleter(hash, fn); ------------------ | | 1044| 56.9M|#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDeleter) | | ------------------ | | | | 123| 56.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 56.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 56.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 198| 56.9M|} _ZNK6icu_789Hashtable5countEv: 200| 8.88M|inline int32_t Hashtable::count() const { 201| 8.88M| return uhash_count(hash); ------------------ | | 1001| 8.88M|#define uhash_count U_ICU_ENTRY_POINT_RENAME(uhash_count) | | ------------------ | | | | 123| 8.88M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.88M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.88M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 202| 8.88M|} _ZNK6icu_789Hashtable11nextElementERi: 245| 94.0M|inline const UHashElement* Hashtable::nextElement(int32_t& pos) const { 246| 94.0M| return uhash_nextElement(hash, &pos); ------------------ | | 1029| 94.0M|#define uhash_nextElement U_ICU_ENTRY_POINT_RENAME(uhash_nextElement) | | ------------------ | | | | 123| 94.0M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 94.0M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 94.0M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 94.0M|} _ZN6icu_789Hashtable9removeAllEv: 249| 22.3M|inline void Hashtable::removeAll() { 250| 22.3M| uhash_removeAll(hash); ------------------ | | 1036| 22.3M|#define uhash_removeAll U_ICU_ENTRY_POINT_RENAME(uhash_removeAll) | | ------------------ | | | | 123| 22.3M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 22.3M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 22.3M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 251| 22.3M|} _ZN6icu_7818Normalizer2Factory11getInstanceE18UNormalizationModeR10UErrorCode: 367| 1.90M|Normalizer2Factory::getInstance(UNormalizationMode mode, UErrorCode &errorCode) { 368| 1.90M| if(U_FAILURE(errorCode)) { ------------------ | Branch (368:8): [True: 0, False: 1.90M] ------------------ 369| 0| return nullptr; 370| 0| } 371| 1.90M| switch(mode) { 372| 1.90M| case UNORM_NFD: ------------------ | Branch (372:5): [True: 1.90M, False: 0] ------------------ 373| 1.90M| return Normalizer2::getNFDInstance(errorCode); 374| 0| case UNORM_NFKD: ------------------ | Branch (374:5): [True: 0, False: 1.90M] ------------------ 375| 0| return Normalizer2::getNFKDInstance(errorCode); 376| 0| case UNORM_NFC: ------------------ | Branch (376:5): [True: 0, False: 1.90M] ------------------ 377| 0| return Normalizer2::getNFCInstance(errorCode); 378| 0| case UNORM_NFKC: ------------------ | Branch (378:5): [True: 0, False: 1.90M] ------------------ 379| 0| return Normalizer2::getNFKCInstance(errorCode); 380| 0| case UNORM_FCD: ------------------ | Branch (380:5): [True: 0, False: 1.90M] ------------------ 381| 0| return getFCDInstance(errorCode); 382| 0| default: // UNORM_NONE ------------------ | Branch (382:5): [True: 0, False: 1.90M] ------------------ 383| 0| return getNoopInstance(errorCode); 384| 1.90M| } 385| 1.90M|} unorm_getQuickCheck_78: 434| 1.90M|unorm_getQuickCheck(UChar32 c, UNormalizationMode mode) { 435| 1.90M| if(mode<=UNORM_NONE || UNORM_FCD<=mode) { ------------------ | Branch (435:8): [True: 0, False: 1.90M] | Branch (435:28): [True: 0, False: 1.90M] ------------------ 436| 0| return UNORM_YES; 437| 0| } 438| 1.90M| UErrorCode errorCode=U_ZERO_ERROR; 439| 1.90M| const Normalizer2 *norm2=Normalizer2Factory::getInstance(mode, errorCode); 440| 1.90M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (440:8): [True: 1.90M, False: 0] ------------------ 441| 1.90M| return ((const Normalizer2WithImpl *)norm2)->getQuickCheck(c); 442| 1.90M| } else { 443| 0| return UNORM_MAYBE; 444| 0| } 445| 1.90M|} _ZN6icu_7827locale_set_default_internalEPKcR10UErrorCode: 168| 1|Locale *locale_set_default_internal(const char *id, UErrorCode& status) { 169| | // Synchronize this entire function. 170| 1| Mutex lock(&gDefaultLocaleMutex); 171| | 172| 1| UBool canonicalize = false; 173| | 174| | // If given a nullptr string for the locale id, grab the default 175| | // name from the system. 176| | // (Different from most other locale APIs, where a null name means use 177| | // the current ICU default locale.) 178| 1| if (id == nullptr) { ------------------ | Branch (178:9): [True: 1, False: 0] ------------------ 179| 1| id = uprv_getDefaultLocaleID(); // This function not thread safe? TODO: verify. ------------------ | | 1505| 1|#define uprv_getDefaultLocaleID U_ICU_ENTRY_POINT_RENAME(uprv_getDefaultLocaleID) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 180| 1| canonicalize = true; // always canonicalize host ID 181| 1| } 182| | 183| 1| CharString localeNameBuf = 184| 1| canonicalize ? ulocimp_canonicalize(id, status) : ulocimp_getName(id, status); ------------------ | | 1197| 1|#define ulocimp_canonicalize U_ICU_ENTRY_POINT_RENAME(ulocimp_canonicalize) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ canonicalize ? ulocimp_canonicalize(id, status) : ulocimp_getName(id, status); ------------------ | | 1204| 0|#define ulocimp_getName U_ICU_ENTRY_POINT_RENAME(ulocimp_getName) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (184:9): [True: 1, False: 0] ------------------ 185| | 186| 1| if (U_FAILURE(status)) { ------------------ | Branch (186:9): [True: 0, False: 1] ------------------ 187| 0| return gDefaultLocale; 188| 0| } 189| | 190| 1| if (gDefaultLocalesHashT == nullptr) { ------------------ | Branch (190:9): [True: 1, False: 0] ------------------ 191| 1| gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &status); ------------------ | | 1030| 1|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &status); ------------------ | | 1011| 1|#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &status); ------------------ | | 993| 1|#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 192| 1| if (U_FAILURE(status)) { ------------------ | Branch (192:13): [True: 0, False: 1] ------------------ 193| 0| return gDefaultLocale; 194| 0| } 195| 1| uhash_setValueDeleter(gDefaultLocalesHashT, deleteLocale); ------------------ | | 1044| 1|#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDeleter) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 196| 1| ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 197| 1| } 198| | 199| 1| Locale* newDefault = static_cast(uhash_get(gDefaultLocalesHashT, localeNameBuf.data())); ------------------ | | 1007| 1|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 1| if (newDefault == nullptr) { ------------------ | Branch (200:9): [True: 1, False: 0] ------------------ 201| 1| newDefault = new Locale(Locale::eBOGUS); 202| 1| if (newDefault == nullptr) { ------------------ | Branch (202:13): [True: 0, False: 1] ------------------ 203| 0| status = U_MEMORY_ALLOCATION_ERROR; 204| 0| return gDefaultLocale; 205| 0| } 206| 1| newDefault->init(localeNameBuf.data(), false); 207| 1| uhash_put(gDefaultLocalesHashT, const_cast(newDefault->getName()), newDefault, &status); ------------------ | | 1032| 1|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 1| if (U_FAILURE(status)) { ------------------ | Branch (208:13): [True: 0, False: 1] ------------------ 209| 0| return gDefaultLocale; 210| 0| } 211| 1| } 212| 1| gDefaultLocale = newDefault; 213| 1| return gDefaultLocale; 214| 1|} locale_get_default_78: 230| 4.97k|{ 231| 4.97k| U_NAMESPACE_USE ------------------ | | 112| 4.97k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 232| 4.97k| return Locale::getDefault().getName(); 233| 4.97k|} _ZN6icu_786LocaleD2Ev: 247| 27.7k|{ 248| 27.7k| if ((baseName != fullName) && (baseName != fullNameBuffer)) { ------------------ | Branch (248:9): [True: 20.4k, False: 7.25k] | Branch (248:35): [True: 20.4k, False: 0] ------------------ 249| 20.4k| uprv_free(baseName); ------------------ | | 1503| 20.4k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 20.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 20.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 20.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 250| 20.4k| } 251| 27.7k| baseName = nullptr; 252| | /*if fullName is on the heap, we free it*/ 253| 27.7k| if (fullName != fullNameBuffer) ------------------ | Branch (253:9): [True: 0, False: 27.7k] ------------------ 254| 0| { 255| 0| uprv_free(fullName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 256| 0| fullName = nullptr; 257| 0| } 258| 27.7k|} _ZN6icu_786LocaleC2Ev: 261| 19| : UObject(), fullName(fullNameBuffer), baseName(nullptr) 262| 19|{ 263| 19| init(nullptr, false); 264| 19|} _ZN6icu_786LocaleC2ENS0_11ELocaleTypeE: 272| 1| : UObject(), fullName(fullNameBuffer), baseName(nullptr) 273| 1|{ 274| 1| setToBogus(); 275| 1|} _ZN6icu_786LocaleC2EPKcS2_S2_S2_: 282| 15.4k| : UObject(), fullName(fullNameBuffer), baseName(nullptr) 283| 15.4k|{ 284| 15.4k| if( (newLanguage==nullptr) && (newCountry == nullptr) && (newVariant == nullptr) ) ------------------ | Branch (284:9): [True: 0, False: 15.4k] | Branch (284:35): [True: 0, False: 0] | Branch (284:62): [True: 0, False: 0] ------------------ 285| 0| { 286| 0| init(nullptr, false); /* shortcut */ 287| 0| } 288| 15.4k| else 289| 15.4k| { 290| 15.4k| UErrorCode status = U_ZERO_ERROR; 291| 15.4k| int32_t lsize = 0; 292| 15.4k| int32_t csize = 0; 293| 15.4k| int32_t vsize = 0; 294| 15.4k| int32_t ksize = 0; 295| | 296| | // Check the sizes of the input strings. 297| | 298| | // Language 299| 15.4k| if ( newLanguage != nullptr ) ------------------ | Branch (299:14): [True: 15.4k, False: 0] ------------------ 300| 15.4k| { 301| 15.4k| lsize = static_cast(uprv_strlen(newLanguage)); ------------------ | | 37| 15.4k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 302| 15.4k| if ( lsize < 0 || lsize > ULOC_STRING_LIMIT ) { // int32 wrap ------------------ | | 76| 15.4k|#define ULOC_STRING_LIMIT 357913941 ------------------ | Branch (302:18): [True: 0, False: 15.4k] | Branch (302:31): [True: 0, False: 15.4k] ------------------ 303| 0| setToBogus(); 304| 0| return; 305| 0| } 306| 15.4k| } 307| | 308| 15.4k| CharString togo(newLanguage, lsize, status); // start with newLanguage 309| | 310| | // _Country 311| 15.4k| if ( newCountry != nullptr ) ------------------ | Branch (311:14): [True: 11, False: 15.4k] ------------------ 312| 11| { 313| 11| csize = static_cast(uprv_strlen(newCountry)); ------------------ | | 37| 11|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 11|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 314| 11| if ( csize < 0 || csize > ULOC_STRING_LIMIT ) { // int32 wrap ------------------ | | 76| 11|#define ULOC_STRING_LIMIT 357913941 ------------------ | Branch (314:18): [True: 0, False: 11] | Branch (314:31): [True: 0, False: 11] ------------------ 315| 0| setToBogus(); 316| 0| return; 317| 0| } 318| 11| } 319| | 320| | // _Variant 321| 15.4k| if ( newVariant != nullptr ) ------------------ | Branch (321:14): [True: 0, False: 15.4k] ------------------ 322| 0| { 323| | // remove leading _'s 324| 0| while(newVariant[0] == SEP_CHAR) ------------------ | | 243| 0|#define SEP_CHAR '_' ------------------ | Branch (324:19): [True: 0, False: 0] ------------------ 325| 0| { 326| 0| newVariant++; 327| 0| } 328| | 329| | // remove trailing _'s 330| 0| vsize = static_cast(uprv_strlen(newVariant)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 331| 0| if ( vsize < 0 || vsize > ULOC_STRING_LIMIT ) { // int32 wrap ------------------ | | 76| 0|#define ULOC_STRING_LIMIT 357913941 ------------------ | Branch (331:18): [True: 0, False: 0] | Branch (331:31): [True: 0, False: 0] ------------------ 332| 0| setToBogus(); 333| 0| return; 334| 0| } 335| 0| while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) ) ------------------ | | 243| 0|#define SEP_CHAR '_' ------------------ | Branch (335:20): [True: 0, False: 0] | Branch (335:33): [True: 0, False: 0] ------------------ 336| 0| { 337| 0| vsize--; 338| 0| } 339| 0| } 340| | 341| 15.4k| if ( newKeywords != nullptr) ------------------ | Branch (341:14): [True: 0, False: 15.4k] ------------------ 342| 0| { 343| 0| ksize = static_cast(uprv_strlen(newKeywords)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 344| 0| if ( ksize < 0 || ksize > ULOC_STRING_LIMIT ) { ------------------ | | 76| 0|#define ULOC_STRING_LIMIT 357913941 ------------------ | Branch (344:18): [True: 0, False: 0] | Branch (344:31): [True: 0, False: 0] ------------------ 345| 0| setToBogus(); 346| 0| return; 347| 0| } 348| 0| } 349| | 350| | // We've checked the input sizes, now build up the full locale string.. 351| | 352| | // newLanguage is already copied 353| | 354| 15.4k| if ( ( vsize != 0 ) || (csize != 0) ) // at least: __v ------------------ | Branch (354:14): [True: 0, False: 15.4k] | Branch (354:32): [True: 11, False: 15.4k] ------------------ 355| 11| { // ^ 356| 11| togo.append(SEP_CHAR, status); ------------------ | | 243| 11|#define SEP_CHAR '_' ------------------ 357| 11| } 358| | 359| 15.4k| if ( csize != 0 ) ------------------ | Branch (359:14): [True: 11, False: 15.4k] ------------------ 360| 11| { 361| 11| togo.append(newCountry, status); 362| 11| } 363| | 364| 15.4k| if ( vsize != 0) ------------------ | Branch (364:14): [True: 0, False: 15.4k] ------------------ 365| 0| { 366| 0| togo.append(SEP_CHAR, status) ------------------ | | 243| 0|#define SEP_CHAR '_' ------------------ 367| 0| .append(newVariant, vsize, status); 368| 0| } 369| | 370| 15.4k| if ( ksize != 0) ------------------ | Branch (370:14): [True: 0, False: 15.4k] ------------------ 371| 0| { 372| 0| if (uprv_strchr(newKeywords, '=')) { ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (40:27): [True: 0, False: 0] | | ------------------ ------------------ 373| 0| togo.append('@', status); /* keyword parsing */ 374| 0| } 375| 0| else { 376| 0| togo.append('_', status); /* Variant parsing with a script */ 377| 0| if ( vsize == 0) { ------------------ | Branch (377:22): [True: 0, False: 0] ------------------ 378| 0| togo.append('_', status); /* No country found */ 379| 0| } 380| 0| } 381| 0| togo.append(newKeywords, status); 382| 0| } 383| | 384| 15.4k| if (U_FAILURE(status)) { ------------------ | Branch (384:13): [True: 0, False: 15.4k] ------------------ 385| | // Something went wrong with appending, etc. 386| 0| setToBogus(); 387| 0| return; 388| 0| } 389| | // Parse it, because for example 'language' might really be a complete 390| | // string. 391| 15.4k| init(togo.data(), false); 392| 15.4k| } 393| 15.4k|} _ZN6icu_786LocaleC2ERKS0_: 396| 12.2k| : UObject(other), fullName(fullNameBuffer), baseName(nullptr) 397| 12.2k|{ 398| 12.2k| *this = other; 399| 12.2k|} _ZN6icu_786LocaleaSERKS0_: 406| 16.4k|Locale& Locale::operator=(const Locale& other) { 407| 16.4k| if (this == &other) { ------------------ | Branch (407:9): [True: 0, False: 16.4k] ------------------ 408| 0| return *this; 409| 0| } 410| | 411| 16.4k| setToBogus(); 412| | 413| 16.4k| if (other.fullName == other.fullNameBuffer) { ------------------ | Branch (413:9): [True: 16.4k, False: 0] ------------------ 414| 16.4k| uprv_strcpy(fullNameBuffer, other.fullNameBuffer); ------------------ | | 36| 16.4k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 16.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 415| 16.4k| } else if (other.fullName == nullptr) { ------------------ | Branch (415:16): [True: 0, False: 0] ------------------ 416| 0| fullName = nullptr; 417| 0| } else { 418| 0| fullName = uprv_strdup(other.fullName); ------------------ | | 1541| 0|#define uprv_strdup U_ICU_ENTRY_POINT_RENAME(uprv_strdup) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 419| 0| if (fullName == nullptr) return *this; ------------------ | Branch (419:13): [True: 0, False: 0] ------------------ 420| 0| } 421| | 422| 16.4k| if (other.baseName == other.fullName) { ------------------ | Branch (422:9): [True: 20, False: 16.3k] ------------------ 423| 20| baseName = fullName; 424| 16.3k| } else if (other.baseName != nullptr) { ------------------ | Branch (424:16): [True: 0, False: 16.3k] ------------------ 425| 0| baseName = uprv_strdup(other.baseName); ------------------ | | 1541| 0|#define uprv_strdup U_ICU_ENTRY_POINT_RENAME(uprv_strdup) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 426| 0| if (baseName == nullptr) return *this; ------------------ | Branch (426:13): [True: 0, False: 0] ------------------ 427| 0| } 428| | 429| 16.4k| uprv_strcpy(language, other.language); ------------------ | | 36| 16.4k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 16.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 430| 16.4k| uprv_strcpy(script, other.script); ------------------ | | 36| 16.4k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 16.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 431| 16.4k| uprv_strcpy(country, other.country); ------------------ | | 36| 16.4k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 16.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 432| | 433| 16.4k| variantBegin = other.variantBegin; 434| 16.4k| fIsBogus = other.fIsBogus; 435| | 436| 16.4k| return *this; 437| 16.4k|} _ZN6icu_786LocaleaSEOS0_: 439| 19|Locale& Locale::operator=(Locale&& other) noexcept { 440| 19| if ((baseName != fullName) && (baseName != fullNameBuffer)) uprv_free(baseName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (440:9): [True: 0, False: 19] | Branch (440:35): [True: 0, False: 0] ------------------ 441| 19| if (fullName != fullNameBuffer) uprv_free(fullName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (441:9): [True: 0, False: 19] ------------------ 442| | 443| 19| if (other.fullName == other.fullNameBuffer || other.baseName == other.fullNameBuffer) { ------------------ | Branch (443:9): [True: 19, False: 0] | Branch (443:51): [True: 0, False: 0] ------------------ 444| 19| uprv_strcpy(fullNameBuffer, other.fullNameBuffer); ------------------ | | 36| 19|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 19|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 445| 19| } 446| 19| if (other.fullName == other.fullNameBuffer) { ------------------ | Branch (446:9): [True: 19, False: 0] ------------------ 447| 19| fullName = fullNameBuffer; 448| 19| } else { 449| 0| fullName = other.fullName; 450| 0| } 451| | 452| 19| if (other.baseName == other.fullNameBuffer) { ------------------ | Branch (452:9): [True: 19, False: 0] ------------------ 453| 19| baseName = fullNameBuffer; 454| 19| } else if (other.baseName == other.fullName) { ------------------ | Branch (454:16): [True: 0, False: 0] ------------------ 455| 0| baseName = fullName; 456| 0| } else { 457| 0| baseName = other.baseName; 458| 0| } 459| | 460| 19| uprv_strcpy(language, other.language); ------------------ | | 36| 19|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 19|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 461| 19| uprv_strcpy(script, other.script); ------------------ | | 36| 19|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 19|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 462| 19| uprv_strcpy(country, other.country); ------------------ | | 36| 19|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 19|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 463| | 464| 19| variantBegin = other.variantBegin; 465| 19| fIsBogus = other.fIsBogus; 466| | 467| 19| other.baseName = other.fullName = other.fullNameBuffer; 468| | 469| 19| return *this; 470| 19|} _ZN6icu_786Locale4initEPKca: 1832| 15.4k|{ 1833| 15.4k| return localeID == nullptr ? *this = getDefault() : init(StringPiece{localeID}, canonicalize); ------------------ | Branch (1833:12): [True: 19, False: 15.4k] ------------------ 1834| 15.4k|} _ZN6icu_786Locale4initENS_11StringPieceEa: 1838| 15.4k|{ 1839| 15.4k| fIsBogus = false; 1840| | /* Free our current storage */ 1841| 15.4k| if ((baseName != fullName) && (baseName != fullNameBuffer)) { ------------------ | Branch (1841:9): [True: 15.4k, False: 0] | Branch (1841:35): [True: 15.4k, False: 0] ------------------ 1842| 15.4k| uprv_free(baseName); ------------------ | | 1503| 15.4k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 15.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1843| 15.4k| } 1844| 15.4k| baseName = nullptr; 1845| 15.4k| if(fullName != fullNameBuffer) { ------------------ | Branch (1845:8): [True: 0, False: 15.4k] ------------------ 1846| 0| uprv_free(fullName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1847| 0| fullName = fullNameBuffer; 1848| 0| } 1849| | 1850| | // not a loop: 1851| | // just an easy way to have a common error-exit 1852| | // without goto and without another function 1853| 15.4k| do { 1854| 15.4k| char *separator; 1855| 15.4k| char *field[5] = {nullptr}; 1856| 15.4k| int32_t fieldLen[5] = {0}; 1857| 15.4k| int32_t fieldIdx; 1858| 15.4k| int32_t variantField; 1859| 15.4k| int32_t length; 1860| 15.4k| UErrorCode err; 1861| | 1862| | /* preset all fields to empty */ 1863| 15.4k| language[0] = script[0] = country[0] = 0; 1864| | 1865| 15.4k| const auto parse = [canonicalize](std::string_view localeID, 1866| 15.4k| char* name, 1867| 15.4k| int32_t nameCapacity, 1868| 15.4k| UErrorCode& status) { 1869| 15.4k| return ByteSinkUtil::viaByteSinkToTerminatedChars( 1870| 15.4k| name, nameCapacity, 1871| 15.4k| [&](ByteSink& sink, UErrorCode& status) { 1872| 15.4k| if (canonicalize) { 1873| 15.4k| ulocimp_canonicalize(localeID, sink, status); 1874| 15.4k| } else { 1875| 15.4k| ulocimp_getName(localeID, sink, status); 1876| 15.4k| } 1877| 15.4k| }, 1878| 15.4k| status); 1879| 15.4k| }; 1880| | 1881| | // "canonicalize" the locale ID to ICU/Java format 1882| 15.4k| err = U_ZERO_ERROR; 1883| 15.4k| length = parse(localeID, fullName, sizeof fullNameBuffer, err); 1884| | 1885| 15.4k| if (err == U_BUFFER_OVERFLOW_ERROR || length >= static_cast(sizeof(fullNameBuffer))) { ------------------ | Branch (1885:13): [True: 0, False: 15.4k] | Branch (1885:47): [True: 0, False: 15.4k] ------------------ 1886| 0| U_ASSERT(baseName == nullptr); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1887| | /*Go to heap for the fullName if necessary*/ 1888| 0| char* newFullName = static_cast(uprv_malloc(sizeof(char) * (length + 1))); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1889| 0| if (newFullName == nullptr) { ------------------ | Branch (1889:17): [True: 0, False: 0] ------------------ 1890| 0| break; // error: out of memory 1891| 0| } 1892| 0| fullName = newFullName; 1893| 0| err = U_ZERO_ERROR; 1894| 0| length = parse(localeID, fullName, length + 1, err); 1895| 0| } 1896| 15.4k| if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) { ------------------ | Branch (1896:12): [True: 0, False: 15.4k] | Branch (1896:30): [True: 0, False: 15.4k] ------------------ 1897| | /* should never occur */ 1898| 0| break; 1899| 0| } 1900| | 1901| 15.4k| variantBegin = length; 1902| | 1903| | /* after uloc_getName/canonicalize() we know that only '_' are separators */ 1904| | /* But _ could also appeared in timezone such as "en@timezone=America/Los_Angeles" */ 1905| 15.4k| separator = field[0] = fullName; 1906| 15.4k| fieldIdx = 1; 1907| 15.4k| char* at = uprv_strchr(fullName, '@'); ------------------ | | 40| 15.4k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1908| 15.4k| while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR)) != nullptr && ------------------ | | 40| 15.4k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1908:16): [True: 13, False: 15.4k] ------------------ 1909| 15.4k| fieldIdx < UPRV_LENGTHOF(field)-1 && ------------------ | | 99| 13|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1909:16): [True: 13, False: 0] ------------------ 1910| 15.4k| (at == nullptr || separator < at)) { ------------------ | Branch (1910:17): [True: 13, False: 0] | Branch (1910:34): [True: 0, False: 0] ------------------ 1911| 13| field[fieldIdx] = separator + 1; 1912| 13| fieldLen[fieldIdx - 1] = static_cast(separator - field[fieldIdx - 1]); 1913| 13| fieldIdx++; 1914| 13| } 1915| | // variant may contain @foo or .foo POSIX cruft; remove it 1916| 15.4k| separator = uprv_strchr(field[fieldIdx-1], '@'); ------------------ | | 40| 15.4k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1917| 15.4k| char* sep2 = uprv_strchr(field[fieldIdx-1], '.'); ------------------ | | 40| 15.4k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1918| 15.4k| if (separator!=nullptr || sep2!=nullptr) { ------------------ | Branch (1918:13): [True: 0, False: 15.4k] | Branch (1918:35): [True: 0, False: 15.4k] ------------------ 1919| 0| if (separator==nullptr || (sep2!=nullptr && separator > sep2)) { ------------------ | Branch (1919:17): [True: 0, False: 0] | Branch (1919:40): [True: 0, False: 0] | Branch (1919:57): [True: 0, False: 0] ------------------ 1920| 0| separator = sep2; 1921| 0| } 1922| 0| fieldLen[fieldIdx - 1] = static_cast(separator - field[fieldIdx - 1]); 1923| 15.4k| } else { 1924| 15.4k| fieldLen[fieldIdx - 1] = length - static_cast(field[fieldIdx - 1] - fullName); 1925| 15.4k| } 1926| | 1927| 15.4k| if (fieldLen[0] >= static_cast(sizeof(language))) ------------------ | Branch (1927:13): [True: 0, False: 15.4k] ------------------ 1928| 0| { 1929| 0| break; // error: the language field is too long 1930| 0| } 1931| | 1932| 15.4k| variantField = 1; /* Usually the 2nd one, except when a script or country is also used. */ 1933| 15.4k| if (fieldLen[0] > 0) { ------------------ | Branch (1933:13): [True: 19, False: 15.4k] ------------------ 1934| | /* We have a language */ 1935| 19| uprv_memcpy(language, fullName, fieldLen[0]); ------------------ | | 42| 19|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 19|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 19| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 19| _Pragma("clang diagnostic push") \ | | 45| 19| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 19| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 19|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 19| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 19|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 19| _Pragma("clang diagnostic pop") \ | | 49| 19| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 19|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 19|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 19|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1936| 19| language[fieldLen[0]] = 0; 1937| 19| } 1938| 15.4k| if (fieldLen[1] == 4 && uprv_isASCIILetter(field[1][0]) && ------------------ | | 1514| 0|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1938:13): [True: 0, False: 15.4k] | Branch (1938:33): [True: 0, False: 0] ------------------ 1939| 15.4k| uprv_isASCIILetter(field[1][1]) && uprv_isASCIILetter(field[1][2]) && ------------------ | | 1514| 0|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ uprv_isASCIILetter(field[1][1]) && uprv_isASCIILetter(field[1][2]) && ------------------ | | 1514| 0|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1939:17): [True: 0, False: 0] | Branch (1939:52): [True: 0, False: 0] ------------------ 1940| 15.4k| uprv_isASCIILetter(field[1][3])) { ------------------ | | 1514| 0|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1940:17): [True: 0, False: 0] ------------------ 1941| | /* We have at least a script */ 1942| 0| uprv_memcpy(script, field[1], fieldLen[1]); ------------------ | | 42| 0|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 0| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 0| _Pragma("clang diagnostic push") \ | | 45| 0| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 0| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 0| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 0| _Pragma("clang diagnostic pop") \ | | 49| 0| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1943| 0| script[fieldLen[1]] = 0; 1944| 0| variantField++; 1945| 0| } 1946| | 1947| 15.4k| if (fieldLen[variantField] == 2 || fieldLen[variantField] == 3) { ------------------ | Branch (1947:13): [True: 12, False: 15.4k] | Branch (1947:44): [True: 0, False: 15.4k] ------------------ 1948| | /* We have a country */ 1949| 12| uprv_memcpy(country, field[variantField], fieldLen[variantField]); ------------------ | | 42| 12|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 12|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 12| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 12| _Pragma("clang diagnostic push") \ | | 45| 12| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 12| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 12|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 12| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 12|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 12| _Pragma("clang diagnostic pop") \ | | 49| 12| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 12|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 12|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 12|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1950| 12| country[fieldLen[variantField]] = 0; 1951| 12| variantField++; 1952| 15.4k| } else if (fieldLen[variantField] == 0) { ------------------ | Branch (1952:20): [True: 15.4k, False: 0] ------------------ 1953| 15.4k| variantField++; /* script or country empty but variant in next field (i.e. en__POSIX) */ 1954| 15.4k| } 1955| | 1956| 15.4k| if (fieldLen[variantField] > 0) { ------------------ | Branch (1956:13): [True: 1, False: 15.4k] ------------------ 1957| | /* We have a variant */ 1958| 1| variantBegin = static_cast(field[variantField] - fullName); 1959| 1| } 1960| | 1961| 15.4k| err = U_ZERO_ERROR; 1962| 15.4k| initBaseName(err); 1963| 15.4k| if (U_FAILURE(err)) { ------------------ | Branch (1963:13): [True: 0, False: 15.4k] ------------------ 1964| 0| break; 1965| 0| } 1966| | 1967| 15.4k| if (canonicalize) { ------------------ | Branch (1967:13): [True: 0, False: 15.4k] ------------------ 1968| 0| if (!isKnownCanonicalizedLocale(fullName, err)) { ------------------ | Branch (1968:17): [True: 0, False: 0] ------------------ 1969| 0| CharString replaced; 1970| | // Not sure it is already canonicalized 1971| 0| if (canonicalizeLocale(*this, replaced, err)) { ------------------ | Branch (1971:21): [True: 0, False: 0] ------------------ 1972| 0| U_ASSERT(U_SUCCESS(err)); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1973| | // If need replacement, call init again. 1974| 0| init(replaced.data(), false); 1975| 0| } 1976| 0| if (U_FAILURE(err)) { ------------------ | Branch (1976:21): [True: 0, False: 0] ------------------ 1977| 0| break; 1978| 0| } 1979| 0| } 1980| 0| } // if (canonicalize) { 1981| | 1982| | // successful end of init() 1983| 15.4k| return *this; 1984| 15.4k| } while(0); /*loop doesn't iterate*/ ------------------ | Branch (1984:13): [Folded - Ignored] ------------------ 1985| | 1986| | // when an error occurs, then set this object to "bogus" (there is no UErrorCode here) 1987| 0| setToBogus(); 1988| | 1989| 0| return *this; 1990| 15.4k|} _ZN6icu_786Locale12initBaseNameER10UErrorCode: 1999| 15.4k|Locale::initBaseName(UErrorCode &status) { 2000| 15.4k| if (U_FAILURE(status)) { ------------------ | Branch (2000:9): [True: 0, False: 15.4k] ------------------ 2001| 0| return; 2002| 0| } 2003| 15.4k| U_ASSERT(baseName==nullptr || baseName==fullName); ------------------ | | 35| 15.4k|# define U_ASSERT(exp) (void)0 ------------------ 2004| 15.4k| const char *atPtr = uprv_strchr(fullName, '@'); ------------------ | | 40| 15.4k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2005| 15.4k| const char *eqPtr = uprv_strchr(fullName, '='); ------------------ | | 40| 15.4k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 15.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2006| 15.4k| if (atPtr && eqPtr && atPtr < eqPtr) { ------------------ | Branch (2006:9): [True: 0, False: 15.4k] | Branch (2006:18): [True: 0, False: 0] | Branch (2006:27): [True: 0, False: 0] ------------------ 2007| | // Key words exist. 2008| 0| int32_t baseNameLength = static_cast(atPtr - fullName); 2009| 0| char* newBaseName = static_cast(uprv_malloc(baseNameLength + 1)); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2010| 0| if (newBaseName == nullptr) { ------------------ | Branch (2010:13): [True: 0, False: 0] ------------------ 2011| 0| status = U_MEMORY_ALLOCATION_ERROR; 2012| 0| return; 2013| 0| } 2014| 0| baseName = newBaseName; 2015| 0| uprv_strncpy(baseName, fullName, baseNameLength); ------------------ | | 43| 0|#define uprv_strncpy(dst, src, size) U_STANDARD_CPP_NAMESPACE strncpy(dst, src, size) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2016| 0| baseName[baseNameLength] = 0; 2017| | 2018| | // The original computation of variantBegin leaves it equal to the length 2019| | // of fullName if there is no variant. It should instead be 2020| | // the length of the baseName. 2021| 0| if (variantBegin > baseNameLength) { ------------------ | Branch (2021:13): [True: 0, False: 0] ------------------ 2022| 0| variantBegin = baseNameLength; 2023| 0| } 2024| 15.4k| } else { 2025| 15.4k| baseName = fullName; 2026| 15.4k| } 2027| 15.4k|} _ZN6icu_786Locale10setToBogusEv: 2037| 20.4k|Locale::setToBogus() { 2038| | /* Free our current storage */ 2039| 20.4k| if((baseName != fullName) && (baseName != fullNameBuffer)) { ------------------ | Branch (2039:8): [True: 12.3k, False: 8.19k] | Branch (2039:34): [True: 12.3k, False: 0] ------------------ 2040| 12.3k| uprv_free(baseName); ------------------ | | 1503| 12.3k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 12.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2041| 12.3k| } 2042| 20.4k| baseName = nullptr; 2043| 20.4k| if(fullName != fullNameBuffer) { ------------------ | Branch (2043:8): [True: 0, False: 20.4k] ------------------ 2044| 0| uprv_free(fullName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2045| 0| fullName = fullNameBuffer; 2046| 0| } 2047| 20.4k| *fullNameBuffer = 0; 2048| 20.4k| *language = 0; 2049| 20.4k| *script = 0; 2050| 20.4k| *country = 0; 2051| 20.4k| fIsBogus = true; 2052| 20.4k| variantBegin = 0; 2053| 20.4k|} _ZN6icu_786Locale10getDefaultEv: 2057| 4.99k|{ 2058| 4.99k| { 2059| 4.99k| Mutex lock(&gDefaultLocaleMutex); 2060| 4.99k| if (gDefaultLocale != nullptr) { ------------------ | Branch (2060:13): [True: 4.99k, False: 1] ------------------ 2061| 4.99k| return *gDefaultLocale; 2062| 4.99k| } 2063| 4.99k| } 2064| 1| UErrorCode status = U_ZERO_ERROR; 2065| 1| return *locale_set_default_internal(nullptr, status); 2066| 4.99k|} _ZN6icu_786Locale7getRootEv: 2273| 1|{ 2274| 1| return getLocale(eROOT); 2275| 1|} _ZN6icu_786Locale9getLocaleEi: 2406| 1|{ 2407| 1| Locale *localeCache = getLocaleCache(); 2408| 1| U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0)); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 2409| 1| if (localeCache == nullptr) { ------------------ | Branch (2409:9): [True: 0, False: 1] ------------------ 2410| | // Failure allocating the locale cache. 2411| | // The best we can do is return a nullptr reference. 2412| 0| locid = 0; 2413| 0| } 2414| 1| return localeCache[locid]; /*operating on nullptr*/ 2415| 1|} _ZN6icu_786Locale14getLocaleCacheEv: 2423| 1|{ 2424| 1| UErrorCode status = U_ZERO_ERROR; 2425| 1| umtx_initOnce(gLocaleCacheInitOnce, locale_init, status); 2426| 1| return gLocaleCache; 2427| 1|} locid.cpp:_ZZN6icu_786Locale4initENS_11StringPieceEaENK3$_0clENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPciR10UErrorCode: 1868| 15.4k| UErrorCode& status) { 1869| 15.4k| return ByteSinkUtil::viaByteSinkToTerminatedChars( 1870| 15.4k| name, nameCapacity, 1871| 15.4k| [&](ByteSink& sink, UErrorCode& status) { 1872| 15.4k| if (canonicalize) { 1873| 15.4k| ulocimp_canonicalize(localeID, sink, status); 1874| 15.4k| } else { 1875| 15.4k| ulocimp_getName(localeID, sink, status); 1876| 15.4k| } 1877| 15.4k| }, 1878| 15.4k| status); 1879| 15.4k| }; locid.cpp:_ZZZN6icu_786Locale4initENS_11StringPieceEaENK3$_0clENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPciR10UErrorCodeENKUlRNS_8ByteSinkESA_E_clESC_SA_: 1871| 15.4k| [&](ByteSink& sink, UErrorCode& status) { 1872| 15.4k| if (canonicalize) { ------------------ | Branch (1872:25): [True: 0, False: 15.4k] ------------------ 1873| 0| ulocimp_canonicalize(localeID, sink, status); ------------------ | | 1197| 0|#define ulocimp_canonicalize U_ICU_ENTRY_POINT_RENAME(ulocimp_canonicalize) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1874| 15.4k| } else { 1875| 15.4k| ulocimp_getName(localeID, sink, status); ------------------ | | 1204| 15.4k|#define ulocimp_getName U_ICU_ENTRY_POINT_RENAME(ulocimp_getName) | | ------------------ | | | | 123| 15.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1876| 15.4k| } 1877| 15.4k| }, locid.cpp:_ZN12_GLOBAL__N_111locale_initER10UErrorCode: 133| 1|void U_CALLCONV locale_init(UErrorCode &status) { 134| 1| U_NAMESPACE_USE ------------------ | | 112| 1|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 135| | 136| 1| U_ASSERT(gLocaleCache == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 137| 1| gLocaleCache = new Locale[static_cast(eMAX_LOCALES)]; 138| 1| if (gLocaleCache == nullptr) { ------------------ | Branch (138:9): [True: 0, False: 1] ------------------ 139| 0| status = U_MEMORY_ALLOCATION_ERROR; 140| 0| return; 141| 0| } 142| 1| ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 143| 1| gLocaleCache[eROOT] = Locale(""); 144| 1| gLocaleCache[eENGLISH] = Locale("en"); 145| 1| gLocaleCache[eFRENCH] = Locale("fr"); 146| 1| gLocaleCache[eGERMAN] = Locale("de"); 147| 1| gLocaleCache[eITALIAN] = Locale("it"); 148| 1| gLocaleCache[eJAPANESE] = Locale("ja"); 149| 1| gLocaleCache[eKOREAN] = Locale("ko"); 150| 1| gLocaleCache[eCHINESE] = Locale("zh"); 151| 1| gLocaleCache[eFRANCE] = Locale("fr", "FR"); 152| 1| gLocaleCache[eGERMANY] = Locale("de", "DE"); 153| 1| gLocaleCache[eITALY] = Locale("it", "IT"); 154| 1| gLocaleCache[eJAPAN] = Locale("ja", "JP"); 155| 1| gLocaleCache[eKOREA] = Locale("ko", "KR"); 156| 1| gLocaleCache[eCHINA] = Locale("zh", "CN"); 157| 1| gLocaleCache[eTAIWAN] = Locale("zh", "TW"); 158| 1| gLocaleCache[eUK] = Locale("en", "GB"); 159| 1| gLocaleCache[eUS] = Locale("en", "US"); 160| 1| gLocaleCache[eCANADA] = Locale("en", "CA"); 161| 1| gLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA"); 162| 1|} _ZN6icu_785MutexC2EPNS_6UMutexE: 58| 195k| Mutex(UMutex *mutex = nullptr) : fMutex(mutex) { 59| 195k| umtx_lock(fMutex); ------------------ | | 1250| 195k|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 195k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 195k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 195k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 60| 195k| } _ZN6icu_785MutexD2Ev: 61| 195k| ~Mutex() { 62| 195k| umtx_unlock(fMutex); ------------------ | | 1251| 195k|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 195k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 195k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 195k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 195k| } _ZN6icu_7813Norm2AllModesC2EPNS_15Normalizer2ImplE: 382| 1| : impl(i), comp(*i, false), decomp(*i), fcd(*i), fcc(*i, true) {} _ZN6icu_7818ComposeNormalizer2C2ERKNS_15Normalizer2ImplEa: 253| 2| Normalizer2WithImpl(ni), onlyContiguous(fcc) {} _ZN6icu_7819Normalizer2WithImplC2ERKNS_15Normalizer2ImplE: 34| 4| Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {} _ZN6icu_7820DecomposeNormalizer2C2ERKNS_15Normalizer2ImplE: 191| 1| DecomposeNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {} _ZN6icu_7814FCDNormalizer2C2ERKNS_15Normalizer2ImplE: 348| 1| FCDNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {} _ZNK6icu_7819Normalizer2WithImpl9normalizeERKNS_13UnicodeStringERS1_R10UErrorCode: 41| 55.8M| UErrorCode &errorCode) const override { 42| 55.8M| if(U_FAILURE(errorCode)) { ------------------ | Branch (42:12): [True: 0, False: 55.8M] ------------------ 43| 0| dest.setToBogus(); 44| 0| return dest; 45| 0| } 46| 55.8M| const char16_t *sArray=src.getBuffer(); 47| 55.8M| if(&dest==&src || sArray==nullptr) { ------------------ | Branch (47:12): [True: 0, False: 55.8M] | Branch (47:27): [True: 0, False: 55.8M] ------------------ 48| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 49| 0| dest.setToBogus(); 50| 0| return dest; 51| 0| } 52| 55.8M| dest.remove(); 53| 55.8M| ReorderingBuffer buffer(impl, dest); 54| 55.8M| if(buffer.init(src.length(), errorCode)) { ------------------ | Branch (54:12): [True: 55.8M, False: 0] ------------------ 55| 55.8M| normalize(sArray, sArray+src.length(), buffer, errorCode); 56| 55.8M| } 57| 55.8M| return dest; 58| 55.8M| } _ZNK6icu_7819Normalizer2WithImpl16getDecompositionEiRNS_13UnicodeStringE: 110| 9.49M| getDecomposition(UChar32 c, UnicodeString &decomposition) const override { 111| 9.49M| char16_t buffer[4]; 112| 9.49M| int32_t length; 113| 9.49M| const char16_t *d=impl.getDecomposition(c, buffer, length); 114| 9.49M| if(d==nullptr) { ------------------ | Branch (114:12): [True: 0, False: 9.49M] ------------------ 115| 0| return false; 116| 0| } 117| 9.49M| if(d==buffer) { ------------------ | Branch (117:12): [True: 9.14k, False: 9.48M] ------------------ 118| 9.14k| decomposition.setTo(buffer, length); // copy the string (Jamos from Hangul syllable c) 119| 9.48M| } else { 120| 9.48M| decomposition.setTo(false, d, length); // read-only alias 121| 9.48M| } 122| 9.49M| return true; 123| 9.49M| } _ZNK6icu_7819Normalizer2WithImpl17getCombiningClassEi: 145| 14.6M| getCombiningClass(UChar32 c) const override { 146| 14.6M| return impl.getCC(impl.getNorm16(c)); 147| 14.6M| } _ZNK6icu_7819Normalizer2WithImpl12isNormalizedERKNS_13UnicodeStringER10UErrorCode: 151| 9.80M| isNormalized(const UnicodeString &s, UErrorCode &errorCode) const override { 152| 9.80M| if(U_FAILURE(errorCode)) { ------------------ | Branch (152:12): [True: 0, False: 9.80M] ------------------ 153| 0| return false; 154| 0| } 155| 9.80M| const char16_t *sArray=s.getBuffer(); 156| 9.80M| if(sArray==nullptr) { ------------------ | Branch (156:12): [True: 0, False: 9.80M] ------------------ 157| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 158| 0| return false; 159| 0| } 160| 9.80M| const char16_t *sLimit=sArray+s.length(); 161| 9.80M| return sLimit==spanQuickCheckYes(sArray, sLimit, errorCode); 162| 9.80M| } _ZNK6icu_7820DecomposeNormalizer27isInertEi: 245| 5.33M| virtual UBool isInert(UChar32 c) const override { 246| 5.33M| return impl.isDecompInert(c); 247| 5.33M| } _ZNK6icu_7820DecomposeNormalizer29normalizeEPKDsS2_RNS_16ReorderingBufferER10UErrorCode: 197| 55.8M| ReorderingBuffer &buffer, UErrorCode &errorCode) const override { 198| 55.8M| impl.decompose(src, limit, &buffer, errorCode); 199| 55.8M| } _ZNK6icu_7820DecomposeNormalizer213getQuickCheckEi: 236| 1.90M| virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const override { 237| 1.90M| return impl.isDecompYes(impl.getNorm16(c)) ? UNORM_YES : UNORM_NO; ------------------ | Branch (237:16): [True: 955k, False: 953k] ------------------ 238| 1.90M| } _ZNK6icu_7818ComposeNormalizer217hasBoundaryBeforeEi: 333| 8.56k| virtual UBool hasBoundaryBefore(UChar32 c) const override { 334| 8.56k| return impl.hasCompBoundaryBefore(c); 335| 8.56k| } _ZNK6icu_7814FCDNormalizer217spanQuickCheckYesEPKDsS2_R10UErrorCode: 365| 9.80M| spanQuickCheckYes(const char16_t *src, const char16_t *limit, UErrorCode &errorCode) const override { 366| 9.80M| return impl.makeFCD(src, limit, nullptr, errorCode); 367| 9.80M| } _ZN6icu_7813Norm2AllModes14createInstanceEPNS_15Normalizer2ImplER10UErrorCode: 216| 1|Norm2AllModes::createInstance(Normalizer2Impl *impl, UErrorCode &errorCode) { 217| 1| if(U_FAILURE(errorCode)) { ------------------ | Branch (217:8): [True: 0, False: 1] ------------------ 218| 0| delete impl; 219| 0| return nullptr; 220| 0| } 221| 1| Norm2AllModes *allModes=new Norm2AllModes(impl); 222| 1| if(allModes==nullptr) { ------------------ | Branch (222:8): [True: 0, False: 1] ------------------ 223| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 224| 0| delete impl; 225| 0| return nullptr; 226| 0| } 227| 1| return allModes; 228| 1|} _ZN6icu_7813Norm2AllModes17createNFCInstanceER10UErrorCode: 232| 1|Norm2AllModes::createNFCInstance(UErrorCode &errorCode) { 233| 1| if(U_FAILURE(errorCode)) { ------------------ | Branch (233:8): [True: 0, False: 1] ------------------ 234| 0| return nullptr; 235| 0| } 236| 1| Normalizer2Impl *impl=new Normalizer2Impl; 237| 1| if(impl==nullptr) { ------------------ | Branch (237:8): [True: 0, False: 1] ------------------ 238| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 239| 0| return nullptr; 240| 0| } 241| 1| impl->init(norm2_nfc_data_indexes, &norm2_nfc_data_trie, 242| 1| norm2_nfc_data_extraData, norm2_nfc_data_smallFCD); 243| 1| return createInstance(impl, errorCode); 244| 1|} _ZN6icu_7813Norm2AllModes14getNFCInstanceER10UErrorCode: 256| 23.7M|Norm2AllModes::getNFCInstance(UErrorCode &errorCode) { 257| 23.7M| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (257:8): [True: 20, False: 23.7M] ------------------ 258| 23.7M| umtx_initOnce(nfcInitOnce, &initNFCSingleton, errorCode); 259| 23.7M| return nfcSingleton; 260| 23.7M|} _ZN6icu_7811Normalizer214getNFCInstanceER10UErrorCode: 263| 7.71k|Normalizer2::getNFCInstance(UErrorCode &errorCode) { 264| 7.71k| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 265| 7.71k| return allModes!=nullptr ? &allModes->comp : nullptr; ------------------ | Branch (265:12): [True: 7.71k, False: 0] ------------------ 266| 7.71k|} _ZN6icu_7811Normalizer214getNFDInstanceER10UErrorCode: 269| 16.9M|Normalizer2::getNFDInstance(UErrorCode &errorCode) { 270| 16.9M| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 271| 16.9M| return allModes!=nullptr ? &allModes->decomp : nullptr; ------------------ | Branch (271:12): [True: 16.9M, False: 10] ------------------ 272| 16.9M|} _ZN6icu_7818Normalizer2Factory14getFCDInstanceER10UErrorCode: 274| 7.71k|const Normalizer2 *Normalizer2Factory::getFCDInstance(UErrorCode &errorCode) { 275| 7.71k| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 276| 7.71k| return allModes!=nullptr ? &allModes->fcd : nullptr; ------------------ | Branch (276:12): [True: 7.71k, False: 0] ------------------ 277| 7.71k|} _ZN6icu_7818Normalizer2Factory10getNFCImplER10UErrorCode: 285| 6.78M|Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) { 286| 6.78M| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 287| 6.78M| return allModes!=nullptr ? allModes->impl : nullptr; ------------------ | Branch (287:12): [True: 6.78M, False: 10] ------------------ 288| 6.78M|} u_getCombiningClass_78: 551| 8.29M|u_getCombiningClass(UChar32 c) { 552| 8.29M| UErrorCode errorCode=U_ZERO_ERROR; 553| 8.29M| const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode); 554| 8.29M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (554:8): [True: 8.29M, False: 0] ------------------ 555| 8.29M| return nfd->getCombiningClass(c); 556| 8.29M| } else { 557| 0| return 0; 558| 0| } 559| 8.29M|} normalizer2.cpp:_ZN6icu_78L16initNFCSingletonER10UErrorCode: 250| 1|static void U_CALLCONV initNFCSingleton(UErrorCode &errorCode) { 251| 1| nfcSingleton=Norm2AllModes::createNFCInstance(errorCode); 252| 1| ucln_common_registerCleanup(UCLN_COMMON_NORMALIZER2, uprv_normalizer2_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 253| 1|} _ZN6icu_7816ReorderingBuffer4initEiR10UErrorCode: 182| 55.8M|UBool ReorderingBuffer::init(int32_t destCapacity, UErrorCode &errorCode) { 183| 55.8M| int32_t length=str.length(); 184| 55.8M| start=str.getBuffer(destCapacity); 185| 55.8M| if(start==nullptr) { ------------------ | Branch (185:8): [True: 0, False: 55.8M] ------------------ 186| | // getBuffer() already did str.setToBogus() 187| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 188| 0| return false; 189| 0| } 190| 55.8M| limit=start+length; 191| 55.8M| remainingCapacity=str.getCapacity()-length; 192| 55.8M| reorderStart=start; 193| 55.8M| if(start==limit) { ------------------ | Branch (193:8): [True: 55.8M, False: 0] ------------------ 194| 55.8M| lastCC=0; 195| 55.8M| } else { 196| 0| setIterator(); 197| 0| lastCC=previousCC(); 198| | // Set reorderStart after the last code point with cc<=1 if there is one. 199| 0| if(lastCC>1) { ------------------ | Branch (199:12): [True: 0, False: 0] ------------------ 200| 0| while(previousCC()>1) {} ------------------ | Branch (200:19): [True: 0, False: 0] ------------------ 201| 0| } 202| 0| reorderStart=codePointLimit; 203| 0| } 204| 55.8M| return true; 205| 55.8M|} _ZN6icu_7816ReorderingBuffer19appendSupplementaryEihR10UErrorCode: 240| 180k|UBool ReorderingBuffer::appendSupplementary(UChar32 c, uint8_t cc, UErrorCode &errorCode) { 241| 180k| if(remainingCapacity<2 && !resize(2, errorCode)) { ------------------ | Branch (241:8): [True: 1.04k, False: 179k] | Branch (241:31): [True: 0, False: 1.04k] ------------------ 242| 0| return false; 243| 0| } 244| 180k| if(lastCC<=cc || cc==0) { ------------------ | Branch (244:8): [True: 103k, False: 77.3k] | Branch (244:22): [True: 16.5k, False: 60.7k] ------------------ 245| 119k| limit[0]=U16_LEAD(c); ------------------ | | 123| 119k|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 246| 119k| limit[1]=U16_TRAIL(c); ------------------ | | 132| 119k|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 247| 119k| limit+=2; 248| 119k| lastCC=cc; 249| 119k| if(cc<=1) { ------------------ | Branch (249:12): [True: 18.2k, False: 101k] ------------------ 250| 18.2k| reorderStart=limit; 251| 18.2k| } 252| 119k| } else { 253| 60.7k| insert(c, cc); 254| 60.7k| } 255| 180k| remainingCapacity-=2; 256| 180k| return true; 257| 180k|} _ZN6icu_7816ReorderingBuffer6appendEPKDsiahhR10UErrorCode: 261| 25.2M| UErrorCode &errorCode) { 262| 25.2M| if(length==0) { ------------------ | Branch (262:8): [True: 0, False: 25.2M] ------------------ 263| 0| return true; 264| 0| } 265| 25.2M| if(remainingCapacity(sLimit - s); 323| 33.1M| if(remainingCapacity(reorderStart - start); 354| 23.3k| int32_t length = static_cast(limit - start); 355| 23.3k| str.releaseBuffer(length); 356| 23.3k| int32_t newCapacity=length+appendLength; 357| 23.3k| int32_t doubleCapacity=2*str.getCapacity(); 358| 23.3k| if(newCapacity=codePointStart) { ------------------ | Branch (386:8): [True: 898k, False: 117M] ------------------ 387| 898k| return 0; 388| 898k| } 389| 117M| UChar32 c=*--codePointStart; 390| 117M| char16_t c2; 391| 117M| if(U16_IS_TRAIL(c) && startcc;) {} ------------------ | Branch (401:40): [True: 109M, False: 8.75M] ------------------ 402| | // insert c at codePointLimit, after the character with prevCC<=cc 403| 8.75M| char16_t *q=limit; 404| 8.75M| char16_t *r=limit+=U16_LENGTH(c); ------------------ | | 141| 8.75M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 8.69M, False: 60.7k] | | ------------------ ------------------ 405| 118M| do { 406| 118M| *--r=*--q; 407| 118M| } while(codePointLimit!=q); ------------------ | Branch (407:13): [True: 109M, False: 8.75M] ------------------ 408| 8.75M| writeCodePoint(q, c); 409| 8.75M| if(cc<=1) { ------------------ | Branch (409:8): [True: 8.47k, False: 8.74M] ------------------ 410| 8.47k| reorderStart=r; 411| 8.47k| } 412| 8.75M|} _ZN6icu_7815Normalizer2Impl4initEPKiPK7UCPTriePKtPKh: 431| 1| const uint16_t *inExtraData, const uint8_t *inSmallFCD) { 432| 1| minDecompNoCP = static_cast(inIndexes[IX_MIN_DECOMP_NO_CP]); 433| 1| minCompNoMaybeCP = static_cast(inIndexes[IX_MIN_COMP_NO_MAYBE_CP]); 434| 1| minLcccCP = static_cast(inIndexes[IX_MIN_LCCC_CP]); 435| | 436| 1| minYesNo = static_cast(inIndexes[IX_MIN_YES_NO]); 437| 1| minYesNoMappingsOnly = static_cast(inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY]); 438| 1| minNoNo = static_cast(inIndexes[IX_MIN_NO_NO]); 439| 1| minNoNoCompBoundaryBefore = static_cast(inIndexes[IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]); 440| 1| minNoNoCompNoMaybeCC = static_cast(inIndexes[IX_MIN_NO_NO_COMP_NO_MAYBE_CC]); 441| 1| minNoNoEmpty = static_cast(inIndexes[IX_MIN_NO_NO_EMPTY]); 442| 1| limitNoNo = static_cast(inIndexes[IX_LIMIT_NO_NO]); 443| 1| minMaybeNo = static_cast(inIndexes[IX_MIN_MAYBE_NO]); 444| 1| minMaybeNoCombinesFwd = static_cast(inIndexes[IX_MIN_MAYBE_NO_COMBINES_FWD]); 445| 1| minMaybeYes = static_cast(inIndexes[IX_MIN_MAYBE_YES]); 446| 1| U_ASSERT((minMaybeNo & 7) == 0); // 8-aligned for noNoDelta bit fields ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 447| 1| centerNoNoDelta = (minMaybeNo >> DELTA_SHIFT) - MAX_DELTA - 1; 448| | 449| 1| normTrie=inTrie; 450| 1| extraData=inExtraData; 451| 1| smallFCD=inSmallFCD; 452| 1|} _ZNK6icu_7815Normalizer2Impl17addPropertyStartsEPK9USetAdderR10UErrorCode: 481| 1|Normalizer2Impl::addPropertyStarts(const USetAdder *sa, UErrorCode & /*errorCode*/) const { 482| | // Add the start code point of each same-value range of the trie. 483| 1| UChar32 start = 0, end; 484| 1| uint32_t value; 485| 4.01k| while ((end = ucptrie_getRange(normTrie, start, UCPMAP_RANGE_FIXED_LEAD_SURROGATES, INERT, ------------------ | | 806| 4.01k|#define ucptrie_getRange U_ICU_ENTRY_POINT_RENAME(ucptrie_getRange) | | ------------------ | | | | 123| 4.01k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.01k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.01k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (485:12): [True: 4.00k, False: 1] ------------------ 486| 4.01k| nullptr, nullptr, &value)) >= 0) { 487| 4.00k| sa->add(sa->set, start); 488| 4.00k| if (start != end && isAlgorithmicNoNo(static_cast(value)) && ------------------ | Branch (488:13): [True: 934, False: 3.07k] | Branch (488:29): [True: 1, False: 933] ------------------ 489| 4.00k| (value & Normalizer2Impl::DELTA_TCCC_MASK) > Normalizer2Impl::DELTA_TCCC_1) { ------------------ | Branch (489:17): [True: 0, False: 1] ------------------ 490| | // Range of code points with same-norm16-value algorithmic decompositions. 491| | // They might have different non-zero FCD16 values. 492| 0| uint16_t prevFCD16 = getFCD16(start); 493| 0| while (++start <= end) { ------------------ | Branch (493:20): [True: 0, False: 0] ------------------ 494| 0| uint16_t fcd16 = getFCD16(start); 495| 0| if (fcd16 != prevFCD16) { ------------------ | Branch (495:21): [True: 0, False: 0] ------------------ 496| 0| sa->add(sa->set, start); 497| 0| prevFCD16 = fcd16; 498| 0| } 499| 0| } 500| 0| } 501| 4.00k| start = end + 1; 502| 4.00k| } 503| | 504| | /* add Hangul LV syllables and LV+1 because of skippables */ 505| 400| for(char16_t c=Hangul::HANGUL_BASE; cadd(sa->set, c); 507| 399| sa->add(sa->set, c+1); 508| 399| } 509| 1| sa->add(sa->set, Hangul::HANGUL_LIMIT); /* add Hangul+1 to continue with other properties */ 510| 1|} _ZNK6icu_7815Normalizer2Impl9decomposeEPKDsS2_RNS_13UnicodeStringEiR10UErrorCode: 570| 21.0k| UErrorCode &errorCode) const { 571| 21.0k| if(destLengthEstimate<0 && limit!=nullptr) { ------------------ | Branch (571:8): [True: 0, False: 21.0k] | Branch (571:32): [True: 0, False: 0] ------------------ 572| 0| destLengthEstimate = static_cast(limit - src); 573| 0| } 574| 21.0k| dest.remove(); 575| 21.0k| ReorderingBuffer buffer(*this, dest); 576| 21.0k| if(buffer.init(destLengthEstimate, errorCode)) { ------------------ | Branch (576:8): [True: 21.0k, False: 0] ------------------ 577| 21.0k| decompose(src, limit, &buffer, errorCode); 578| 21.0k| } 579| 21.0k|} _ZNK6icu_7815Normalizer2Impl9decomposeEPKDsS2_PNS_16ReorderingBufferER10UErrorCode: 587| 55.8M| UErrorCode &errorCode) const { 588| 55.8M| UChar32 minNoCP=minDecompNoCP; 589| 55.8M| if(limit==nullptr) { ------------------ | Branch (589:8): [True: 0, False: 55.8M] ------------------ 590| 0| src=copyLowPrefixFromNulTerminated(src, minNoCP, buffer, errorCode); 591| 0| if(U_FAILURE(errorCode)) { ------------------ | Branch (591:12): [True: 0, False: 0] ------------------ 592| 0| return src; 593| 0| } 594| 0| limit=u_strchr(src, 0); ------------------ | | 385| 0|#define u_strchr U_ICU_ENTRY_POINT_RENAME(u_strchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 595| 0| } 596| | 597| 55.8M| const char16_t *prevSrc; 598| 55.8M| UChar32 c=0; 599| 55.8M| uint16_t norm16=0; 600| | 601| | // only for quick check 602| 55.8M| const char16_t *prevBoundary=src; 603| 55.8M| uint8_t prevCC=0; 604| | 605| 127M| for(;;) { 606| | // count code units below the minimum or with irrelevant data for the quick check 607| 153M| for(prevSrc=src; src!=limit;) { ------------------ | Branch (607:26): [True: 97.8M, False: 55.8M] ------------------ 608| 97.8M| if( (c=*src)data.ptr16[i]) | | | | ------------------ | | ------------------ ------------------ | Branch (609:17): [True: 21.5M, False: 71.4M] ------------------ 610| 97.8M| ) { 611| 26.4M| ++src; 612| 71.4M| } else if(!U16_IS_LEAD(c)) { ------------------ | | 59| 71.4M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ | Branch (612:23): [True: 71.0M, False: 367k] ------------------ 613| 71.0M| break; 614| 71.0M| } else { 615| 367k| char16_t c2; 616| 367k| if((src+1)!=limit && U16_IS_TRAIL(c2=src[1])) { ------------------ | | 67| 367k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 366k, False: 750] | | ------------------ ------------------ | Branch (616:20): [True: 367k, False: 8] ------------------ 617| 366k| c=U16_GET_SUPPLEMENTARY(c, c2); ------------------ | | 113| 366k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 366k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 618| 366k| norm16=UCPTRIE_FAST_SUPP_GET(normTrie, UCPTRIE_16, c); ------------------ | | 542| 366k|#define UCPTRIE_FAST_SUPP_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_SMALL_INDEX(trie, c)) | | ------------------ | | | | 618| 366k| norm16=UCPTRIE_FAST_SUPP_GET(normTrie, UCPTRIE_16, c); | | | | ------------------ | | | | | | 326| 733k|#define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i]) | | | | | | ------------------ | | | | | | | Branch (326:49): [True: 0, False: 366k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 619| 366k| if(isMostDecompYesAndZeroCC(norm16)) { ------------------ | Branch (619:24): [True: 23.6k, False: 343k] ------------------ 620| 23.6k| src+=2; 621| 343k| } else { 622| 343k| break; 623| 343k| } 624| 366k| } else { 625| 758| ++src; // unpaired lead surrogate: inert 626| 758| } 627| 367k| } 628| 97.8M| } 629| | // copy these code units all at once 630| 127M| if(src!=prevSrc) { ------------------ | Branch (630:12): [True: 23.0M, False: 104M] ------------------ 631| 23.0M| if(buffer!=nullptr) { ------------------ | Branch (631:16): [True: 23.0M, False: 712] ------------------ 632| 23.0M| if(!buffer->appendZeroCC(prevSrc, src, errorCode)) { ------------------ | Branch (632:20): [True: 0, False: 23.0M] ------------------ 633| 0| break; 634| 0| } 635| 23.0M| } else { 636| 712| prevCC=0; 637| 712| prevBoundary=src; 638| 712| } 639| 23.0M| } 640| 127M| if(src==limit) { ------------------ | Branch (640:12): [True: 55.8M, False: 71.3M] ------------------ 641| 55.8M| break; 642| 55.8M| } 643| | 644| | // Check one above-minimum, relevant code point. 645| 71.3M| src+=U16_LENGTH(c); ------------------ | | 141| 71.3M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 71.0M, False: 343k] | | ------------------ ------------------ 646| 71.3M| if(buffer!=nullptr) { ------------------ | Branch (646:12): [True: 71.3M, False: 772] ------------------ 647| 71.3M| if(!decompose(c, norm16, *buffer, errorCode)) { ------------------ | Branch (647:16): [True: 0, False: 71.3M] ------------------ 648| 0| break; 649| 0| } 650| 71.3M| } else { 651| 772| if(isDecompYes(norm16)) { ------------------ | Branch (651:16): [True: 458, False: 314] ------------------ 652| 458| uint8_t cc=getCCFromYesOrMaybeYes(norm16); 653| 458| if(prevCC<=cc || cc==0) { ------------------ | Branch (653:20): [True: 456, False: 2] | Branch (653:34): [True: 0, False: 2] ------------------ 654| 456| prevCC=cc; 655| 456| if(cc<=1) { ------------------ | Branch (655:24): [True: 52, False: 404] ------------------ 656| 52| prevBoundary=src; 657| 52| } 658| 456| continue; 659| 456| } 660| 458| } 661| 316| return prevBoundary; // "no" or cc out of order 662| 772| } 663| 71.3M| } 664| 55.8M| return src; 665| 55.8M|} _ZNK6icu_7815Normalizer2Impl9decomposeEitRNS_16ReorderingBufferER10UErrorCode: 701| 71.3M| UErrorCode &errorCode) const { 702| | // get the decomposition and the lead and trail cc's 703| 71.3M| if (norm16 >= limitNoNo) { ------------------ | Branch (703:9): [True: 36.0M, False: 35.3M] ------------------ 704| 36.0M| if (isMaybeYesOrNonZeroCC(norm16)) { ------------------ | Branch (704:13): [True: 36.0M, False: 24.8k] ------------------ 705| 36.0M| return buffer.append(c, getCCFromYesOrMaybeYes(norm16), errorCode); 706| 36.0M| } else if (norm16 < minMaybeNo) { ------------------ | Branch (706:20): [True: 14.5k, False: 10.3k] ------------------ 707| | // Maps to an isCompYesAndZeroCC. 708| 14.5k| c=mapAlgorithmic(c, norm16); 709| 14.5k| norm16=getRawNorm16(c); 710| 14.5k| } 711| 36.0M| } 712| 35.3M| if (norm16 < minYesNo) { ------------------ | Branch (712:9): [True: 14.5k, False: 35.3M] ------------------ 713| | // c does not decompose 714| 14.5k| return buffer.append(c, 0, errorCode); 715| 35.3M| } else if(isHangulLV(norm16) || isHangulLVT(norm16)) { ------------------ | Branch (715:15): [True: 399k, False: 34.9M] | Branch (715:37): [True: 9.68M, False: 25.2M] ------------------ 716| | // Hangul syllable: decompose algorithmically 717| 10.0M| char16_t jamos[3]; 718| 10.0M| return buffer.appendZeroCC(jamos, jamos+Hangul::decompose(c, jamos), errorCode); 719| 10.0M| } 720| | // c decomposes, get everything from the variable-length extra data 721| 25.2M| const uint16_t *mapping=getData(norm16); 722| 25.2M| uint16_t firstUnit=*mapping; 723| 25.2M| int32_t length=firstUnit&MAPPING_LENGTH_MASK; 724| 25.2M| uint8_t leadCC, trailCC; 725| 25.2M| trailCC = static_cast(firstUnit >> 8); 726| 25.2M| if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) { ------------------ | Branch (726:8): [True: 6.12M, False: 19.1M] ------------------ 727| 6.12M| leadCC = static_cast(*(mapping - 1) >> 8); 728| 19.1M| } else { 729| 19.1M| leadCC=0; 730| 19.1M| } 731| 25.2M| return buffer.append(reinterpret_cast(mapping) + 1, length, true, leadCC, trailCC, errorCode); 732| 35.3M|} _ZNK6icu_7815Normalizer2Impl16getDecompositionEiPDsRi: 948| 9.49M|Normalizer2Impl::getDecomposition(UChar32 c, char16_t buffer[4], int32_t &length) const { 949| 9.49M| uint16_t norm16; 950| 9.49M| if(c>10)+0xd7c0); \ | | 372| 0| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 373| 0| } \ | | 374| 9.14k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 9.14k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 961| | // The mapping might decompose further. 962| 9.14k| norm16 = getRawNorm16(c); 963| 9.14k| } 964| 9.49M| if (norm16 < minYesNo) { ------------------ | Branch (964:9): [True: 9.14k, False: 9.48M] ------------------ 965| 9.14k| return decomp; 966| 9.48M| } else if(isHangulLV(norm16) || isHangulLVT(norm16)) { ------------------ | Branch (966:15): [True: 0, False: 9.48M] | Branch (966:37): [True: 0, False: 9.48M] ------------------ 967| | // Hangul syllable: decompose algorithmically 968| 0| length=Hangul::decompose(c, buffer); 969| 0| return buffer; 970| 0| } 971| | // c decomposes, get everything from the variable-length extra data 972| 9.48M| const uint16_t *mapping=getData(norm16); 973| 9.48M| length=*mapping&MAPPING_LENGTH_MASK; 974| 9.48M| return reinterpret_cast(mapping) + 1; 975| 9.49M|} _ZNK6icu_7815Normalizer2Impl13addCompositesEPKtRNS_10UnicodeSetE: 1191| 3.88M|void Normalizer2Impl::addComposites(const uint16_t *list, UnicodeSet &set) const { 1192| 3.88M| uint16_t firstUnit; 1193| 3.88M| int32_t compositeAndFwd; 1194| 17.6M| do { 1195| 17.6M| firstUnit=*list; 1196| 17.6M| if((firstUnit&COMP_1_TRIPLE)==0) { ------------------ | Branch (1196:12): [True: 17.6M, False: 13.9k] ------------------ 1197| 17.6M| compositeAndFwd=list[1]; 1198| 17.6M| list+=2; 1199| 17.6M| } else { 1200| 13.9k| compositeAndFwd = ((static_cast(list[1]) & ~COMP_2_TRAIL_MASK) << 16) | list[2]; 1201| 13.9k| list+=3; 1202| 13.9k| } 1203| 17.6M| UChar32 composite=compositeAndFwd>>1; 1204| 17.6M| if((compositeAndFwd&1)!=0) { ------------------ | Branch (1204:12): [True: 2.78M, False: 14.8M] ------------------ 1205| 2.78M| addComposites(getCompositionsListForComposite(getRawNorm16(composite)), set); 1206| 2.78M| } 1207| 17.6M| set.add(composite); 1208| 17.6M| } while((firstUnit&COMP_1_LAST_TUPLE)==0); ------------------ | Branch (1208:13): [True: 13.7M, False: 3.88M] ------------------ 1209| 3.88M|} _ZNK6icu_7815Normalizer2Impl20getFCD16FromNormDataEi: 2248| 120M|uint16_t Normalizer2Impl::getFCD16FromNormData(UChar32 c) const { 2249| 120M| uint16_t norm16=getNorm16(c); 2250| 120M| if (norm16 >= limitNoNo) { ------------------ | Branch (2250:9): [True: 59.6M, False: 60.8M] ------------------ 2251| 59.6M| if(norm16>=MIN_NORMAL_MAYBE_YES) { ------------------ | Branch (2251:12): [True: 59.5M, False: 17.6k] ------------------ 2252| | // combining mark 2253| 59.5M| norm16=getCCFromNormalYesOrMaybe(norm16); 2254| 59.5M| return norm16|(norm16<<8); 2255| 59.5M| } else if(norm16>=minMaybeYes) { ------------------ | Branch (2255:19): [True: 6.67k, False: 10.9k] ------------------ 2256| 6.67k| return 0; 2257| 10.9k| } else if(norm16> OFFSET_SHIFT; 2261| 0| } 2262| | // Maps to an isCompYesAndZeroCC. 2263| 0| c=mapAlgorithmic(c, norm16); 2264| 0| norm16=getRawNorm16(c); 2265| 0| } 2266| 59.6M| } 2267| 60.8M| if(norm16<=minYesNo || isHangulLVT(norm16)) { ------------------ | Branch (2267:8): [True: 7.08M, False: 53.7M] | Branch (2267:28): [True: 0, False: 53.7M] ------------------ 2268| | // no decomposition or Hangul syllable, all zeros 2269| 7.08M| return 0; 2270| 7.08M| } 2271| | // c decomposes, get everything from the variable-length extra data 2272| 53.7M| const uint16_t *mapping=getData(norm16); 2273| 53.7M| uint16_t firstUnit=*mapping; 2274| 53.7M| norm16=firstUnit>>8; // tccc 2275| 53.7M| if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) { ------------------ | Branch (2275:8): [True: 33.9M, False: 19.8M] ------------------ 2276| 33.9M| norm16|=*(mapping-1)&0xff00; // lccc 2277| 33.9M| } 2278| 53.7M| return norm16; 2279| 60.8M|} _ZNK6icu_7815Normalizer2Impl7makeFCDEPKDsS2_PNS_16ReorderingBufferER10UErrorCode: 2307| 9.80M| UErrorCode &errorCode) const { 2308| | // Tracks the last FCD-safe boundary, before lccc=0 or after properly-ordered tccc<=1. 2309| | // Similar to the prevBoundary in the compose() implementation. 2310| 9.80M| const char16_t *prevBoundary=src; 2311| 9.80M| int32_t prevFCD16=0; 2312| 9.80M| if(limit==nullptr) { ------------------ | Branch (2312:8): [True: 0, False: 9.80M] ------------------ 2313| 0| src=copyLowPrefixFromNulTerminated(src, minLcccCP, buffer, errorCode); 2314| 0| if(U_FAILURE(errorCode)) { ------------------ | Branch (2314:12): [True: 0, False: 0] ------------------ 2315| 0| return src; 2316| 0| } 2317| 0| if(prevBoundary1) { ------------------ | Branch (2322:16): [True: 0, False: 0] ------------------ 2323| 0| --prevBoundary; 2324| 0| } 2325| 0| } 2326| 0| limit=u_strchr(src, 0); ------------------ | | 385| 0|#define u_strchr U_ICU_ENTRY_POINT_RENAME(u_strchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2327| 0| } 2328| | 2329| | // Note: In this function we use buffer->appendZeroCC() because we track 2330| | // the lead and trail combining classes here, rather than leaving it to 2331| | // the ReorderingBuffer. 2332| | // The exception is the call to decomposeShort() which uses the buffer 2333| | // in the normal way. 2334| | 2335| 9.80M| const char16_t *prevSrc; 2336| 9.80M| UChar32 c=0; 2337| 9.80M| uint16_t fcd16=0; 2338| | 2339| 60.0M| for(;;) { 2340| | // count code units with lccc==0 2341| 173M| for(prevSrc=src; src!=limit;) { ------------------ | Branch (2341:26): [True: 164M, False: 8.67M] ------------------ 2342| 164M| if((c=*src)appendZeroCC(prevSrc, src, errorCode)) { ------------------ | Branch (2365:16): [True: 0, False: 55.8M] | Branch (2365:35): [True: 0, False: 0] ------------------ 2366| 0| break; 2367| 0| } 2368| 55.8M| if(src==limit) { ------------------ | Branch (2368:16): [True: 7.16M, False: 48.6M] ------------------ 2369| 7.16M| break; 2370| 7.16M| } 2371| 48.6M| prevBoundary=src; 2372| | // We know that the previous character's lccc==0. 2373| 48.6M| if(prevFCD16<0) { ------------------ | Branch (2373:16): [True: 2.29M, False: 46.3M] ------------------ 2374| | // Fetching the fcd16 value was deferred for this below-minLcccCP code point. 2375| 2.29M| UChar32 prev=~prevFCD16; 2376| 2.29M| if(prev1) { ------------------ | Branch (2380:24): [True: 420k, False: 62.0k] ------------------ 2381| 420k| --prevBoundary; 2382| 420k| } 2383| 482k| } 2384| 46.3M| } else { 2385| 46.3M| const char16_t *p=src-1; 2386| 46.3M| if(U16_IS_TRAIL(*p) && prevSrc

1) { ------------------ | Branch (2393:20): [True: 312k, False: 46.0M] ------------------ 2394| 312k| prevBoundary=p; 2395| 312k| } 2396| 46.3M| } 2397| | // The start of the current character (c). 2398| 48.6M| prevSrc=src; 2399| 48.6M| } else if(src==limit) { ------------------ | Branch (2399:19): [True: 1.51M, False: 2.73M] ------------------ 2400| 1.51M| break; 2401| 1.51M| } 2402| | 2403| 51.4M| src+=U16_LENGTH(c); ------------------ | | 141| 51.4M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 51.3M, False: 99.5k] | | ------------------ ------------------ 2404| | // The current character (c) at [prevSrc..src[ has a non-zero lead combining class. 2405| | // Check for proper order, and decompose locally if necessary. 2406| 51.4M| if((prevFCD16&0xff)<=(fcd16>>8)) { ------------------ | Branch (2406:12): [True: 50.2M, False: 1.13M] ------------------ 2407| | // proper order: prev tccc <= current lccc 2408| 50.2M| if((fcd16&0xff)<=1) { ------------------ | Branch (2408:16): [True: 46.0k, False: 50.2M] ------------------ 2409| 46.0k| prevBoundary=src; 2410| 46.0k| } 2411| 50.2M| if(buffer!=nullptr && !buffer->appendZeroCC(c, errorCode)) { ------------------ | Branch (2411:16): [True: 0, False: 50.2M] | Branch (2411:35): [True: 0, False: 0] ------------------ 2412| 0| break; 2413| 0| } 2414| 50.2M| prevFCD16=fcd16; 2415| 50.2M| continue; 2416| 50.2M| } else if(buffer==nullptr) { ------------------ | Branch (2416:19): [True: 1.13M, False: 0] ------------------ 2417| 1.13M| return prevBoundary; // quick check "no" 2418| 1.13M| } else { 2419| | /* 2420| | * Back out the part of the source that we copied or appended 2421| | * already but is now going to be decomposed. 2422| | * prevSrc is set to after what was copied/appended. 2423| | */ 2424| 0| buffer->removeSuffix(static_cast(prevSrc - prevBoundary)); 2425| | /* 2426| | * Find the part of the source that needs to be decomposed, 2427| | * up to the next safe boundary. 2428| | */ 2429| 0| src=findNextFCDBoundary(src, limit); 2430| | /* 2431| | * The source text does not fulfill the conditions for FCD. 2432| | * Decompose and reorder a limited piece of the text. 2433| | */ 2434| 0| decomposeShort(prevBoundary, src, false, false, *buffer, errorCode); 2435| 0| if (U_FAILURE(errorCode)) { ------------------ | Branch (2435:17): [True: 0, False: 0] ------------------ 2436| 0| break; 2437| 0| } 2438| 0| prevBoundary=src; 2439| 0| prevFCD16=0; 2440| 0| } 2441| 51.4M| } 2442| 8.67M| return src; 2443| 9.80M|} _ZN6icu_7813CanonIterDataC2ER10UErrorCode: 2513| 1| mutableTrie(umutablecptrie_open(0, 0, &errorCode)), trie(nullptr), ------------------ | | 1259| 1|#define umutablecptrie_open U_ICU_ENTRY_POINT_RENAME(umutablecptrie_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2514| 1| canonStartSets(uprv_deleteUObject, nullptr, errorCode) {} ------------------ | | 1489| 1|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ _ZN6icu_7813CanonIterData13addToStartSetEiiR10UErrorCode: 2521| 1.12k|void CanonIterData::addToStartSet(UChar32 origin, UChar32 decompLead, UErrorCode &errorCode) { 2522| 1.12k| uint32_t canonValue = umutablecptrie_get(mutableTrie, decompLead); ------------------ | | 1257| 1.12k|#define umutablecptrie_get U_ICU_ENTRY_POINT_RENAME(umutablecptrie_get) | | ------------------ | | | | 123| 1.12k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.12k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.12k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2523| 1.12k| if((canonValue&(CANON_HAS_SET|CANON_VALUE_MASK))==0 && origin!=0) { ------------------ | | 757| 1.12k|#define CANON_HAS_SET 0x200000 ------------------ if((canonValue&(CANON_HAS_SET|CANON_VALUE_MASK))==0 && origin!=0) { ------------------ | | 758| 1.12k|#define CANON_VALUE_MASK 0x1fffff ------------------ | Branch (2523:8): [True: 994, False: 126] | Branch (2523:60): [True: 994, False: 0] ------------------ 2524| | // origin is the first character whose decomposition starts with 2525| | // the character for which we are setting the value. 2526| 994| umutablecptrie_set(mutableTrie, decompLead, canonValue|origin, &errorCode); ------------------ | | 1260| 994|#define umutablecptrie_set U_ICU_ENTRY_POINT_RENAME(umutablecptrie_set) | | ------------------ | | | | 123| 994|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 994|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 994|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2527| 994| } else { 2528| | // origin is not the first character, or it is U+0000. 2529| 126| UnicodeSet *set; 2530| 126| if((canonValue&CANON_HAS_SET)==0) { ------------------ | | 757| 126|#define CANON_HAS_SET 0x200000 ------------------ | Branch (2530:12): [True: 102, False: 24] ------------------ 2531| 102| LocalPointer lpSet(new UnicodeSet, errorCode); 2532| 102| set=lpSet.getAlias(); 2533| 102| if(U_FAILURE(errorCode)) { ------------------ | Branch (2533:16): [True: 0, False: 102] ------------------ 2534| 0| return; 2535| 0| } 2536| 102| UChar32 firstOrigin = static_cast(canonValue & CANON_VALUE_MASK); ------------------ | | 758| 102|#define CANON_VALUE_MASK 0x1fffff ------------------ 2537| 102| canonValue = (canonValue & ~CANON_VALUE_MASK) | CANON_HAS_SET | static_cast(canonStartSets.size()); ------------------ | | 758| 102|#define CANON_VALUE_MASK 0x1fffff ------------------ canonValue = (canonValue & ~CANON_VALUE_MASK) | CANON_HAS_SET | static_cast(canonStartSets.size()); ------------------ | | 757| 102|#define CANON_HAS_SET 0x200000 ------------------ 2538| 102| umutablecptrie_set(mutableTrie, decompLead, canonValue, &errorCode); ------------------ | | 1260| 102|#define umutablecptrie_set U_ICU_ENTRY_POINT_RENAME(umutablecptrie_set) | | ------------------ | | | | 123| 102|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 102|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 102|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2539| 102| canonStartSets.adoptElement(lpSet.orphan(), errorCode); 2540| 102| if (U_FAILURE(errorCode)) { ------------------ | Branch (2540:17): [True: 0, False: 102] ------------------ 2541| 0| return; 2542| 0| } 2543| 102| if(firstOrigin!=0) { ------------------ | Branch (2543:16): [True: 102, False: 0] ------------------ 2544| 102| set->add(firstOrigin); 2545| 102| } 2546| 102| } else { 2547| 24| set = static_cast(canonStartSets[static_cast(canonValue & CANON_VALUE_MASK)]); ------------------ | | 758| 24|#define CANON_VALUE_MASK 0x1fffff ------------------ 2548| 24| } 2549| 126| set->add(origin); 2550| 126| } 2551| 1.12k|} _ZN6icu_7817InitCanonIterData6doInitEPNS_15Normalizer2ImplER10UErrorCode: 2569| 1|void InitCanonIterData::doInit(Normalizer2Impl *impl, UErrorCode &errorCode) { 2570| 1| U_ASSERT(impl->fCanonIterData == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 2571| 1| impl->fCanonIterData = new CanonIterData(errorCode); 2572| 1| if (impl->fCanonIterData == nullptr) { ------------------ | Branch (2572:9): [True: 0, False: 1] ------------------ 2573| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 2574| 0| } 2575| 1| if (U_SUCCESS(errorCode)) { ------------------ | Branch (2575:9): [True: 1, False: 0] ------------------ 2576| 1| UChar32 start = 0, end; 2577| 1| uint32_t value; 2578| 4.01k| while ((end = ucptrie_getRange(impl->normTrie, start, ------------------ | | 806| 4.01k|#define ucptrie_getRange U_ICU_ENTRY_POINT_RENAME(ucptrie_getRange) | | ------------------ | | | | 123| 4.01k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.01k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.01k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2578:16): [True: 4.00k, False: 1] ------------------ 2579| 4.01k| UCPMAP_RANGE_FIXED_LEAD_SURROGATES, Normalizer2Impl::INERT, 2580| 4.01k| nullptr, nullptr, &value)) >= 0) { 2581| | // Call Normalizer2Impl::makeCanonIterDataFromNorm16() for a range of same-norm16 characters. 2582| 4.00k| if (value != Normalizer2Impl::INERT) { ------------------ | Branch (2582:17): [True: 3.55k, False: 452] ------------------ 2583| 3.55k| impl->makeCanonIterDataFromNorm16(start, end, value, *impl->fCanonIterData, errorCode); 2584| 3.55k| } 2585| 4.00k| start = end + 1; 2586| 4.00k| } 2587| |#ifdef UCPTRIE_DEBUG 2588| | umutablecptrie_setName(impl->fCanonIterData->mutableTrie, "CanonIterData"); 2589| |#endif 2590| 1| impl->fCanonIterData->trie = umutablecptrie_buildImmutable( ------------------ | | 1252| 1|#define umutablecptrie_buildImmutable U_ICU_ENTRY_POINT_RENAME(umutablecptrie_buildImmutable) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2591| 1| impl->fCanonIterData->mutableTrie, UCPTRIE_TYPE_SMALL, UCPTRIE_VALUE_BITS_32, &errorCode); 2592| 1| umutablecptrie_close(impl->fCanonIterData->mutableTrie); ------------------ | | 1254| 1|#define umutablecptrie_close U_ICU_ENTRY_POINT_RENAME(umutablecptrie_close) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2593| 1| impl->fCanonIterData->mutableTrie = nullptr; 2594| 1| } 2595| 1| if (U_FAILURE(errorCode)) { ------------------ | Branch (2595:9): [True: 0, False: 1] ------------------ 2596| 0| delete impl->fCanonIterData; 2597| 0| impl->fCanonIterData = nullptr; 2598| 0| } 2599| 1|} _ZNK6icu_7815Normalizer2Impl27makeCanonIterDataFromNorm16EiitRNS_13CanonIterDataER10UErrorCode: 2603| 3.55k| UErrorCode &errorCode) const { 2604| 3.55k| if(isInert(norm16) || ------------------ | Branch (2604:8): [True: 0, False: 3.55k] ------------------ 2605| 3.55k| (minYesNo<=norm16 && norm16 minYesNo) { ------------------ | Branch (2638:17): [True: 1.11k, False: 2] ------------------ 2639| | // c decomposes, get everything from the variable-length extra data 2640| 1.11k| const uint16_t *mapping=getDataForYesOrNo(norm16_2); 2641| 1.11k| uint16_t firstUnit=*mapping; 2642| 1.11k| int32_t length=firstUnit&MAPPING_LENGTH_MASK; 2643| 1.11k| if((firstUnit&MAPPING_HAS_CCC_LCCC_WORD)!=0) { ------------------ | Branch (2643:20): [True: 7, False: 1.11k] ------------------ 2644| 7| if(c==c2 && (*(mapping-1)&0xff)!=0) { ------------------ | Branch (2644:24): [True: 7, False: 0] | Branch (2644:33): [True: 4, False: 3] ------------------ 2645| 4| newValue|=CANON_NOT_SEGMENT_STARTER; // original c has cc!=0 ------------------ | | 755| 4|#define CANON_NOT_SEGMENT_STARTER 0x80000000 ------------------ 2646| 4| } 2647| 7| } 2648| | // Skip empty mappings (no characters in the decomposition). 2649| 1.11k| if(length!=0) { ------------------ | Branch (2649:20): [True: 1.11k, False: 0] ------------------ 2650| 1.11k| ++mapping; // skip over the firstUnit 2651| | // add c to first code point's start set 2652| 1.11k| int32_t i=0; 2653| 1.11k| U16_NEXT_UNSAFE(mapping, i, c2); ------------------ | | 281| 1.11k|#define U16_NEXT_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.11k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 282| 1.11k| (c)=(s)[(i)++]; \ | | 283| 1.11k| if(U16_IS_LEAD(c)) { \ | | ------------------ | | | | 59| 1.11k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 125, False: 993] | | | | ------------------ | | ------------------ | | 284| 125| (c)=U16_GET_SUPPLEMENTARY((c), (s)[(i)++]); \ | | ------------------ | | | | 113| 125| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 125|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 285| 125| } \ | | 286| 1.11k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.11k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2654| 1.11k| newData.addToStartSet(c, c2, errorCode); 2655| | // Set CANON_NOT_SEGMENT_STARTER for each remaining code point of a 2656| | // one-way mapping. A 2-way mapping is possible here after 2657| | // intermediate algorithmic mapping. 2658| 1.11k| if(norm16_2>=minNoNo) { ------------------ | Branch (2658:24): [True: 1.11k, False: 0] ------------------ 2659| 1.23k| while(i(this); 2683| 6.77M| umtx_initOnce(me->fCanonIterDataInitOnce, &initCanonIterData, me, errorCode); 2684| 6.77M| return U_SUCCESS(errorCode); 2685| 6.77M|} _ZNK6icu_7815Normalizer2Impl13getCanonValueEi: 2687| 20.3M|int32_t Normalizer2Impl::getCanonValue(UChar32 c) const { 2688| 20.3M| return static_cast(ucptrie_get(fCanonIterData->trie, c)); ------------------ | | 805| 20.3M|#define ucptrie_get U_ICU_ENTRY_POINT_RENAME(ucptrie_get) | | ------------------ | | | | 123| 20.3M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 20.3M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 20.3M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2689| 20.3M|} _ZNK6icu_7815Normalizer2Impl16getCanonStartSetEi: 2691| 870k|const UnicodeSet &Normalizer2Impl::getCanonStartSet(int32_t n) const { 2692| 870k| return *static_cast(fCanonIterData->canonStartSets[n]); 2693| 870k|} _ZNK6icu_7815Normalizer2Impl21isCanonSegmentStarterEi: 2695| 1.44M|UBool Normalizer2Impl::isCanonSegmentStarter(UChar32 c) const { 2696| 1.44M| return getCanonValue(c)>=0; 2697| 1.44M|} _ZNK6icu_7815Normalizer2Impl16getCanonStartSetEiRNS_10UnicodeSetE: 2699| 18.9M|UBool Normalizer2Impl::getCanonStartSet(UChar32 c, UnicodeSet &set) const { 2700| 18.9M| int32_t canonValue=getCanonValue(c)&~CANON_NOT_SEGMENT_STARTER; ------------------ | | 755| 18.9M|#define CANON_NOT_SEGMENT_STARTER 0x80000000 ------------------ 2701| 18.9M| if(canonValue==0) { ------------------ | Branch (2701:8): [True: 16.3M, False: 2.58M] ------------------ 2702| 16.3M| return false; 2703| 16.3M| } 2704| 2.58M| set.clear(); 2705| 2.58M| int32_t value=canonValue&CANON_VALUE_MASK; ------------------ | | 758| 2.58M|#define CANON_VALUE_MASK 0x1fffff ------------------ 2706| 2.58M| if((canonValue&CANON_HAS_SET)!=0) { ------------------ | | 757| 2.58M|#define CANON_HAS_SET 0x200000 ------------------ | Branch (2706:8): [True: 870k, False: 1.71M] ------------------ 2707| 870k| set.addAll(getCanonStartSet(value)); 2708| 1.71M| } else if(value!=0) { ------------------ | Branch (2708:15): [True: 690k, False: 1.02M] ------------------ 2709| 690k| set.add(value); 2710| 690k| } 2711| 2.58M| if((canonValue&CANON_HAS_COMPOSITIONS)!=0) { ------------------ | | 756| 2.58M|#define CANON_HAS_COMPOSITIONS 0x40000000 ------------------ | Branch (2711:8): [True: 1.11M, False: 1.47M] ------------------ 2712| 1.11M| uint16_t norm16=getRawNorm16(c); 2713| 1.11M| if(norm16==JAMO_L) { ------------------ | Branch (2713:12): [True: 16.9k, False: 1.09M] ------------------ 2714| 16.9k| UChar32 syllable= 2715| 16.9k| static_cast(Hangul::HANGUL_BASE + (c - Hangul::JAMO_L_BASE) * Hangul::JAMO_VT_COUNT); 2716| 16.9k| set.add(syllable, syllable+Hangul::JAMO_VT_COUNT-1); 2717| 1.09M| } else { 2718| 1.09M| addComposites(getCompositionsList(norm16), set); 2719| 1.09M| } 2720| 1.11M| } 2721| 2.58M| return true; 2722| 18.9M|} normalizer2impl.cpp:_ZN6icu_78L17initCanonIterDataEPNS_15Normalizer2ImplER10UErrorCode: 2563| 1|initCanonIterData(Normalizer2Impl *impl, UErrorCode &errorCode) { 2564| 1| InitCanonIterData::doInit(impl, errorCode); 2565| 1|} _ZN6icu_786Hangul8isHangulEi: 75| 8.61M| static inline UBool isHangul(UChar32 c) { 76| 8.61M| return HANGUL_BASE<=c && c(c - JAMO_L_BASE) < JAMO_L_COUNT; 85| 7.49M| } _ZN6icu_786Hangul7isJamoVEi: 86| 1.54M| static inline UBool isJamoV(UChar32 c) { 87| 1.54M| return static_cast(c - JAMO_V_BASE) < JAMO_V_COUNT; 88| 1.54M| } _ZN6icu_786Hangul9decomposeEiPDs: 102| 53.9M| static inline int32_t decompose(UChar32 c, char16_t buffer[3]) { 103| 53.9M| c-=HANGUL_BASE; 104| 53.9M| UChar32 c2=c%JAMO_T_COUNT; 105| 53.9M| c/=JAMO_T_COUNT; 106| 53.9M| buffer[0] = static_cast(JAMO_L_BASE + c / JAMO_V_COUNT); 107| 53.9M| buffer[1] = static_cast(JAMO_V_BASE + c % JAMO_V_COUNT); 108| 53.9M| if(c2==0) { ------------------ | Branch (108:12): [True: 1.96M, False: 51.9M] ------------------ 109| 1.96M| return 2; 110| 51.9M| } else { 111| 51.9M| buffer[2] = static_cast(JAMO_T_BASE + c2); 112| 51.9M| return 3; 113| 51.9M| } 114| 53.9M| } _ZN6icu_7816ReorderingBufferC2ERKNS_15Normalizer2ImplERNS_13UnicodeStringE: 143| 55.8M| impl(ni), str(dest), 144| 55.8M| start(nullptr), reorderStart(nullptr), limit(nullptr), 145| 55.8M| remainingCapacity(0), lastCC(0) {} _ZN6icu_7816ReorderingBufferD2Ev: 148| 55.8M| ~ReorderingBuffer() { 149| 55.8M| if (start != nullptr) { ------------------ | Branch (149:13): [True: 55.8M, False: 0] ------------------ 150| 55.8M| str.releaseBuffer(static_cast(limit - start)); 151| 55.8M| } 152| 55.8M| } _ZN6icu_7816ReorderingBuffer6appendEihR10UErrorCode: 164| 37.0M| UBool append(UChar32 c, uint8_t cc, UErrorCode &errorCode) { 165| 37.0M| return (c<=0xffff) ? ------------------ | Branch (165:16): [True: 36.9M, False: 180k] ------------------ 166| 36.9M| appendBMP(static_cast(c), cc, errorCode) : 167| 37.0M| appendSupplementary(c, cc, errorCode); 168| 37.0M| } _ZN6icu_7816ReorderingBuffer9appendBMPEDshR10UErrorCode: 172| 36.9M| UBool appendBMP(char16_t c, uint8_t cc, UErrorCode &errorCode) { 173| 36.9M| if(remainingCapacity==0 && !resize(1, errorCode)) { ------------------ | Branch (173:12): [True: 19.0k, False: 36.8M] | Branch (173:36): [True: 0, False: 19.0k] ------------------ 174| 0| return false; 175| 0| } 176| 36.9M| if(lastCC<=cc || cc==0) { ------------------ | Branch (176:12): [True: 29.3M, False: 7.53M] | Branch (176:26): [True: 2.94k, False: 7.53M] ------------------ 177| 29.3M| *limit++=c; 178| 29.3M| lastCC=cc; 179| 29.3M| if(cc<=1) { ------------------ | Branch (179:16): [True: 34.6k, False: 29.3M] ------------------ 180| 34.6k| reorderStart=limit; 181| 34.6k| } 182| 29.3M| } else { 183| 7.53M| insert(c, cc); 184| 7.53M| } 185| 36.9M| --remainingCapacity; 186| 36.9M| return true; 187| 36.9M| } _ZN6icu_7816ReorderingBuffer14writeCodePointEPDsi: 216| 8.75M| static void writeCodePoint(char16_t *p, UChar32 c) { 217| 8.75M| if(c<=0xffff) { ------------------ | Branch (217:12): [True: 8.69M, False: 60.7k] ------------------ 218| 8.69M| *p = static_cast(c); 219| 8.69M| } else { 220| 60.7k| p[0]=U16_LEAD(c); ------------------ | | 123| 60.7k|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 221| 60.7k| p[1]=U16_TRAIL(c); ------------------ | | 132| 60.7k|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 222| 60.7k| } 223| 8.75M| } _ZN6icu_7816ReorderingBuffer11setIteratorEv: 233| 8.75M| void setIterator() { codePointStart=limit; } _ZN6icu_7815Normalizer2ImplC2Ev: 248| 1| Normalizer2Impl() : normTrie(nullptr), fCanonIterData(nullptr) {} _ZNK6icu_7815Normalizer2Impl9getNorm16Ei: 264| 269M| uint16_t getNorm16(UChar32 c) const { 265| 269M| return U_IS_LEAD(c) ? ------------------ | | 177| 269M|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 803, False: 269M] | | ------------------ ------------------ 266| 803| static_cast(INERT) : 267| 269M| UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); ------------------ | | 358| 269M|#define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c)) | | ------------------ | | | | 267| 269M| UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); | | | | ------------------ | | | | | | 326| 567M|#define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i]) | | | | | | ------------------ | | | | | | | Branch (326:49): [True: 860k, False: 6.43M] | | | | | | | Branch (326:49): [True: 7.30M, False: 0] | | | | | | | Branch (326:49): [True: 262M, False: 7.30M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 268| 269M| } _ZNK6icu_7815Normalizer2Impl12getRawNorm16Ei: 269| 3.92M| uint16_t getRawNorm16(UChar32 c) const { return UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); } ------------------ | | 358| 3.92M|#define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c)) | | ------------------ | | | | 269| 3.92M| uint16_t getRawNorm16(UChar32 c) const { return UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); } | | | | ------------------ | | | | | | 326| 7.88M|#define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i]) | | | | | | ------------------ | | | | | | | Branch (326:49): [True: 0, False: 9.31k] | | | | | | | Branch (326:49): [True: 9.31k, False: 0] | | | | | | | Branch (326:49): [True: 3.91M, False: 9.31k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ _ZNK6icu_7815Normalizer2Impl17isAlgorithmicNoNoEt: 280| 1.80k| UBool isAlgorithmicNoNo(uint16_t norm16) const { return limitNoNo<=norm16 && norm16=MIN_NORMAL_MAYBE_YES) { ------------------ | Branch (285:12): [True: 7.44M, False: 7.23M] ------------------ 286| 7.44M| return getCCFromNormalYesOrMaybe(norm16); 287| 7.44M| } 288| 7.23M| if(norm16(norm16 >> OFFSET_SHIFT); 295| 220M| } _ZN6icu_7815Normalizer2Impl22getCCFromYesOrMaybeYesEt: 296| 153M| static uint8_t getCCFromYesOrMaybeYes(uint16_t norm16) { 297| 153M| return norm16>=MIN_NORMAL_MAYBE_YES ? getCCFromNormalYesOrMaybe(norm16) : 0; ------------------ | Branch (297:16): [True: 153M, False: 20.2k] ------------------ 298| 153M| } _ZNK6icu_7815Normalizer2Impl24getCCFromYesOrMaybeYesCPEi: 299| 117M| uint8_t getCCFromYesOrMaybeYesCP(UChar32 c) const { 300| 117M| if (c < minCompNoMaybeCP) { return 0; } ------------------ | Branch (300:13): [True: 0, False: 117M] ------------------ 301| 117M| return getCCFromYesOrMaybeYes(getNorm16(c)); 302| 117M| } _ZNK6icu_7815Normalizer2Impl8getFCD16Ei: 309| 112M| uint16_t getFCD16(UChar32 c) const { 310| 112M| if(c>8]; 366| 249M| if(bits==0) { return false; } ------------------ | Branch (366:12): [True: 119M, False: 129M] ------------------ 367| 129M| return (bits >> ((lead >> 5) & 7)) & 1; 368| 249M| } _ZNK6icu_7815Normalizer2Impl13isDecompInertEi: 540| 5.33M| UBool isDecompInert(UChar32 c) const { return isDecompYesAndZeroCC(getNorm16(c)); } _ZNK6icu_7815Normalizer2Impl21hasCompBoundaryBeforeEi: 542| 8.56k| UBool hasCompBoundaryBefore(UChar32 c) const { 543| 8.56k| return c=minMaybeYes; } _ZN6icu_7815Normalizer2Impl7isInertEt: 565| 3.55k| static UBool isInert(uint16_t norm16) { return norm16==INERT; } _ZNK6icu_7815Normalizer2Impl9hangulLVTEv: 568| 98.1M| uint16_t hangulLVT() const { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; } _ZNK6icu_7815Normalizer2Impl10isHangulLVEt: 569| 44.8M| UBool isHangulLV(uint16_t norm16) const { return norm16==minYesNo; } _ZNK6icu_7815Normalizer2Impl11isHangulLVTEt: 570| 98.1M| UBool isHangulLVT(uint16_t norm16) const { 571| 98.1M| return norm16==hangulLVT(); 572| 98.1M| } _ZNK6icu_7815Normalizer2Impl20isDecompYesAndZeroCCEt: 583| 5.33M| UBool isDecompYesAndZeroCC(uint16_t norm16) const { 584| 5.33M| return norm16(*(mapping - 1)); 607| 1.27M| } else { 608| 0| return 0; 609| 0| } 610| 1.27M| } _ZNK6icu_7815Normalizer2Impl14mapAlgorithmicEit: 624| 23.6k| UChar32 mapAlgorithmic(UChar32 c, uint16_t norm16) const { 625| 23.6k| return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta; 626| 23.6k| } _ZNK6icu_7815Normalizer2Impl17getDataForYesOrNoEt: 631| 1.27M| const uint16_t *getDataForYesOrNo(uint16_t norm16) const { 632| 1.27M| return extraData+(norm16>>OFFSET_SHIFT); 633| 1.27M| } _ZNK6icu_7815Normalizer2Impl7getDataEt: 637| 92.3M| const uint16_t *getData(uint16_t norm16) const { 638| 92.3M| if(norm16>=minMaybeNo) { ------------------ | Branch (638:12): [True: 76.4k, False: 92.3M] ------------------ 639| 76.4k| norm16=norm16-minMaybeNo+limitNoNo; 640| 76.4k| } 641| 92.3M| return extraData+(norm16>>OFFSET_SHIFT); 642| 92.3M| } _ZNK6icu_7815Normalizer2Impl31getCompositionsListForDecompYesEt: 643| 1.09M| const uint16_t *getCompositionsListForDecompYes(uint16_t norm16) const { 644| 1.09M| if(norm16> 2) & 1; 160| 4.94M| } else if(0x200e<=c && c<=0x2029) { ------------------ | Branch (160:15): [True: 3.39M, False: 1.55M] | Branch (160:28): [True: 1.63M, False: 1.75M] ------------------ 161| 1.63M| return c<=0x200f || 0x2028<=c; ------------------ | Branch (161:16): [True: 1.63M, False: 4.03k] | Branch (161:29): [True: 52, False: 3.98k] ------------------ 162| 3.30M| } else { 163| 3.30M| return false; 164| 3.30M| } 165| 7.89M|} _ZN6icu_7812PatternProps14skipWhiteSpaceEPKDsi: 168| 21.9k|PatternProps::skipWhiteSpace(const char16_t *s, int32_t length) { 169| 22.0k| while(length>0 && isWhiteSpace(*s)) { ------------------ | Branch (169:11): [True: 12.9k, False: 9.14k] | Branch (169:23): [True: 146, False: 12.7k] ------------------ 170| 146| ++s; 171| 146| --length; 172| 146| } 173| 21.9k| return s; 174| 21.9k|} uprv_compareASCIIPropertyNames_78: 93| 428|uprv_compareASCIIPropertyNames(const char *name1, const char *name2) { 94| 428| int32_t rc, r1, r2; 95| | 96| 840| for(;;) { 97| 840| r1=getASCIIPropertyNameChar(name1); 98| 840| r2=getASCIIPropertyNameChar(name2); 99| | 100| | /* If we reach the ends of both strings then they match */ 101| 840| if(((r1|r2)&0xff)==0) { ------------------ | Branch (101:12): [True: 103, False: 737] ------------------ 102| 103| return 0; 103| 103| } 104| | 105| | /* Compare the lowercased characters */ 106| 737| if(r1!=r2) { ------------------ | Branch (106:12): [True: 471, False: 266] ------------------ 107| 471| rc=(r1&0xff)-(r2&0xff); 108| 471| if(rc!=0) { ------------------ | Branch (108:16): [True: 325, False: 146] ------------------ 109| 325| return rc; 110| 325| } 111| 471| } 112| | 113| 412| name1+=r1>>8; 114| 412| name2+=r2>>8; 115| 412| } 116| 428|} _ZN6icu_7812PropNameData12findPropertyEi: 148| 21.1k|int32_t PropNameData::findProperty(int32_t property) { 149| 21.1k| int32_t i=1; // valueMaps index, initially after numRanges 150| 49.5k| for(int32_t numRanges=valueMaps[0]; numRanges>0; --numRanges) { ------------------ | Branch (150:41): [True: 49.5k, False: 0] ------------------ 151| | // Read and skip the start and limit of this range. 152| 49.5k| int32_t start=valueMaps[i]; 153| 49.5k| int32_t limit=valueMaps[i+1]; 154| 49.5k| i+=2; 155| 49.5k| if(property(c)); 235| 78.6k| } 236| 26.7k| return USTRINGTRIE_HAS_VALUE(result); ------------------ | | 86| 26.7k|#define USTRINGTRIE_HAS_VALUE(result) ((result)>=USTRINGTRIE_FINAL_VALUE) ------------------ 237| 27.6k|} _ZN6icu_7812PropNameData22getPropertyOrValueEnumEiPKc: 259| 27.6k|int32_t PropNameData::getPropertyOrValueEnum(int32_t bytesTrieOffset, const char *alias) { 260| 27.6k| BytesTrie trie(bytesTries+bytesTrieOffset); 261| 27.6k| if(containsName(trie, alias)) { ------------------ | Branch (261:8): [True: 25.0k, False: 2.51k] ------------------ 262| 25.0k| return trie.getValue(); 263| 25.0k| } else { 264| 2.51k| return UCHAR_INVALID_CODE; 265| 2.51k| } 266| 27.6k|} _ZN6icu_7812PropNameData15getPropertyEnumEPKc: 268| 6.42k|int32_t PropNameData::getPropertyEnum(const char *alias) { 269| 6.42k| return getPropertyOrValueEnum(0, alias); 270| 6.42k|} _ZN6icu_7812PropNameData20getPropertyValueEnumEiPKc: 272| 21.1k|int32_t PropNameData::getPropertyValueEnum(int32_t property, const char *alias) { 273| 21.1k| int32_t valueMapIndex=findProperty(property); 274| 21.1k| if(valueMapIndex==0) { ------------------ | Branch (274:8): [True: 0, False: 21.1k] ------------------ 275| 0| return UCHAR_INVALID_CODE; // Not a known property. 276| 0| } 277| 21.1k| valueMapIndex=valueMaps[valueMapIndex+1]; 278| 21.1k| if(valueMapIndex==0) { ------------------ | Branch (278:8): [True: 0, False: 21.1k] ------------------ 279| 0| return UCHAR_INVALID_CODE; // The property does not have named values. 280| 0| } 281| | // valueMapIndex is the start of the property's valueMap, 282| | // where the first word is the BytesTrie offset. 283| 21.1k| return getPropertyOrValueEnum(valueMaps[valueMapIndex], alias); 284| 21.1k|} u_getPropertyEnum_78: 301| 6.42k|u_getPropertyEnum(const char* alias) { 302| 6.42k| U_NAMESPACE_USE ------------------ | | 112| 6.42k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 303| 6.42k| return (UProperty)PropNameData::getPropertyEnum(alias); 304| 6.42k|} u_getPropertyValueEnum_78: 319| 21.1k| const char* alias) { 320| 21.1k| U_NAMESPACE_USE ------------------ | | 112| 21.1k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 321| 21.1k| return PropNameData::getPropertyValueEnum(property, alias); 322| 21.1k|} propname.cpp:_ZL24getASCIIPropertyNameCharPKc: 35| 1.68k|getASCIIPropertyNameChar(const char *name) { 36| 1.68k| int32_t i; 37| 1.68k| char c; 38| | 39| | /* Ignore delimiters '-', '_', and ASCII White_Space */ 40| 1.68k| for(i=0; 41| 3.11k| (c=name[i++])==0x2d || c==0x5f || ------------------ | Branch (41:9): [True: 111, False: 3.00k] | Branch (41:32): [True: 574, False: 2.43k] ------------------ 42| 3.11k| c==0x20 || (0x09<=c && c<=0x0d); ------------------ | Branch (42:9): [True: 672, False: 1.76k] | Branch (42:21): [True: 1.44k, False: 312] | Branch (42:32): [True: 81, False: 1.36k] ------------------ 43| 1.68k| ) {} 44| | 45| 1.68k| if(c!=0) { ------------------ | Branch (45:8): [True: 1.38k, False: 300] ------------------ 46| 1.38k| return (i << 8) | static_cast(uprv_asciitolower(c)); ------------------ | | 1397| 1.38k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | ------------------ | | | | 123| 1.38k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.38k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.38k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 47| 1.38k| } else { 48| 300| return i<<8; 49| 300| } 50| 1.68k|} uprv_add32_overflow_78: 524| 20.0M|uprv_add32_overflow(int32_t a, int32_t b, int32_t* res) { 525| | // NOTE: Some compilers (GCC, Clang) have primitives available, like __builtin_add_overflow. 526| | // This function could be optimized by calling one of those primitives. 527| 20.0M| auto a64 = static_cast(a); 528| 20.0M| auto b64 = static_cast(b); 529| 20.0M| int64_t res64 = a64 + b64; 530| 20.0M| *res = static_cast(res64); 531| 20.0M| return res64 != *res; 532| 20.0M|} u_setDataDirectory_78: 1316| 1|u_setDataDirectory(const char *directory) { 1317| 1| char *newDataDir; 1318| 1| int32_t length; 1319| | 1320| 1| if(directory==nullptr || *directory==0) { ------------------ | Branch (1320:8): [True: 0, False: 1] | Branch (1320:30): [True: 1, False: 0] ------------------ 1321| | /* A small optimization to prevent the malloc and copy when the 1322| | shared library is used, and this is a way to make sure that nullptr 1323| | is never returned. 1324| | */ 1325| 1| newDataDir = (char *)""; 1326| 1| } 1327| 0| else { 1328| 0| length=(int32_t)uprv_strlen(directory); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1329| 0| newDataDir = (char *)uprv_malloc(length + 2); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1330| | /* Exit out if newDataDir could not be created. */ 1331| 0| if (newDataDir == nullptr) { ------------------ | Branch (1331:13): [True: 0, False: 0] ------------------ 1332| 0| return; 1333| 0| } 1334| 0| uprv_strcpy(newDataDir, directory); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1335| | 1336| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) 1337| | { 1338| | char *p; 1339| | while((p = uprv_strchr(newDataDir, U_FILE_ALT_SEP_CHAR)) != nullptr) { 1340| | *p = U_FILE_SEP_CHAR; 1341| | } 1342| | } 1343| |#endif 1344| 0| } 1345| | 1346| 1| if (gDataDirectory && *gDataDirectory) { ------------------ | Branch (1346:9): [True: 0, False: 1] | Branch (1346:27): [True: 0, False: 0] ------------------ 1347| 0| uprv_free(gDataDirectory); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1348| 0| } 1349| 1| gDataDirectory = newDataDir; 1350| 1| ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1351| 1|} uprv_pathIsAbsolute_78: 1355| 707|{ 1356| 707| if(!path || !*path) { ------------------ | Branch (1356:6): [True: 0, False: 707] | Branch (1356:15): [True: 0, False: 707] ------------------ 1357| 0| return false; 1358| 0| } 1359| | 1360| 707| if(*path == U_FILE_SEP_CHAR) { ------------------ | | 130| 707|# define U_FILE_SEP_CHAR '/' ------------------ | Branch (1360:6): [True: 0, False: 707] ------------------ 1361| 0| return true; 1362| 0| } 1363| | 1364| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) 1365| | if(*path == U_FILE_ALT_SEP_CHAR) { 1366| | return true; 1367| | } 1368| |#endif 1369| | 1370| |#if U_PLATFORM_USES_ONLY_WIN32_API 1371| | if( (((path[0] >= 'A') && (path[0] <= 'Z')) || 1372| | ((path[0] >= 'a') && (path[0] <= 'z'))) && 1373| | path[1] == ':' ) { 1374| | return true; 1375| | } 1376| |#endif 1377| | 1378| 707| return false; 1379| 707|} u_getDataDirectory_78: 1499| 711|u_getDataDirectory() { 1500| 711| umtx_initOnce(gDataDirInitOnce, &dataDirectoryInitFn); 1501| 711| return gDataDirectory; 1502| 711|} u_getTimeZoneFilesDirectory_78: 1575| 1|u_getTimeZoneFilesDirectory(UErrorCode *status) { 1576| 1| umtx_initOnce(gTimeZoneFilesInitOnce, &TimeZoneDataDirInitFn, *status); ------------------ | | 122| 1|#define gTimeZoneFilesInitOnce U_ICU_ENTRY_POINT_RENAME(gTimeZoneFilesInitOnce) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1577| 1| return U_SUCCESS(*status) ? gTimeZoneFilesDirectory->data() : ""; ------------------ | Branch (1577:12): [True: 1, False: 0] ------------------ 1578| 1|} uprv_getDefaultLocaleID_78: 1686| 1|{ 1687| 1|#if U_POSIX_LOCALE 1688| |/* 1689| | Note that: (a '!' means the ID is improper somehow) 1690| | LC_ALL ----> default_loc codepage 1691| |-------------------------------------------------------- 1692| | ab.CD ab CD 1693| | ab@CD ab__CD - 1694| | ab@CD.EF ab__CD EF 1695| | 1696| | ab_CD.EF@GH ab_CD_GH EF 1697| | 1698| |Some 'improper' ways to do the same as above: 1699| | ! ab_CD@GH.EF ab_CD_GH EF 1700| | ! ab_CD.EF@GH.IJ ab_CD_GH EF 1701| | ! ab_CD@ZZ.EF@GH.IJ ab_CD_GH EF 1702| | 1703| | _CD@GH _CD_GH - 1704| | _CD.EF@GH _CD_GH EF 1705| | 1706| |The variant cannot have dots in it. 1707| |The 'rightmost' variant (@xxx) wins. 1708| |The leftmost codepage (.xxx) wins. 1709| |*/ 1710| 1| const char* posixID = uprv_getPOSIXIDForDefaultLocale(); 1711| | 1712| | /* Format: (no spaces) 1713| | ll [ _CC ] [ . MM ] [ @ VV] 1714| | 1715| | l = lang, C = ctry, M = charmap, V = variant 1716| | */ 1717| | 1718| 1| if (gCorrectedPOSIXLocale != nullptr) { ------------------ | Branch (1718:9): [True: 0, False: 1] ------------------ 1719| 0| return gCorrectedPOSIXLocale; 1720| 0| } 1721| | 1722| | // Copy the ID into owned memory. 1723| | // Over-allocate in case we replace "C" with "en_US_POSIX" (+10), + null termination 1724| 1| char *correctedPOSIXLocale = static_cast(uprv_malloc(uprv_strlen(posixID) + 10 + 1)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ char *correctedPOSIXLocale = static_cast(uprv_malloc(uprv_strlen(posixID) + 10 + 1)); ------------------ | | 37| 1|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1725| 1| if (correctedPOSIXLocale == nullptr) { ------------------ | Branch (1725:9): [True: 0, False: 1] ------------------ 1726| 0| return nullptr; 1727| 0| } 1728| 1| uprv_strcpy(correctedPOSIXLocale, posixID); ------------------ | | 36| 1|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1729| | 1730| 1| char *limit; 1731| 1| if ((limit = uprv_strchr(correctedPOSIXLocale, '.')) != nullptr) { ------------------ | | 40| 1|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1731:9): [True: 0, False: 1] ------------------ 1732| 0| *limit = 0; 1733| 0| } 1734| 1| if ((limit = uprv_strchr(correctedPOSIXLocale, '@')) != nullptr) { ------------------ | | 40| 1|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1734:9): [True: 0, False: 1] ------------------ 1735| 0| *limit = 0; 1736| 0| } 1737| | 1738| 1| if ((uprv_strcmp("C", correctedPOSIXLocale) == 0) // no @ variant ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1738:9): [True: 0, False: 1] ------------------ 1739| 1| || (uprv_strcmp("POSIX", correctedPOSIXLocale) == 0)) { ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1739:12): [True: 0, False: 1] ------------------ 1740| | // Raw input was C.* or POSIX.*, Give it a nice POSIX default value. 1741| | // (The "C"/"POSIX" case is handled in uprv_getPOSIXIDForCategory()) 1742| 0| uprv_strcpy(correctedPOSIXLocale, "en_US_POSIX"); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1743| 0| } 1744| | 1745| | /* Note that we scan the *uncorrected* ID. */ 1746| 1| const char *p; 1747| 1| if ((p = uprv_strrchr(posixID, '@')) != nullptr) { ------------------ | | 42| 1|#define uprv_strrchr(s, c) U_STANDARD_CPP_NAMESPACE strrchr(s, c) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1747:9): [True: 0, False: 1] ------------------ 1748| 0| p++; 1749| | 1750| | /* Take care of any special cases here.. */ 1751| 0| if (!uprv_strcmp(p, "nynorsk")) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1751:13): [True: 0, False: 0] ------------------ 1752| 0| p = "NY"; 1753| | /* Don't worry about no__NY. In practice, it won't appear. */ 1754| 0| } 1755| | 1756| 0| if (uprv_strchr(correctedPOSIXLocale,'_') == nullptr) { ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1756:13): [True: 0, False: 0] ------------------ 1757| 0| uprv_strcat(correctedPOSIXLocale, "__"); /* aa@b -> aa__b (note this can make the new locale 1 char longer) */ ------------------ | | 39| 0|#define uprv_strcat(dst, src) U_STANDARD_CPP_NAMESPACE strcat(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1758| 0| } 1759| 0| else { 1760| 0| uprv_strcat(correctedPOSIXLocale, "_"); /* aa_CC@b -> aa_CC_b */ ------------------ | | 39| 0|#define uprv_strcat(dst, src) U_STANDARD_CPP_NAMESPACE strcat(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1761| 0| } 1762| | 1763| 0| const char *q; 1764| 0| if ((q = uprv_strchr(p, '.')) != nullptr) { ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1764:13): [True: 0, False: 0] ------------------ 1765| | /* How big will the resulting string be? */ 1766| 0| int32_t len = (int32_t)(uprv_strlen(correctedPOSIXLocale) + (q-p)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1767| 0| uprv_strncat(correctedPOSIXLocale, p, q-p); // do not include charset ------------------ | | 45| 0|#define uprv_strncat(dst, src, n) U_STANDARD_CPP_NAMESPACE strncat(dst, src, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1768| 0| correctedPOSIXLocale[len] = 0; 1769| 0| } 1770| 0| else { 1771| | /* Anything following the @ sign */ 1772| 0| uprv_strcat(correctedPOSIXLocale, p); ------------------ | | 39| 0|#define uprv_strcat(dst, src) U_STANDARD_CPP_NAMESPACE strcat(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1773| 0| } 1774| | 1775| | /* Should there be a map from 'no@nynorsk' -> no_NO_NY here? 1776| | * How about 'russian' -> 'ru'? 1777| | * Many of the other locales using ISO codes will be handled by the 1778| | * canonicalization functions in uloc_getDefault. 1779| | */ 1780| 0| } 1781| | 1782| 1| if (gCorrectedPOSIXLocale == nullptr) { ------------------ | Branch (1782:9): [True: 1, False: 0] ------------------ 1783| 1| gCorrectedPOSIXLocale = correctedPOSIXLocale; 1784| 1| gCorrectedPOSIXLocaleHeapAllocated = true; 1785| 1| ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1786| 1| correctedPOSIXLocale = nullptr; 1787| 1| } 1788| 1| posixID = gCorrectedPOSIXLocale; 1789| | 1790| 1| if (correctedPOSIXLocale != nullptr) { /* Was already set - clean up. */ ------------------ | Branch (1790:9): [True: 0, False: 1] ------------------ 1791| 0| uprv_free(correctedPOSIXLocale); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1792| 0| } 1793| | 1794| 1| return posixID; 1795| | 1796| |#elif U_PLATFORM_USES_ONLY_WIN32_API 1797| |#define POSIX_LOCALE_CAPACITY 64 1798| | UErrorCode status = U_ZERO_ERROR; 1799| | char *correctedPOSIXLocale = nullptr; 1800| | 1801| | // If we have already figured this out just use the cached value 1802| | if (gCorrectedPOSIXLocale != nullptr) { 1803| | return gCorrectedPOSIXLocale; 1804| | } 1805| | 1806| | // No cached value, need to determine the current value 1807| | static WCHAR windowsLocale[LOCALE_NAME_MAX_LENGTH] = {}; 1808| | int length = GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SNAME, windowsLocale, LOCALE_NAME_MAX_LENGTH); 1809| | 1810| | // Now we should have a Windows locale name that needs converted to the POSIX style. 1811| | if (length > 0) // If length is 0, then the GetLocaleInfoEx failed. 1812| | { 1813| | // First we need to go from UTF-16 to char (and also convert from _ to - while we're at it.) 1814| | char modifiedWindowsLocale[LOCALE_NAME_MAX_LENGTH] = {}; 1815| | 1816| | int32_t i; 1817| | for (i = 0; i < UPRV_LENGTHOF(modifiedWindowsLocale); i++) 1818| | { 1819| | if (windowsLocale[i] == '_') 1820| | { 1821| | modifiedWindowsLocale[i] = '-'; 1822| | } 1823| | else 1824| | { 1825| | modifiedWindowsLocale[i] = static_cast(windowsLocale[i]); 1826| | } 1827| | 1828| | if (modifiedWindowsLocale[i] == '\0') 1829| | { 1830| | break; 1831| | } 1832| | } 1833| | 1834| | if (i >= UPRV_LENGTHOF(modifiedWindowsLocale)) 1835| | { 1836| | // Ran out of room, can't really happen, maybe we'll be lucky about a matching 1837| | // locale when tags are dropped 1838| | modifiedWindowsLocale[UPRV_LENGTHOF(modifiedWindowsLocale) - 1] = '\0'; 1839| | } 1840| | 1841| | // Now normalize the resulting name 1842| | correctedPOSIXLocale = static_cast(uprv_malloc(POSIX_LOCALE_CAPACITY + 1)); 1843| | /* TODO: Should we just exit on memory allocation failure? */ 1844| | if (correctedPOSIXLocale) 1845| | { 1846| | int32_t posixLen = uloc_canonicalize(modifiedWindowsLocale, correctedPOSIXLocale, POSIX_LOCALE_CAPACITY, &status); 1847| | if (U_SUCCESS(status)) 1848| | { 1849| | *(correctedPOSIXLocale + posixLen) = 0; 1850| | gCorrectedPOSIXLocale = correctedPOSIXLocale; 1851| | gCorrectedPOSIXLocaleHeapAllocated = true; 1852| | ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup); 1853| | } 1854| | else 1855| | { 1856| | uprv_free(correctedPOSIXLocale); 1857| | } 1858| | } 1859| | } 1860| | 1861| | // If unable to find a locale we can agree upon, use en-US by default 1862| | if (gCorrectedPOSIXLocale == nullptr) { 1863| | gCorrectedPOSIXLocale = "en_US"; 1864| | } 1865| | return gCorrectedPOSIXLocale; 1866| | 1867| |#elif U_PLATFORM == U_PF_OS400 1868| | /* locales are process scoped and are by definition thread safe */ 1869| | static char correctedLocale[64]; 1870| | const char *localeID = getenv("LC_ALL"); 1871| | char *p; 1872| | 1873| | if (localeID == nullptr) 1874| | localeID = getenv("LANG"); 1875| | if (localeID == nullptr) 1876| | localeID = setlocale(LC_ALL, nullptr); 1877| | /* Make sure we have something... */ 1878| | if (localeID == nullptr) 1879| | return "en_US_POSIX"; 1880| | 1881| | /* Extract the locale name from the path. */ 1882| | if((p = uprv_strrchr(localeID, '/')) != nullptr) 1883| | { 1884| | /* Increment p to start of locale name. */ 1885| | p++; 1886| | localeID = p; 1887| | } 1888| | 1889| | /* Copy to work location. */ 1890| | uprv_strcpy(correctedLocale, localeID); 1891| | 1892| | /* Strip off the '.locale' extension. */ 1893| | if((p = uprv_strchr(correctedLocale, '.')) != nullptr) { 1894| | *p = 0; 1895| | } 1896| | 1897| | /* Upper case the locale name. */ 1898| | T_CString_toUpperCase(correctedLocale); 1899| | 1900| | /* See if we are using the POSIX locale. Any of the 1901| | * following are equivalent and use the same QLGPGCMA 1902| | * (POSIX) locale. 1903| | * QLGPGCMA2 means UCS2 1904| | * QLGPGCMA_4 means UTF-32 1905| | * QLGPGCMA_8 means UTF-8 1906| | */ 1907| | if ((uprv_strcmp("C", correctedLocale) == 0) || 1908| | (uprv_strcmp("POSIX", correctedLocale) == 0) || 1909| | (uprv_strncmp("QLGPGCMA", correctedLocale, 8) == 0)) 1910| | { 1911| | uprv_strcpy(correctedLocale, "en_US_POSIX"); 1912| | } 1913| | else 1914| | { 1915| | int16_t LocaleLen; 1916| | 1917| | /* Lower case the lang portion. */ 1918| | for(p = correctedLocale; *p != 0 && *p != '_'; p++) 1919| | { 1920| | *p = uprv_tolower(*p); 1921| | } 1922| | 1923| | /* Adjust for Euro. After '_E' add 'URO'. */ 1924| | LocaleLen = uprv_strlen(correctedLocale); 1925| | if (correctedLocale[LocaleLen - 2] == '_' && 1926| | correctedLocale[LocaleLen - 1] == 'E') 1927| | { 1928| | uprv_strcat(correctedLocale, "URO"); 1929| | } 1930| | 1931| | /* If using Lotus-based locale then convert to 1932| | * equivalent non Lotus. 1933| | */ 1934| | else if (correctedLocale[LocaleLen - 2] == '_' && 1935| | correctedLocale[LocaleLen - 1] == 'L') 1936| | { 1937| | correctedLocale[LocaleLen - 2] = 0; 1938| | } 1939| | 1940| | /* There are separate simplified and traditional 1941| | * locales called zh_HK_S and zh_HK_T. 1942| | */ 1943| | else if (uprv_strncmp(correctedLocale, "zh_HK", 5) == 0) 1944| | { 1945| | uprv_strcpy(correctedLocale, "zh_HK"); 1946| | } 1947| | 1948| | /* A special zh_CN_GBK locale... 1949| | */ 1950| | else if (uprv_strcmp(correctedLocale, "zh_CN_GBK") == 0) 1951| | { 1952| | uprv_strcpy(correctedLocale, "zh_CN"); 1953| | } 1954| | 1955| | } 1956| | 1957| | return correctedLocale; 1958| |#endif 1959| | 1960| 1|} u_versionFromString_78: 2257| 70|u_versionFromString(UVersionInfo versionArray, const char *versionString) { 2258| 70| char *end; 2259| 70| uint16_t part=0; 2260| | 2261| 70| if(versionArray==nullptr) { ------------------ | Branch (2261:8): [True: 0, False: 70] ------------------ 2262| 0| return; 2263| 0| } 2264| | 2265| 70| if(versionString!=nullptr) { ------------------ | Branch (2265:8): [True: 70, False: 0] ------------------ 2266| 70| for(;;) { 2267| 70| versionArray[part]=(uint8_t)uprv_strtoul(versionString, &end, 10); ------------------ | | 76| 70|#define uprv_strtoul(str, end, base) U_STANDARD_CPP_NAMESPACE strtoul(str, end, base) | | ------------------ | | | | 393| 70|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2268| 70| if(end==versionString || ++part==U_MAX_VERSION_LENGTH || *end!=U_VERSION_DELIMITER) { ------------------ | | 43| 130|#define U_MAX_VERSION_LENGTH 4 ------------------ if(end==versionString || ++part==U_MAX_VERSION_LENGTH || *end!=U_VERSION_DELIMITER) { ------------------ | | 48| 60|#define U_VERSION_DELIMITER '.' ------------------ | Branch (2268:16): [True: 10, False: 60] | Branch (2268:38): [True: 0, False: 60] | Branch (2268:70): [True: 60, False: 0] ------------------ 2269| 70| break; 2270| 70| } 2271| 0| versionString=end+1; 2272| 0| } 2273| 70| } 2274| | 2275| 290| while(partclear(); 1509| 1| gTimeZoneFilesDirectory->append(path, status); 1510| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) 1511| | char *p = gTimeZoneFilesDirectory->data(); 1512| | while ((p = uprv_strchr(p, U_FILE_ALT_SEP_CHAR)) != nullptr) { 1513| | *p = U_FILE_SEP_CHAR; 1514| | } 1515| |#endif 1516| 1|} putil.cpp:_ZL31uprv_getPOSIXIDForDefaultLocalev: 1660| 1|{ 1661| 1| static const char* posixID = nullptr; 1662| 1| if (posixID == nullptr) { ------------------ | Branch (1662:9): [True: 1, False: 0] ------------------ 1663| 1| posixID = uprv_getPOSIXIDForCategory(LC_MESSAGES); 1664| 1| } 1665| 1| return posixID; 1666| 1|} putil.cpp:_ZL26uprv_getPOSIXIDForCategoryi: 1597| 1|{ 1598| 1| const char* posixID = nullptr; 1599| 1| if (category == LC_MESSAGES || category == LC_CTYPE) { ------------------ | Branch (1599:9): [True: 1, False: 0] | Branch (1599:36): [True: 0, False: 0] ------------------ 1600| | /* 1601| | * On Solaris two different calls to setlocale can result in 1602| | * different values. Only get this value once. 1603| | * 1604| | * We must check this first because an application can set this. 1605| | * 1606| | * LC_ALL can't be used because it's platform dependent. The LANG 1607| | * environment variable seems to affect LC_CTYPE variable by default. 1608| | * Here is what setlocale(LC_ALL, nullptr) can return. 1609| | * HPUX can return 'C C C C C C C' 1610| | * Solaris can return /en_US/C/C/C/C/C on the second try. 1611| | * Linux can return LC_CTYPE=C;LC_NUMERIC=C;... 1612| | * 1613| | * The default codepage detection also needs to use LC_CTYPE. 1614| | * 1615| | * Do not call setlocale(LC_*, "")! Using an empty string instead 1616| | * of nullptr, will modify the libc behavior. 1617| | */ 1618| 1| posixID = setlocale(category, nullptr); 1619| 1| if ((posixID == nullptr) ------------------ | Branch (1619:13): [True: 0, False: 1] ------------------ 1620| 1| || (uprv_strcmp("C", posixID) == 0) ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1620:16): [True: 1, False: 0] ------------------ 1621| 1| || (uprv_strcmp("POSIX", posixID) == 0)) ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1621:16): [True: 0, False: 0] ------------------ 1622| 1| { 1623| | /* Maybe we got some garbage. Try something more reasonable */ 1624| 1| posixID = getenv("LC_ALL"); 1625| | /* Solaris speaks POSIX - See IEEE Std 1003.1-2008 1626| | * This is needed to properly handle empty env. variables 1627| | */ 1628| |#if U_PLATFORM == U_PF_SOLARIS 1629| | if ((posixID == 0) || (posixID[0] == '\0')) { 1630| | posixID = getenv(category == LC_MESSAGES ? "LC_MESSAGES" : "LC_CTYPE"); 1631| | if ((posixID == 0) || (posixID[0] == '\0')) { 1632| |#else 1633| 1| if (posixID == nullptr) { ------------------ | Branch (1633:17): [True: 1, False: 0] ------------------ 1634| 1| posixID = getenv(category == LC_MESSAGES ? "LC_MESSAGES" : "LC_CTYPE"); ------------------ | Branch (1634:34): [True: 1, False: 0] ------------------ 1635| 1| if (posixID == nullptr) { ------------------ | Branch (1635:21): [True: 1, False: 0] ------------------ 1636| 1|#endif 1637| 1| posixID = getenv("LANG"); 1638| 1| } 1639| 1| } 1640| 1| } 1641| 1| } 1642| 1| if ((posixID == nullptr) ------------------ | Branch (1642:9): [True: 1, False: 0] ------------------ 1643| 1| || (uprv_strcmp("C", posixID) == 0) ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1643:12): [True: 0, False: 0] ------------------ 1644| 1| || (uprv_strcmp("POSIX", posixID) == 0)) ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1644:12): [True: 0, False: 0] ------------------ 1645| 1| { 1646| | /* Nothing worked. Give it a nice POSIX default value. */ 1647| 1| posixID = "en_US_POSIX"; 1648| | // Note: this test will not catch 'C.UTF-8', 1649| | // that will be handled in uprv_getDefaultLocaleID(). 1650| | // Leave this mapping here for the uprv_getPOSIXIDForDefaultCodepage() 1651| | // caller which expects to see "en_US_POSIX" in many branches. 1652| 1| } 1653| 1| return posixID; 1654| 1|} _ZN6icu_7814ResourceTracerC2EPKv: 118| 174k| ResourceTracer(const void*) {} _ZN6icu_7814ResourceTracerC2EPKvPKc: 120| 4.81k| ResourceTracer(const void*, const char*) {} _ZNK6icu_7814ResourceTracer5traceEPKc: 128| 174k| void trace(const char*) const {} _ZNK6icu_7814ResourceTracer9traceOpenEv: 130| 4.85k| void traceOpen() const {} _ZNK6icu_7814ResourceTracer10maybeTraceEPKc: 132| 3| void maybeTrace(const char*) const {} _ZN6icu_7810FileTracer9traceOpenEPKcS2_S2_: 140| 710| static void traceOpen(const char*, const char*, const char*) {} _ZN6icu_7821RuleCharacterIteratorC2ERKNS_13UnicodeStringEPKNS_11SymbolTableERNS_13ParsePositionE: 27| 9.79k| text(theText), 28| 9.79k| pos(thePos), 29| 9.79k| sym(theSym), 30| 9.79k| buf(nullptr), 31| 9.79k| bufPos(0) 32| 9.79k|{} _ZNK6icu_7821RuleCharacterIterator5atEndEv: 34| 213k|UBool RuleCharacterIterator::atEnd() const { 35| 213k| return buf == nullptr && pos.getIndex() == text.length(); ------------------ | Branch (35:12): [True: 213k, False: 0] | Branch (35:30): [True: 500, False: 213k] ------------------ 36| 213k|} _ZN6icu_7821RuleCharacterIterator4nextEiRaR10UErrorCode: 38| 425k|UChar32 RuleCharacterIterator::next(int32_t options, UBool& isEscaped, UErrorCode& ec) { 39| 425k| if (U_FAILURE(ec)) return DONE; ------------------ | Branch (39:9): [True: 249, False: 424k] ------------------ 40| | 41| 424k| UChar32 c = DONE; 42| 424k| isEscaped = false; 43| | 44| 433k| for (;;) { 45| 433k| c = _current(); 46| 433k| _advance(U16_LENGTH(c)); ------------------ | | 141| 433k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 432k, False: 1.24k] | | ------------------ ------------------ 47| | 48| 433k| if (c == SymbolTable::SYMBOL_REF && buf == nullptr && ------------------ | Branch (48:13): [True: 2.66k, False: 431k] | Branch (48:45): [True: 2.66k, False: 0] ------------------ 49| 433k| (options & PARSE_VARIABLES) != 0 && sym != nullptr) { ------------------ | Branch (49:13): [True: 2.66k, False: 0] | Branch (49:49): [True: 0, False: 2.66k] ------------------ 50| 0| UnicodeString name = sym->parseReference(text, pos, text.length()); 51| | // If name is empty there was an isolated SYMBOL_REF; 52| | // return it. Caller must be prepared for this. 53| 0| if (name.length() == 0) { ------------------ | Branch (53:17): [True: 0, False: 0] ------------------ 54| 0| break; 55| 0| } 56| 0| bufPos = 0; 57| 0| buf = sym->lookup(name); 58| 0| if (buf == nullptr) { ------------------ | Branch (58:17): [True: 0, False: 0] ------------------ 59| 0| ec = U_UNDEFINED_VARIABLE; 60| 0| return DONE; 61| 0| } 62| | // Handle empty variable value 63| 0| if (buf->length() == 0) { ------------------ | Branch (63:17): [True: 0, False: 0] ------------------ 64| 0| buf = nullptr; 65| 0| } 66| 0| continue; 67| 0| } 68| | 69| 433k| if ((options & SKIP_WHITESPACE) != 0 && PatternProps::isWhiteSpace(c)) { ------------------ | Branch (69:13): [True: 401k, False: 32.3k] | Branch (69:49): [True: 9.12k, False: 392k] ------------------ 70| 9.12k| continue; 71| 9.12k| } 72| | 73| 424k| if (c == 0x5C /*'\\'*/ && (options & PARSE_ESCAPES) != 0) { ------------------ | Branch (73:13): [True: 14.3k, False: 410k] | Branch (73:35): [True: 4.67k, False: 9.65k] ------------------ 74| 4.67k| UnicodeString tempEscape; 75| 4.67k| int32_t offset = 0; 76| 4.67k| c = lookahead(tempEscape, MAX_U_NOTATION_LEN).unescapeAt(offset); ------------------ | | 21| 4.67k|#define MAX_U_NOTATION_LEN 12 ------------------ 77| 4.67k| jumpahead(offset); 78| 4.67k| isEscaped = true; 79| 4.67k| if (c < 0) { ------------------ | Branch (79:17): [True: 33, False: 4.63k] ------------------ 80| 33| ec = U_MALFORMED_UNICODE_ESCAPE; 81| 33| return DONE; 82| 33| } 83| 4.67k| } 84| | 85| 424k| break; 86| 424k| } 87| | 88| 424k| return c; 89| 424k|} _ZNK6icu_7821RuleCharacterIterator6getPosERNS0_3PosE: 91| 361k|void RuleCharacterIterator::getPos(RuleCharacterIterator::Pos& p) const { 92| 361k| p.buf = buf; 93| 361k| p.pos = pos.getIndex(); 94| 361k| p.bufPos = bufPos; 95| 361k|} _ZN6icu_7821RuleCharacterIterator6setPosERKNS0_3PosE: 97| 197k|void RuleCharacterIterator::setPos(const RuleCharacterIterator::Pos& p) { 98| 197k| buf = p.buf; 99| 197k| pos.setIndex(p.pos); 100| 197k| bufPos = p.bufPos; 101| 197k|} _ZN6icu_7821RuleCharacterIterator11skipIgnoredEi: 103| 28.0k|void RuleCharacterIterator::skipIgnored(int32_t options) { 104| 28.0k| if ((options & SKIP_WHITESPACE) != 0) { ------------------ | Branch (104:9): [True: 28.0k, False: 0] ------------------ 105| 28.5k| for (;;) { 106| 28.5k| UChar32 a = _current(); 107| 28.5k| if (!PatternProps::isWhiteSpace(a)) break; ------------------ | Branch (107:17): [True: 28.0k, False: 432] ------------------ 108| 432| _advance(U16_LENGTH(a)); ------------------ | | 141| 432|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 432, False: 0] | | ------------------ ------------------ 109| 432| } 110| 28.0k| } 111| 28.0k|} _ZNK6icu_7821RuleCharacterIterator9lookaheadERNS_13UnicodeStringEi: 113| 17.4k|UnicodeString& RuleCharacterIterator::lookahead(UnicodeString& result, int32_t maxLookAhead) const { 114| 17.4k| if (maxLookAhead < 0) { ------------------ | Branch (114:9): [True: 12.7k, False: 4.67k] ------------------ 115| 12.7k| maxLookAhead = 0x7FFFFFFF; 116| 12.7k| } 117| 17.4k| if (buf != nullptr) { ------------------ | Branch (117:9): [True: 0, False: 17.4k] ------------------ 118| 0| buf->extract(bufPos, maxLookAhead, result); 119| 17.4k| } else { 120| 17.4k| text.extract(pos.getIndex(), maxLookAhead, result); 121| 17.4k| } 122| 17.4k| return result; 123| 17.4k|} _ZN6icu_7821RuleCharacterIterator9jumpaheadEi: 125| 17.1k|void RuleCharacterIterator::jumpahead(int32_t count) { 126| 17.1k| _advance(count); 127| 17.1k|} _ZNK6icu_7821RuleCharacterIterator8_currentEv: 137| 462k|UChar32 RuleCharacterIterator::_current() const { 138| 462k| if (buf != nullptr) { ------------------ | Branch (138:9): [True: 0, False: 462k] ------------------ 139| 0| return buf->char32At(bufPos); 140| 462k| } else { 141| 462k| int i = pos.getIndex(); 142| 462k| return (i < text.length()) ? text.char32At(i) : static_cast(DONE); ------------------ | Branch (142:16): [True: 453k, False: 9.18k] ------------------ 143| 462k| } 144| 462k|} _ZN6icu_7821RuleCharacterIterator8_advanceEi: 146| 451k|void RuleCharacterIterator::_advance(int32_t count) { 147| 451k| if (buf != nullptr) { ------------------ | Branch (147:9): [True: 0, False: 451k] ------------------ 148| 0| bufPos += count; 149| 0| if (bufPos == buf->length()) { ------------------ | Branch (149:13): [True: 0, False: 0] ------------------ 150| 0| buf = nullptr; 151| 0| } 152| 451k| } else { 153| 451k| pos.setIndex(pos.getIndex() + count); 154| 451k| if (pos.getIndex() > text.length()) { ------------------ | Branch (154:13): [True: 0, False: 451k] ------------------ 155| 0| pos.setIndex(text.length()); 156| 0| } 157| 451k| } 158| 451k|} _ZNK6icu_7821RuleCharacterIterator10inVariableEv: 226| 9.16k|inline UBool RuleCharacterIterator::inVariable() const { 227| 9.16k| return buf != nullptr; 228| 9.16k|} _ZN6icu_7812SharedObjectD2Ev: 18| 19.5k|SharedObject::~SharedObject() {} _ZNK6icu_7812SharedObject6addRefEv: 23| 27.7k|SharedObject::addRef() const { 24| 27.7k| umtx_atomic_inc(&hardRefCount); 25| 27.7k|} _ZNK6icu_7812SharedObject9removeRefEv: 36| 27.7k|SharedObject::removeRef() const { 37| 27.7k| const UnifiedCacheBase *cache = this->cachePtr; 38| 27.7k| int32_t updatedRefCount = umtx_atomic_dec(&hardRefCount); 39| 27.7k| U_ASSERT(updatedRefCount >= 0); ------------------ | | 35| 27.7k|# define U_ASSERT(exp) (void)0 ------------------ 40| 27.7k| if (updatedRefCount == 0) { ------------------ | Branch (40:9): [True: 15.9k, False: 11.8k] ------------------ 41| 15.9k| if (cache) { ------------------ | Branch (41:13): [True: 0, False: 15.9k] ------------------ 42| 0| cache->handleUnreferencedObject(); 43| 15.9k| } else { 44| 15.9k| delete this; 45| 15.9k| } 46| 15.9k| } 47| 27.7k|} _ZNK6icu_7812SharedObject11getRefCountEv: 51| 7.71k|SharedObject::getRefCount() const { 52| 7.71k| return umtx_loadAcquire(hardRefCount); 53| 7.71k|} _ZN6icu_7812SharedObjectC2Ev: 58| 11.8k| softRefCount(0), 59| 11.8k| hardRefCount(0), 60| 11.8k| cachePtr(nullptr) {} _ZN6icu_7812SharedObjectC2ERKS0_: 64| 7.71k| UObject(other), 65| 7.71k| softRefCount(0), 66| 7.71k| hardRefCount(0), 67| 7.71k| cachePtr(nullptr) {} _ZN6icu_7812SharedObject11copyOnWriteINS_17CollationSettingsEEEPT_RPKS3_: 124| 7.71k| static T *copyOnWrite(const T *&ptr) { 125| 7.71k| const T *p = ptr; 126| 7.71k| if(p->getRefCount() <= 1) { return const_cast(p); } ------------------ | Branch (126:12): [True: 1, False: 7.71k] ------------------ 127| 7.71k| T *p2 = new T(*p); 128| 7.71k| if(p2 == nullptr) { return nullptr; } ------------------ | Branch (128:12): [True: 0, False: 7.71k] ------------------ 129| 7.71k| p->removeRef(); 130| 7.71k| ptr = p2; 131| 7.71k| p2->addRef(); 132| 7.71k| return p2; 133| 7.71k| } _ZN6icu_7812SharedObject8clearPtrINS_19CollationCacheEntryEEEvRPKT_: 156| 7.71k| static void clearPtr(const T *&ptr) { 157| 7.71k| if (ptr != nullptr) { ------------------ | Branch (157:13): [True: 4.09k, False: 3.61k] ------------------ 158| 4.09k| ptr->removeRef(); 159| 4.09k| ptr = nullptr; 160| 4.09k| } 161| 7.71k| } _ZN6icu_7812SharedObject8clearPtrINS_17CollationSettingsEEEvRPKT_: 156| 15.4k| static void clearPtr(const T *&ptr) { 157| 15.4k| if (ptr != nullptr) { ------------------ | Branch (157:13): [True: 11.8k, False: 3.61k] ------------------ 158| 11.8k| ptr->removeRef(); 159| 11.8k| ptr = nullptr; 160| 11.8k| } 161| 15.4k| } _ZN6icu_7812SharedObject8clearPtrINS_18CollationTailoringEEEvRPKT_: 156| 4.09k| static void clearPtr(const T *&ptr) { 157| 4.09k| if (ptr != nullptr) { ------------------ | Branch (157:13): [True: 4.09k, False: 0] ------------------ 158| 4.09k| ptr->removeRef(); 159| 4.09k| ptr = nullptr; 160| 4.09k| } 161| 4.09k| } _ZN6icu_7811StringPieceC2EPKc: 19| 30.3k| : ptr_(str), length_((str == nullptr) ? 0 : static_cast(uprv_strlen(str))) { } ------------------ | | 37| 30.3k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 30.3k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (19:26): [True: 0, False: 30.3k] ------------------ _ZN6icu_7817StringTrieBuilderC2Ev: 39| 859k|StringTrieBuilder::StringTrieBuilder() : nodes(nullptr) {} _ZN6icu_7817StringTrieBuilderD2Ev: 41| 859k|StringTrieBuilder::~StringTrieBuilder() { 42| 859k| deleteCompactBuilder(); 43| 859k|} _ZN6icu_7817StringTrieBuilder20createCompactBuilderEiR10UErrorCode: 46| 1.28M|StringTrieBuilder::createCompactBuilder(int32_t sizeGuess, UErrorCode &errorCode) { 47| 1.28M| if(U_FAILURE(errorCode)) { ------------------ | Branch (47:8): [True: 0, False: 1.28M] ------------------ 48| 0| return; 49| 0| } 50| 1.28M| nodes=uhash_openSize(hashStringTrieNode, equalStringTrieNodes, nullptr, ------------------ | | 1031| 1.28M|#define uhash_openSize U_ICU_ENTRY_POINT_RENAME(uhash_openSize) | | ------------------ | | | | 123| 1.28M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.28M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.28M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 51| 1.28M| sizeGuess, &errorCode); 52| 1.28M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (52:8): [True: 1.28M, False: 0] ------------------ 53| 1.28M| if(nodes==nullptr) { ------------------ | Branch (53:12): [True: 0, False: 1.28M] ------------------ 54| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 55| 1.28M| } else { 56| 1.28M| uhash_setKeyDeleter(nodes, uprv_deleteUObject); ------------------ | | 1040| 1.28M|#define uhash_setKeyDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setKeyDeleter) | | ------------------ | | | | 123| 1.28M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.28M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.28M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ uhash_setKeyDeleter(nodes, uprv_deleteUObject); ------------------ | | 1489| 1.28M|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 1.28M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.28M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.28M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 57| 1.28M| } 58| 1.28M| } 59| 1.28M|} _ZN6icu_7817StringTrieBuilder20deleteCompactBuilderEv: 62| 2.14M|StringTrieBuilder::deleteCompactBuilder() { 63| 2.14M| uhash_close(nodes); ------------------ | | 991| 2.14M|#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close) | | ------------------ | | | | 123| 2.14M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.14M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.14M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 2.14M| nodes=nullptr; 65| 2.14M|} _ZN6icu_7817StringTrieBuilder5buildE22UStringTrieBuildOptioniR10UErrorCode: 69| 1.28M| UErrorCode &errorCode) { 70| 1.28M| if(buildOption==USTRINGTRIE_BUILD_FAST) { ------------------ | Branch (70:8): [True: 0, False: 1.28M] ------------------ 71| 0| writeNode(0, elementsLength, 0); 72| 1.28M| } else /* USTRINGTRIE_BUILD_SMALL */ { 73| 1.28M| createCompactBuilder(2*elementsLength, errorCode); 74| 1.28M| Node *root=makeNode(0, elementsLength, 0, errorCode); 75| 1.28M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (75:12): [True: 1.28M, False: 0] ------------------ 76| 1.28M| root->markRightEdgesFirst(-1); 77| 1.28M| root->write(*this); 78| 1.28M| } 79| 1.28M| deleteCompactBuilder(); 80| 1.28M| } 81| 1.28M|} _ZN6icu_7817StringTrieBuilder8makeNodeEiiiR10UErrorCode: 208| 81.0M|StringTrieBuilder::makeNode(int32_t start, int32_t limit, int32_t unitIndex, UErrorCode &errorCode) { 209| 81.0M| if(U_FAILURE(errorCode)) { ------------------ | Branch (209:8): [True: 0, False: 81.0M] ------------------ 210| 0| return nullptr; 211| 0| } 212| 81.0M| UBool hasValue=false; 213| 81.0M| int32_t value=0; 214| 81.0M| if(unitIndex==getElementStringLength(start)) { ------------------ | Branch (214:8): [True: 22.3M, False: 58.7M] ------------------ 215| | // An intermediate or final value. 216| 22.3M| value=getElementValue(start++); 217| 22.3M| if(start==limit) { ------------------ | Branch (217:12): [True: 21.9M, False: 326k] ------------------ 218| 21.9M| return registerFinalValue(value, errorCode); 219| 21.9M| } 220| 326k| hasValue=true; 221| 326k| } 222| 59.1M| Node *node; 223| | // Now all [start..limit[ strings are longer than unitIndex. 224| 59.1M| int32_t minUnit=getElementUnit(start, unitIndex); 225| 59.1M| int32_t maxUnit=getElementUnit(limit-1, unitIndex); 226| 59.1M| if(minUnit==maxUnit) { ------------------ | Branch (226:8): [True: 36.5M, False: 22.5M] ------------------ 227| | // Linear-match node: All strings have the same character at unitIndex. 228| 36.5M| int32_t lastUnitIndex=getLimitOfLinearMatch(start, limit-1, unitIndex); 229| 36.5M| Node *nextNode=makeNode(start, limit, lastUnitIndex, errorCode); 230| | // Break the linear-match sequence into chunks of at most kMaxLinearMatchLength. 231| 36.5M| int32_t length=lastUnitIndex-unitIndex; 232| 36.5M| int32_t maxLinearMatchLength=getMaxLinearMatchLength(); 233| 51.0M| while(length>maxLinearMatchLength) { ------------------ | Branch (233:15): [True: 14.4M, False: 36.5M] ------------------ 234| 14.4M| lastUnitIndex-=maxLinearMatchLength; 235| 14.4M| length-=maxLinearMatchLength; 236| 14.4M| node=createLinearMatchNode(start, lastUnitIndex, maxLinearMatchLength, nextNode); 237| 14.4M| nextNode=registerNode(node, errorCode); 238| 14.4M| } 239| 36.5M| node=createLinearMatchNode(start, unitIndex, length, nextNode); 240| 36.5M| } else { 241| | // Branch node. 242| 22.5M| int32_t length=countElementUnits(start, limit, unitIndex); 243| | // length>=2 because minUnit!=maxUnit. 244| 22.5M| Node *subNode=makeBranchSubNode(start, limit, unitIndex, length, errorCode); 245| 22.5M| node=new BranchHeadNode(length, subNode); 246| 22.5M| } 247| 59.1M| if(hasValue && node!=nullptr) { ------------------ | Branch (247:8): [True: 326k, False: 58.7M] | Branch (247:20): [True: 326k, False: 0] ------------------ 248| 326k| if(matchNodesCanHaveValues()) { ------------------ | Branch (248:12): [True: 326k, False: 0] ------------------ 249| 326k| ((ValueNode *)node)->setValue(value); 250| 326k| } else { 251| 0| node=new IntermediateValueNode(value, registerNode(node, errorCode)); 252| 0| } 253| 326k| } 254| 59.1M| return registerNode(node, errorCode); 255| 81.0M|} _ZN6icu_7817StringTrieBuilder17makeBranchSubNodeEiiiiR10UErrorCode: 261| 25.2M| int32_t length, UErrorCode &errorCode) { 262| 25.2M| if(U_FAILURE(errorCode)) { ------------------ | Branch (262:8): [True: 0, False: 25.2M] ------------------ 263| 0| return nullptr; 264| 0| } 265| 25.2M| char16_t middleUnits[kMaxSplitBranchLevels]; 266| 25.2M| Node *lessThan[kMaxSplitBranchLevels]; 267| 25.2M| int32_t ltLength=0; 268| 28.0M| while(length>getMaxBranchLinearSubNodeLength()) { ------------------ | Branch (268:11): [True: 2.76M, False: 25.2M] ------------------ 269| | // Branch on the middle unit. 270| | // First, find the middle unit. 271| 2.76M| int32_t i=skipElementsBySomeUnits(start, unitIndex, length/2); 272| | // Create the less-than branch. 273| 2.76M| middleUnits[ltLength]=getElementUnit(i, unitIndex); // middle unit 274| 2.76M| lessThan[ltLength]=makeBranchSubNode(start, i, unitIndex, length/2, errorCode); 275| 2.76M| ++ltLength; 276| | // Continue for the greater-or-equal branch. 277| 2.76M| start=i; 278| 2.76M| length=length-length/2; 279| 2.76M| } 280| 25.2M| if(U_FAILURE(errorCode)) { ------------------ | Branch (280:8): [True: 0, False: 25.2M] ------------------ 281| 0| return nullptr; 282| 0| } 283| 25.2M| ListBranchNode *listNode=new ListBranchNode(); 284| 25.2M| if(listNode==nullptr) { ------------------ | Branch (284:8): [True: 0, False: 25.2M] ------------------ 285| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 286| 0| return nullptr; 287| 0| } 288| | // For each unit, find its elements array start and whether it has a final value. 289| 25.2M| int32_t unitNumber=0; 290| 41.7M| do { 291| 41.7M| int32_t i=start; 292| 41.7M| char16_t unit=getElementUnit(i++, unitIndex); 293| 41.7M| i=indexOfElementWithNextUnit(i, unitIndex, unit); 294| 41.7M| if(start==i-1 && unitIndex+1==getElementStringLength(start)) { ------------------ | Branch (294:12): [True: 28.1M, False: 13.5M] | Branch (294:26): [True: 14.0M, False: 14.0M] ------------------ 295| 14.0M| listNode->add(unit, getElementValue(start)); 296| 27.6M| } else { 297| 27.6M| listNode->add(unit, makeNode(start, i, unitIndex+1, errorCode)); 298| 27.6M| } 299| 41.7M| start=i; 300| 41.7M| } while(++unitNumberadd(unit, getElementValue(start)); 305| 15.5M| } else { 306| 15.5M| listNode->add(unit, makeNode(start, limit, unitIndex+1, errorCode)); 307| 15.5M| } 308| 25.2M| Node *node=registerNode(listNode, errorCode); 309| | // Create the split-branch nodes. 310| 28.0M| while(ltLength>0) { ------------------ | Branch (310:11): [True: 2.76M, False: 25.2M] ------------------ 311| 2.76M| --ltLength; 312| 2.76M| node=registerNode( 313| 2.76M| new SplitBranchNode(middleUnits[ltLength], lessThan[ltLength], node), errorCode); 314| 2.76M| } 315| 25.2M| return node; 316| 25.2M|} _ZN6icu_7817StringTrieBuilder12registerNodeEPNS0_4NodeER10UErrorCode: 319| 101M|StringTrieBuilder::registerNode(Node *newNode, UErrorCode &errorCode) { 320| 101M| if(U_FAILURE(errorCode)) { ------------------ | Branch (320:8): [True: 0, False: 101M] ------------------ 321| 0| delete newNode; 322| 0| return nullptr; 323| 0| } 324| 101M| if(newNode==nullptr) { ------------------ | Branch (324:8): [True: 0, False: 101M] ------------------ 325| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 326| 0| return nullptr; 327| 0| } 328| 101M| const UHashElement *old=uhash_find(nodes, newNode); ------------------ | | 1006| 101M|#define uhash_find U_ICU_ENTRY_POINT_RENAME(uhash_find) | | ------------------ | | | | 123| 101M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 101M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 101M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 329| 101M| if(old!=nullptr) { ------------------ | Branch (329:8): [True: 86.8M, False: 14.7M] ------------------ 330| 86.8M| delete newNode; 331| 86.8M| return static_cast(old->key.pointer); 332| 86.8M| } 333| | // If uhash_puti() returns a non-zero value from an equivalent, previously 334| | // registered node, then uhash_find() failed to find that and we will leak newNode. 335| |#if U_DEBUG 336| | int32_t oldValue= // Only in debug mode to avoid a compiler warning about unused oldValue. 337| |#endif 338| 14.7M| uhash_puti(nodes, newNode, 1, &errorCode); ------------------ | | 1033| 14.7M|#define uhash_puti U_ICU_ENTRY_POINT_RENAME(uhash_puti) | | ------------------ | | | | 123| 14.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 14.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 14.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 339| 14.7M| U_ASSERT(oldValue==0); ------------------ | | 35| 14.7M|# define U_ASSERT(exp) (void)0 ------------------ 340| 14.7M| if(U_FAILURE(errorCode)) { ------------------ | Branch (340:8): [True: 0, False: 14.7M] ------------------ 341| 0| delete newNode; 342| 0| return nullptr; 343| 0| } 344| 14.7M| return newNode; 345| 14.7M|} _ZN6icu_7817StringTrieBuilder18registerFinalValueEiR10UErrorCode: 348| 21.9M|StringTrieBuilder::registerFinalValue(int32_t value, UErrorCode &errorCode) { 349| 21.9M| if(U_FAILURE(errorCode)) { ------------------ | Branch (349:8): [True: 0, False: 21.9M] ------------------ 350| 0| return nullptr; 351| 0| } 352| 21.9M| FinalValueNode key(value); 353| 21.9M| const UHashElement *old=uhash_find(nodes, &key); ------------------ | | 1006| 21.9M|#define uhash_find U_ICU_ENTRY_POINT_RENAME(uhash_find) | | ------------------ | | | | 123| 21.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 21.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 21.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 354| 21.9M| if(old!=nullptr) { ------------------ | Branch (354:8): [True: 20.7M, False: 1.20M] ------------------ 355| 20.7M| return static_cast(old->key.pointer); 356| 20.7M| } 357| 1.20M| Node *newNode=new FinalValueNode(value); 358| 1.20M| if(newNode==nullptr) { ------------------ | Branch (358:8): [True: 0, False: 1.20M] ------------------ 359| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 360| 0| return nullptr; 361| 0| } 362| | // If uhash_puti() returns a non-zero value from an equivalent, previously 363| | // registered node, then uhash_find() failed to find that and we will leak newNode. 364| |#if U_DEBUG 365| | int32_t oldValue= // Only in debug mode to avoid a compiler warning about unused oldValue. 366| |#endif 367| 1.20M| uhash_puti(nodes, newNode, 1, &errorCode); ------------------ | | 1033| 1.20M|#define uhash_puti U_ICU_ENTRY_POINT_RENAME(uhash_puti) | | ------------------ | | | | 123| 1.20M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.20M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.20M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 368| 1.20M| U_ASSERT(oldValue==0); ------------------ | | 35| 1.20M|# define U_ASSERT(exp) (void)0 ------------------ 369| 1.20M| if(U_FAILURE(errorCode)) { ------------------ | Branch (369:8): [True: 0, False: 1.20M] ------------------ 370| 0| delete newNode; 371| 0| return nullptr; 372| 0| } 373| 1.20M| return newNode; 374| 1.20M|} _ZN6icu_7817StringTrieBuilder8hashNodeEPKv: 377| 139M|StringTrieBuilder::hashNode(const void *node) { 378| 139M| return static_cast(node)->hashCode(); 379| 139M|} _ZN6icu_7817StringTrieBuilder10equalNodesEPKvS2_: 382| 107M|StringTrieBuilder::equalNodes(const void *left, const void *right) { 383| 107M| return *static_cast(left) == *static_cast(right); 384| 107M|} _ZNK6icu_7817StringTrieBuilder4NodeeqERKS1_: 387| 107M|StringTrieBuilder::Node::operator==(const Node &other) const { 388| 107M| return this==&other || (typeid(*this)==typeid(other) && hash==other.hash); ------------------ | Branch (388:12): [True: 0, False: 107M] | Branch (388:29): [True: 107M, False: 944] | Branch (388:61): [True: 107M, False: 2.49k] ------------------ 389| 107M|} _ZN6icu_7817StringTrieBuilder4Node19markRightEdgesFirstEi: 392| 1.74M|StringTrieBuilder::Node::markRightEdgesFirst(int32_t edgeNumber) { 393| 1.74M| if(offset==0) { ------------------ | Branch (393:8): [True: 1.20M, False: 545k] ------------------ 394| 1.20M| offset=edgeNumber; 395| 1.20M| } 396| 1.74M| return edgeNumber; 397| 1.74M|} _ZNK6icu_7817StringTrieBuilder14FinalValueNodeeqERKNS0_4NodeE: 400| 20.7M|StringTrieBuilder::FinalValueNode::operator==(const Node &other) const { 401| 20.7M| if(this==&other) { ------------------ | Branch (401:8): [True: 0, False: 20.7M] ------------------ 402| 0| return true; 403| 0| } 404| 20.7M| if(!Node::operator==(other)) { ------------------ | Branch (404:8): [True: 25, False: 20.7M] ------------------ 405| 25| return false; 406| 25| } 407| 20.7M| const FinalValueNode &o=static_cast(other); 408| 20.7M| return value==o.value; 409| 20.7M|} _ZN6icu_7817StringTrieBuilder14FinalValueNode5writeERS0_: 412| 2.57M|StringTrieBuilder::FinalValueNode::write(StringTrieBuilder &builder) { 413| 2.57M| offset=builder.writeValueAndFinal(value, true); 414| 2.57M|} _ZNK6icu_7817StringTrieBuilder9ValueNodeeqERKNS0_4NodeE: 417| 64.5M|StringTrieBuilder::ValueNode::operator==(const Node &other) const { 418| 64.5M| if(this==&other) { ------------------ | Branch (418:8): [True: 0, False: 64.5M] ------------------ 419| 0| return true; 420| 0| } 421| 64.5M| if(!Node::operator==(other)) { ------------------ | Branch (421:8): [True: 1.87k, False: 64.5M] ------------------ 422| 1.87k| return false; 423| 1.87k| } 424| 64.5M| const ValueNode &o=static_cast(other); 425| 64.5M| return hasValue==o.hasValue && (!hasValue || value==o.value); ------------------ | Branch (425:12): [True: 64.5M, False: 0] | Branch (425:37): [True: 64.2M, False: 225k] | Branch (425:50): [True: 225k, False: 0] ------------------ 426| 64.5M|} _ZNK6icu_7817StringTrieBuilder15LinearMatchNodeeqERKNS0_4NodeE: 455| 45.3M|StringTrieBuilder::LinearMatchNode::operator==(const Node &other) const { 456| 45.3M| if(this==&other) { ------------------ | Branch (456:8): [True: 0, False: 45.3M] ------------------ 457| 0| return true; 458| 0| } 459| 45.3M| if(!ValueNode::operator==(other)) { ------------------ | Branch (459:8): [True: 685, False: 45.3M] ------------------ 460| 685| return false; 461| 685| } 462| 45.3M| const LinearMatchNode &o=static_cast(other); 463| 45.3M| return length==o.length && next==o.next; ------------------ | Branch (463:12): [True: 45.2M, False: 11.3k] | Branch (463:32): [True: 45.2M, False: 1.84k] ------------------ 464| 45.3M|} _ZN6icu_7817StringTrieBuilder15LinearMatchNode19markRightEdgesFirstEi: 467| 6.86M|StringTrieBuilder::LinearMatchNode::markRightEdgesFirst(int32_t edgeNumber) { 468| 6.86M| if(offset==0) { ------------------ | Branch (468:8): [True: 5.77M, False: 1.09M] ------------------ 469| 5.77M| offset=edgeNumber=next->markRightEdgesFirst(edgeNumber); 470| 5.77M| } 471| 6.86M| return edgeNumber; 472| 6.86M|} _ZNK6icu_7817StringTrieBuilder14ListBranchNodeeqERKNS0_4NodeE: 475| 20.8M|StringTrieBuilder::ListBranchNode::operator==(const Node &other) const { 476| 20.8M| if(this==&other) { ------------------ | Branch (476:8): [True: 0, False: 20.8M] ------------------ 477| 0| return true; 478| 0| } 479| 20.8M| if(!Node::operator==(other)) { ------------------ | Branch (479:8): [True: 1.05k, False: 20.8M] ------------------ 480| 1.05k| return false; 481| 1.05k| } 482| 20.8M| const ListBranchNode &o=static_cast(other); 483| 75.3M| for(int32_t i=0; imarkRightEdgesFirst(edgeNumber-step); 501| 6.35M| } 502| | // For all but the rightmost edge, decrement the edge number. 503| 12.5M| step=1; 504| 12.5M| } while(i>0); ------------------ | Branch (504:17): [True: 8.04M, False: 4.46M] ------------------ 505| 4.46M| offset=edgeNumber; 506| 4.46M| } 507| 4.49M| return edgeNumber; 508| 4.49M|} _ZN6icu_7817StringTrieBuilder14ListBranchNode5writeERS0_: 511| 7.64M|StringTrieBuilder::ListBranchNode::write(StringTrieBuilder &builder) { 512| | // Write the sub-nodes in reverse order: The jump lengths are deltas from 513| | // after their own positions, so if we wrote the minUnit sub-node first, 514| | // then its jump delta would be larger. 515| | // Instead we write the minUnit sub-node last, for a shorter delta. 516| 7.64M| int32_t unitNumber=length-1; 517| 7.64M| Node *rightEdge=equal[unitNumber]; 518| 7.64M| int32_t rightEdgeNumber= rightEdge==nullptr ? firstEdgeNumber : rightEdge->getOffset(); ------------------ | Branch (518:30): [True: 3.02M, False: 4.61M] ------------------ 519| 13.3M| do { 520| 13.3M| --unitNumber; 521| 13.3M| if(equal[unitNumber]!=nullptr) { ------------------ | Branch (521:12): [True: 8.07M, False: 5.25M] ------------------ 522| 8.07M| equal[unitNumber]->writeUnlessInsideRightEdge(firstEdgeNumber, rightEdgeNumber, builder); 523| 8.07M| } 524| 13.3M| } while(unitNumber>0); ------------------ | Branch (524:13): [True: 5.68M, False: 7.64M] ------------------ 525| | // The maxUnit sub-node is written as the very last one because we do 526| | // not jump for it at all. 527| 7.64M| unitNumber=length-1; 528| 7.64M| if(rightEdge==nullptr) { ------------------ | Branch (528:8): [True: 3.02M, False: 4.61M] ------------------ 529| 3.02M| builder.writeValueAndFinal(values[unitNumber], true); 530| 4.61M| } else { 531| 4.61M| rightEdge->write(builder); 532| 4.61M| } 533| 7.64M| offset=builder.write(units[unitNumber]); 534| | // Write the rest of this node's unit-value pairs. 535| 20.9M| while(--unitNumber>=0) { ------------------ | Branch (535:11): [True: 13.3M, False: 7.64M] ------------------ 536| 13.3M| int32_t value; 537| 13.3M| UBool isFinal; 538| 13.3M| if(equal[unitNumber]==nullptr) { ------------------ | Branch (538:12): [True: 5.25M, False: 8.07M] ------------------ 539| | // Write the final value for the one string ending with this unit. 540| 5.25M| value=values[unitNumber]; 541| 5.25M| isFinal=true; 542| 8.07M| } else { 543| | // Write the delta to the start position of the sub-node. 544| 8.07M| U_ASSERT(equal[unitNumber]->getOffset()>0); ------------------ | | 35| 8.07M|# define U_ASSERT(exp) (void)0 ------------------ 545| 8.07M| value=offset-equal[unitNumber]->getOffset(); 546| 8.07M| isFinal=false; 547| 8.07M| } 548| 13.3M| builder.writeValueAndFinal(value, isFinal); 549| 13.3M| offset=builder.write(units[unitNumber]); 550| 13.3M| } 551| 7.64M|} _ZNK6icu_7817StringTrieBuilder15SplitBranchNodeeqERKNS0_4NodeE: 554| 1.58M|StringTrieBuilder::SplitBranchNode::operator==(const Node &other) const { 555| 1.58M| if(this==&other) { ------------------ | Branch (555:8): [True: 0, False: 1.58M] ------------------ 556| 0| return true; 557| 0| } 558| 1.58M| if(!Node::operator==(other)) { ------------------ | Branch (558:8): [True: 486, False: 1.58M] ------------------ 559| 486| return false; 560| 486| } 561| 1.58M| const SplitBranchNode &o=static_cast(other); 562| 1.58M| return unit==o.unit && lessThan==o.lessThan && greaterOrEqual==o.greaterOrEqual; ------------------ | Branch (562:12): [True: 1.58M, False: 0] | Branch (562:28): [True: 1.58M, False: 86] | Branch (562:52): [True: 1.58M, False: 0] ------------------ 563| 1.58M|} _ZN6icu_7817StringTrieBuilder15SplitBranchNode19markRightEdgesFirstEi: 566| 1.19M|StringTrieBuilder::SplitBranchNode::markRightEdgesFirst(int32_t edgeNumber) { 567| 1.19M| if(offset==0) { ------------------ | Branch (567:8): [True: 1.17M, False: 19.0k] ------------------ 568| 1.17M| firstEdgeNumber=edgeNumber; 569| 1.17M| edgeNumber=greaterOrEqual->markRightEdgesFirst(edgeNumber); 570| 1.17M| offset=edgeNumber=lessThan->markRightEdgesFirst(edgeNumber-1); 571| 1.17M| } 572| 1.19M| return edgeNumber; 573| 1.19M|} _ZN6icu_7817StringTrieBuilder15SplitBranchNode5writeERS0_: 576| 1.55M|StringTrieBuilder::SplitBranchNode::write(StringTrieBuilder &builder) { 577| | // Encode the less-than branch first. 578| 1.55M| lessThan->writeUnlessInsideRightEdge(firstEdgeNumber, greaterOrEqual->getOffset(), builder); 579| | // Encode the greater-or-equal branch last because we do not jump for it at all. 580| 1.55M| greaterOrEqual->write(builder); 581| | // Write this node. 582| 1.55M| U_ASSERT(lessThan->getOffset()>0); ------------------ | | 35| 1.55M|# define U_ASSERT(exp) (void)0 ------------------ 583| 1.55M| builder.writeDeltaTo(lessThan->getOffset()); // less-than 584| 1.55M| offset=builder.write(unit); 585| 1.55M|} _ZNK6icu_7817StringTrieBuilder14BranchHeadNodeeqERKNS0_4NodeE: 588| 19.1M|StringTrieBuilder::BranchHeadNode::operator==(const Node &other) const { 589| 19.1M| if(this==&other) { ------------------ | Branch (589:8): [True: 0, False: 19.1M] ------------------ 590| 0| return true; 591| 0| } 592| 19.1M| if(!ValueNode::operator==(other)) { ------------------ | Branch (592:8): [True: 1.19k, False: 19.1M] ------------------ 593| 1.19k| return false; 594| 1.19k| } 595| 19.1M| const BranchHeadNode &o=static_cast(other); 596| 19.1M| return length==o.length && next==o.next; ------------------ | Branch (596:12): [True: 19.1M, False: 0] | Branch (596:32): [True: 19.1M, False: 4.72k] ------------------ 597| 19.1M|} _ZN6icu_7817StringTrieBuilder14BranchHeadNode19markRightEdgesFirstEi: 600| 4.81M|StringTrieBuilder::BranchHeadNode::markRightEdgesFirst(int32_t edgeNumber) { 601| 4.81M| if(offset==0) { ------------------ | Branch (601:8): [True: 3.33M, False: 1.47M] ------------------ 602| 3.33M| offset=edgeNumber=next->markRightEdgesFirst(edgeNumber); 603| 3.33M| } 604| 4.81M| return edgeNumber; 605| 4.81M|} _ZN6icu_7817StringTrieBuilder14BranchHeadNode5writeERS0_: 608| 6.50M|StringTrieBuilder::BranchHeadNode::write(StringTrieBuilder &builder) { 609| 6.50M| next->write(builder); 610| 6.50M| if(length<=builder.getMinLinearMatch()) { ------------------ | Branch (610:8): [True: 6.48M, False: 18.2k] ------------------ 611| 6.48M| offset=builder.writeValueAndType(hasValue, value, length-1); 612| 6.48M| } else { 613| 18.2k| builder.write(length-1); 614| 18.2k| offset=builder.writeValueAndType(hasValue, value, 0); 615| 18.2k| } 616| 6.50M|} stringtriebuilder.cpp:_ZL18hashStringTrieNode8UElement: 26| 139M|hashStringTrieNode(const UHashTok key) { 27| 139M| return icu::StringTrieBuilder::hashNode(key.pointer); 28| 139M|} stringtriebuilder.cpp:_ZL20equalStringTrieNodes8UElementS_: 31| 107M|equalStringTrieNodes(const UHashTok key1, const UHashTok key2) { 32| 107M| return icu::StringTrieBuilder::equalNodes(key1.pointer, key2.pointer); 33| 107M|} uprv_stableBinarySearch_78: 76| 33.5M| UComparator *cmp, const void *context) { 77| 33.5M| int32_t start=0; 78| 33.5M| UBool found=false; 79| | 80| | /* Binary search until we get down to a tiny sub-array. */ 81| 33.5M| while((limit-start)>=MIN_QSORT) { ------------------ | Branch (81:11): [True: 0, False: 33.5M] ------------------ 82| 0| int32_t i=(start+limit)/2; 83| 0| int32_t diff=cmp(context, item, array+i*itemSize); 84| 0| if(diff==0) { ------------------ | Branch (84:12): [True: 0, False: 0] ------------------ 85| | /* 86| | * Found the item. We look for the *last* occurrence of such 87| | * an item, for stable sorting. 88| | * If we knew that there will be only few equal items, 89| | * we could break now and enter the linear search. 90| | * However, if there are many equal items, then it should be 91| | * faster to continue with the binary search. 92| | * It seems likely that we either have all unique items 93| | * (where found will never become true in the insertion sort) 94| | * or potentially many duplicates. 95| | */ 96| 0| found=true; 97| 0| start=i+1; 98| 0| } else if(diff<0) { ------------------ | Branch (98:19): [True: 0, False: 0] ------------------ 99| 0| limit=i; 100| 0| } else { 101| 0| start=i; 102| 0| } 103| 0| } 104| | 105| | /* Linear search over the remaining tiny sub-array. */ 106| 142M| while(start0 && array==nullptr) || length<0 || itemSize<=0 || cmp==nullptr) { ------------------ | Branch (262:9): [True: 1.28M, False: 0] | Branch (262:21): [True: 0, False: 1.28M] | Branch (262:40): [True: 0, False: 1.28M] | Branch (262:52): [True: 0, False: 1.28M] | Branch (262:67): [True: 0, False: 1.28M] ------------------ 263| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 264| 0| return; 265| 0| } 266| | 267| 1.28M| if(length<=1) { ------------------ | Branch (267:8): [True: 368k, False: 920k] ------------------ 268| 368k| return; 269| 920k| } else if(length v; 145| 527k| if (sizeInMaxAlignTs(itemSize) > v.getCapacity() && ------------------ | Branch (145:9): [True: 0, False: 527k] ------------------ 146| 527k| v.resize(sizeInMaxAlignTs(itemSize)) == nullptr) { ------------------ | Branch (146:13): [True: 0, False: 0] ------------------ 147| 0| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 148| 0| return; 149| 0| } 150| | 151| 527k| doInsertionSort(array, length, itemSize, cmp, context, v.getAlias()); 152| 527k|} uarrsort.cpp:_ZL16sizeInMaxAlignTsi: 39| 1.31M|static constexpr int32_t sizeInMaxAlignTs(int32_t sizeInBytes) { 40| 1.31M| return (sizeInBytes + sizeof(std::max_align_t) - 1) / sizeof(std::max_align_t); 41| 1.31M|} uarrsort.cpp:_ZL15doInsertionSortPciiPFiPKvS1_S1_ES1_Pv: 120| 6.72M| UComparator *cmp, const void *context, void *pv) { 121| 6.72M| int32_t j; 122| | 123| 40.2M| for(j=1; j xw; 239| 392k| if(sizeInMaxAlignTs(itemSize)*2 > xw.getCapacity() && ------------------ | Branch (239:8): [True: 0, False: 392k] ------------------ 240| 392k| xw.resize(sizeInMaxAlignTs(itemSize) * 2) == nullptr) { ------------------ | Branch (240:13): [True: 0, False: 0] ------------------ 241| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 242| 0| return; 243| 0| } 244| | 245| 392k| subQuickSort(array, 0, length, itemSize, cmp, context, 246| 392k| xw.getAlias(), xw.getAlias() + sizeInMaxAlignTs(itemSize)); 247| 392k|} uarrsort.cpp:_ZL12subQuickSortPciiiPFiPKvS1_S1_ES1_PvS4_: 171| 6.19M| void *px, void *pw) { 172| 6.19M| int32_t left, right; 173| | 174| | /* start and left are inclusive, limit and right are exclusive */ 175| 12.0M| do { 176| 12.0M| if((start+MIN_QSORT)>=limit) { ------------------ | Branch (176:12): [True: 6.19M, False: 5.84M] ------------------ 177| 6.19M| doInsertionSort(array+start*itemSize, limit-start, itemSize, cmp, context, px); 178| 6.19M| break; 179| 6.19M| } 180| | 181| 5.84M| left=start; 182| 5.84M| right=limit; 183| | 184| | /* x=array[middle] */ 185| 5.84M| uprv_memcpy(px, array+(size_t)((start+limit)/2)*itemSize, itemSize); ------------------ | | 42| 5.84M|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5.84M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 5.84M| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 5.84M| _Pragma("clang diagnostic push") \ | | 45| 5.84M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 5.84M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 5.84M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 5.84M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 5.84M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 5.84M| _Pragma("clang diagnostic pop") \ | | 49| 5.84M| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 5.84M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 5.84M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5.84M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 186| | 187| 8.35M| do { 188| 8.35M| while(/* array[left]indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <= 0); ------------------ | | 35| 3.09k|# define U_ASSERT(exp) (void)0 ------------------ 1156| 3.09k| UChar32 result=c; 1157| | // Reset the output pointer in case it was uninitialized. 1158| 3.09k| *pString=nullptr; 1159| 3.09k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 3.09k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 680|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1163| 680| } 1164| 2.71k| } else { 1165| 388| const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2; ------------------ | | 79| 388|#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 388|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 1166| 388| uint16_t excWord=*pe++; 1167| 388| int32_t full; 1168| | 1169| 388| pe2=pe; 1170| | 1171| 388| if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) { ------------------ | | 444| 388|#define UCASE_EXC_CONDITIONAL_SPECIAL 0x4000 ------------------ | Branch (1171:12): [True: 10, False: 378] ------------------ 1172| | /* use hardcoded conditions and mappings */ 1173| | 1174| | /* 1175| | * Test for conditional mappings first 1176| | * (otherwise the unconditional default mappings are always taken), 1177| | * then test for characters that have unconditional mappings in SpecialCasing.txt, 1178| | * then get the UnicodeData.txt mappings. 1179| | */ 1180| 10| if( loc==UCASE_LOC_LITHUANIAN && ------------------ | Branch (1180:17): [True: 0, False: 10] ------------------ 1181| | /* base characters, find accents above */ 1182| 10| (((c==0x49 || c==0x4a || c==0x12e) && ------------------ | Branch (1182:24): [True: 0, False: 0] | Branch (1182:35): [True: 0, False: 0] | Branch (1182:46): [True: 0, False: 0] ------------------ 1183| 0| isFollowedByMoreAbove(iter, context)) || ------------------ | Branch (1183:25): [True: 0, False: 0] ------------------ 1184| | /* precomposed with accent above, no need to find one */ 1185| 0| (c==0xcc || c==0xcd || c==0x128)) ------------------ | Branch (1185:22): [True: 0, False: 0] | Branch (1185:33): [True: 0, False: 0] | Branch (1185:44): [True: 0, False: 0] ------------------ 1186| 10| ) { 1187| | /* 1188| | # Lithuanian 1189| | 1190| | # Lithuanian retains the dot in a lowercase i when followed by accents. 1191| | 1192| | # Introduce an explicit dot above when lowercasing capital I's and J's 1193| | # whenever there are more accents above. 1194| | # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek) 1195| | 1196| | 0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I 1197| | 004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J 1198| | 012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK 1199| | 00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE 1200| | 00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE 1201| | 0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE 1202| | */ 1203| 0| switch(c) { 1204| 0| case 0x49: /* LATIN CAPITAL LETTER I */ ------------------ | Branch (1204:17): [True: 0, False: 0] ------------------ 1205| 0| *pString=iDot; 1206| 0| return 2; 1207| 0| case 0x4a: /* LATIN CAPITAL LETTER J */ ------------------ | Branch (1207:17): [True: 0, False: 0] ------------------ 1208| 0| *pString=jDot; 1209| 0| return 2; 1210| 0| case 0x12e: /* LATIN CAPITAL LETTER I WITH OGONEK */ ------------------ | Branch (1210:17): [True: 0, False: 0] ------------------ 1211| 0| *pString=iOgonekDot; 1212| 0| return 2; 1213| 0| case 0xcc: /* LATIN CAPITAL LETTER I WITH GRAVE */ ------------------ | Branch (1213:17): [True: 0, False: 0] ------------------ 1214| 0| *pString=iDotGrave; 1215| 0| return 3; 1216| 0| case 0xcd: /* LATIN CAPITAL LETTER I WITH ACUTE */ ------------------ | Branch (1216:17): [True: 0, False: 0] ------------------ 1217| 0| *pString=iDotAcute; 1218| 0| return 3; 1219| 0| case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */ ------------------ | Branch (1219:17): [True: 0, False: 0] ------------------ 1220| 0| *pString=iDotTilde; 1221| 0| return 3; 1222| 0| default: ------------------ | Branch (1222:17): [True: 0, False: 0] ------------------ 1223| 0| return 0; /* will not occur */ 1224| 0| } 1225| | /* # Turkish and Azeri */ 1226| 10| } else if(loc==UCASE_LOC_TURKISH && c==0x130) { ------------------ | Branch (1226:23): [True: 0, False: 10] | Branch (1226:49): [True: 0, False: 0] ------------------ 1227| | /* 1228| | # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri 1229| | # The following rules handle those cases. 1230| | 1231| | 0130; 0069; 0130; 0130; tr # LATIN CAPITAL LETTER I WITH DOT ABOVE 1232| | 0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE 1233| | */ 1234| 0| return 0x69; 1235| 10| } else if(loc==UCASE_LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, context)) { ------------------ | Branch (1235:23): [True: 0, False: 10] | Branch (1235:49): [True: 0, False: 0] | Branch (1235:61): [True: 0, False: 0] ------------------ 1236| | /* 1237| | # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i. 1238| | # This matches the behavior of the canonically equivalent I-dot_above 1239| | 1240| | 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE 1241| | 0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE 1242| | */ 1243| 0| return 0; /* remove the dot (continue without output) */ 1244| 10| } else if(loc==UCASE_LOC_TURKISH && c==0x49 && !isFollowedByDotAbove(iter, context)) { ------------------ | Branch (1244:23): [True: 0, False: 10] | Branch (1244:49): [True: 0, False: 0] | Branch (1244:60): [True: 0, False: 0] ------------------ 1245| | /* 1246| | # When lowercasing, unless an I is before a dot_above, it turns into a dotless i. 1247| | 1248| | 0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I 1249| | 0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I 1250| | */ 1251| 0| return 0x131; 1252| 10| } else if(c==0x130) { ------------------ | Branch (1252:23): [True: 1, False: 9] ------------------ 1253| | /* 1254| | # Preserve canonical equivalence for I with dot. Turkic is handled below. 1255| | 1256| | 0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE 1257| | */ 1258| 1| *pString=iDot; 1259| 1| return 2; 1260| 9| } else if( c==0x3a3 && ------------------ | Branch (1260:25): [True: 1, False: 8] ------------------ 1261| 9| !isFollowedByCasedLetter(iter, context, 1) && ------------------ | Branch (1261:25): [True: 1, False: 0] ------------------ 1262| 9| isFollowedByCasedLetter(iter, context, -1) /* -1=preceded */ ------------------ | Branch (1262:25): [True: 0, False: 1] ------------------ 1263| 9| ) { 1264| | /* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */ 1265| | /* 1266| | # Special case for final form of sigma 1267| | 1268| | 03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA 1269| | */ 1270| 0| return 0x3c2; /* greek small final sigma */ 1271| 9| } else { 1272| | /* no known conditional special case mapping, use a normal mapping */ 1273| 9| } 1274| 378| } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) { ------------------ | | 101| 378|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 102, False: 276] | | ------------------ ------------------ 1275| 102| GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full); ------------------ | | 113| 102|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 102|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 102| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 102|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 102, False: 0] | | ------------------ | | 115| 102| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 102|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 102| (value)=*pExc16; \ | | 117| 102| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 102|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 102|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1276| 102| full&=UCASE_FULL_LOWER; ------------------ | | 448| 102|#define UCASE_FULL_LOWER 0xf ------------------ 1277| 102| if(full!=0) { ------------------ | Branch (1277:16): [True: 0, False: 102] ------------------ 1278| | /* set the output pointer to the lowercase mapping */ 1279| 0| *pString=reinterpret_cast(pe+1); 1280| | 1281| | /* return the string length */ 1282| 0| return full; 1283| 0| } 1284| 102| } 1285| | 1286| 387| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 101| 774|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 125, False: 262] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 374| 125|#define UCASE_IS_UPPER_OR_TITLE(props) ((props)&2) | | ------------------ | | | Branch (374:40): [True: 69, False: 56] | | ------------------ ------------------ 1287| 69| int32_t delta; 1288| 69| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 69|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 69|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 69| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 69|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 69, False: 0] | | ------------------ | | 115| 69| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 69|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 69| (value)=*pExc16; \ | | 117| 69| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 69|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 69|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1289| 69| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1289:20): [True: 14, False: 55] ------------------ 1290| 69| } 1291| 318| if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) { ------------------ | | 101| 318|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 31, False: 287] | | ------------------ ------------------ 1292| 31| GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result); ------------------ | | 113| 31|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 31|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 31| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 31|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 31, False: 0] | | ------------------ | | 115| 31| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 31|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 31| (value)=*pExc16; \ | | 117| 31| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 31|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 31|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1293| 31| } 1294| 318| } 1295| | 1296| 3.02k| return (result==c) ? ~result : result; ------------------ | Branch (1296:12): [True: 2.36k, False: 663] ------------------ 1297| 3.09k|} ucase_toFullTitle_78: 1423| 3.09k| int32_t caseLocale) { 1424| 3.09k| return toUpperOrTitle(c, iter, context, pString, caseLocale, false); 1425| 3.09k|} ucase_hasBinaryProperty_78: 1659| 12.3k|ucase_hasBinaryProperty(UChar32 c, UProperty which) { 1660| | /* case mapping properties */ 1661| 12.3k| const char16_t *resultString; 1662| 12.3k| switch(which) { 1663| 0| case UCHAR_LOWERCASE: ------------------ | Branch (1663:5): [True: 0, False: 12.3k] ------------------ 1664| 0| return (UBool)(UCASE_LOWER==ucase_getType(c)); ------------------ | | 575| 0|#define ucase_getType U_ICU_ENTRY_POINT_RENAME(ucase_getType) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1665| 0| case UCHAR_UPPERCASE: ------------------ | Branch (1665:5): [True: 0, False: 12.3k] ------------------ 1666| 0| return (UBool)(UCASE_UPPER==ucase_getType(c)); ------------------ | | 575| 0|#define ucase_getType U_ICU_ENTRY_POINT_RENAME(ucase_getType) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1667| 3.09k| case UCHAR_SOFT_DOTTED: ------------------ | Branch (1667:5): [True: 3.09k, False: 9.29k] ------------------ 1668| 3.09k| return ucase_isSoftDotted(c); ------------------ | | 579| 3.09k|#define ucase_isSoftDotted U_ICU_ENTRY_POINT_RENAME(ucase_isSoftDotted) | | ------------------ | | | | 123| 3.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1669| 0| case UCHAR_CASE_SENSITIVE: ------------------ | Branch (1669:5): [True: 0, False: 12.3k] ------------------ 1670| 0| return ucase_isCaseSensitive(c); ------------------ | | 578| 0|#define ucase_isCaseSensitive U_ICU_ENTRY_POINT_RENAME(ucase_isCaseSensitive) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1671| 0| case UCHAR_CASED: ------------------ | Branch (1671:5): [True: 0, False: 12.3k] ------------------ 1672| 0| return (UBool)(UCASE_NONE!=ucase_getType(c)); ------------------ | | 575| 0|#define ucase_getType U_ICU_ENTRY_POINT_RENAME(ucase_getType) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1673| 3.09k| case UCHAR_CASE_IGNORABLE: ------------------ | Branch (1673:5): [True: 3.09k, False: 9.29k] ------------------ 1674| 3.09k| return (UBool)(ucase_getTypeOrIgnorable(c)>>2); ------------------ | | 576| 3.09k|#define ucase_getTypeOrIgnorable U_ICU_ENTRY_POINT_RENAME(ucase_getTypeOrIgnorable) | | ------------------ | | | | 123| 3.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1675| | /* 1676| | * Note: The following Changes_When_Xyz are defined as testing whether 1677| | * the NFD form of the input changes when Xyz-case-mapped. 1678| | * However, this simpler implementation of these properties, 1679| | * ignoring NFD, passes the tests. 1680| | * The implementation needs to be changed if the tests start failing. 1681| | * When that happens, optimizations should be used to work with the 1682| | * per-single-code point ucase_toFullXyz() functions unless 1683| | * the NFD form has more than one code point, 1684| | * and the property starts set needs to be the union of the 1685| | * start sets for normalization and case mappings. 1686| | */ 1687| 3.09k| case UCHAR_CHANGES_WHEN_LOWERCASED: ------------------ | Branch (1687:5): [True: 3.09k, False: 9.29k] ------------------ 1688| 3.09k| return (UBool)(ucase_toFullLower(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 581| 3.09k|#define ucase_toFullLower U_ICU_ENTRY_POINT_RENAME(ucase_toFullLower) | | ------------------ | | | | 123| 3.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1689| 0| case UCHAR_CHANGES_WHEN_UPPERCASED: ------------------ | Branch (1689:5): [True: 0, False: 12.3k] ------------------ 1690| 0| return (UBool)(ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 583| 0|#define ucase_toFullUpper U_ICU_ENTRY_POINT_RENAME(ucase_toFullUpper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1691| 3.09k| case UCHAR_CHANGES_WHEN_TITLECASED: ------------------ | Branch (1691:5): [True: 3.09k, False: 9.29k] ------------------ 1692| 3.09k| return (UBool)(ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 582| 3.09k|#define ucase_toFullTitle U_ICU_ENTRY_POINT_RENAME(ucase_toFullTitle) | | ------------------ | | | | 123| 3.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1693| | /* case UCHAR_CHANGES_WHEN_CASEFOLDED: -- in uprops.c */ 1694| 0| case UCHAR_CHANGES_WHEN_CASEMAPPED: ------------------ | Branch (1694:5): [True: 0, False: 12.3k] ------------------ 1695| 0| return (UBool)( 1696| 0| ucase_toFullLower(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 || ------------------ | | 581| 0|#define ucase_toFullLower U_ICU_ENTRY_POINT_RENAME(ucase_toFullLower) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1696:13): [True: 0, False: 0] ------------------ 1697| 0| ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 || ------------------ | | 583| 0|#define ucase_toFullUpper U_ICU_ENTRY_POINT_RENAME(ucase_toFullUpper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1697:13): [True: 0, False: 0] ------------------ 1698| 0| ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 582| 0|#define ucase_toFullTitle U_ICU_ENTRY_POINT_RENAME(ucase_toFullTitle) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1698:13): [True: 0, False: 0] ------------------ 1699| 0| default: ------------------ | Branch (1699:5): [True: 0, False: 12.3k] ------------------ 1700| 0| return false; 1701| 12.3k| } 1702| 12.3k|} ucase.cpp:_ZL24_enumPropertyStartsRangePKviij: 39| 3.09k|_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 /*end*/, uint32_t /*value*/) { 40| | /* add the start code point to the USet */ 41| 3.09k| const USetAdder* sa = static_cast(context); 42| 3.09k| sa->add(sa->set, start); 43| 3.09k| return true; 44| 3.09k|} ucase.cpp:_ZL10getDotTypei: 687| 3.09k|getDotType(UChar32 c) { 688| 3.09k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 3.09k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 388|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 693| 388| return (*pe>>UCASE_EXC_DOT_SHIFT)&UCASE_DOT_MASK; ------------------ | | 432| 388|#define UCASE_EXC_DOT_SHIFT 7 ------------------ return (*pe>>UCASE_EXC_DOT_SHIFT)&UCASE_DOT_MASK; ------------------ | | 382| 388|#define UCASE_DOT_MASK 0x60 ------------------ 694| 388| } 695| 3.09k|} ucase.cpp:_ZL23isFollowedByCasedLetterPFiPvaES_a: 1000| 2|isFollowedByCasedLetter(UCaseContextIterator *iter, void *context, int8_t dir) { 1001| 2| UChar32 c; 1002| | 1003| 2| if(iter==nullptr) { ------------------ | Branch (1003:8): [True: 2, False: 0] ------------------ 1004| 2| return false; 1005| 2| } 1006| | 1007| 0| for(/* dir!=0 sets direction */; (c=iter(context, dir))>=0; dir=0) { ------------------ | Branch (1007:38): [True: 0, False: 0] ------------------ 1008| 0| int32_t type=ucase_getTypeOrIgnorable(c); ------------------ | | 576| 0|#define ucase_getTypeOrIgnorable U_ICU_ENTRY_POINT_RENAME(ucase_getTypeOrIgnorable) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1009| 0| if(type&4) { ------------------ | Branch (1009:12): [True: 0, False: 0] ------------------ 1010| | /* case-ignorable, continue with the loop */ 1011| 0| } else if(type!=UCASE_NONE) { ------------------ | Branch (1011:19): [True: 0, False: 0] ------------------ 1012| 0| return true; /* followed by cased letter */ 1013| 0| } else { 1014| 0| return false; /* uncased and not case-ignorable */ 1015| 0| } 1016| 0| } 1017| | 1018| 0| return false; /* not followed by cased letter */ 1019| 0|} ucase.cpp:_ZL14toUpperOrTitleiPFiPvaES_PPKDsia: 1305| 3.09k| UBool upperNotTitle) { 1306| | // The sign of the result has meaning, input must be non-negative so that it can be returned as is. 1307| 3.09k| U_ASSERT(c >= 0); ------------------ | | 35| 3.09k|# define U_ASSERT(exp) (void)0 ------------------ 1308| 3.09k| UChar32 result=c; 1309| | // Reset the output pointer in case it was uninitialized. 1310| 3.09k| *pString=nullptr; 1311| 3.09k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 3.09k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 794|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1315| 794| } 1316| 2.71k| } else { 1317| 388| const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2; ------------------ | | 79| 388|#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 388|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 1318| 388| uint16_t excWord=*pe++; 1319| 388| int32_t full, idx; 1320| | 1321| 388| pe2=pe; 1322| | 1323| 388| if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) { ------------------ | | 444| 388|#define UCASE_EXC_CONDITIONAL_SPECIAL 0x4000 ------------------ | Branch (1323:12): [True: 10, False: 378] ------------------ 1324| | /* use hardcoded conditions and mappings */ 1325| 10| if(loc==UCASE_LOC_TURKISH && c==0x69) { ------------------ | Branch (1325:16): [True: 0, False: 10] | Branch (1325:42): [True: 0, False: 0] ------------------ 1326| | /* 1327| | # Turkish and Azeri 1328| | 1329| | # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri 1330| | # The following rules handle those cases. 1331| | 1332| | # When uppercasing, i turns into a dotted capital I 1333| | 1334| | 0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I 1335| | 0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I 1336| | */ 1337| 0| return 0x130; 1338| 10| } else if(loc==UCASE_LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, context)) { ------------------ | Branch (1338:23): [True: 0, False: 10] | Branch (1338:52): [True: 0, False: 0] | Branch (1338:64): [True: 0, False: 0] ------------------ 1339| | /* 1340| | # Lithuanian 1341| | 1342| | # Lithuanian retains the dot in a lowercase i when followed by accents. 1343| | 1344| | # Remove DOT ABOVE after "i" with upper or titlecase 1345| | 1346| | 0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE 1347| | */ 1348| 0| return 0; /* remove the dot (continue without output) */ 1349| 10| } else if(c==0x0587) { ------------------ | Branch (1349:23): [True: 1, False: 9] ------------------ 1350| | // See ICU-13416: 1351| | // և ligature ech-yiwn 1352| | // uppercases to ԵՒ=ech+yiwn by default and in Western Armenian, 1353| | // but to ԵՎ=ech+vew in Eastern Armenian. 1354| 1| if(loc==UCASE_LOC_ARMENIAN) { ------------------ | Branch (1354:20): [True: 0, False: 1] ------------------ 1355| 0| *pString=upperNotTitle ? u"ԵՎ" : u"Եվ"; ------------------ | Branch (1355:30): [True: 0, False: 0] ------------------ 1356| 1| } else { 1357| 1| *pString=upperNotTitle ? u"ԵՒ" : u"Եւ"; ------------------ | Branch (1357:30): [True: 0, False: 1] ------------------ 1358| 1| } 1359| 1| return 2; 1360| 9| } else { 1361| | /* no known conditional special case mapping, use a normal mapping */ 1362| 9| } 1363| 378| } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) { ------------------ | | 101| 378|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 102, False: 276] | | ------------------ ------------------ 1364| 102| GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full); ------------------ | | 113| 102|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 102|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 102| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 102|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 102, False: 0] | | ------------------ | | 115| 102| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 102|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 102| (value)=*pExc16; \ | | 117| 102| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 102|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 102|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1365| | 1366| | /* start of full case mapping strings */ 1367| 102| ++pe; 1368| | 1369| | /* skip the lowercase and case-folding result strings */ 1370| 102| pe+=full&UCASE_FULL_LOWER; ------------------ | | 448| 102|#define UCASE_FULL_LOWER 0xf ------------------ 1371| 102| full>>=4; 1372| 102| pe+=full&0xf; 1373| 102| full>>=4; 1374| | 1375| 102| if(upperNotTitle) { ------------------ | Branch (1375:16): [True: 0, False: 102] ------------------ 1376| 0| full&=0xf; 1377| 102| } else { 1378| | /* skip the uppercase result string */ 1379| 102| pe+=full&0xf; 1380| 102| full=(full>>4)&0xf; 1381| 102| } 1382| | 1383| 102| if(full!=0) { ------------------ | Branch (1383:16): [True: 47, False: 55] ------------------ 1384| | /* set the output pointer to the result string */ 1385| 47| *pString=reinterpret_cast(pe); 1386| | 1387| | /* return the string length */ 1388| 47| return full; 1389| 47| } 1390| 102| } 1391| | 1392| 340| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) { ------------------ | | 101| 680|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 126, False: 214] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) { ------------------ | | 371| 126|#define UCASE_GET_TYPE(props) ((props)&UCASE_TYPE_MASK) | | ------------------ | | | | 363| 126|#define UCASE_TYPE_MASK 3 | | ------------------ ------------------ | Branch (1392:50): [True: 56, False: 70] ------------------ 1393| 56| int32_t delta; 1394| 56| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 56|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 56|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 56| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 56|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 56, False: 0] | | ------------------ | | 115| 56| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 56|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 56| (value)=*pExc16; \ | | 117| 56| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 56|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 56|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1395| 56| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1395:20): [True: 49, False: 7] ------------------ 1396| 56| } 1397| 284| if(!upperNotTitle && HAS_SLOT(excWord, UCASE_EXC_TITLE)) { ------------------ | | 101| 284|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 58, False: 226] | | ------------------ ------------------ | Branch (1397:12): [True: 284, False: 0] ------------------ 1398| 58| idx=UCASE_EXC_TITLE; 1399| 226| } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) { ------------------ | | 101| 226|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 132, False: 94] | | ------------------ ------------------ 1400| | /* here, titlecase is same as uppercase */ 1401| 132| idx=UCASE_EXC_UPPER; 1402| 132| } else { 1403| 94| return ~c; 1404| 94| } 1405| 284| GET_SLOT_VALUE(excWord, idx, pe2, result); ------------------ | | 113| 190|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 190|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 190| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 190|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 190, False: 0] | | ------------------ | | 115| 190| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 190|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 190| (value)=*pExc16; \ | | 117| 190| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 284|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 284|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1406| 190| } 1407| | 1408| 2.90k| return (result==c) ? ~result : result; ------------------ | Branch (1408:12): [True: 2.12k, False: 778] ------------------ 1409| 3.09k|} u_charType_78: 50| 35.6M|u_charType(UChar32 c) { 51| 35.6M| uint32_t props; 52| 35.6M| GET_PROPS(c, props); ------------------ | | 44| 35.6M|#define GET_PROPS(c, result) ((result)=UTRIE2_GET16(&propsTrie, c)) | | ------------------ | | | | 360| 35.6M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | | | ------------------ | | | | | | 871| 35.6M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 35.6M| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 20.9M, False: 14.6M] | | | | | | | | ------------------ | | | | | | | | 846| 35.6M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 20.9M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 20.9M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 5.93k, False: 1.06M] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 1.07M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 14.6M| (trie)->index, c) : \ | | | | | | | | 851| 14.6M| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 13.5M] | | | | | | | | ------------------ | | | | | | | | 852| 13.5M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 13.5M| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 13.5M] | | | | | | | | ------------------ | | | | | | | | 854| 13.5M| (trie)->highValueIndex : \ | | | | | | | | 855| 13.5M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 13.5M| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 13.5M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 13.5M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 13.5M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 13.5M| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 50.8k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 50.8k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 48.4k, False: 2.46k] | | | | | | | | ------------------ | | | | | | | | 846| 50.8k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 48.4k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 48.4k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 0, False: 164] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 164| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 2.46k| (trie)->index, c) : \ | | | | | | | | 851| 2.46k| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 2.30k] | | | | | | | | ------------------ | | | | | | | | 852| 2.30k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 2.30k| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 2.30k] | | | | | | | | ------------------ | | | | | | | | 854| 2.30k| (trie)->highValueIndex : \ | | | | | | | | 855| 2.30k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 2.30k| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 2.30k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 2.30k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 2.30k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 2.30k| <>UPROPS_NUMERIC_TYPE_VALUE_SHIFT) ------------------ 348| 50.8k| if(value<=9) { ------------------ | Branch (348:8): [True: 50.8k, False: 0] ------------------ 349| 50.8k| return value; 350| 50.8k| } else { 351| 0| return -1; 352| 0| } 353| 50.8k|} u_getUnicodeProperties_78: 499| 1.05M|u_getUnicodeProperties(UChar32 c, int32_t column) { 500| 1.05M| U_ASSERT(column>=0); ------------------ | | 35| 1.05M|# define U_ASSERT(exp) (void)0 ------------------ 501| 1.05M| if(column>=propsVectorsColumns) { ------------------ | Branch (501:8): [True: 0, False: 1.05M] ------------------ 502| 0| return 0; 503| 1.05M| } else { 504| 1.05M| uint16_t vecIndex=UTRIE2_GET16(&propsVectorsTrie, c); ------------------ | | 360| 1.05M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 1.05M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 1.05M| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 608k, False: 446k] | | | | | | ------------------ | | | | | | 846| 1.05M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 608k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 608k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 74, False: 63.1k] | | | | | | | | ------------------ | | | | | | | | 816| 63.2k| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 446k| (trie)->index, c) : \ | | | | | | 851| 446k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 383k] | | | | | | ------------------ | | | | | | 852| 383k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 383k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 383k] | | | | | | ------------------ | | | | | | 854| 383k| (trie)->highValueIndex : \ | | | | | | 855| 383k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 383k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 383k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 383k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 383k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 383k| <>UPROPS_AGE_SHIFT; ------------------ | | 288| 499k|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 499k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 499k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 499k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 527| 499k| versionArray[0]=(uint8_t)(version>>2); 528| 499k| versionArray[1]=(uint8_t)(version&3); 529| 499k| versionArray[2]=versionArray[3]=0; 530| 499k| } 531| 499k|} uscript_getScript_78: 534| 534k|uscript_getScript(UChar32 c, UErrorCode *pErrorCode) { 535| 534k| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (535:8): [True: 0, False: 534k] | Branch (535:31): [True: 0, False: 534k] ------------------ 536| 0| return USCRIPT_INVALID_CODE; 537| 0| } 538| 534k| if((uint32_t)c>0x10ffff) { ------------------ | Branch (538:8): [True: 0, False: 534k] ------------------ 539| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 540| 0| return USCRIPT_INVALID_CODE; 541| 0| } 542| 534k| uint32_t scriptX=u_getUnicodeProperties(c, 0)&UPROPS_SCRIPT_X_MASK; ------------------ | | 288| 534k|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 534k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 534k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 534k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 543| 534k| uint32_t codeOrIndex=scriptX&UPROPS_MAX_SCRIPT; 544| 534k| if(scriptXadd(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 659| | 660| | /* add for IS_THAT_CONTROL_SPACE() */ 661| 1| sa->add(sa->set, CR+1); /* range TAB..CR */ 662| 1| sa->add(sa->set, 0x1c); 663| 1| sa->add(sa->set, 0x1f+1); 664| 1| USET_ADD_CP_AND_NEXT(sa, 0x85); // NEXT LINE (NEL) ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 665| | 666| | /* add for u_isIDIgnorable() what was not added above */ 667| 1| sa->add(sa->set, 0x7f); /* range DEL..NBSP-1, NBSP added below */ 668| 1| sa->add(sa->set, HAIRSP); 669| 1| sa->add(sa->set, RLM+1); 670| 1| sa->add(sa->set, 0x206a); // INHIBIT SYMMETRIC SWAPPING 671| 1| sa->add(sa->set, 0x206f+1); // NOMINAL DIGIT SHAPES 672| 1| USET_ADD_CP_AND_NEXT(sa, ZWNBSP); ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 673| | 674| | /* add no-break spaces for u_isWhitespace() what was not added above */ 675| 1| USET_ADD_CP_AND_NEXT(sa, NBSP); ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 676| 1| USET_ADD_CP_AND_NEXT(sa, FIGURESP); ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 677| 1| USET_ADD_CP_AND_NEXT(sa, NNBSP); ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 678| | 679| | /* add for u_digit() */ 680| 1| sa->add(sa->set, u'a'); 681| 1| sa->add(sa->set, u'z'+1); 682| 1| sa->add(sa->set, u'A'); 683| 1| sa->add(sa->set, u'Z'+1); 684| | // fullwidth 685| 1| sa->add(sa->set, u'ａ'); 686| 1| sa->add(sa->set, u'ｚ'+1); 687| 1| sa->add(sa->set, u'Ａ'); 688| 1| sa->add(sa->set, u'Ｚ'+1); 689| | 690| | /* add for u_isxdigit() */ 691| 1| sa->add(sa->set, u'f'+1); 692| 1| sa->add(sa->set, u'F'+1); 693| | // fullwidth 694| 1| sa->add(sa->set, u'ｆ'+1); 695| 1| sa->add(sa->set, u'Ｆ'+1); 696| | 697| | /* add for UCHAR_DEFAULT_IGNORABLE_CODE_POINT what was not added above */ 698| 1| sa->add(sa->set, 0x2060); /* range 2060..206f */ 699| 1| sa->add(sa->set, 0xfff0); 700| 1| sa->add(sa->set, 0xfffb+1); 701| 1| sa->add(sa->set, 0xe0000); 702| 1| sa->add(sa->set, 0xe0fff+1); 703| | 704| | /* add for UCHAR_GRAPHEME_BASE and others */ 705| 1| USET_ADD_CP_AND_NEXT(sa, CGJ); ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 706| 1|} upropsvec_addPropertyStarts_78: 709| 1|upropsvec_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 710| 1| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (710:8): [True: 0, False: 1] ------------------ 711| 0| return; 712| 0| } 713| | 714| | /* add the start code point of each same-value range of the properties vectors trie */ 715| 1| utrie2_enum(&propsVectorsTrie, nullptr, _enumPropertyStartsRange, sa); ------------------ | | 1962| 1|#define utrie2_enum U_ICU_ENTRY_POINT_RENAME(utrie2_enum) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 716| 1|} uchar.cpp:_ZL24_enumPropertyStartsRangePKviij: 635| 13.1k|_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 end, uint32_t value) { 636| | /* add the start code point to the USet */ 637| 13.1k| const USetAdder* sa = static_cast(context); 638| 13.1k| sa->add(sa->set, start); 639| 13.1k| (void)end; 640| 13.1k| (void)value; 641| 13.1k| return true; 642| 13.1k|} _ZN6icu_7810UCharsTrieD2Ev: 27| 2.85M|UCharsTrie::~UCharsTrie() { 28| 2.85M| uprv_free(ownedArray_); ------------------ | | 1503| 2.85M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.85M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.85M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.85M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 29| 2.85M|} _ZN6icu_7810UCharsTrie17firstForCodePointEi: 44| 2.17M|UCharsTrie::firstForCodePoint(UChar32 cp) { 45| 2.17M| return cp<=0xffff ? ------------------ | Branch (45:12): [True: 2.04M, False: 128k] ------------------ 46| 2.04M| first(cp) : 47| 2.17M| (USTRINGTRIE_HAS_NEXT(first(U16_LEAD(cp))) ? ------------------ | | 95| 128k|#define USTRINGTRIE_HAS_NEXT(result) ((result)&1) | | ------------------ | | | Branch (95:38): [True: 122k, False: 5.82k] | | ------------------ ------------------ 48| 122k| next(U16_TRAIL(cp)) : ------------------ | | 132| 122k|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 49| 128k| USTRINGTRIE_NO_MATCH); 50| 2.17M|} _ZN6icu_7810UCharsTrie16nextForCodePointEi: 53| 16.3M|UCharsTrie::nextForCodePoint(UChar32 cp) { 54| 16.3M| return cp<=0xffff ? ------------------ | Branch (54:12): [True: 16.2M, False: 116k] ------------------ 55| 16.2M| next(cp) : 56| 16.3M| (USTRINGTRIE_HAS_NEXT(next(U16_LEAD(cp))) ? ------------------ | | 95| 116k|#define USTRINGTRIE_HAS_NEXT(result) ((result)&1) | | ------------------ | | | Branch (95:38): [True: 99.4k, False: 16.7k] | | ------------------ ------------------ 57| 99.4k| next(U16_TRAIL(cp)) : ------------------ | | 132| 99.4k|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 58| 116k| USTRINGTRIE_NO_MATCH); 59| 16.3M|} _ZN6icu_7810UCharsTrie10branchNextEPKDsii: 62| 3.54M|UCharsTrie::branchNext(const char16_t *pos, int32_t length, int32_t uchar) { 63| | // Branch according to the current unit. 64| 3.54M| if(length==0) { ------------------ | Branch (64:8): [True: 48.5k, False: 3.49M] ------------------ 65| 48.5k| length=*pos++; 66| 48.5k| } 67| 3.54M| ++length; 68| | // The length of the branch is the number of units to select from. 69| | // The data structure encodes a binary search. 70| 4.49M| while(length>kMaxBranchLinearSubNodeLength) { ------------------ | Branch (70:11): [True: 953k, False: 3.54M] ------------------ 71| 953k| if(uchar<*pos++) { ------------------ | Branch (71:12): [True: 520k, False: 432k] ------------------ 72| 520k| length>>=1; 73| 520k| pos=jumpByDelta(pos); 74| 520k| } else { 75| 432k| length=length-(length>>1); 76| 432k| pos=skipDelta(pos); 77| 432k| } 78| 953k| } 79| | // Drop down to linear search for the last few units. 80| | // length>=2 because the loop body above sees length>kMaxBranchLinearSubNodeLength>=3 81| | // and divides length by 2. 82| 5.56M| do { 83| 5.56M| if(uchar==*pos++) { ------------------ | Branch (83:12): [True: 1.67M, False: 3.88M] ------------------ 84| 1.67M| UStringTrieResult result; 85| 1.67M| int32_t node=*pos; 86| 1.67M| if(node&kValueIsFinal) { ------------------ | Branch (86:16): [True: 437k, False: 1.23M] ------------------ 87| | // Leave the final value for getValue() to read. 88| 437k| result=USTRINGTRIE_FINAL_VALUE; 89| 1.23M| } else { 90| | // Use the non-final value as the jump delta. 91| 1.23M| ++pos; 92| | // int32_t delta=readValue(pos, node); 93| 1.23M| int32_t delta; 94| 1.23M| if(node=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (105:25): [True: 70.1k, False: 1.16M] ------------------ 106| 1.23M| } 107| 1.67M| pos_=pos; 108| 1.67M| return result; 109| 1.67M| } 110| 3.88M| --length; 111| 3.88M| pos=skipValue(pos); 112| 3.88M| } while(length>1); ------------------ | Branch (112:13): [True: 2.01M, False: 1.87M] ------------------ 113| 1.87M| if(uchar==*pos++) { ------------------ | Branch (113:8): [True: 854k, False: 1.01M] ------------------ 114| 854k| pos_=pos; 115| 854k| int32_t node=*pos; 116| 854k| return node>=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (116:16): [True: 234k, False: 620k] ------------------ 117| 1.01M| } else { 118| 1.01M| stop(); 119| 1.01M| return USTRINGTRIE_NO_MATCH; 120| 1.01M| } 121| 1.87M|} _ZN6icu_7810UCharsTrie8nextImplEPKDsi: 124| 6.86M|UCharsTrie::nextImpl(const char16_t *pos, int32_t uchar) { 125| 6.86M| int32_t node=*pos++; 126| 7.13M| for(;;) { 127| 7.13M| if(node=kMinValueLead) ? ------------------ | Branch (135:25): [True: 1.01M, False: 1.84M] | Branch (135:37): [True: 452k, False: 563k] ------------------ 136| 2.41M| valueResult(node) : USTRINGTRIE_NO_VALUE; 137| 2.86M| } else { 138| | // No match. 139| 455k| break; 140| 455k| } 141| 3.32M| } else if(node&kValueIsFinal) { ------------------ | Branch (141:19): [True: 0, False: 271k] ------------------ 142| | // No further matching units. 143| 0| break; 144| 271k| } else { 145| | // Skip intermediate value. 146| 271k| pos=skipNodeValue(pos, node); 147| 271k| node&=kNodeTypeMask; 148| 271k| } 149| 7.13M| } 150| 455k| stop(); 151| 455k| return USTRINGTRIE_NO_MATCH; 152| 6.86M|} _ZN6icu_7810UCharsTrie4nextEi: 155| 16.5M|UCharsTrie::next(int32_t uchar) { 156| 16.5M| const char16_t *pos=pos_; 157| 16.5M| if(pos==nullptr) { ------------------ | Branch (157:8): [True: 0, False: 16.5M] ------------------ 158| 0| return USTRINGTRIE_NO_MATCH; 159| 0| } 160| 16.5M| int32_t length=remainingMatchLength_; // Actual remaining match length minus 1. 161| 16.5M| if(length>=0) { ------------------ | Branch (161:8): [True: 11.9M, False: 4.69M] ------------------ 162| | // Remaining part of a linear-match node. 163| 11.9M| if(uchar==*pos++) { ------------------ | Branch (163:12): [True: 11.5M, False: 336k] ------------------ 164| 11.5M| remainingMatchLength_=--length; 165| 11.5M| pos_=pos; 166| 11.5M| int32_t node; 167| 11.5M| return (length<0 && (node=*pos)>=kMinValueLead) ? ------------------ | Branch (167:21): [True: 1.49M, False: 10.0M] | Branch (167:33): [True: 229k, False: 1.26M] ------------------ 168| 11.3M| valueResult(node) : USTRINGTRIE_NO_VALUE; 169| 11.5M| } else { 170| 336k| stop(); 171| 336k| return USTRINGTRIE_NO_MATCH; 172| 336k| } 173| 11.9M| } 174| 4.69M| return nextImpl(pos, uchar); 175| 16.5M|} _ZN6icu_7817UCharsTrieElement5setToERKNS_13UnicodeStringEiRS1_R10UErrorCode: 67| 46.1M| UnicodeString &strings, UErrorCode &errorCode) { 68| 46.1M| if(U_FAILURE(errorCode)) { ------------------ | Branch (68:8): [True: 0, False: 46.1M] ------------------ 69| 0| return; 70| 0| } 71| 46.1M| int32_t length=s.length(); 72| 46.1M| if(length>0xffff) { ------------------ | Branch (72:8): [True: 0, False: 46.1M] ------------------ 73| | // Too long: We store the length in 1 unit. 74| 0| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; 75| 0| return; 76| 0| } 77| 46.1M| stringOffset=strings.length(); 78| 46.1M| strings.append(static_cast(length)); 79| 46.1M| value=val; 80| 46.1M| strings.append(s); 81| 46.1M|} _ZNK6icu_7817UCharsTrieElement15compareStringToERKS0_RKNS_13UnicodeStringE: 84| 341M|UCharsTrieElement::compareStringTo(const UCharsTrieElement &other, const UnicodeString &strings) const { 85| 341M| return getString(strings).compare(other.getString(strings)); 86| 341M|} _ZN6icu_7817UCharsTrieBuilderC2ER10UErrorCode: 89| 859k| : elements(nullptr), elementsCapacity(0), elementsLength(0), 90| 859k| uchars(nullptr), ucharsCapacity(0), ucharsLength(0) {} _ZN6icu_7817UCharsTrieBuilderD2Ev: 92| 859k|UCharsTrieBuilder::~UCharsTrieBuilder() { 93| 859k| delete[] elements; 94| 859k| uprv_free(uchars); ------------------ | | 1503| 859k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 859k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 859k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 859k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 95| 859k|} _ZN6icu_7817UCharsTrieBuilder3addERKNS_13UnicodeStringEiR10UErrorCode: 98| 46.1M|UCharsTrieBuilder::add(const UnicodeString &s, int32_t value, UErrorCode &errorCode) { 99| 46.1M| if(U_FAILURE(errorCode)) { ------------------ | Branch (99:8): [True: 0, False: 46.1M] ------------------ 100| 0| return *this; 101| 0| } 102| 46.1M| if(ucharsLength>0) { ------------------ | Branch (102:8): [True: 0, False: 46.1M] ------------------ 103| | // Cannot add elements after building. 104| 0| errorCode=U_NO_WRITE_PERMISSION; 105| 0| return *this; 106| 0| } 107| 46.1M| if(elementsLength==elementsCapacity) { ------------------ | Branch (107:8): [True: 480k, False: 45.6M] ------------------ 108| 480k| int32_t newCapacity; 109| 480k| if(elementsCapacity==0) { ------------------ | Branch (109:12): [True: 478k, False: 1.99k] ------------------ 110| 478k| newCapacity=1024; 111| 478k| } else { 112| 1.99k| newCapacity=4*elementsCapacity; 113| 1.99k| } 114| 480k| UCharsTrieElement *newElements=new UCharsTrieElement[newCapacity]; 115| 480k| if(newElements==nullptr) { ------------------ | Branch (115:12): [True: 0, False: 480k] ------------------ 116| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 117| 0| return *this; 118| 0| } 119| 480k| if(elementsLength>0) { ------------------ | Branch (119:12): [True: 1.99k, False: 478k] ------------------ 120| 1.99k| uprv_memcpy(newElements, elements, (size_t)elementsLength*sizeof(UCharsTrieElement)); ------------------ | | 42| 1.99k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.99k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.99k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.99k| _Pragma("clang diagnostic push") \ | | 45| 1.99k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.99k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.99k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.99k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.99k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.99k| _Pragma("clang diagnostic pop") \ | | 49| 1.99k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.99k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.99k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.99k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 121| 1.99k| } 122| 480k| delete[] elements; 123| 480k| elements=newElements; 124| 480k| elementsCapacity=newCapacity; 125| 480k| } 126| 46.1M| elements[elementsLength++].setTo(s, value, strings, errorCode); 127| 46.1M| if(U_SUCCESS(errorCode) && strings.isBogus()) { ------------------ | Branch (127:8): [True: 46.1M, False: 0] | Branch (127:32): [True: 0, False: 46.1M] ------------------ 128| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 129| 0| } 130| 46.1M| return *this; 131| 46.1M|} _ZN6icu_7817UCharsTrieBuilder18buildUnicodeStringE22UStringTrieBuildOptionRNS_13UnicodeStringER10UErrorCode: 163| 1.28M| UErrorCode &errorCode) { 164| 1.28M| buildUChars(buildOption, errorCode); 165| 1.28M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (165:8): [True: 1.28M, False: 0] ------------------ 166| 1.28M| result.setTo(false, uchars+(ucharsCapacity-ucharsLength), ucharsLength); 167| 1.28M| } 168| 1.28M| return result; 169| 1.28M|} _ZN6icu_7817UCharsTrieBuilder11buildUCharsE22UStringTrieBuildOptionR10UErrorCode: 172| 1.28M|UCharsTrieBuilder::buildUChars(UStringTrieBuildOption buildOption, UErrorCode &errorCode) { 173| 1.28M| if(U_FAILURE(errorCode)) { ------------------ | Branch (173:8): [True: 0, False: 1.28M] ------------------ 174| 0| return; 175| 0| } 176| 1.28M| if(uchars!=nullptr && ucharsLength>0) { ------------------ | Branch (176:8): [True: 811k, False: 478k] | Branch (176:27): [True: 0, False: 811k] ------------------ 177| | // Already built. 178| 0| return; 179| 0| } 180| 1.28M| if(ucharsLength==0) { ------------------ | Branch (180:8): [True: 1.28M, False: 0] ------------------ 181| 1.28M| if(elementsLength==0) { ------------------ | Branch (181:12): [True: 0, False: 1.28M] ------------------ 182| 0| errorCode=U_INDEX_OUTOFBOUNDS_ERROR; 183| 0| return; 184| 0| } 185| 1.28M| if(strings.isBogus()) { ------------------ | Branch (185:12): [True: 0, False: 1.28M] ------------------ 186| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 187| 0| return; 188| 0| } 189| 1.28M| uprv_sortArray(elements, elementsLength, static_cast(sizeof(UCharsTrieElement)), ------------------ | | 1538| 1.28M|#define uprv_sortArray U_ICU_ENTRY_POINT_RENAME(uprv_sortArray) | | ------------------ | | | | 123| 1.28M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.28M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.28M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 190| 1.28M| compareElementStrings, &strings, 191| 1.28M| false, // need not be a stable sort 192| 1.28M| &errorCode); 193| 1.28M| if(U_FAILURE(errorCode)) { ------------------ | Branch (193:12): [True: 0, False: 1.28M] ------------------ 194| 0| return; 195| 0| } 196| | // Duplicate strings are not allowed. 197| 1.28M| UnicodeString prev=elements[0].getString(strings); 198| 46.1M| for(int32_t i=1; i(uprv_malloc(capacity*2)); ------------------ | | 1524| 484k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 484k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 484k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 484k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 216| 484k| if(uchars==nullptr) { ------------------ | Branch (216:12): [True: 0, False: 484k] ------------------ 217| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 218| 0| ucharsCapacity=0; 219| 0| return; 220| 0| } 221| 484k| ucharsCapacity=capacity; 222| 484k| } 223| 1.28M| StringTrieBuilder::build(buildOption, elementsLength, errorCode); 224| 1.28M| if(uchars==nullptr) { ------------------ | Branch (224:8): [True: 0, False: 1.28M] ------------------ 225| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 226| 0| } 227| 1.28M|} _ZNK6icu_7817UCharsTrieBuilder22getElementStringLengthEi: 230| 126M|UCharsTrieBuilder::getElementStringLength(int32_t i) const { 231| 126M| return elements[i].getStringLength(strings); 232| 126M|} _ZNK6icu_7817UCharsTrieBuilder14getElementUnitEii: 235| 187M|UCharsTrieBuilder::getElementUnit(int32_t i, int32_t unitIndex) const { 236| 187M| return elements[i].charAt(unitIndex, strings); 237| 187M|} _ZNK6icu_7817UCharsTrieBuilder15getElementValueEi: 240| 46.1M|UCharsTrieBuilder::getElementValue(int32_t i) const { 241| 46.1M| return elements[i].getValue(); 242| 46.1M|} _ZNK6icu_7817UCharsTrieBuilder21getLimitOfLinearMatchEiii: 245| 36.5M|UCharsTrieBuilder::getLimitOfLinearMatch(int32_t first, int32_t last, int32_t unitIndex) const { 246| 36.5M| const UCharsTrieElement &firstElement=elements[first]; 247| 36.5M| const UCharsTrieElement &lastElement=elements[last]; 248| 36.5M| int32_t minStringLength=firstElement.getStringLength(strings); 249| 391M| while(++unitIndex0); ------------------ | Branch (276:13): [True: 12.2M, False: 2.76M] ------------------ 277| 2.76M| return i; 278| 2.76M|} _ZNK6icu_7817UCharsTrieBuilder26indexOfElementWithNextUnitEiiDs: 281| 41.7M|UCharsTrieBuilder::indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const { 282| 155M| while(unit==elements[i].charAt(unitIndex, strings)) { ------------------ | Branch (282:11): [True: 113M, False: 41.7M] ------------------ 283| 113M| ++i; 284| 113M| } 285| 41.7M| return i; 286| 41.7M|} _ZN6icu_7817UCharsTrieBuilder18UCTLinearMatchNodeC2EPKDsiPNS_17StringTrieBuilder4NodeE: 289| 51.0M| : LinearMatchNode(len, nextNode), s(units) { 290| 51.0M| hash=hash*37u+ustr_hashUCharsN(units, len); ------------------ | | 1880| 51.0M|#define ustr_hashUCharsN U_ICU_ENTRY_POINT_RENAME(ustr_hashUCharsN) | | ------------------ | | | | 123| 51.0M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 51.0M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 51.0M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 291| 51.0M|} _ZNK6icu_7817UCharsTrieBuilder18UCTLinearMatchNodeeqERKNS_17StringTrieBuilder4NodeE: 294| 45.3M|UCharsTrieBuilder::UCTLinearMatchNode::operator==(const Node &other) const { 295| 45.3M| if(this==&other) { ------------------ | Branch (295:8): [True: 0, False: 45.3M] ------------------ 296| 0| return true; 297| 0| } 298| 45.3M| if(!LinearMatchNode::operator==(other)) { ------------------ | Branch (298:8): [True: 13.8k, False: 45.2M] ------------------ 299| 13.8k| return false; 300| 13.8k| } 301| 45.2M| const UCTLinearMatchNode &o=static_cast(other); 302| 45.2M| return 0==u_memcmp(s, o.s, length); ------------------ | | 332| 45.2M|#define u_memcmp U_ICU_ENTRY_POINT_RENAME(u_memcmp) | | ------------------ | | | | 123| 45.2M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 45.2M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 45.2M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 303| 45.3M|} _ZN6icu_7817UCharsTrieBuilder18UCTLinearMatchNode5writeERNS_17StringTrieBuilderE: 306| 9.98M|UCharsTrieBuilder::UCTLinearMatchNode::write(StringTrieBuilder &builder) { 307| 9.98M| UCharsTrieBuilder &b=(UCharsTrieBuilder &)builder; 308| 9.98M| next->write(builder); 309| 9.98M| b.write(s, length); 310| 9.98M| offset=b.writeValueAndType(hasValue, value, b.getMinLinearMatch()+length-1); 311| 9.98M|} _ZNK6icu_7817UCharsTrieBuilder21createLinearMatchNodeEiiiPNS_17StringTrieBuilder4NodeE: 315| 51.0M| Node *nextNode) const { 316| 51.0M| return new UCTLinearMatchNode( 317| 51.0M| elements[i].getString(strings).getBuffer()+unitIndex, 318| 51.0M| length, 319| 51.0M| nextNode); 320| 51.0M|} _ZN6icu_7817UCharsTrieBuilder14ensureCapacityEi: 323| 69.4M|UCharsTrieBuilder::ensureCapacity(int32_t length) { 324| 69.4M| if(uchars==nullptr) { ------------------ | Branch (324:8): [True: 0, False: 69.4M] ------------------ 325| 0| return false; // previous memory allocation had failed 326| 0| } 327| 69.4M| if(length>ucharsCapacity) { ------------------ | Branch (327:8): [True: 1.27k, False: 69.4M] ------------------ 328| 1.27k| int32_t newCapacity=ucharsCapacity; 329| 1.27k| do { 330| 1.27k| newCapacity*=2; 331| 1.27k| } while(newCapacity<=length); ------------------ | Branch (331:17): [True: 0, False: 1.27k] ------------------ 332| 1.27k| char16_t *newUChars=static_cast(uprv_malloc(newCapacity*2)); ------------------ | | 1524| 1.27k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.27k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.27k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.27k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 333| 1.27k| if(newUChars==nullptr) { ------------------ | Branch (333:12): [True: 0, False: 1.27k] ------------------ 334| | // unable to allocate memory 335| 0| uprv_free(uchars); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 336| 0| uchars=nullptr; 337| 0| ucharsCapacity=0; 338| 0| return false; 339| 0| } 340| 1.27k| u_memcpy(newUChars+(newCapacity-ucharsLength), ------------------ | | 334| 1.27k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 1.27k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.27k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.27k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 341| 1.27k| uchars+(ucharsCapacity-ucharsLength), ucharsLength); 342| 1.27k| uprv_free(uchars); ------------------ | | 1503| 1.27k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.27k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.27k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.27k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 343| 1.27k| uchars=newUChars; 344| 1.27k| ucharsCapacity=newCapacity; 345| 1.27k| } 346| 69.4M| return true; 347| 69.4M|} _ZN6icu_7817UCharsTrieBuilder5writeEi: 350| 49.5M|UCharsTrieBuilder::write(int32_t unit) { 351| 49.5M| int32_t newLength=ucharsLength+1; 352| 49.5M| if(ensureCapacity(newLength)) { ------------------ | Branch (352:8): [True: 49.5M, False: 0] ------------------ 353| 49.5M| ucharsLength=newLength; 354| 49.5M| uchars[ucharsCapacity - ucharsLength] = static_cast(unit); 355| 49.5M| } 356| 49.5M| return ucharsLength; 357| 49.5M|} _ZN6icu_7817UCharsTrieBuilder5writeEPKDsi: 360| 19.9M|UCharsTrieBuilder::write(const char16_t *s, int32_t length) { 361| 19.9M| int32_t newLength=ucharsLength+length; 362| 19.9M| if(ensureCapacity(newLength)) { ------------------ | Branch (362:8): [True: 19.9M, False: 0] ------------------ 363| 19.9M| ucharsLength=newLength; 364| 19.9M| u_memcpy(uchars+(ucharsCapacity-ucharsLength), s, length); ------------------ | | 334| 19.9M|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 19.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 19.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 19.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 365| 19.9M| } 366| 19.9M| return ucharsLength; 367| 19.9M|} _ZN6icu_7817UCharsTrieBuilder18writeValueAndFinalEia: 375| 18.9M|UCharsTrieBuilder::writeValueAndFinal(int32_t i, UBool isFinal) { 376| 18.9M| if(0<=i && i<=UCharsTrie::kMaxOneUnitValue) { ------------------ | Branch (376:8): [True: 18.7M, False: 147k] | Branch (376:16): [True: 9.08M, False: 9.69M] ------------------ 377| 9.08M| return write(i|(isFinal<<15)); 378| 9.08M| } 379| 9.84M| char16_t intUnits[3]; 380| 9.84M| int32_t length; 381| 9.84M| if(i<0 || i>UCharsTrie::kMaxTwoUnitValue) { ------------------ | Branch (381:8): [True: 147k, False: 9.69M] | Branch (381:15): [True: 4.07M, False: 5.61M] ------------------ 382| 4.22M| intUnits[0] = static_cast(UCharsTrie::kThreeUnitValueLead); 383| 4.22M| intUnits[1] = static_cast(static_cast(i) >> 16); 384| 4.22M| intUnits[2] = static_cast(i); 385| 4.22M| length=3; 386| | // } else if(i<=UCharsTrie::kMaxOneUnitValue) { 387| | // intUnits[0]=(char16_t)(i); 388| | // length=1; 389| 5.61M| } else { 390| 5.61M| intUnits[0] = static_cast(UCharsTrie::kMinTwoUnitValueLead + (i >> 16)); 391| 5.61M| intUnits[1] = static_cast(i); 392| 5.61M| length=2; 393| 5.61M| } 394| 9.84M| intUnits[0] = static_cast(intUnits[0] | (isFinal << 15)); 395| 9.84M| return write(intUnits, length); 396| 18.9M|} _ZN6icu_7817UCharsTrieBuilder17writeValueAndTypeEaii: 399| 16.4M|UCharsTrieBuilder::writeValueAndType(UBool hasValue, int32_t value, int32_t node) { 400| 16.4M| if(!hasValue) { ------------------ | Branch (400:8): [True: 16.3M, False: 125k] ------------------ 401| 16.3M| return write(node); 402| 16.3M| } 403| 125k| char16_t intUnits[3]; 404| 125k| int32_t length; 405| 125k| if(value<0 || value>UCharsTrie::kMaxTwoUnitNodeValue) { ------------------ | Branch (405:8): [True: 5.01k, False: 120k] | Branch (405:19): [True: 55.5k, False: 64.7k] ------------------ 406| 60.6k| intUnits[0] = static_cast(UCharsTrie::kThreeUnitNodeValueLead); 407| 60.6k| intUnits[1] = static_cast(static_cast(value) >> 16); 408| 60.6k| intUnits[2] = static_cast(value); 409| 60.6k| length=3; 410| 64.7k| } else if(value<=UCharsTrie::kMaxOneUnitNodeValue) { ------------------ | Branch (410:15): [True: 4.95k, False: 59.8k] ------------------ 411| 4.95k| intUnits[0] = static_cast((value + 1) << 6); 412| 4.95k| length=1; 413| 59.8k| } else { 414| 59.8k| intUnits[0] = static_cast(UCharsTrie::kMinTwoUnitNodeValueLead + ((value >> 10) & 0x7fc0)); 415| 59.8k| intUnits[1] = static_cast(value); 416| 59.8k| length=2; 417| 59.8k| } 418| 125k| intUnits[0] |= static_cast(node); 419| 125k| return write(intUnits, length); 420| 16.4M|} _ZN6icu_7817UCharsTrieBuilder12writeDeltaToEi: 423| 1.55M|UCharsTrieBuilder::writeDeltaTo(int32_t jumpTarget) { 424| 1.55M| int32_t i=ucharsLength-jumpTarget; 425| 1.55M| U_ASSERT(i>=0); ------------------ | | 35| 1.55M|# define U_ASSERT(exp) (void)0 ------------------ 426| 1.55M| if(i<=UCharsTrie::kMaxOneUnitDelta) { ------------------ | Branch (426:8): [True: 1.55M, False: 0] ------------------ 427| 1.55M| return write(i); 428| 1.55M| } 429| 0| char16_t intUnits[3]; 430| 0| int32_t length; 431| 0| if(i<=UCharsTrie::kMaxTwoUnitDelta) { ------------------ | Branch (431:8): [True: 0, False: 0] ------------------ 432| 0| intUnits[0] = static_cast(UCharsTrie::kMinTwoUnitDeltaLead + (i >> 16)); 433| 0| length=1; 434| 0| } else { 435| 0| intUnits[0] = static_cast(UCharsTrie::kThreeUnitDeltaLead); 436| 0| intUnits[1] = static_cast(i >> 16); 437| 0| length=2; 438| 0| } 439| 0| intUnits[length++] = static_cast(i); 440| 0| return write(intUnits, length); 441| 1.55M|} _ZNK6icu_7817UCharsTrieElement9getStringERKNS_13UnicodeStringE: 42| 780M| UnicodeString getString(const UnicodeString &strings) const { 43| 780M| int32_t length=strings[stringOffset]; 44| 780M| return strings.tempSubString(stringOffset+1, length); 45| 780M| } ucharstriebuilder.cpp:_ZN6icu_78L21compareElementStringsEPKvS1_S1_: 136| 341M|compareElementStrings(const void *context, const void *left, const void *right) { 137| 341M| const UnicodeString *strings=static_cast(context); 138| 341M| const UCharsTrieElement *leftElement=static_cast(left); 139| 341M| const UCharsTrieElement *rightElement=static_cast(right); 140| 341M| return leftElement->compareStringTo(*rightElement, *strings); 141| 341M|} _ZNK6icu_7817UCharsTrieElement15getStringLengthERKNS_13UnicodeStringE: 46| 162M| int32_t getStringLength(const UnicodeString &strings) const { 47| 162M| return strings[stringOffset]; 48| 162M| } _ZNK6icu_7817UCharsTrieElement6charAtEiRKNS_13UnicodeStringE: 50| 1.42G| char16_t charAt(int32_t index, const UnicodeString &strings) const { 51| 1.42G| return strings[stringOffset+1+index]; 52| 1.42G| } _ZNK6icu_7817UCharsTrieElement8getValueEv: 54| 46.1M| int32_t getValue() const { return value; } _ZN6icu_7810UCharsTrie8IteratorC2ENS_14ConstChar16PtrEiR10UErrorCode: 26| 44.7k| : uchars_(trieUChars), 27| 44.7k| pos_(uchars_), initialPos_(uchars_), 28| 44.7k| remainingMatchLength_(-1), initialRemainingMatchLength_(-1), 29| 44.7k| skipValue_(false), 30| 44.7k| maxLength_(maxStringLength), value_(0), stack_(nullptr) { 31| 44.7k| if(U_FAILURE(errorCode)) { ------------------ | Branch (31:8): [True: 0, False: 44.7k] ------------------ 32| 0| return; 33| 0| } 34| | // stack_ is a pointer so that it's easy to turn ucharstrie.h into 35| | // a public API header for which we would want it to depend only on 36| | // other public headers. 37| | // Unlike UCharsTrie itself, its Iterator performs memory allocations anyway 38| | // via the UnicodeString and UVector32 implementations, so this additional 39| | // cost is minimal. 40| 44.7k| stack_=new UVector32(errorCode); 41| 44.7k| if(stack_==nullptr) { ------------------ | Branch (41:8): [True: 0, False: 44.7k] ------------------ 42| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 43| 0| } 44| 44.7k|} _ZN6icu_7810UCharsTrie8IteratorD2Ev: 77| 44.7k|UCharsTrie::Iterator::~Iterator() { 78| 44.7k| delete stack_; 79| 44.7k|} _ZN6icu_7810UCharsTrie8Iterator4nextER10UErrorCode: 101| 517k|UCharsTrie::Iterator::next(UErrorCode &errorCode) { 102| 517k| if(U_FAILURE(errorCode)) { ------------------ | Branch (102:8): [True: 0, False: 517k] ------------------ 103| 0| return false; 104| 0| } 105| 517k| const char16_t *pos=pos_; 106| 517k| if(pos==nullptr) { ------------------ | Branch (106:8): [True: 467k, False: 50.3k] ------------------ 107| 467k| if(stack_->isEmpty()) { ------------------ | Branch (107:12): [True: 44.7k, False: 422k] ------------------ 108| 44.7k| return false; 109| 44.7k| } 110| | // Pop the state off the stack and continue with the next outbound edge of 111| | // the branch node. 112| 422k| int32_t stackSize=stack_->size(); 113| 422k| int32_t length=stack_->elementAti(stackSize-1); 114| 422k| pos=uchars_+stack_->elementAti(stackSize-2); 115| 422k| stack_->setSize(stackSize-2); 116| 422k| str_.truncate(length&0xffff); 117| 422k| length = static_cast(static_cast(length) >> 16); 118| 422k| if(length>1) { ------------------ | Branch (118:12): [True: 221k, False: 201k] ------------------ 119| 221k| pos=branchNext(pos, length, errorCode); 120| 221k| if(pos==nullptr) { ------------------ | Branch (120:16): [True: 181k, False: 39.4k] ------------------ 121| 181k| return true; // Reached a final value. 122| 181k| } 123| 221k| } else { 124| 201k| str_.append(*pos++); 125| 201k| } 126| 422k| } 127| 291k| if(remainingMatchLength_>=0) { ------------------ | Branch (127:8): [True: 0, False: 291k] ------------------ 128| | // We only get here if we started in a pending linear-match node 129| | // with more than maxLength remaining units. 130| 0| return truncateAndStop(); 131| 0| } 132| 679k| for(;;) { 133| 679k| int32_t node=*pos++; 134| 679k| if(node>=kMinValueLead) { ------------------ | Branch (134:12): [True: 253k, False: 426k] ------------------ 135| 253k| if(skipValue_) { ------------------ | Branch (135:16): [True: 5.57k, False: 247k] ------------------ 136| 5.57k| pos=skipNodeValue(pos, node); 137| 5.57k| node&=kNodeTypeMask; 138| 5.57k| skipValue_=false; 139| 247k| } else { 140| | // Deliver value for the string so far. 141| 247k| UBool isFinal = static_cast(node >> 15); 142| 247k| if(isFinal) { ------------------ | Branch (142:20): [True: 242k, False: 5.57k] ------------------ 143| 242k| value_=readValue(pos, node&0x7fff); 144| 242k| } else { 145| 5.57k| value_=readNodeValue(pos, node); 146| 5.57k| } 147| 247k| if(isFinal || (maxLength_>0 && str_.length()==maxLength_)) { ------------------ | Branch (147:20): [True: 242k, False: 5.57k] | Branch (147:32): [True: 0, False: 5.57k] | Branch (147:48): [True: 0, False: 0] ------------------ 148| 242k| pos_=nullptr; 149| 242k| } else { 150| | // We cannot skip the value right here because it shares its 151| | // lead unit with a match node which we have to evaluate 152| | // next time. 153| | // Instead, keep pos_ on the node lead unit itself. 154| 5.57k| pos_=pos-1; 155| 5.57k| skipValue_=true; 156| 5.57k| } 157| 247k| return true; 158| 247k| } 159| 253k| } 160| 432k| if(maxLength_>0 && str_.length()==maxLength_) { ------------------ | Branch (160:12): [True: 0, False: 432k] | Branch (160:28): [True: 0, False: 0] ------------------ 161| 0| return truncateAndStop(); 162| 0| } 163| 432k| if(node0 && str_.length()+length>maxLength_) { ------------------ | Branch (174:16): [True: 0, False: 287k] | Branch (174:32): [True: 0, False: 0] ------------------ 175| 0| str_.append(pos, maxLength_-str_.length()); 176| 0| return truncateAndStop(); 177| 0| } 178| 287k| str_.append(pos, length); 179| 287k| pos+=length; 180| 287k| } 181| 432k| } 182| 291k|} _ZN6icu_7810UCharsTrie8Iterator10branchNextEPKDsiR10UErrorCode: 186| 365k|UCharsTrie::Iterator::branchNext(const char16_t *pos, int32_t length, UErrorCode &errorCode) { 187| 422k| while(length>kMaxBranchLinearSubNodeLength) { ------------------ | Branch (187:11): [True: 57.5k, False: 365k] ------------------ 188| 57.5k| ++pos; // ignore the comparison unit 189| | // Push state for the greater-or-equal edge. 190| 57.5k| stack_->addElement(static_cast(skipDelta(pos) - uchars_), errorCode); 191| 57.5k| stack_->addElement(((length-(length>>1))<<16)|str_.length(), errorCode); 192| | // Follow the less-than edge. 193| 57.5k| length>>=1; 194| 57.5k| pos=jumpByDelta(pos); 195| 57.5k| } 196| | // List of key-value pairs where values are either final values or jump deltas. 197| | // Read the first (key, value) pair. 198| 365k| char16_t trieUnit=*pos++; 199| 365k| int32_t node=*pos++; 200| 365k| UBool isFinal = static_cast(node >> 15); 201| 365k| int32_t value=readValue(pos, node&=0x7fff); 202| 365k| pos=skipValue(pos, node); 203| 365k| stack_->addElement(static_cast(pos - uchars_), errorCode); 204| 365k| stack_->addElement(((length-1)<<16)|str_.length(), errorCode); 205| 365k| str_.append(trieUnit); 206| 365k| if(isFinal) { ------------------ | Branch (206:8): [True: 225k, False: 139k] ------------------ 207| 225k| pos_=nullptr; 208| 225k| value_=value; 209| 225k| return nullptr; 210| 225k| } else { 211| 139k| return pos+value; 212| 139k| } 213| 365k|} ucln_common_registerCleanup_78: 67| 18|{ 68| | // Thread safety messiness: From ticket 10295, calls to registerCleanup() may occur 69| | // concurrently. Although such cases should be storing the same value, they raise errors 70| | // from the thread sanity checker. Doing the store within a mutex avoids those. 71| | // BUT that can trigger a recursive entry into std::call_once() in umutex.cpp when this code, 72| | // running from the call_once function, tries to grab the ICU global mutex, which 73| | // re-enters the mutex init path. So, work-around by special casing UCLN_COMMON_MUTEX, not 74| | // using the ICU global mutex for it. 75| | // 76| | // No other point in ICU uses std::call_once(). 77| | 78| 18| U_ASSERT(UCLN_COMMON_START < type && type < UCLN_COMMON_COUNT); ------------------ | | 35| 18|# define U_ASSERT(exp) (void)0 ------------------ 79| 18| if (type == UCLN_COMMON_MUTEX) { ------------------ | Branch (79:9): [True: 1, False: 17] ------------------ 80| 1| gCommonCleanupFunctions[type] = func; 81| 17| } else if (UCLN_COMMON_START < type && type < UCLN_COMMON_COUNT) { ------------------ | Branch (81:16): [True: 17, False: 0] | Branch (81:44): [True: 17, False: 0] ------------------ 82| 17| icu::Mutex m; // See ticket 10295 for discussion. 83| 17| gCommonCleanupFunctions[type] = func; 84| 17| } 85| |#if !UCLN_NO_AUTO_CLEANUP && (defined(UCLN_AUTO_ATEXIT) || defined(UCLN_AUTO_LOCAL)) 86| | ucln_registerAutomaticCleanup(); 87| |#endif 88| 18|} ucln_registerCleanup_78: 97| 1|{ 98| 1| U_ASSERT(UCLN_START < type && type < UCLN_COMMON); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 99| 1| if (UCLN_START < type && type < UCLN_COMMON) ------------------ | Branch (99:9): [True: 1, False: 0] | Branch (99:30): [True: 1, False: 0] ------------------ 100| 1| { 101| 1| gLibCleanupFunctions[type] = func; 102| 1| } 103| 1|} udata_getHeaderSize_78: 36| 78|udata_getHeaderSize(const DataHeader *udh) { 37| 78| if(udh==nullptr) { ------------------ | Branch (37:8): [True: 0, False: 78] ------------------ 38| 0| return 0; 39| 78| } else if(udh->info.isBigEndian==U_IS_BIG_ENDIAN) { ------------------ | | 353| 78|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (39:15): [True: 78, False: 0] ------------------ 40| | /* same endianness */ 41| 78| return udh->dataHeader.headerSize; 42| 78| } else { 43| | /* opposite endianness */ 44| 0| uint16_t x=udh->dataHeader.headerSize; 45| 0| return (uint16_t)((x<<8)|(x>>8)); 46| 0| } 47| 78|} udata_checkCommonData_78: 326| 1|U_CFUNC void udata_checkCommonData(UDataMemory *udm, UErrorCode *err) { 327| 1| if (U_FAILURE(*err)) { ------------------ | Branch (327:9): [True: 0, False: 1] ------------------ 328| 0| return; 329| 0| } 330| | 331| 1| if(udm==nullptr || udm->pHeader==nullptr) { ------------------ | Branch (331:8): [True: 0, False: 1] | Branch (331:24): [True: 0, False: 1] ------------------ 332| 0| *err=U_INVALID_FORMAT_ERROR; 333| 1| } else if(!(udm->pHeader->dataHeader.magic1==0xda && ------------------ | Branch (333:17): [True: 1, False: 0] ------------------ 334| 1| udm->pHeader->dataHeader.magic2==0x27 && ------------------ | Branch (334:9): [True: 1, False: 0] ------------------ 335| 1| udm->pHeader->info.isBigEndian==U_IS_BIG_ENDIAN && ------------------ | | 353| 2|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (335:9): [True: 1, False: 0] ------------------ 336| 1| udm->pHeader->info.charsetFamily==U_CHARSET_FAMILY) ------------------ | | 588| 1|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 1|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (336:9): [True: 1, False: 0] ------------------ 337| 1| ) { 338| | /* header not valid */ 339| 0| *err=U_INVALID_FORMAT_ERROR; 340| 0| } 341| 1| else if (udm->pHeader->info.dataFormat[0]==0x43 && ------------------ | Branch (341:14): [True: 1, False: 0] ------------------ 342| 1| udm->pHeader->info.dataFormat[1]==0x6d && ------------------ | Branch (342:9): [True: 1, False: 0] ------------------ 343| 1| udm->pHeader->info.dataFormat[2]==0x6e && ------------------ | Branch (343:9): [True: 1, False: 0] ------------------ 344| 1| udm->pHeader->info.dataFormat[3]==0x44 && ------------------ | Branch (344:9): [True: 1, False: 0] ------------------ 345| 1| udm->pHeader->info.formatVersion[0]==1 ------------------ | Branch (345:9): [True: 1, False: 0] ------------------ 346| 1| ) { 347| | /* dataFormat="CmnD" */ 348| 1| udm->vFuncs = &CmnDFuncs; 349| 1| udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader); ------------------ | | 887| 1|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 350| 1| } 351| 0| else if(udm->pHeader->info.dataFormat[0]==0x54 && ------------------ | Branch (351:13): [True: 0, False: 0] ------------------ 352| 0| udm->pHeader->info.dataFormat[1]==0x6f && ------------------ | Branch (352:9): [True: 0, False: 0] ------------------ 353| 0| udm->pHeader->info.dataFormat[2]==0x43 && ------------------ | Branch (353:9): [True: 0, False: 0] ------------------ 354| 0| udm->pHeader->info.dataFormat[3]==0x50 && ------------------ | Branch (354:9): [True: 0, False: 0] ------------------ 355| 0| udm->pHeader->info.formatVersion[0]==1 ------------------ | Branch (355:9): [True: 0, False: 0] ------------------ 356| 0| ) { 357| | /* dataFormat="ToCP" */ 358| 0| udm->vFuncs = &ToCPFuncs; 359| 0| udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader); ------------------ | | 887| 0|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 360| 0| } 361| 0| else { 362| | /* dataFormat not recognized */ 363| 0| *err=U_INVALID_FORMAT_ERROR; 364| 0| } 365| | 366| 1| if (U_FAILURE(*err)) { ------------------ | Branch (366:9): [True: 0, False: 1] ------------------ 367| | /* If the data is no good and we memory-mapped it ourselves, 368| | * close the memory mapping so it doesn't leak. Note that this has 369| | * no effect on non-memory mapped data, other than clearing fields in udm. 370| | */ 371| 0| udata_close(udm); ------------------ | | 885| 0|#define udata_close U_ICU_ENTRY_POINT_RENAME(udata_close) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 372| 0| } 373| 1|} ucmndata.cpp:_ZL17offsetTOCLookupFnPK11UDataMemoryPKcPiP10UErrorCode: 229| 710| UErrorCode *pErrorCode) { 230| 710| (void)pErrorCode; 231| 710| const UDataOffsetTOC *toc = (UDataOffsetTOC *)pData->toc; 232| 710| if(toc!=nullptr) { ------------------ | Branch (232:8): [True: 710, False: 0] ------------------ 233| 710| const char *base=(const char *)toc; 234| 710| int32_t number, count=(int32_t)toc->count; 235| | 236| | /* perform a binary search for the data in the common data's table of contents */ 237| |#if defined (UDATA_DEBUG_DUMP) 238| | /* list the contents of the TOC each time .. not recommended */ 239| | for(number=0; numberentry[number].nameOffset]); 241| | } 242| |#endif 243| 710| number=offsetTOCPrefixBinarySearch(tocEntryName, base, toc->entry, count); 244| 710| if(number>=0) { ------------------ | Branch (244:12): [True: 76, False: 634] ------------------ 245| | /* found it */ 246| 76| const UDataOffsetTOCEntry *entry=toc->entry+number; 247| |#ifdef UDATA_DEBUG 248| | fprintf(stderr, "%s: Found.\n", tocEntryName); 249| |#endif 250| 76| if((number+1) < count) { ------------------ | Branch (250:16): [True: 76, False: 0] ------------------ 251| 76| *pLength = (int32_t)(entry[1].dataOffset - entry->dataOffset); 252| 76| } else { 253| 0| *pLength = -1; 254| 0| } 255| 76| return (const DataHeader *)(base+entry->dataOffset); 256| 634| } else { 257| |#ifdef UDATA_DEBUG 258| | fprintf(stderr, "%s: Not found.\n", tocEntryName); 259| |#endif 260| 634| return nullptr; 261| 634| } 262| 710| } else { 263| |#ifdef UDATA_DEBUG 264| | fprintf(stderr, "returning header\n"); 265| |#endif 266| | 267| 0| return pData->pHeader; 268| 0| } 269| 710|} ucmndata.cpp:_ZL27offsetTOCPrefixBinarySearchPKcS0_PK19UDataOffsetTOCEntryi: 125| 710| const UDataOffsetTOCEntry *toc, int32_t count) { 126| 710| int32_t start=0; 127| 710| int32_t limit=count; 128| | /* 129| | * Remember the shared prefix between s, start and limit, 130| | * and don't compare that shared prefix again. 131| | * The shared prefix should get longer as we narrow the [start, limit[ range. 132| | */ 133| 710| int32_t startPrefixLength=0; 134| 710| int32_t limitPrefixLength=0; 135| 710| if(count==0) { ------------------ | Branch (135:8): [True: 0, False: 710] ------------------ 136| 0| return -1; 137| 0| } 138| | /* 139| | * Prime the prefix lengths so that we don't keep prefixLength at 0 until 140| | * both the start and limit indexes have moved. 141| | * At the same time, we find if s is one of the start and (limit-1) names, 142| | * and if not, exclude them from the actual binary search. 143| | */ 144| 710| if(0==strcmpAfterPrefix(s, names+toc[0].nameOffset, &startPrefixLength)) { ------------------ | Branch (144:8): [True: 0, False: 710] ------------------ 145| 0| return 0; 146| 0| } 147| 710| ++start; 148| 710| --limit; 149| 710| if(0==strcmpAfterPrefix(s, names+toc[limit].nameOffset, &limitPrefixLength)) { ------------------ | Branch (149:8): [True: 0, False: 710] ------------------ 150| 0| return limit; 151| 0| } 152| 9.10k| while(start(*s1++); 112| 33.8k| int32_t c2 = static_cast(*s2++); 113| 33.8k| cmp=c1-c2; 114| 33.8k| if(cmp!=0 || c1==0) { /* different or done */ ------------------ | Branch (114:12): [True: 9.81k, False: 24.0k] | Branch (114:22): [True: 76, False: 23.9k] ------------------ 115| 9.89k| break; 116| 9.89k| } 117| 23.9k| ++pl; /* increment shared same-prefix length */ 118| 23.9k| } 119| 9.89k| *pPrefixLength=pl; 120| 9.89k| return cmp; 121| 9.89k|} ucptrie_internalSmallIndex_78: 161| 17.8M|ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c) { 162| 17.8M| int32_t i1 = c >> UCPTRIE_SHIFT_1; 163| 17.8M| if (trie->type == UCPTRIE_TYPE_FAST) { ------------------ | Branch (163:9): [True: 6.81M, False: 11.0M] ------------------ 164| 6.81M| U_ASSERT(0xffff < c && c < trie->highStart); ------------------ | | 35| 6.81M|# define U_ASSERT(exp) (void)0 ------------------ 165| 6.81M| i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 166| 11.0M| } else { 167| 11.0M| U_ASSERT((uint32_t)c < (uint32_t)trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); ------------------ | | 35| 11.0M|# define U_ASSERT(exp) (void)0 ------------------ 168| 11.0M| i1 += UCPTRIE_SMALL_INDEX_LENGTH; 169| 11.0M| } 170| 17.8M| int32_t i3Block = trie->index[ 171| 17.8M| (int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 172| 17.8M| int32_t i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 173| 17.8M| int32_t dataBlock; 174| 17.8M| if ((i3Block & 0x8000) == 0) { ------------------ | Branch (174:9): [True: 17.8M, False: 0] ------------------ 175| | // 16-bit indexes 176| 17.8M| dataBlock = trie->index[i3Block + i3]; 177| 17.8M| } else { 178| | // 18-bit indexes stored in groups of 9 entries per 8 indexes. 179| 0| i3Block = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3); 180| 0| i3 &= 7; 181| 0| dataBlock = ((int32_t)trie->index[i3Block++] << (2 + (2 * i3))) & 0x30000; 182| 0| dataBlock |= trie->index[i3Block + i3]; 183| 0| } 184| 17.8M| return dataBlock + (c & UCPTRIE_SMALL_DATA_MASK); 185| 17.8M|} ucptrie_get_78: 233| 20.3M|ucptrie_get(const UCPTrie *trie, UChar32 c) { 234| 20.3M| int32_t dataIndex; 235| 20.3M| if ((uint32_t)c <= 0x7f) { ------------------ | Branch (235:9): [True: 1.43M, False: 18.9M] ------------------ 236| | // linear ASCII 237| 1.43M| dataIndex = c; 238| 18.9M| } else { 239| 18.9M| UChar32 fastMax = trie->type == UCPTRIE_TYPE_FAST ? 0xffff : UCPTRIE_SMALL_MAX; ------------------ | Branch (239:27): [True: 0, False: 18.9M] ------------------ 240| 18.9M| dataIndex = _UCPTRIE_CP_INDEX(trie, fastMax, c); ------------------ | | 616| 18.9M| ((uint32_t)(c) <= (uint32_t)(fastMax) ? \ | | ------------------ | | | Branch (616:6): [True: 6.86M, False: 12.0M] | | ------------------ | | 617| 18.9M| _UCPTRIE_FAST_INDEX(trie, c) : \ | | ------------------ | | | | 602| 6.86M| ((int32_t)(trie)->index[(c) >> UCPTRIE_FAST_SHIFT] + ((c) & UCPTRIE_FAST_DATA_MASK)) | | ------------------ | | 618| 18.9M| (uint32_t)(c) <= 0x10ffff ? \ | | ------------------ | | | Branch (618:9): [True: 12.0M, False: 0] | | ------------------ | | 619| 12.0M| _UCPTRIE_SMALL_INDEX(trie, c) : \ | | ------------------ | | | | 606| 12.0M| ((c) >= (trie)->highStart ? \ | | | | ------------------ | | | | | Branch (606:6): [True: 1.02M, False: 11.0M] | | | | ------------------ | | | | 607| 12.0M| (trie)->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET : \ | | | | 608| 12.0M| ucptrie_internalSmallIndex(trie, c)) | | | | ------------------ | | | | | | 810| 11.0M|#define ucptrie_internalSmallIndex U_ICU_ENTRY_POINT_RENAME(ucptrie_internalSmallIndex) | | | | | | ------------------ | | | | | | | | 123| 11.0M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | | | ------------------ | | | | | | | | | | 122| 11.0M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | | | ------------------ | | | | | | | | | | | | 121| 11.0M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 620| 12.0M| (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET) ------------------ 241| 18.9M| } 242| 20.3M| return getValue(trie->data, (UCPTrieValueWidth)trie->valueWidth, dataIndex); 243| 20.3M|} ucptrie_internalGetRange_78: 418| 8.02k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 419| 8.02k| if (option == UCPMAP_RANGE_NORMAL) { ------------------ | Branch (419:9): [True: 0, False: 8.02k] ------------------ 420| 0| return getRange(trie, start, filter, context, pValue); 421| 0| } 422| 8.02k| uint32_t value; 423| 8.02k| if (pValue == nullptr) { ------------------ | Branch (423:9): [True: 0, False: 8.02k] ------------------ 424| | // We need to examine the range value even if the caller does not want it. 425| 0| pValue = &value; 426| 0| } 427| 8.02k| UChar32 surrEnd = option == UCPMAP_RANGE_FIXED_ALL_SURROGATES ? 0xdfff : 0xdbff; ------------------ | Branch (427:23): [True: 0, False: 8.02k] ------------------ 428| 8.02k| UChar32 end = getRange(trie, start, filter, context, pValue); 429| 8.02k| if (end < 0xd7ff || start > surrEnd) { ------------------ | Branch (429:9): [True: 5.36k, False: 2.66k] | Branch (429:25): [True: 2.65k, False: 2] ------------------ 430| 8.01k| return end; 431| 8.01k| } 432| | // The range overlaps with surrogates, or ends just before the first one. 433| 2| if (*pValue == surrogateValue) { ------------------ | Branch (433:9): [True: 2, False: 0] ------------------ 434| 2| if (end >= surrEnd) { ------------------ | Branch (434:13): [True: 0, False: 2] ------------------ 435| | // Surrogates followed by a non-surrogateValue range, 436| | // or surrogates are part of a larger surrogateValue range. 437| 0| return end; 438| 0| } 439| 2| } else { 440| 0| if (start <= 0xd7ff) { ------------------ | Branch (440:13): [True: 0, False: 0] ------------------ 441| 0| return 0xd7ff; // Non-surrogateValue range ends before surrogateValue surrogates. 442| 0| } 443| | // Start is a surrogate with a non-surrogateValue code *unit* value. 444| | // Return a surrogateValue code *point* range. 445| 0| *pValue = surrogateValue; 446| 0| if (end > surrEnd) { ------------------ | Branch (446:13): [True: 0, False: 0] ------------------ 447| 0| return surrEnd; // Surrogate range ends before non-surrogateValue rest of range. 448| 0| } 449| 0| } 450| | // See if the surrogateValue surrogate range can be merged with 451| | // an immediately following range. 452| 2| uint32_t value2; 453| 2| UChar32 end2 = getRange(trie, surrEnd + 1, filter, context, &value2); 454| 2| if (value2 == surrogateValue) { ------------------ | Branch (454:9): [True: 2, False: 0] ------------------ 455| 2| return end2; 456| 2| } 457| 0| return surrEnd; 458| 2|} ucptrie_getRange_78: 463| 8.02k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 464| 8.02k| return ucptrie_internalGetRange(getRange, trie, start, ------------------ | | 809| 8.02k|#define ucptrie_internalGetRange U_ICU_ENTRY_POINT_RENAME(ucptrie_internalGetRange) | | ------------------ | | | | 123| 8.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 465| 8.02k| option, surrogateValue, 466| 8.02k| filter, context, pValue); 467| 8.02k|} ucptrie.cpp:_ZN12_GLOBAL__N_18getValueE11UCPTrieData17UCPTrieValueWidthi: 216| 20.4M|inline uint32_t getValue(UCPTrieData data, UCPTrieValueWidth valueWidth, int32_t dataIndex) { 217| 20.4M| switch (valueWidth) { 218| 50.5k| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (218:5): [True: 50.5k, False: 20.3M] ------------------ 219| 50.5k| return data.ptr16[dataIndex]; 220| 20.3M| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (220:5): [True: 20.3M, False: 50.5k] ------------------ 221| 20.3M| return data.ptr32[dataIndex]; 222| 0| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (222:5): [True: 0, False: 20.4M] ------------------ 223| 0| return data.ptr8[dataIndex]; 224| 0| default: ------------------ | Branch (224:5): [True: 0, False: 20.4M] ------------------ 225| | // Unreachable if the trie is properly initialized. 226| 0| return 0xffffffff; 227| 20.4M| } 228| 20.4M|} ucptrie.cpp:_ZN12_GLOBAL__N_18getRangeEPKviPFjS1_jES1_Pj: 260| 8.02k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 261| 8.02k| if (static_cast(start) > MAX_UNICODE) { ------------------ | Branch (261:9): [True: 2, False: 8.02k] ------------------ 262| 2| return U_SENTINEL; ------------------ | | 469| 2|#define U_SENTINEL (-1) ------------------ 263| 2| } 264| 8.02k| const UCPTrie *trie = reinterpret_cast(t); 265| 8.02k| UCPTrieValueWidth valueWidth = static_cast(trie->valueWidth); 266| 8.02k| if (start >= trie->highStart) { ------------------ | Branch (266:9): [True: 0, False: 8.02k] ------------------ 267| 0| if (pValue != nullptr) { ------------------ | Branch (267:13): [True: 0, False: 0] ------------------ 268| 0| int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 269| 0| uint32_t value = getValue(trie->data, valueWidth, di); 270| 0| if (filter != nullptr) { value = filter(context, value); } ------------------ | Branch (270:17): [True: 0, False: 0] ------------------ 271| 0| *pValue = value; 272| 0| } 273| 0| return MAX_UNICODE; 274| 0| } 275| | 276| 8.02k| uint32_t nullValue = trie->nullValue; 277| 8.02k| if (filter != nullptr) { nullValue = filter(context, nullValue); } ------------------ | Branch (277:9): [True: 0, False: 8.02k] ------------------ 278| 8.02k| const uint16_t *index = trie->index; 279| | 280| 8.02k| int32_t prevI3Block = -1; 281| 8.02k| int32_t prevBlock = -1; 282| 8.02k| UChar32 c = start; 283| 8.02k| uint32_t trieValue, value = nullValue; 284| 8.02k| bool haveValue = false; 285| 8.52k| do { 286| 8.52k| int32_t i3Block; 287| 8.52k| int32_t i3; 288| 8.52k| int32_t i3BlockLength; 289| 8.52k| int32_t dataBlockLength; 290| 8.52k| if (c <= 0xffff && (trie->type == UCPTRIE_TYPE_FAST || c <= UCPTRIE_SMALL_MAX)) { ------------------ | Branch (290:13): [True: 6.38k, False: 2.14k] | Branch (290:29): [True: 6.38k, False: 0] | Branch (290:64): [True: 0, False: 0] ------------------ 291| 6.38k| i3Block = 0; 292| 6.38k| i3 = c >> UCPTRIE_FAST_SHIFT; 293| 6.38k| i3BlockLength = trie->type == UCPTRIE_TYPE_FAST ? ------------------ | Branch (293:29): [True: 6.38k, False: 0] ------------------ 294| 6.38k| UCPTRIE_BMP_INDEX_LENGTH : UCPTRIE_SMALL_INDEX_LENGTH; 295| 6.38k| dataBlockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 296| 6.38k| } else { 297| | // Use the multi-stage index. 298| 2.14k| int32_t i1 = c >> UCPTRIE_SHIFT_1; 299| 2.14k| if (trie->type == UCPTRIE_TYPE_FAST) { ------------------ | Branch (299:17): [True: 2.14k, False: 0] ------------------ 300| 2.14k| U_ASSERT(0xffff < c && c < trie->highStart); ------------------ | | 35| 2.14k|# define U_ASSERT(exp) (void)0 ------------------ 301| 2.14k| i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 302| 2.14k| } else { 303| 0| U_ASSERT(c < trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 304| 0| i1 += UCPTRIE_SMALL_INDEX_LENGTH; 305| 0| } 306| 2.14k| i3Block = trie->index[ 307| 2.14k| static_cast(trie->index[i1]) + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 308| 2.14k| if (i3Block == prevI3Block && (c - start) >= UCPTRIE_CP_PER_INDEX_2_ENTRY) { ------------------ | Branch (308:17): [True: 438, False: 1.70k] | Branch (308:43): [True: 438, False: 0] ------------------ 309| | // The index-3 block is the same as the previous one, and filled with value. 310| 438| U_ASSERT((c & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0); ------------------ | | 35| 438|# define U_ASSERT(exp) (void)0 ------------------ 311| 438| c += UCPTRIE_CP_PER_INDEX_2_ENTRY; 312| 438| continue; 313| 438| } 314| 1.70k| prevI3Block = i3Block; 315| 1.70k| if (i3Block == trie->index3NullOffset) { ------------------ | Branch (315:17): [True: 16, False: 1.68k] ------------------ 316| | // This is the index-3 null block. 317| 16| if (haveValue) { ------------------ | Branch (317:21): [True: 16, False: 0] ------------------ 318| 16| if (nullValue != value) { ------------------ | Branch (318:25): [True: 0, False: 16] ------------------ 319| 0| return c - 1; 320| 0| } 321| 16| } else { 322| 0| trieValue = trie->nullValue; 323| 0| value = nullValue; 324| 0| if (pValue != nullptr) { *pValue = nullValue; } ------------------ | Branch (324:25): [True: 0, False: 0] ------------------ 325| 0| haveValue = true; 326| 0| } 327| 16| prevBlock = trie->dataNullOffset; 328| 16| c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 329| 16| continue; 330| 16| } 331| 1.68k| i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 332| 1.68k| i3BlockLength = UCPTRIE_INDEX_3_BLOCK_LENGTH; 333| 1.68k| dataBlockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 334| 1.68k| } 335| | // Enumerate data blocks for one index-3 block. 336| 11.7k| do { 337| 11.7k| int32_t block; 338| 11.7k| if ((i3Block & 0x8000) == 0) { ------------------ | Branch (338:17): [True: 11.7k, False: 0] ------------------ 339| 11.7k| block = index[i3Block + i3]; 340| 11.7k| } else { 341| | // 18-bit indexes stored in groups of 9 entries per 8 indexes. 342| 0| int32_t group = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3); 343| 0| int32_t gi = i3 & 7; 344| 0| block = (static_cast(index[group++]) << (2 + (2 * gi))) & 0x30000; 345| 0| block |= index[group + gi]; 346| 0| } 347| 11.7k| if (block == prevBlock && (c - start) >= dataBlockLength) { ------------------ | Branch (347:17): [True: 2.72k, False: 9.04k] | Branch (347:39): [True: 2.72k, False: 0] ------------------ 348| | // The block is the same as the previous one, and filled with value. 349| 2.72k| U_ASSERT((c & (dataBlockLength - 1)) == 0); ------------------ | | 35| 2.72k|# define U_ASSERT(exp) (void)0 ------------------ 350| 2.72k| c += dataBlockLength; 351| 9.04k| } else { 352| 9.04k| int32_t dataMask = dataBlockLength - 1; 353| 9.04k| prevBlock = block; 354| 9.04k| if (block == trie->dataNullOffset) { ------------------ | Branch (354:21): [True: 204, False: 8.83k] ------------------ 355| | // This is the data null block. 356| 204| if (haveValue) { ------------------ | Branch (356:25): [True: 176, False: 28] ------------------ 357| 176| if (nullValue != value) { ------------------ | Branch (357:29): [True: 26, False: 150] ------------------ 358| 26| return c - 1; 359| 26| } 360| 176| } else { 361| 28| trieValue = trie->nullValue; 362| 28| value = nullValue; 363| 28| if (pValue != nullptr) { *pValue = nullValue; } ------------------ | Branch (363:29): [True: 28, False: 0] ------------------ 364| 28| haveValue = true; 365| 28| } 366| 178| c = (c + dataBlockLength) & ~dataMask; 367| 8.83k| } else { 368| 8.83k| int32_t di = block + (c & dataMask); 369| 8.83k| uint32_t trieValue2 = getValue(trie->data, valueWidth, di); 370| 8.83k| if (haveValue) { ------------------ | Branch (370:25): [True: 844, False: 7.99k] ------------------ 371| 844| if (trieValue2 != trieValue) { ------------------ | Branch (371:29): [True: 238, False: 606] ------------------ 372| 238| if (filter == nullptr || ------------------ | Branch (372:33): [True: 238, False: 0] ------------------ 373| 238| maybeFilterValue(trieValue2, trie->nullValue, nullValue, ------------------ | Branch (373:37): [True: 0, False: 0] ------------------ 374| 238| filter, context) != value) { 375| 238| return c - 1; 376| 238| } 377| 0| trieValue = trieValue2; // may or may not help 378| 0| } 379| 7.99k| } else { 380| 7.99k| trieValue = trieValue2; 381| 7.99k| value = maybeFilterValue(trieValue2, trie->nullValue, nullValue, 382| 7.99k| filter, context); 383| 7.99k| if (pValue != nullptr) { *pValue = value; } ------------------ | Branch (383:29): [True: 7.99k, False: 0] ------------------ 384| 7.99k| haveValue = true; 385| 7.99k| } 386| 42.5k| while ((++c & dataMask) != 0) { ------------------ | Branch (386:28): [True: 41.7k, False: 844] ------------------ 387| 41.7k| trieValue2 = getValue(trie->data, valueWidth, ++di); 388| 41.7k| if (trieValue2 != trieValue) { ------------------ | Branch (388:29): [True: 7.75k, False: 33.9k] ------------------ 389| 7.75k| if (filter == nullptr || ------------------ | Branch (389:33): [True: 7.75k, False: 0] ------------------ 390| 7.75k| maybeFilterValue(trieValue2, trie->nullValue, nullValue, ------------------ | Branch (390:37): [True: 0, False: 0] ------------------ 391| 7.75k| filter, context) != value) { 392| 7.75k| return c - 1; 393| 7.75k| } 394| 0| trieValue = trieValue2; // may or may not help 395| 0| } 396| 41.7k| } 397| 8.59k| } 398| 9.04k| } 399| 11.7k| } while (++i3 < i3BlockLength); ------------------ | Branch (399:18): [True: 3.68k, False: 56] ------------------ 400| 8.07k| } while (c < trie->highStart); ------------------ | Branch (400:14): [True: 508, False: 2] ------------------ 401| 2| U_ASSERT(haveValue); ------------------ | | 35| 2|# define U_ASSERT(exp) (void)0 ------------------ 402| 2| int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 403| 2| uint32_t highValue = getValue(trie->data, valueWidth, di); 404| 2| if (maybeFilterValue(highValue, trie->nullValue, nullValue, ------------------ | Branch (404:9): [True: 0, False: 2] ------------------ 405| 2| filter, context) != value) { 406| 0| return c - 1; 407| 2| } else { 408| 2| return MAX_UNICODE; 409| 2| } 410| 2|} ucptrie.cpp:_ZN12_GLOBAL__N_116maybeFilterValueEjjjPFjPKvjES1_: 250| 7.99k| UCPMapValueFilter *filter, const void *context) { 251| 7.99k| if (value == trieNullValue) { ------------------ | Branch (251:9): [True: 880, False: 7.11k] ------------------ 252| 880| value = nullValue; 253| 7.11k| } else if (filter != nullptr) { ------------------ | Branch (253:16): [True: 0, False: 7.11k] ------------------ 254| 0| value = filter(context, value); 255| 0| } 256| 7.99k| return value; 257| 7.99k|} _ZN6icu_7817UDataPathIteratorC2EPKcS2_S2_S2_aP10UErrorCode: 451| 1|{ 452| |#ifdef UDATA_DEBUG 453| | fprintf(stderr, "SUFFIX1=%s PATH=%s\n", inSuffix, inPath); 454| |#endif 455| | /** Path **/ 456| 1| if(inPath == nullptr) { ------------------ | Branch (456:8): [True: 0, False: 1] ------------------ 457| 0| path = u_getDataDirectory(); ------------------ | | 271| 0|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 458| 1| } else { 459| 1| path = inPath; 460| 1| } 461| | 462| | /** Package **/ 463| 1| if(pkg != nullptr) { ------------------ | Branch (463:8): [True: 1, False: 0] ------------------ 464| 1| packageStub.append(U_FILE_SEP_CHAR, *pErrorCode).append(pkg, *pErrorCode); ------------------ | | 130| 1|# define U_FILE_SEP_CHAR '/' ------------------ 465| |#ifdef UDATA_DEBUG 466| | fprintf(stderr, "STUB=%s [%d]\n", packageStub.data(), packageStub.length()); 467| |#endif 468| 1| } 469| | 470| | /** Item **/ 471| 1| basename = findBasename(item); 472| 1| basenameLen = static_cast(uprv_strlen(basename)); ------------------ | | 37| 1|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 473| | 474| | /** Item path **/ 475| 1| if(basename == item) { ------------------ | Branch (475:8): [True: 1, False: 0] ------------------ 476| 1| nextPath = path; 477| 1| } else { 478| 0| itemPath.append(item, static_cast(basename - item), *pErrorCode); 479| 0| nextPath = itemPath.data(); 480| 0| } 481| |#ifdef UDATA_DEBUG 482| | fprintf(stderr, "SUFFIX=%s [%p]\n", inSuffix, (void*) inSuffix); 483| |#endif 484| | 485| | /** Suffix **/ 486| 1| if(inSuffix != nullptr) { ------------------ | Branch (486:8): [True: 1, False: 0] ------------------ 487| 1| suffix = inSuffix; 488| 1| } else { 489| 0| suffix = ""; 490| 0| } 491| | 492| 1| checkLastFour = doCheckLastFour; 493| | 494| | /* pathBuffer will hold the output path strings returned by this iterator */ 495| | 496| |#ifdef UDATA_DEBUG 497| | fprintf(stderr, "0: init %s -> [path=%s], [base=%s], [suff=%s], [itempath=%s], [nextpath=%s], [checklast4=%s]\n", 498| | item, 499| | path, 500| | basename, 501| | suffix.data(), 502| | itemPath.data(), 503| | nextPath, 504| | checkLastFour?"true":"false"); 505| |#endif 506| 1|} _ZN6icu_7817UDataPathIterator4nextEP10UErrorCode: 516| 1|{ 517| 1| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (517:8): [True: 0, False: 1] ------------------ 518| 0| return nullptr; 519| 0| } 520| | 521| 1| const char *currentPath = nullptr; 522| 1| int32_t pathLen = 0; 523| 1| const char *pathBasename; 524| | 525| 1| do 526| 2| { 527| 2| if( nextPath == nullptr ) { ------------------ | Branch (527:13): [True: 1, False: 1] ------------------ 528| 1| break; 529| 1| } 530| 1| currentPath = nextPath; 531| | 532| 1| if(nextPath == itemPath.data()) { /* we were processing item's path. */ ------------------ | Branch (532:12): [True: 0, False: 1] ------------------ 533| 0| nextPath = path; /* start with regular path next tm. */ 534| 0| pathLen = static_cast(uprv_strlen(currentPath)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 535| 1| } else { 536| | /* fix up next for next time */ 537| 1| nextPath = uprv_strchr(currentPath, U_PATH_SEP_CHAR); ------------------ | | 40| 1|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 538| 1| if(nextPath == nullptr) { ------------------ | Branch (538:16): [True: 1, False: 0] ------------------ 539| | /* segment: entire path */ 540| 1| pathLen = static_cast(uprv_strlen(currentPath)); ------------------ | | 37| 1|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 541| 1| } else { 542| | /* segment: until next segment */ 543| 0| pathLen = static_cast(nextPath - currentPath); 544| | /* skip divider */ 545| 0| nextPath ++; 546| 0| } 547| 1| } 548| | 549| 1| if(pathLen == 0) { ------------------ | Branch (549:12): [True: 1, False: 0] ------------------ 550| 1| continue; 551| 1| } 552| | 553| |#ifdef UDATA_DEBUG 554| | fprintf(stderr, "rest of path (IDD) = %s\n", currentPath); 555| | fprintf(stderr, " "); 556| | { 557| | int32_t qqq; 558| | for(qqq=0;qqq=4) && ------------------ | Branch (572:12): [True: 0, False: 0] ------------------ 573| 0| uprv_strncmp(pathBuffer.data() +(pathLen-4), suffix.data(), 4)==0 && /* suffix matches */ ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (573:12): [True: 0, False: 0] ------------------ 574| 0| uprv_strncmp(findBasename(pathBuffer.data()), basename, basenameLen)==0 && /* base matches */ ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (574:12): [True: 0, False: 0] ------------------ 575| 0| uprv_strlen(pathBasename)==(basenameLen+4)) { /* base+suffix = full len */ ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (575:12): [True: 0, False: 0] ------------------ 576| | 577| |#ifdef UDATA_DEBUG 578| | fprintf(stderr, "Have %s file on the path: %s\n", suffix.data(), pathBuffer.data()); 579| |#endif 580| | /* do nothing */ 581| 0| } 582| 0| else 583| 0| { /* regular dir path */ 584| 0| if(pathBuffer[pathLen-1] != U_FILE_SEP_CHAR) { ------------------ | | 130| 0|# define U_FILE_SEP_CHAR '/' ------------------ | Branch (584:16): [True: 0, False: 0] ------------------ 585| 0| if((pathLen>=4) && ------------------ | Branch (585:20): [True: 0, False: 0] ------------------ 586| 0| uprv_strncmp(pathBuffer.data()+(pathLen-4), ".dat", 4) == 0) ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (586:20): [True: 0, False: 0] ------------------ 587| 0| { 588| |#ifdef UDATA_DEBUG 589| | fprintf(stderr, "skipping non-directory .dat file %s\n", pathBuffer.data()); 590| |#endif 591| 0| continue; 592| 0| } 593| | 594| | /* Check if it is a directory with the same name as our package */ 595| 0| if(!packageStub.isEmpty() && ------------------ | Branch (595:20): [True: 0, False: 0] ------------------ 596| 0| (pathLen > packageStub.length()) && ------------------ | Branch (596:20): [True: 0, False: 0] ------------------ 597| 0| !uprv_strcmp(pathBuffer.data() + pathLen - packageStub.length(), packageStub.data())) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (597:20): [True: 0, False: 0] ------------------ 598| |#ifdef UDATA_DEBUG 599| | fprintf(stderr, "Found stub %s (will add package %s of len %d)\n", packageStub.data(), basename, basenameLen); 600| |#endif 601| 0| pathBuffer.truncate(pathLen - packageStub.length()); 602| 0| } 603| 0| pathBuffer.append(U_FILE_SEP_CHAR, *pErrorCode); ------------------ | | 130| 0|# define U_FILE_SEP_CHAR '/' ------------------ 604| 0| } 605| | 606| | /* + basename */ 607| 0| pathBuffer.append(packageStub.data()+1, packageStub.length()-1, *pErrorCode); 608| | 609| 0| if (!suffix.empty()) /* tack on suffix */ ------------------ | Branch (609:17): [True: 0, False: 0] ------------------ 610| 0| { 611| 0| if (suffix.length() > 4) { ------------------ | Branch (611:21): [True: 0, False: 0] ------------------ 612| | // If the suffix is actually an item ("ibm-5348_P100-1997.cnv") and not an extension (".res") 613| | // then we need to ensure that the path ends with a separator. 614| 0| pathBuffer.ensureEndsWithFileSeparator(*pErrorCode); 615| 0| } 616| 0| pathBuffer.append(suffix, *pErrorCode); 617| 0| } 618| 0| } 619| | 620| |#ifdef UDATA_DEBUG 621| | fprintf(stderr, " --> %s\n", pathBuffer.data()); 622| |#endif 623| | 624| 0| return pathBuffer.data(); 625| | 626| 1| } while(path); ------------------ | Branch (626:13): [True: 1, False: 0] ------------------ 627| | 628| | /* fell way off the end */ 629| 1| return nullptr; 630| 1|} udata_openChoice_78: 1406| 710| UErrorCode *pErrorCode) { 1407| |#ifdef UDATA_DEBUG 1408| | fprintf(stderr, "udata_openChoice(): Opening: %s : %s . %s\n", (path?path:"nullptr"), name, type); 1409| |#endif 1410| | 1411| 710| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1411:8): [True: 0, False: 710] | Branch (1411:31): [True: 0, False: 710] ------------------ 1412| 0| return nullptr; 1413| 710| } else if(name==nullptr || *name==0 || isAcceptable==nullptr) { ------------------ | Branch (1413:15): [True: 0, False: 710] | Branch (1413:32): [True: 0, False: 710] | Branch (1413:44): [True: 0, False: 710] ------------------ 1414| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1415| 0| return nullptr; 1416| 710| } else { 1417| 710| return doOpenChoice(path, type, name, isAcceptable, context, pErrorCode); 1418| 710| } 1419| 710|} udata.cpp:_ZL12findBasenamePKc: 225| 636|findBasename(const char *path) { 226| 636| const char *basename=uprv_strrchr(path, U_FILE_SEP_CHAR); ------------------ | | 42| 636|#define uprv_strrchr(s, c) U_STANDARD_CPP_NAMESPACE strrchr(s, c) | | ------------------ | | | | 393| 636|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 227| 636| if(basename==nullptr) { ------------------ | Branch (227:8): [True: 636, False: 0] ------------------ 228| 636| return path; 229| 636| } else { 230| 0| return basename+1; 231| 0| } 232| 636|} udata.cpp:_ZL16setCommonICUDataP11UDataMemoryaP10UErrorCode: 174| 1|{ 175| 1| UDataMemory *newCommonData = UDataMemory_createNewInstance(pErr); ------------------ | | 79| 1|#define UDataMemory_createNewInstance U_ICU_ENTRY_POINT_RENAME(UDataMemory_createNewInstance) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 176| 1| int32_t i; 177| 1| UBool didUpdate = false; 178| 1| if (U_FAILURE(*pErr)) { ------------------ | Branch (178:9): [True: 0, False: 1] ------------------ 179| 0| return false; 180| 0| } 181| | 182| | /* For the assignment, other threads must cleanly see either the old */ 183| | /* or the new, not some partially initialized new. The old can not be */ 184| | /* deleted - someone may still have a pointer to it lying around in */ 185| | /* their locals. */ 186| 1| UDatamemory_assign(newCommonData, pData); ------------------ | | 84| 1|#define UDatamemory_assign U_ICU_ENTRY_POINT_RENAME(UDatamemory_assign) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 187| 1| umtx_lock(nullptr); ------------------ | | 1250| 1|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 188| 1| for (i = 0; i < UPRV_LENGTHOF(gCommonICUDataArray); ++i) { ------------------ | | 99| 1|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (188:17): [True: 1, False: 0] ------------------ 189| 1| if (gCommonICUDataArray[i] == nullptr) { ------------------ | Branch (189:13): [True: 1, False: 0] ------------------ 190| 1| gCommonICUDataArray[i] = newCommonData; 191| 1| didUpdate = true; 192| 1| break; 193| 1| } else if (gCommonICUDataArray[i]->pHeader == pData->pHeader) { ------------------ | Branch (193:20): [True: 0, False: 0] ------------------ 194| | /* The same data pointer is already in the array. */ 195| 0| break; 196| 0| } 197| 1| } 198| 1| umtx_unlock(nullptr); ------------------ | | 1251| 1|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 199| | 200| 1| if (i == UPRV_LENGTHOF(gCommonICUDataArray) && warn) { ------------------ | | 99| 2|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (200:9): [True: 0, False: 1] | Branch (200:52): [True: 0, False: 0] ------------------ 201| 0| *pErr = U_USING_DEFAULT_WARNING; 202| 0| } 203| 1| if (didUpdate) { ------------------ | Branch (203:9): [True: 1, False: 0] ------------------ 204| 1| ucln_common_registerCleanup(UCLN_COMMON_UDATA, udata_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 205| 1| } else { 206| 0| uprv_free(newCommonData); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 207| 0| } 208| 1| return didUpdate; 209| 1|} udata.cpp:_ZL18udata_getHashTableR10UErrorCode: 298| 635|static UHashtable *udata_getHashTable(UErrorCode &err) { 299| 635| umtx_initOnce(gCommonDataCacheInitOnce, &udata_initHashTable, err); 300| 635| return gCommonDataCache; 301| 635|} udata.cpp:_ZL19udata_initHashTableR10UErrorCode: 283| 1|static void U_CALLCONV udata_initHashTable(UErrorCode &err) { 284| 1| U_ASSERT(gCommonDataCache == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 285| 1| gCommonDataCache = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &err); ------------------ | | 1030| 1|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gCommonDataCache = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &err); ------------------ | | 1011| 1|#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gCommonDataCache = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &err); ------------------ | | 993| 1|#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 286| 1| if (U_FAILURE(err)) { ------------------ | Branch (286:9): [True: 0, False: 1] ------------------ 287| 0| return; 288| 0| } 289| 1| U_ASSERT(gCommonDataCache != nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 290| 1| uhash_setValueDeleter(gCommonDataCache, DataCacheElement_deleter); ------------------ | | 1044| 1|#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDeleter) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 291| 1| ucln_common_registerCleanup(UCLN_COMMON_UDATA, udata_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 292| 1|} udata.cpp:_ZL12doOpenChoicePKcS0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCode: 1151| 710|{ 1152| 710| UDataMemory *retVal = nullptr; 1153| | 1154| 710| const char *dataPath; 1155| | 1156| 710| int32_t tocEntrySuffixIndex; 1157| 710| const char *tocEntryPathSuffix; 1158| 710| UErrorCode subErrorCode=U_ZERO_ERROR; 1159| 710| const char *treeChar; 1160| | 1161| 710| UBool isICUData = false; 1162| | 1163| | 1164| 710| FileTracer::traceOpen(path, type, name); 1165| | 1166| | 1167| | /* Is this path ICU data? */ 1168| 710| if(path == nullptr || ------------------ | Branch (1168:8): [True: 3, False: 707] ------------------ 1169| 710| !strcmp(path, U_ICUDATA_ALIAS) || /* "ICUDATA" */ ------------------ | | 74| 707|#define U_ICUDATA_ALIAS "ICUDATA" ------------------ | Branch (1169:8): [True: 0, False: 707] ------------------ 1170| 710| !uprv_strncmp(path, U_ICUDATA_NAME U_TREE_SEPARATOR_STRING, /* "icudt26e-" */ ------------------ | | 44| 707|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 707|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1170:8): [True: 707, False: 0] ------------------ 1171| 710| uprv_strlen(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING)) || 1172| 710| !uprv_strncmp(path, U_ICUDATA_ALIAS U_TREE_SEPARATOR_STRING, /* "ICUDATA-" */ ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1172:8): [True: 0, False: 0] ------------------ 1173| 710| uprv_strlen(U_ICUDATA_ALIAS U_TREE_SEPARATOR_STRING))) { 1174| 710| isICUData = true; 1175| 710| } 1176| | 1177| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) /* Windows: try "foo\bar" and "foo/bar" */ 1178| | /* remap from alternate path char to the main one */ 1179| | CharString altSepPath; 1180| | if(path) { 1181| | if(uprv_strchr(path,U_FILE_ALT_SEP_CHAR) != nullptr) { 1182| | altSepPath.append(path, *pErrorCode); 1183| | char *p; 1184| | while ((p = uprv_strchr(altSepPath.data(), U_FILE_ALT_SEP_CHAR)) != nullptr) { 1185| | *p = U_FILE_SEP_CHAR; 1186| | } 1187| |#if defined (UDATA_DEBUG) 1188| | fprintf(stderr, "Changed path from [%s] to [%s]\n", path, altSepPath.data()); 1189| |#endif 1190| | path = altSepPath.data(); 1191| | } 1192| | } 1193| |#endif 1194| | 1195| 710| CharString tocEntryName; /* entry name in tree format. ex: 'icudt28b/coll/ar.res' */ 1196| 710| CharString tocEntryPath; /* entry name in path format. ex: 'icudt28b\\coll\\ar.res' */ 1197| | 1198| 710| CharString pkgName; 1199| 710| CharString treeName; 1200| | 1201| | /* ======= Set up strings */ 1202| 710| if(path==nullptr) { ------------------ | Branch (1202:8): [True: 3, False: 707] ------------------ 1203| 3| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 3|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 3|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1204| 707| } else { 1205| 707| const char *pkg; 1206| 707| const char *first; 1207| 707| pkg = uprv_strrchr(path, U_FILE_SEP_CHAR); ------------------ | | 42| 707|#define uprv_strrchr(s, c) U_STANDARD_CPP_NAMESPACE strrchr(s, c) | | ------------------ | | | | 393| 707|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1208| 707| first = uprv_strchr(path, U_FILE_SEP_CHAR); ------------------ | | 40| 707|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 707|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1209| 707| if(uprv_pathIsAbsolute(path) || (pkg != first)) { /* more than one slash in the path- not a tree name */ ------------------ | | 1533| 707|#define uprv_pathIsAbsolute U_ICU_ENTRY_POINT_RENAME(uprv_pathIsAbsolute) | | ------------------ | | | | 123| 707|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 707|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 707|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1209:12): [True: 0, False: 707] | Branch (1209:41): [True: 0, False: 707] ------------------ 1210| | /* see if this is an /absolute/path/to/package path */ 1211| 0| if(pkg) { ------------------ | Branch (1211:16): [True: 0, False: 0] ------------------ 1212| 0| pkgName.append(pkg+1, *pErrorCode); 1213| 0| } else { 1214| 0| pkgName.append(path, *pErrorCode); 1215| 0| } 1216| 707| } else { 1217| 707| treeChar = uprv_strchr(path, U_TREE_SEPARATOR); ------------------ | | 40| 707|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 707|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1218| 707| if(treeChar) { ------------------ | Branch (1218:16): [True: 707, False: 0] ------------------ 1219| 707| treeName.append(treeChar+1, *pErrorCode); /* following '-' */ 1220| 707| if(isICUData) { ------------------ | Branch (1220:20): [True: 707, False: 0] ------------------ 1221| 707| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 707|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 707|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1222| 707| } else { 1223| 0| pkgName.append(path, static_cast(treeChar - path), *pErrorCode); 1224| 0| if (first == nullptr) { ------------------ | Branch (1224:25): [True: 0, False: 0] ------------------ 1225| | /* 1226| | This user data has no path, but there is a tree name. 1227| | Look up the correct path from the data cache later. 1228| | */ 1229| 0| path = pkgName.data(); 1230| 0| } 1231| 0| } 1232| 707| } else { 1233| 0| if(isICUData) { ------------------ | Branch (1233:20): [True: 0, False: 0] ------------------ 1234| 0| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 0|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 0|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1235| 0| } else { 1236| 0| pkgName.append(path, *pErrorCode); 1237| 0| } 1238| 0| } 1239| 707| } 1240| 707| } 1241| | 1242| |#ifdef UDATA_DEBUG 1243| | fprintf(stderr, " P=%s T=%s\n", pkgName.data(), treeName.data()); 1244| |#endif 1245| | 1246| | /* setting up the entry name and file name 1247| | * Make up a full name by appending the type to the supplied 1248| | * name, assuming that a type was supplied. 1249| | */ 1250| | 1251| | /* prepend the package */ 1252| 710| tocEntryName.append(pkgName, *pErrorCode); 1253| 710| tocEntryPath.append(pkgName, *pErrorCode); 1254| 710| tocEntrySuffixIndex = tocEntryName.length(); 1255| | 1256| 710| if(!treeName.isEmpty()) { ------------------ | Branch (1256:8): [True: 707, False: 3] ------------------ 1257| 707| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(treeName, *pErrorCode); ------------------ | | 62| 707|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1258| 707| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(treeName, *pErrorCode); ------------------ | | 130| 707|# define U_FILE_SEP_CHAR '/' ------------------ 1259| 707| } 1260| | 1261| 710| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 62| 710|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1262| 710| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 130| 710|# define U_FILE_SEP_CHAR '/' ------------------ 1263| 710| if(type!=nullptr && *type!=0) { ------------------ | Branch (1263:8): [True: 710, False: 0] | Branch (1263:25): [True: 710, False: 0] ------------------ 1264| 710| tocEntryName.append(".", *pErrorCode).append(type, *pErrorCode); 1265| 710| tocEntryPath.append(".", *pErrorCode).append(type, *pErrorCode); 1266| 710| } 1267| | // The +1 is for the U_FILE_SEP_CHAR that is always appended above. 1268| 710| tocEntryPathSuffix = tocEntryPath.data() + tocEntrySuffixIndex + 1; /* suffix starts here */ 1269| | 1270| |#ifdef UDATA_DEBUG 1271| | fprintf(stderr, " tocEntryName = %s\n", tocEntryName.data()); 1272| | fprintf(stderr, " tocEntryPath = %s\n", tocEntryName.data()); 1273| |#endif 1274| | 1275| 710|#if !defined(ICU_DATA_DIR_WINDOWS) 1276| 710| if(path == nullptr) { ------------------ | Branch (1276:8): [True: 3, False: 707] ------------------ 1277| 3| path = COMMON_DATA_NAME; /* "icudt26e" */ ------------------ | | 34| 3|#define COMMON_DATA_NAME U_ICUDATA_NAME | | ------------------ | | | | 154| 3|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | | | ------------------ | | | | | | 144| 3|# define U_ICUDATA_TYPE_LETTER "l" | | | | ------------------ | | ------------------ ------------------ 1278| 3| } 1279| |#else 1280| | // When using the Windows system data, we expects only a single data file. 1281| | path = COMMON_DATA_NAME; /* "icudt26e" */ 1282| |#endif 1283| | 1284| | /************************ Begin loop looking for ind. files ***************/ 1285| |#ifdef UDATA_DEBUG 1286| | fprintf(stderr, "IND: inBasename = %s, pkg=%s\n", "(n/a)", packageNameFromPath(path)); 1287| |#endif 1288| | 1289| | /* End of dealing with a null basename */ 1290| 710| dataPath = u_getDataDirectory(); ------------------ | | 271| 710|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 123| 710|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 710|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 710|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1291| | 1292| | /**** Time zone individual files override */ 1293| 710| if (isICUData && isTimeZoneFile(name, type)) { ------------------ | Branch (1293:9): [True: 710, False: 0] | Branch (1293:22): [True: 1, False: 709] ------------------ 1294| 1| const char *tzFilesDir = u_getTimeZoneFilesDirectory(pErrorCode); ------------------ | | 287| 1|#define u_getTimeZoneFilesDirectory U_ICU_ENTRY_POINT_RENAME(u_getTimeZoneFilesDirectory) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1295| 1| if (tzFilesDir[0] != 0) { ------------------ | Branch (1295:13): [True: 0, False: 1] ------------------ 1296| |#ifdef UDATA_DEBUG 1297| | fprintf(stderr, "Trying Time Zone Files directory = %s\n", tzFilesDir); 1298| |#endif 1299| 0| retVal = doLoadFromIndividualFiles(/* pkgName.data() */ "", tzFilesDir, tocEntryPathSuffix, 1300| 0| /* path */ "", type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1301| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1301:16): [True: 0, False: 0] | Branch (1301:39): [True: 0, False: 0] ------------------ 1302| 0| return retVal; 1303| 0| } 1304| 0| } 1305| 1| } 1306| | 1307| | /**** COMMON PACKAGE - only if packages are first. */ 1308| 710| if(gDataFileAccess == UDATA_PACKAGES_FIRST) { ------------------ | Branch (1308:8): [True: 0, False: 710] ------------------ 1309| |#ifdef UDATA_DEBUG 1310| | fprintf(stderr, "Trying packages (UDATA_PACKAGES_FIRST)\n"); 1311| |#endif 1312| | /* #2 */ 1313| 0| retVal = doLoadFromCommonData(isICUData, 1314| 0| pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(), 1315| 0| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1316| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1316:12): [True: 0, False: 0] | Branch (1316:35): [True: 0, False: 0] ------------------ 1317| 0| return retVal; 1318| 0| } 1319| 0| } 1320| | 1321| | /**** INDIVIDUAL FILES */ 1322| 710| if((gDataFileAccess==UDATA_PACKAGES_FIRST) || ------------------ | Branch (1322:8): [True: 0, False: 710] ------------------ 1323| 710| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1323:8): [True: 710, False: 0] ------------------ 1324| |#ifdef UDATA_DEBUG 1325| | fprintf(stderr, "Trying individual files\n"); 1326| |#endif 1327| | /* Check to make sure that there is a dataPath to iterate over */ 1328| 710| if ((dataPath && *dataPath) || !isICUData) { ------------------ | Branch (1328:14): [True: 710, False: 0] | Branch (1328:26): [True: 0, False: 710] | Branch (1328:40): [True: 0, False: 710] ------------------ 1329| 0| retVal = doLoadFromIndividualFiles(pkgName.data(), dataPath, tocEntryPathSuffix, 1330| 0| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1331| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1331:16): [True: 0, False: 0] | Branch (1331:39): [True: 0, False: 0] ------------------ 1332| 0| return retVal; 1333| 0| } 1334| 0| } 1335| 710| } 1336| | 1337| | /**** COMMON PACKAGE */ 1338| 710| if((gDataFileAccess==UDATA_ONLY_PACKAGES) || ------------------ | Branch (1338:8): [True: 0, False: 710] ------------------ 1339| 710| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1339:8): [True: 710, False: 0] ------------------ 1340| |#ifdef UDATA_DEBUG 1341| | fprintf(stderr, "Trying packages (UDATA_ONLY_PACKAGES || UDATA_FILES_FIRST)\n"); 1342| |#endif 1343| 710| retVal = doLoadFromCommonData(isICUData, 1344| 710| pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(), 1345| 710| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1346| 710| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1346:12): [True: 76, False: 634] | Branch (1346:35): [True: 0, False: 634] ------------------ 1347| 76| return retVal; 1348| 76| } 1349| 710| } 1350| | 1351| | /* Load from DLL. If we haven't attempted package load, we also haven't had any chance to 1352| | try a DLL (static or setCommonData/etc) load. 1353| | If we ever have a "UDATA_ONLY_FILES", add it to the or list here. */ 1354| 634| if(gDataFileAccess==UDATA_NO_FILES) { ------------------ | Branch (1354:8): [True: 0, False: 634] ------------------ 1355| |#ifdef UDATA_DEBUG 1356| | fprintf(stderr, "Trying common data (UDATA_NO_FILES)\n"); 1357| |#endif 1358| 0| retVal = doLoadFromCommonData(isICUData, 1359| 0| pkgName.data(), "", tocEntryPathSuffix, tocEntryName.data(), 1360| 0| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1361| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1361:12): [True: 0, False: 0] | Branch (1361:35): [True: 0, False: 0] ------------------ 1362| 0| return retVal; 1363| 0| } 1364| 0| } 1365| | 1366| | /* data not found */ 1367| 634| if(U_SUCCESS(*pErrorCode)) { ------------------ | Branch (1367:8): [True: 634, False: 0] ------------------ 1368| 634| if(U_SUCCESS(subErrorCode)) { ------------------ | Branch (1368:12): [True: 633, False: 1] ------------------ 1369| | /* file not found */ 1370| 633| *pErrorCode=U_FILE_ACCESS_ERROR; 1371| 633| } else { 1372| | /* entry point not found or rejected */ 1373| 1| *pErrorCode=subErrorCode; 1374| 1| } 1375| 634| } 1376| 634| return retVal; 1377| 634|} udata.cpp:_ZL14isTimeZoneFilePKcS0_: 1107| 710|static UBool isTimeZoneFile(const char *name, const char *type) { 1108| 710| return ((uprv_strcmp(type, "res") == 0) && ------------------ | | 38| 710|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 710|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1108:13): [True: 708, False: 2] ------------------ 1109| 710| (uprv_strcmp(name, "zoneinfo64") == 0 || ------------------ | | 38| 708|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 708|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1109:14): [True: 0, False: 708] ------------------ 1110| 708| uprv_strcmp(name, "timezoneTypes") == 0 || ------------------ | | 38| 708|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 708|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1110:14): [True: 1, False: 707] ------------------ 1111| 708| uprv_strcmp(name, "windowsZones") == 0 || ------------------ | | 38| 707|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 707|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1111:14): [True: 0, False: 707] ------------------ 1112| 708| uprv_strcmp(name, "metaZones") == 0)); ------------------ | | 38| 707|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 707|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1112:14): [True: 0, False: 707] ------------------ 1113| 710|} udata.cpp:_ZL13checkDataItemPK10DataHeaderPFaPvPKcS4_PK9UDataInfoES2_S4_S4_P10UErrorCodeSB_: 949| 76|{ 950| 76| UDataMemory *rDataMem = nullptr; /* the new UDataMemory, to be returned. */ 951| | 952| 76| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (952:9): [True: 0, False: 76] ------------------ 953| 0| return nullptr; 954| 0| } 955| | 956| 76| if(pHeader->dataHeader.magic1==0xda && ------------------ | Branch (956:8): [True: 76, False: 0] ------------------ 957| 76| pHeader->dataHeader.magic2==0x27 && ------------------ | Branch (957:9): [True: 76, False: 0] ------------------ 958| 76| (isAcceptable==nullptr || isAcceptable(context, type, name, &pHeader->info)) ------------------ | Branch (958:10): [True: 0, False: 76] | Branch (958:35): [True: 76, False: 0] ------------------ 959| 76| ) { 960| 76| rDataMem=UDataMemory_createNewInstance(fatalErr); ------------------ | | 79| 76|#define UDataMemory_createNewInstance U_ICU_ENTRY_POINT_RENAME(UDataMemory_createNewInstance) | | ------------------ | | | | 123| 76|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 76|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 76|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 961| 76| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (961:13): [True: 0, False: 76] ------------------ 962| 0| return nullptr; 963| 0| } 964| 76| rDataMem->pHeader = pHeader; 965| 76| } else { 966| | /* the data is not acceptable, look further */ 967| | /* If we eventually find something good, this errorcode will be */ 968| | /* cleared out. */ 969| 0| *nonFatalErr=U_INVALID_FORMAT_ERROR; 970| 0| } 971| 76| return rDataMem; 972| 76|} udata.cpp:_ZL20doLoadFromCommonDataaPKcS0_S0_S0_S0_S0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCodeS8_: 1042| 710|{ 1043| 710| UDataMemory *pEntryData; 1044| 710| const DataHeader *pHeader; 1045| 710| UDataMemory *pCommonData; 1046| 710| int32_t commonDataIndex; 1047| 710| UBool checkedExtendedICUData = false; 1048| | /* try to get common data. The loop is for platforms such as the 390 that do 1049| | * not initially load the full set of ICU data. If the lookup of an ICU data item 1050| | * fails, the full (but slower to load) set is loaded, the and the loop repeats, 1051| | * trying the lookup again. Once the full set of ICU data is loaded, the loop wont 1052| | * repeat because the full set will be checked the first time through. 1053| | * 1054| | * The loop also handles the fallback to a .dat file if the application linked 1055| | * to the stub data library rather than a real library. 1056| | */ 1057| 1.34k| for (commonDataIndex = isICUData ? 0 : -1;;) { ------------------ | Branch (1057:28): [True: 710, False: 0] ------------------ 1058| 1.34k| pCommonData=openCommonData(path, commonDataIndex, subErrorCode); /** search for pkg **/ 1059| | 1060| 1.34k| if(U_SUCCESS(*subErrorCode) && pCommonData!=nullptr) { ------------------ | Branch (1060:12): [True: 1.34k, False: 0] | Branch (1060:40): [True: 710, False: 634] ------------------ 1061| 710| int32_t length; 1062| | 1063| | /* look up the data piece in the common data */ 1064| 710| pHeader=pCommonData->vFuncs->Lookup(pCommonData, tocEntryName, &length, subErrorCode); 1065| |#ifdef UDATA_DEBUG 1066| | fprintf(stderr, "%s: pHeader=%p - %s\n", tocEntryName, (void*) pHeader, u_errorName(*subErrorCode)); 1067| |#endif 1068| | 1069| 710| if(pHeader!=nullptr) { ------------------ | Branch (1069:16): [True: 76, False: 634] ------------------ 1070| 76| pEntryData = checkDataItem(pHeader, isAcceptable, context, type, name, subErrorCode, pErrorCode); 1071| |#ifdef UDATA_DEBUG 1072| | fprintf(stderr, "pEntryData=%p\n", (void*) pEntryData); 1073| |#endif 1074| 76| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1074:21): [True: 0, False: 76] ------------------ 1075| 0| return nullptr; 1076| 0| } 1077| 76| if (pEntryData != nullptr) { ------------------ | Branch (1077:21): [True: 76, False: 0] ------------------ 1078| 76| pEntryData->length = length; 1079| 76| return pEntryData; 1080| 76| } 1081| 76| } 1082| 710| } 1083| | // If we failed due to being out-of-memory, then stop early and report the error. 1084| 1.26k| if (*subErrorCode == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (1084:13): [True: 0, False: 1.26k] ------------------ 1085| 0| *pErrorCode = *subErrorCode; 1086| 0| return nullptr; 1087| 0| } 1088| | /* Data wasn't found. If we were looking for an ICUData item and there is 1089| | * more data available, load it and try again, 1090| | * otherwise break out of this loop. */ 1091| 1.26k| if (!isICUData) { ------------------ | Branch (1091:13): [True: 0, False: 1.26k] ------------------ 1092| 0| return nullptr; 1093| 1.26k| } else if (pCommonData != nullptr) { ------------------ | Branch (1093:20): [True: 634, False: 634] ------------------ 1094| 634| ++commonDataIndex; /* try the next data package */ 1095| 634| } else if ((!checkedExtendedICUData) && extendICUData(subErrorCode)) { ------------------ | Branch (1095:20): [True: 634, False: 0] | Branch (1095:49): [True: 0, False: 634] ------------------ 1096| 0| checkedExtendedICUData = true; 1097| | /* try this data package slot again: it changed from nullptr to non-nullptr */ 1098| 634| } else { 1099| 634| return nullptr; 1100| 634| } 1101| 1.26k| } 1102| 710|} udata.cpp:_ZL14openCommonDataPKciP10UErrorCode: 673| 1.34k|{ 674| 1.34k| UDataMemory tData; 675| 1.34k| const char *pathBuffer; 676| 1.34k| const char *inBasename; 677| | 678| 1.34k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (678:9): [True: 0, False: 1.34k] ------------------ 679| 0| return nullptr; 680| 0| } 681| | 682| 1.34k| UDataMemory_init(&tData); ------------------ | | 80| 1.34k|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 1.34k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.34k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.34k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 683| | 684| | /* ??????? TODO revisit this */ 685| 1.34k| if (commonDataIndex >= 0) { ------------------ | Branch (685:9): [True: 1.34k, False: 1] ------------------ 686| | /* "mini-cache" for common ICU data */ 687| 1.34k| if(commonDataIndex >= UPRV_LENGTHOF(gCommonICUDataArray)) { ------------------ | | 99| 1.34k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (687:12): [True: 0, False: 1.34k] ------------------ 688| 0| return nullptr; 689| 0| } 690| 1.34k| { 691| 1.34k| Mutex lock; 692| 1.34k| if(gCommonICUDataArray[commonDataIndex] != nullptr) { ------------------ | Branch (692:16): [True: 709, False: 635] ------------------ 693| 709| return gCommonICUDataArray[commonDataIndex]; 694| 709| } 695| 635|#if !defined(ICU_DATA_DIR_WINDOWS) 696| |// When using the Windows system data, we expect only a single data file. 697| 635| int32_t i; 698| 635| for(i = 0; i < commonDataIndex; ++i) { ------------------ | Branch (698:24): [True: 634, False: 1] ------------------ 699| 634| if(gCommonICUDataArray[i]->pHeader == &U_ICUDATA_ENTRY_POINT) { ------------------ | | 171| 634|#define U_ICUDATA_ENTRY_POINT U_DEF2_ICUDATA_ENTRY_POINT(U_ICU_VERSION_MAJOR_NUM,U_LIB_SUFFIX_C_NAME) | | ------------------ | | | | 178| 634|#define U_DEF2_ICUDATA_ENTRY_POINT(major,suff) U_DEF_ICUDATA_ENTRY_POINT(major,suff) | | | | ------------------ | | | | | | 187| 634|#define U_DEF_ICUDATA_ENTRY_POINT(major, suff) icudt##major##_dat | | | | ------------------ | | ------------------ ------------------ | Branch (699:20): [True: 634, False: 0] ------------------ 700| | /* The linked-in data is already in the list. */ 701| 634| return nullptr; 702| 634| } 703| 634| } 704| 635|#endif 705| 635| } 706| | 707| | /* Add the linked-in data to the list. */ 708| | /* 709| | * This is where we would check and call weakly linked partial-data-library 710| | * access functions. 711| | */ 712| | /* 713| | if (uprv_getICUData_collation) { 714| | setCommonICUDataPointer(uprv_getICUData_collation(), false, pErrorCode); 715| | } 716| | if (uprv_getICUData_conversion) { 717| | setCommonICUDataPointer(uprv_getICUData_conversion(), false, pErrorCode); 718| | } 719| | */ 720| 1|#if !defined(ICU_DATA_DIR_WINDOWS) 721| |// When using the Windows system data, we expect only a single data file. 722| 1| setCommonICUDataPointer(&U_ICUDATA_ENTRY_POINT, false, pErrorCode); ------------------ | | 171| 1|#define U_ICUDATA_ENTRY_POINT U_DEF2_ICUDATA_ENTRY_POINT(U_ICU_VERSION_MAJOR_NUM,U_LIB_SUFFIX_C_NAME) | | ------------------ | | | | 178| 1|#define U_DEF2_ICUDATA_ENTRY_POINT(major,suff) U_DEF_ICUDATA_ENTRY_POINT(major,suff) | | | | ------------------ | | | | | | 187| 1|#define U_DEF_ICUDATA_ENTRY_POINT(major, suff) icudt##major##_dat | | | | ------------------ | | ------------------ ------------------ 723| 1| { 724| 1| Mutex lock; 725| 1| return gCommonICUDataArray[commonDataIndex]; 726| 635| } 727| 635|#endif 728| 635| } 729| | 730| | 731| | /* request is NOT for ICU Data. */ 732| | 733| | /* Find the base name portion of the supplied path. */ 734| | /* inBasename will be left pointing somewhere within the original path string. */ 735| 1| inBasename = findBasename(path); 736| |#ifdef UDATA_DEBUG 737| | fprintf(stderr, "inBasename = %s\n", inBasename); 738| |#endif 739| | 740| 1| if(*inBasename==0) { ------------------ | Branch (740:8): [True: 0, False: 1] ------------------ 741| | /* no basename. This will happen if the original path was a directory name, */ 742| | /* like "a/b/c/". (Fallback to separate files will still work.) */ 743| |#ifdef UDATA_DEBUG 744| | fprintf(stderr, "ocd: no basename in %s, bailing.\n", path); 745| |#endif 746| 0| if (U_SUCCESS(*pErrorCode)) { ------------------ | Branch (746:13): [True: 0, False: 0] ------------------ 747| 0| *pErrorCode=U_FILE_ACCESS_ERROR; 748| 0| } 749| 0| return nullptr; 750| 0| } 751| | 752| | /* Is the requested common data file already open and cached? */ 753| | /* Note that the cache is keyed by the base name only. The rest of the path, */ 754| | /* if any, is not considered. */ 755| 1| UDataMemory *dataToReturn = udata_findCachedData(inBasename, *pErrorCode); 756| 1| if (dataToReturn != nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (756:9): [True: 0, False: 1] | Branch (756:36): [True: 0, False: 1] ------------------ 757| 0| return dataToReturn; 758| 0| } 759| | 760| | /* Requested item is not in the cache. 761| | * Hunt it down, trying all the path locations 762| | */ 763| | 764| 1| UDataPathIterator iter(u_getDataDirectory(), inBasename, path, ".dat", true, pErrorCode); ------------------ | | 271| 1|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 765| | 766| 1| while ((UDataMemory_isLoaded(&tData)==false) && (pathBuffer = iter.next(pErrorCode)) != nullptr) ------------------ | | 81| 1|#define UDataMemory_isLoaded U_ICU_ENTRY_POINT_RENAME(UDataMemory_isLoaded) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (766:12): [True: 1, False: 0] | Branch (766:53): [True: 0, False: 1] ------------------ 767| 0| { 768| |#ifdef UDATA_DEBUG 769| | fprintf(stderr, "ocd: trying path %s - ", pathBuffer); 770| |#endif 771| 0| uprv_mapFile(&tData, pathBuffer, pErrorCode); ------------------ | | 1525| 0|#define uprv_mapFile U_ICU_ENTRY_POINT_RENAME(uprv_mapFile) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 772| |#ifdef UDATA_DEBUG 773| | fprintf(stderr, "%s\n", UDataMemory_isLoaded(&tData)?"LOADED":"not loaded"); 774| |#endif 775| 0| } 776| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (776:9): [True: 0, False: 1] ------------------ 777| 0| return nullptr; 778| 0| } 779| | 780| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (780:9): [True: 0, False: 1] ------------------ 781| 0| return nullptr; 782| 0| } 783| 1| if (!UDataMemory_isLoaded(&tData)) { ------------------ | | 81| 1|#define UDataMemory_isLoaded U_ICU_ENTRY_POINT_RENAME(UDataMemory_isLoaded) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (783:9): [True: 1, False: 0] ------------------ 784| | /* no common data */ 785| 1| *pErrorCode=U_FILE_ACCESS_ERROR; 786| 1| return nullptr; 787| 1| } 788| | 789| | /* we have mapped a file, check its header */ 790| 0| udata_checkCommonData(&tData, pErrorCode); ------------------ | | 884| 0|#define udata_checkCommonData U_ICU_ENTRY_POINT_RENAME(udata_checkCommonData) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 791| | 792| | 793| | /* Cache the UDataMemory struct for this .dat file, 794| | * so we won't need to hunt it down and map it again next time 795| | * something is needed from it. */ 796| 0| return udata_cacheDataItem(inBasename, &tData, pErrorCode); 797| 1|} udata.cpp:_ZL23setCommonICUDataPointerPKvaP10UErrorCode: 214| 1|setCommonICUDataPointer(const void *pData, UBool /*warn*/, UErrorCode *pErrorCode) { 215| 1| UDataMemory tData; 216| 1| UDataMemory_init(&tData); ------------------ | | 80| 1|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 217| 1| UDataMemory_setData(&tData, pData); ------------------ | | 83| 1|#define UDataMemory_setData U_ICU_ENTRY_POINT_RENAME(UDataMemory_setData) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 218| 1| udata_checkCommonData(&tData, pErrorCode); ------------------ | | 884| 1|#define udata_checkCommonData U_ICU_ENTRY_POINT_RENAME(udata_checkCommonData) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 219| 1| return setCommonICUData(&tData, false, pErrorCode); 220| 1|} udata.cpp:_ZL20udata_findCachedDataPKcR10UErrorCode: 306| 635|{ 307| 635| UHashtable *htable; 308| 635| UDataMemory *retVal = nullptr; 309| 635| DataCacheElement *el; 310| 635| const char *baseName; 311| | 312| 635| htable = udata_getHashTable(err); 313| 635| if (U_FAILURE(err)) { ------------------ | Branch (313:9): [True: 1, False: 634] ------------------ 314| 1| return nullptr; 315| 1| } 316| | 317| 634| baseName = findBasename(path); /* Cache remembers only the base name, not the full path. */ 318| 634| umtx_lock(nullptr); ------------------ | | 1250| 634|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 634|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 634|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 634|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 319| 634| el = static_cast(uhash_get(htable, baseName)); ------------------ | | 1007| 634|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 634|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 634|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 634|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 320| 634| umtx_unlock(nullptr); ------------------ | | 1251| 634|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 634|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 634|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 634|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 321| 634| if (el != nullptr) { ------------------ | Branch (321:9): [True: 0, False: 634] ------------------ 322| 0| retVal = el->item; 323| 0| } 324| |#ifdef UDATA_DEBUG 325| | fprintf(stderr, "Cache: [%s] -> %p\n", baseName, (void*) retVal); 326| |#endif 327| 634| return retVal; 328| 635|} udata.cpp:_ZL13extendICUDataP10UErrorCode: 811| 634|{ 812| 634| UDataMemory *pData; 813| 634| UDataMemory copyPData; 814| 634| UBool didUpdate = false; 815| | 816| | /* 817| | * There is a chance for a race condition here. 818| | * Normally, ICU data is loaded from a DLL or via mmap() and 819| | * setCommonICUData() will detect if the same address is set twice. 820| | * If ICU is built with data loading via fread() then the address will 821| | * be different each time the common data is loaded and we may add 822| | * multiple copies of the data. 823| | * In this case, use a mutex to prevent the race. 824| | * Use a specific mutex to avoid nested locks of the global mutex. 825| | */ 826| |#if MAP_IMPLEMENTATION==MAP_STDIO 827| | static UMutex extendICUDataMutex; 828| | umtx_lock(&extendICUDataMutex); 829| |#endif 830| 634| if(!umtx_loadAcquire(gHaveTriedToLoadCommonData)) { ------------------ | Branch (830:8): [True: 1, False: 633] ------------------ 831| | /* See if we can explicitly open a .dat file for the ICUData. */ 832| 1| pData = openCommonData( 833| 1| U_ICUDATA_NAME, /* "icudt20l" , for example. */ ------------------ | | 154| 1|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 1|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 834| 1| -1, /* Pretend we're not opening ICUData */ 835| 1| pErr); 836| | 837| | /* How about if there is no pData, eh... */ 838| | 839| 1| UDataMemory_init(©PData); ------------------ | | 80| 1|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 840| 1| if(pData != nullptr) { ------------------ | Branch (840:11): [True: 0, False: 1] ------------------ 841| 0| UDatamemory_assign(©PData, pData); ------------------ | | 84| 0|#define UDatamemory_assign U_ICU_ENTRY_POINT_RENAME(UDatamemory_assign) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 842| 0| copyPData.map = nullptr; /* The mapping for this data is owned by the hash table */ 843| 0| copyPData.mapAddr = nullptr; /* which will unmap it when ICU is shut down. */ 844| | /* CommonICUData is also unmapped when ICU is shut down.*/ 845| | /* To avoid unmapping the data twice, zero out the map */ 846| | /* fields in the UDataMemory that we're assigning */ 847| | /* to CommonICUData. */ 848| | 849| 0| didUpdate = /* no longer using this result */ 850| 0| setCommonICUData(©PData,/* The new common data. */ 851| 0| false, /* No warnings if write didn't happen */ 852| 0| pErr); /* setCommonICUData honors errors; NOP if error set */ 853| 0| } 854| | 855| 1| umtx_storeRelease(gHaveTriedToLoadCommonData, 1); 856| 1| } 857| | 858| 634| didUpdate = findCommonICUDataByName(U_ICUDATA_NAME, *pErr); /* Return 'true' when a racing writes out the extended */ ------------------ | | 154| 634|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 634|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 859| | /* data after another thread has failed to see it (in openCommonData), so */ 860| | /* extended data can be examined. */ 861| | /* Also handles a race through here before gHaveTriedToLoadCommonData is set. */ 862| | 863| |#if MAP_IMPLEMENTATION==MAP_STDIO 864| | umtx_unlock(&extendICUDataMutex); 865| |#endif 866| 634| return didUpdate; /* Return true if ICUData pointer was updated. */ 867| | /* (Could potentially have been done by another thread racing */ 868| | /* us through here, but that's fine, we still return true */ 869| | /* so that current thread will also examine extended data. */ 870| 634|} udata.cpp:_ZL23findCommonICUDataByNamePKcR10UErrorCode: 144| 634|{ 145| 634| UBool found = false; 146| 634| int32_t i; 147| | 148| 634| UDataMemory *pData = udata_findCachedData(inBasename, err); 149| 634| if (U_FAILURE(err) || pData == nullptr) ------------------ | Branch (149:9): [True: 1, False: 633] | Branch (149:27): [True: 633, False: 0] ------------------ 150| 634| return false; 151| | 152| 0| { 153| 0| Mutex lock; 154| 0| for (i = 0; i < UPRV_LENGTHOF(gCommonICUDataArray); ++i) { ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (154:21): [True: 0, False: 0] ------------------ 155| 0| if ((gCommonICUDataArray[i] != nullptr) && (gCommonICUDataArray[i]->pHeader == pData->pHeader)) { ------------------ | Branch (155:17): [True: 0, False: 0] | Branch (155:56): [True: 0, False: 0] ------------------ 156| | /* The data pointer is already in the array. */ 157| 0| found = true; 158| 0| break; 159| 0| } 160| 0| } 161| 0| } 162| 0| return found; 163| 634|} UDataMemory_init_78: 28| 1.42k|U_CFUNC void UDataMemory_init(UDataMemory *This) { 29| 1.42k| uprv_memset(This, 0, sizeof(UDataMemory)); ------------------ | | 100| 1.42k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 1.42k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 30| 1.42k| This->length=-1; 31| 1.42k|} UDatamemory_assign_78: 34| 1|U_CFUNC void UDatamemory_assign(UDataMemory *dest, UDataMemory *source) { 35| | /* UDataMemory Assignment. Destination UDataMemory must be initialized first. */ 36| 1| UBool mallocedFlag = dest->heapAllocated; 37| 1| uprv_memcpy(dest, source, sizeof(UDataMemory)); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 38| 1| dest->heapAllocated = mallocedFlag; 39| 1|} UDataMemory_createNewInstance_78: 41| 77|U_CFUNC UDataMemory *UDataMemory_createNewInstance(UErrorCode *pErr) { 42| 77| UDataMemory *This; 43| | 44| 77| if (U_FAILURE(*pErr)) { ------------------ | Branch (44:9): [True: 0, False: 77] ------------------ 45| 0| return nullptr; 46| 0| } 47| 77| This = (UDataMemory *)uprv_malloc(sizeof(UDataMemory)); ------------------ | | 1524| 77|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 77|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 77|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 77|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 48| 77| if (This == nullptr) { ------------------ | Branch (48:9): [True: 0, False: 77] ------------------ 49| 0| *pErr = U_MEMORY_ALLOCATION_ERROR; } 50| 77| else { 51| 77| UDataMemory_init(This); ------------------ | | 80| 77|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 77|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 77|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 77|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 52| 77| This->heapAllocated = true; 53| 77| } 54| 77| return This; 55| 77|} UDataMemory_normalizeDataPointer_78: 59| 1|UDataMemory_normalizeDataPointer(const void *p) { 60| | /* allow the data to be optionally prepended with an alignment-forcing double value */ 61| 1| const DataHeader *pdh = (const DataHeader *)p; 62| 1| if(pdh==nullptr || (pdh->dataHeader.magic1==0xda && pdh->dataHeader.magic2==0x27)) { ------------------ | Branch (62:8): [True: 0, False: 1] | Branch (62:25): [True: 1, False: 0] | Branch (62:57): [True: 1, False: 0] ------------------ 63| 1| return pdh; 64| 1| } else { 65| |#if U_PLATFORM == U_PF_OS400 66| | /* 67| | TODO: Fix this once the compiler implements this feature. Keep in sync with genccode.c 68| | 69| | This is here because this platform can't currently put 70| | const data into the read-only pages of an object or 71| | shared library (service program). Only strings are allowed in read-only 72| | pages, so we use char * strings to store the data. 73| | 74| | In order to prevent the beginning of the data from ever matching the 75| | magic numbers we must skip the initial double. 76| | [grhoten 4/24/2003] 77| | */ 78| | return (const DataHeader *)*((const void **)p+1); 79| |#else 80| 0| return (const DataHeader *)((const double *)p+1); 81| 0|#endif 82| 0| } 83| 1|} UDataMemory_setData_78: 86| 1|U_CFUNC void UDataMemory_setData (UDataMemory *This, const void *dataAddr) { 87| 1| This->pHeader = UDataMemory_normalizeDataPointer(dataAddr); ------------------ | | 82| 1|#define UDataMemory_normalizeDataPointer U_ICU_ENTRY_POINT_RENAME(UDataMemory_normalizeDataPointer) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 88| 1|} udata_close_78: 92| 7.71k|udata_close(UDataMemory *pData) { 93| 7.71k| if(pData!=nullptr) { ------------------ | Branch (93:8): [True: 0, False: 7.71k] ------------------ 94| 0| uprv_unmapFile(pData); ------------------ | | 1554| 0|#define uprv_unmapFile U_ICU_ENTRY_POINT_RENAME(uprv_unmapFile) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 95| 0| if(pData->heapAllocated ) { ------------------ | Branch (95:12): [True: 0, False: 0] ------------------ 96| 0| uprv_free(pData); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 97| 0| } else { 98| 0| UDataMemory_init(pData); ------------------ | | 80| 0|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 99| 0| } 100| 0| } 101| 7.71k|} udata_getMemory_78: 104| 76|udata_getMemory(UDataMemory *pData) { 105| 76| if(pData!=nullptr && pData->pHeader!=nullptr) { ------------------ | Branch (105:8): [True: 76, False: 0] | Branch (105:26): [True: 76, False: 0] ------------------ 106| 76| return (char *)(pData->pHeader)+udata_getHeaderSize(pData->pHeader); ------------------ | | 887| 76|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 76|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 76|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 76|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 76| } else { 108| 0| return nullptr; 109| 0| } 110| 76|} udata_getLength_78: 133| 1|udata_getLength(const UDataMemory *pData) { 134| 1| if(pData!=nullptr && pData->pHeader!=nullptr && pData->length>=0) { ------------------ | Branch (134:8): [True: 1, False: 0] | Branch (134:26): [True: 1, False: 0] | Branch (134:53): [True: 1, False: 0] ------------------ 135| | /* 136| | * subtract the header size, 137| | * return only the size of the actual data starting at udata_getMemory() 138| | */ 139| 1| return pData->length-udata_getHeaderSize(pData->pHeader); ------------------ | | 887| 1|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 140| 1| } else { 141| 0| return -1; 142| 0| } 143| 1|} UDataMemory_isLoaded_78: 159| 2|U_CFUNC UBool UDataMemory_isLoaded(const UDataMemory *This) { 160| 2| return This->pHeader != nullptr; 161| 2|} uhash_open_78: 547| 41| UErrorCode *status) { 548| | 549| 41| return _uhash_create(keyHash, keyComp, valueComp, DEFAULT_PRIME_INDEX, status); ------------------ | | 91| 41|#define DEFAULT_PRIME_INDEX 4 ------------------ 550| 41|} uhash_openSize_78: 557| 1.28M| UErrorCode *status) { 558| | 559| | /* Find the smallest index i for which PRIMES[i] >= size. */ 560| 1.28M| int32_t i = 0; 561| 3.00M| while (i<(PRIMES_LENGTH-1) && PRIMES[i]elements != nullptr) { ------------------ | Branch (599:9): [True: 58.2M, False: 0] ------------------ 600| 58.2M| if (hash->keyDeleter != nullptr || hash->valueDeleter != nullptr) { ------------------ | Branch (600:13): [True: 58.2M, False: 0] | Branch (600:44): [True: 0, False: 0] ------------------ 601| 58.2M| int32_t pos=UHASH_FIRST; ------------------ | | 610| 58.2M|#define UHASH_FIRST (-1) ------------------ 602| 58.2M| UHashElement *e; 603| 111M| while ((e = (UHashElement*) uhash_nextElement(hash, &pos)) != nullptr) { ------------------ | | 1029| 111M|#define uhash_nextElement U_ICU_ENTRY_POINT_RENAME(uhash_nextElement) | | ------------------ | | | | 123| 111M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 111M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 111M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (603:20): [True: 53.0M, False: 58.2M] ------------------ 604| 53.0M| HASH_DELETE_KEY_VALUE(hash, e->key.pointer, e->value.pointer); ------------------ | | 124| 53.0M|#define HASH_DELETE_KEY_VALUE(hash, keypointer, valuepointer) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 53.0M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 125| 53.0M| if (hash->keyDeleter != nullptr && keypointer != nullptr) { \ | | ------------------ | | | Branch (125:9): [True: 53.0M, False: 0] | | | Branch (125:40): [True: 53.0M, False: 0] | | ------------------ | | 126| 53.0M| (*hash->keyDeleter)(keypointer); \ | | 127| 53.0M| } \ | | 128| 53.0M| if (hash->valueDeleter != nullptr && valuepointer != nullptr) { \ | | ------------------ | | | Branch (128:9): [True: 37.0M, False: 15.9M] | | | Branch (128:42): [True: 37.0M, False: 0] | | ------------------ | | 129| 37.0M| (*hash->valueDeleter)(valuepointer); \ | | 130| 37.0M| } \ | | 131| 53.0M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 53.0M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 605| 53.0M| } 606| 58.2M| } 607| 58.2M| uprv_free(hash->elements); ------------------ | | 1503| 58.2M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 58.2M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 58.2M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 58.2M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 608| 58.2M| hash->elements = nullptr; 609| 58.2M| } 610| 58.2M| if (hash->allocated) { ------------------ | Branch (610:9): [True: 1.28M, False: 56.9M] ------------------ 611| 1.28M| uprv_free(hash); ------------------ | | 1503| 1.28M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.28M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.28M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.28M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 612| 1.28M| } 613| 58.2M|} uhash_setKeyDeleter_78: 636| 58.2M|uhash_setKeyDeleter(UHashtable *hash, UObjectDeleter *fn) { 637| 58.2M| UObjectDeleter *result = hash->keyDeleter; 638| 58.2M| hash->keyDeleter = fn; 639| 58.2M| return result; 640| 58.2M|} uhash_setValueDeleter_78: 643| 56.9M|uhash_setValueDeleter(UHashtable *hash, UObjectDeleter *fn) { 644| 56.9M| UObjectDeleter *result = hash->valueDeleter; 645| 56.9M| hash->valueDeleter = fn; 646| 56.9M| return result; 647| 56.9M|} uhash_count_78: 659| 8.88M|uhash_count(const UHashtable *hash) { 660| 8.88M| return hash->count; 661| 8.88M|} uhash_get_78: 665| 12.9k| const void* key) { 666| 12.9k| UHashTok keyholder; 667| 12.9k| keyholder.pointer = (void*) key; 668| 12.9k| return _uhash_find(hash, keyholder, hash->keyHasher(keyholder))->value.pointer; 669| 12.9k|} uhash_put_78: 721| 60.2M| UErrorCode *status) { 722| 60.2M| UHashTok keyholder, valueholder; 723| 60.2M| keyholder.pointer = key; 724| 60.2M| valueholder.pointer = value; 725| 60.2M| return _uhash_put(hash, keyholder, valueholder, 726| 60.2M| HINT_KEY_POINTER | HINT_VALUE_POINTER, ------------------ | | 139| 60.2M|#define HINT_KEY_POINTER (1) ------------------ HINT_KEY_POINTER | HINT_VALUE_POINTER, ------------------ | | 140| 60.2M|#define HINT_VALUE_POINTER (2) ------------------ 727| 60.2M| status).pointer; 728| 60.2M|} uhash_puti_78: 747| 15.9M| UErrorCode *status) { 748| 15.9M| UHashTok keyholder, valueholder; 749| 15.9M| keyholder.pointer = key; 750| 15.9M| valueholder.integer = value; 751| 15.9M| return _uhash_put(hash, keyholder, valueholder, 752| 15.9M| HINT_KEY_POINTER, ------------------ | | 139| 15.9M|#define HINT_KEY_POINTER (1) ------------------ 753| 15.9M| status).integer; 754| 15.9M|} uhash_removeAll_78: 830| 22.3M|uhash_removeAll(UHashtable *hash) { 831| 22.3M| int32_t pos = UHASH_FIRST; ------------------ | | 610| 22.3M|#define UHASH_FIRST (-1) ------------------ 832| 22.3M| const UHashElement *e; 833| 22.3M| U_ASSERT(hash != nullptr); ------------------ | | 35| 22.3M|# define U_ASSERT(exp) (void)0 ------------------ 834| 22.3M| if (hash->count != 0) { ------------------ | Branch (834:9): [True: 8.98M, False: 13.3M] ------------------ 835| 27.9M| while ((e = uhash_nextElement(hash, &pos)) != nullptr) { ------------------ | | 1029| 27.9M|#define uhash_nextElement U_ICU_ENTRY_POINT_RENAME(uhash_nextElement) | | ------------------ | | | | 123| 27.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 27.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 27.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (835:16): [True: 19.0M, False: 8.98M] ------------------ 836| 19.0M| uhash_removeElement(hash, e); ------------------ | | 1037| 19.0M|#define uhash_removeElement U_ICU_ENTRY_POINT_RENAME(uhash_removeElement) | | ------------------ | | | | 123| 19.0M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 19.0M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 19.0M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 837| 19.0M| } 838| 8.98M| } 839| 22.3M| U_ASSERT(hash->count == 0); ------------------ | | 35| 22.3M|# define U_ASSERT(exp) (void)0 ------------------ 840| 22.3M|} uhash_find_78: 866| 123M|uhash_find(const UHashtable *hash, const void* key) { 867| 123M| UHashTok keyholder; 868| 123M| const UHashElement *e; 869| 123M| keyholder.pointer = (void*) key; 870| 123M| e = _uhash_find(hash, keyholder, hash->keyHasher(keyholder)); 871| 123M| return IS_EMPTY_OR_DELETED(e->hashcode) ? nullptr : e; ------------------ | | 120| 123M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) | | ------------------ | | | Branch (120:32): [True: 15.9M, False: 107M] | | ------------------ ------------------ 872| 123M|} uhash_nextElement_78: 875| 233M|uhash_nextElement(const UHashtable *hash, int32_t *pos) { 876| | /* Walk through the array until we find an element that is not 877| | * EMPTY and not DELETED. 878| | */ 879| 233M| int32_t i; 880| 233M| U_ASSERT(hash != nullptr); ------------------ | | 35| 233M|# define U_ASSERT(exp) (void)0 ------------------ 881| 13.5G| for (i = *pos + 1; i < hash->length; ++i) { ------------------ | Branch (881:24): [True: 13.4G, False: 105M] ------------------ 882| 13.4G| if (!IS_EMPTY_OR_DELETED(hash->elements[i].hashcode)) { ------------------ | | 120| 13.4G|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (882:13): [True: 127M, False: 13.2G] ------------------ 883| 127M| *pos = i; 884| 127M| return &(hash->elements[i]); 885| 127M| } 886| 13.4G| } 887| | 888| | /* No more elements */ 889| 105M| return nullptr; 890| 233M|} uhash_removeElement_78: 893| 19.0M|uhash_removeElement(UHashtable *hash, const UHashElement* e) { 894| 19.0M| U_ASSERT(hash != nullptr); ------------------ | | 35| 19.0M|# define U_ASSERT(exp) (void)0 ------------------ 895| 19.0M| U_ASSERT(e != nullptr); ------------------ | | 35| 19.0M|# define U_ASSERT(exp) (void)0 ------------------ 896| 19.0M| if (!IS_EMPTY_OR_DELETED(e->hashcode)) { ------------------ | | 120| 19.0M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (896:9): [True: 19.0M, False: 0] ------------------ 897| 19.0M| UHashElement *nce = (UHashElement *)e; 898| 19.0M| return _uhash_internalRemoveElement(hash, nce).pointer; 899| 19.0M| } 900| 0| return nullptr; 901| 19.0M|} uhash_hashChars_78: 938| 19.7k|uhash_hashChars(const UHashTok key) { 939| 19.7k| const char *s = (const char *)key.pointer; 940| 19.7k| return s == nullptr ? 0 : static_cast(ustr_hashCharsN(s, static_cast(uprv_strlen(s)))); ------------------ | | 1878| 19.7k|#define ustr_hashCharsN U_ICU_ENTRY_POINT_RENAME(ustr_hashCharsN) | | ------------------ | | | | 123| 19.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 19.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 19.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return s == nullptr ? 0 : static_cast(ustr_hashCharsN(s, static_cast(uprv_strlen(s)))); ------------------ | | 37| 19.7k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 19.7k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (940:12): [True: 8, False: 19.7k] ------------------ 941| 19.7k|} uhash_hashIStringView_78: 950| 5.23k|uhash_hashIStringView(const UHashTok key) { 951| 5.23k| const std::string_view* s = static_cast(key.pointer); 952| 5.23k| return s == nullptr ? 0 : ustr_hashICharsN(s->data(), static_cast(s->size())); ------------------ | | 1879| 5.23k|#define ustr_hashICharsN U_ICU_ENTRY_POINT_RENAME(ustr_hashICharsN) | | ------------------ | | | | 123| 5.23k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.23k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.23k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (952:12): [True: 0, False: 5.23k] ------------------ 953| 5.23k|} uhash_compareChars_78: 1029| 14.8k|uhash_compareChars(const UHashTok key1, const UHashTok key2) { 1030| 14.8k| const char *p1 = (const char*) key1.pointer; 1031| 14.8k| const char *p2 = (const char*) key2.pointer; 1032| 14.8k| if (p1 == p2) { ------------------ | Branch (1032:9): [True: 2, False: 14.8k] ------------------ 1033| 2| return true; 1034| 2| } 1035| 14.8k| if (p1 == nullptr || p2 == nullptr) { ------------------ | Branch (1035:9): [True: 0, False: 14.8k] | Branch (1035:26): [True: 0, False: 14.8k] ------------------ 1036| 0| return false; 1037| 0| } 1038| 158k| while (*p1 != 0 && *p1 == *p2) { ------------------ | Branch (1038:12): [True: 143k, False: 14.8k] | Branch (1038:24): [True: 143k, False: 7] ------------------ 1039| 143k| ++p1; 1040| 143k| ++p2; 1041| 143k| } 1042| 14.8k| return *p1 == *p2; 1043| 14.8k|} uhash_compareIStringView_78: 1063| 1.48k|uhash_compareIStringView(const UHashTok key1, const UHashTok key2) { 1064| 1.48k| const std::string_view* p1 = static_cast(key1.pointer); 1065| 1.48k| const std::string_view* p2 = static_cast(key2.pointer); 1066| 1.48k| if (p1 == p2) { ------------------ | Branch (1066:9): [True: 0, False: 1.48k] ------------------ 1067| 0| return true; 1068| 0| } 1069| 1.48k| if (p1 == nullptr || p2 == nullptr) { ------------------ | Branch (1069:9): [True: 0, False: 1.48k] | Branch (1069:26): [True: 0, False: 1.48k] ------------------ 1070| 0| return false; 1071| 0| } 1072| 1.48k| const std::string_view& v1 = *p1; 1073| 1.48k| const std::string_view& v2 = *p2; 1074| 1.48k| if (v1.size() != v2.size()) { ------------------ | Branch (1074:9): [True: 0, False: 1.48k] ------------------ 1075| 0| return false; 1076| 0| } 1077| 6.91k| for (size_t i = 0; i < v1.size(); ++i) { ------------------ | Branch (1077:24): [True: 5.48k, False: 1.43k] ------------------ 1078| 5.48k| if (uprv_tolower(v1[i]) != uprv_tolower(v2[i])) { ------------------ | | 68| 5.48k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 5.48k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 5.48k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 5.48k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 5.48k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (uprv_tolower(v1[i]) != uprv_tolower(v2[i])) { ------------------ | | 68| 5.48k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 5.48k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 5.48k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 5.48k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 5.48k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1078:13): [True: 55, False: 5.43k] ------------------ 1079| 55| return false; 1080| 55| } 1081| 5.48k| } 1082| 1.43k| return true; 1083| 1.48k|} uhash.cpp:_ZL13_uhash_createPFi8UElementEPFaS_S_ES3_iP10UErrorCode: 287| 1.28M| UErrorCode *status) { 288| 1.28M| UHashtable *result; 289| | 290| 1.28M| if (U_FAILURE(*status)) return nullptr; ------------------ | Branch (290:9): [True: 0, False: 1.28M] ------------------ 291| | 292| 1.28M| result = static_cast(uprv_malloc(sizeof(UHashtable))); ------------------ | | 1524| 1.28M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.28M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.28M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.28M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 293| 1.28M| if (result == nullptr) { ------------------ | Branch (293:9): [True: 0, False: 1.28M] ------------------ 294| 0| *status = U_MEMORY_ALLOCATION_ERROR; 295| 0| return nullptr; 296| 0| } 297| | 298| 1.28M| _uhash_init(result, keyHash, keyComp, valueComp, primeIndex, status); 299| 1.28M| result->allocated = true; 300| | 301| 1.28M| if (U_FAILURE(*status)) { ------------------ | Branch (301:9): [True: 0, False: 1.28M] ------------------ 302| 0| uprv_free(result); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 303| 0| return nullptr; 304| 0| } 305| | 306| 1.28M| return result; 307| 1.28M|} uhash.cpp:_ZL11_uhash_initP10UHashtablePFi8UElementEPFaS1_S1_ES5_iP10UErrorCode: 260| 58.2M|{ 261| 58.2M| if (U_FAILURE(*status)) return nullptr; ------------------ | Branch (261:9): [True: 0, False: 58.2M] ------------------ 262| 58.2M| U_ASSERT(keyHash != nullptr); ------------------ | | 35| 58.2M|# define U_ASSERT(exp) (void)0 ------------------ 263| 58.2M| U_ASSERT(keyComp != nullptr); ------------------ | | 35| 58.2M|# define U_ASSERT(exp) (void)0 ------------------ 264| | 265| 58.2M| result->keyHasher = keyHash; 266| 58.2M| result->keyComparator = keyComp; 267| 58.2M| result->valueComparator = valueComp; 268| 58.2M| result->keyDeleter = nullptr; 269| 58.2M| result->valueDeleter = nullptr; 270| 58.2M| result->allocated = false; 271| 58.2M| _uhash_internalSetResizePolicy(result, U_GROW); 272| | 273| 58.2M| _uhash_allocate(result, primeIndex, status); 274| | 275| 58.2M| if (U_FAILURE(*status)) { ------------------ | Branch (275:9): [True: 0, False: 58.2M] ------------------ 276| 0| return nullptr; 277| 0| } 278| | 279| 58.2M| return result; 280| 58.2M|} uhash.cpp:_ZL15_uhash_allocateP10UHashtableiP10UErrorCode: 217| 58.4M| UErrorCode *status) { 218| | 219| 58.4M| UHashElement *p, *limit; 220| 58.4M| UHashTok emptytok; 221| | 222| 58.4M| if (U_FAILURE(*status)) return; ------------------ | Branch (222:9): [True: 0, False: 58.4M] ------------------ 223| | 224| 58.4M| U_ASSERT(primeIndex >= 0 && primeIndex < PRIMES_LENGTH); ------------------ | | 35| 58.4M|# define U_ASSERT(exp) (void)0 ------------------ 225| | 226| 58.4M| hash->primeIndex = static_cast(primeIndex); 227| 58.4M| hash->length = PRIMES[primeIndex]; 228| | 229| 58.4M| p = hash->elements = static_cast( 230| 58.4M| uprv_malloc(sizeof(UHashElement) * hash->length)); ------------------ | | 1524| 58.4M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 58.4M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 58.4M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 58.4M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 231| | 232| 58.4M| if (hash->elements == nullptr) { ------------------ | Branch (232:9): [True: 0, False: 58.4M] ------------------ 233| 0| *status = U_MEMORY_ALLOCATION_ERROR; 234| 0| return; 235| 0| } 236| | 237| 58.4M| emptytok.pointer = nullptr; /* Only one of these two is needed */ 238| 58.4M| emptytok.integer = 0; /* but we don't know which one. */ 239| | 240| 58.4M| limit = p + hash->length; 241| 7.44G| while (p < limit) { ------------------ | Branch (241:12): [True: 7.38G, False: 58.4M] ------------------ 242| 7.38G| p->key = emptytok; 243| 7.38G| p->value = emptytok; 244| 7.38G| p->hashcode = HASH_EMPTY; ------------------ | | 118| 7.38G|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 7.38G|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ 245| 7.38G| ++p; 246| 7.38G| } 247| | 248| 58.4M| hash->count = 0; 249| 58.4M| hash->lowWaterMark = static_cast(hash->length * hash->lowWaterRatio); 250| 58.4M| hash->highWaterMark = static_cast(hash->length * hash->highWaterRatio); 251| 58.4M|} uhash.cpp:_ZL30_uhash_internalSetResizePolicyP10UHashtable17UHashResizePolicy: 197| 58.2M|_uhash_internalSetResizePolicy(UHashtable *hash, enum UHashResizePolicy policy) { 198| 58.2M| U_ASSERT(hash != nullptr); ------------------ | | 35| 58.2M|# define U_ASSERT(exp) (void)0 ------------------ 199| 58.2M| U_ASSERT(((int32_t)policy) >= 0); ------------------ | | 35| 58.2M|# define U_ASSERT(exp) (void)0 ------------------ 200| 58.2M| U_ASSERT(((int32_t)policy) < 3); ------------------ | | 35| 58.2M|# define U_ASSERT(exp) (void)0 ------------------ 201| 58.2M| hash->lowWaterRatio = RESIZE_POLICY_RATIO_TABLE[policy * 2]; 202| 58.2M| hash->highWaterRatio = RESIZE_POLICY_RATIO_TABLE[policy * 2 + 1]; 203| 58.2M|} uhash.cpp:_ZL13_uhash_rehashP10UHashtableP10UErrorCode: 399| 177k|_uhash_rehash(UHashtable *hash, UErrorCode *status) { 400| | 401| 177k| UHashElement *old = hash->elements; 402| 177k| int32_t oldLength = hash->length; 403| 177k| int32_t newPrimeIndex = hash->primeIndex; 404| 177k| int32_t i; 405| | 406| 177k| if (hash->count > hash->highWaterMark) { ------------------ | Branch (406:9): [True: 177k, False: 0] ------------------ 407| 177k| if (++newPrimeIndex >= PRIMES_LENGTH) { ------------------ | | 90| 177k|#define PRIMES_LENGTH UPRV_LENGTHOF(PRIMES) | | ------------------ | | | | 99| 177k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) | | ------------------ ------------------ | Branch (407:13): [True: 0, False: 177k] ------------------ 408| 0| return; 409| 0| } 410| 177k| } else if (hash->count < hash->lowWaterMark) { ------------------ | Branch (410:16): [True: 0, False: 0] ------------------ 411| 0| if (--newPrimeIndex < 0) { ------------------ | Branch (411:13): [True: 0, False: 0] ------------------ 412| 0| return; 413| 0| } 414| 0| } else { 415| 0| return; 416| 0| } 417| | 418| 177k| _uhash_allocate(hash, newPrimeIndex, status); 419| | 420| 177k| if (U_FAILURE(*status)) { ------------------ | Branch (420:9): [True: 0, False: 177k] ------------------ 421| 0| hash->elements = old; 422| 0| hash->length = oldLength; 423| 0| return; 424| 0| } 425| | 426| 8.52M| for (i = oldLength - 1; i >= 0; --i) { ------------------ | Branch (426:29): [True: 8.35M, False: 177k] ------------------ 427| 8.35M| if (!IS_EMPTY_OR_DELETED(old[i].hashcode)) { ------------------ | | 120| 8.35M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (427:13): [True: 4.26M, False: 4.08M] ------------------ 428| 4.26M| UHashElement *e = _uhash_find(hash, old[i].key, old[i].hashcode); 429| 4.26M| U_ASSERT(e != nullptr); ------------------ | | 35| 4.26M|# define U_ASSERT(exp) (void)0 ------------------ 430| 4.26M| U_ASSERT(e->hashcode == HASH_EMPTY); ------------------ | | 35| 4.26M|# define U_ASSERT(exp) (void)0 ------------------ 431| 4.26M| e->key = old[i].key; 432| 4.26M| e->value = old[i].value; 433| 4.26M| e->hashcode = old[i].hashcode; 434| 4.26M| ++hash->count; 435| 4.26M| } 436| 8.35M| } 437| | 438| 177k| uprv_free(old); ------------------ | | 1503| 177k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 177k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 177k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 177k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 439| 177k|} uhash.cpp:_ZL11_uhash_findPK10UHashtable8UElementi: 339| 204M| int32_t hashcode) { 340| | 341| 204M| int32_t firstDeleted = -1; /* assume invalid index */ 342| 204M| int32_t theIndex, startIndex; 343| 204M| int32_t jump = 0; /* lazy evaluate */ 344| 204M| int32_t tableHash; 345| 204M| UHashElement *elements = hash->elements; 346| | 347| 204M| hashcode &= 0x7FFFFFFF; /* must be positive */ 348| 204M| startIndex = theIndex = (hashcode ^ 0x4000000) % hash->length; 349| | 350| 231M| do { 351| 231M| tableHash = elements[theIndex].hashcode; 352| 231M| if (tableHash == hashcode) { /* quick check */ ------------------ | Branch (352:13): [True: 117M, False: 113M] ------------------ 353| 117M| if ((*hash->keyComparator)(key, elements[theIndex].key)) { ------------------ | Branch (353:17): [True: 111M, False: 6.07M] ------------------ 354| 111M| return &(elements[theIndex]); 355| 111M| } 356| 117M| } else if (!IS_EMPTY_OR_DELETED(tableHash)) { ------------------ | | 120| 113M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (356:20): [True: 11.7M, False: 101M] ------------------ 357| | /* We have hit a slot which contains a key-value pair, 358| | * but for which the hash code does not match. Keep 359| | * looking. 360| | */ 361| 101M| } else if (tableHash == HASH_EMPTY) { /* empty, end o' the line */ ------------------ | | 118| 101M|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 101M|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ | Branch (361:20): [True: 92.2M, False: 9.12M] ------------------ 362| 92.2M| break; 363| 92.2M| } else if (firstDeleted < 0) { /* remember first deleted */ ------------------ | Branch (363:20): [True: 5.35M, False: 3.77M] ------------------ 364| 5.35M| firstDeleted = theIndex; 365| 5.35M| } 366| 26.9M| if (jump == 0) { /* lazy compute jump */ ------------------ | Branch (366:13): [True: 12.8M, False: 14.1M] ------------------ 367| | /* The jump value must be relatively prime to the table 368| | * length. As long as the length is prime, then any value 369| | * 1..length-1 will be relatively prime to it. 370| | */ 371| 12.8M| jump = (hashcode % (hash->length - 1)) + 1; 372| 12.8M| } 373| 26.9M| theIndex = (theIndex + jump) % hash->length; 374| 26.9M| } while (theIndex != startIndex); ------------------ | Branch (374:14): [True: 26.9M, False: 777] ------------------ 375| | 376| 92.2M| if (firstDeleted >= 0) { ------------------ | Branch (376:9): [True: 5.35M, False: 86.9M] ------------------ 377| 5.35M| theIndex = firstDeleted; /* reset if had deleted slot */ 378| 86.9M| } else if (tableHash != HASH_EMPTY) { ------------------ | | 118| 86.9M|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 86.9M|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ | Branch (378:16): [True: 0, False: 86.9M] ------------------ 379| | /* We get to this point if the hashtable is full (no empty or 380| | * deleted slots), and we've failed to find a match. THIS 381| | * WILL NEVER HAPPEN as long as uhash_put() makes sure that 382| | * count is always < length. 383| | */ 384| 0| UPRV_UNREACHABLE_EXIT; ------------------ | | 68| 0|# define UPRV_UNREACHABLE_EXIT abort() ------------------ 385| 0| } 386| 92.2M| return &(elements[theIndex]); 387| 92.2M|} uhash.cpp:_ZL10_uhash_putP10UHashtable8UElementS1_aP10UErrorCode: 471| 76.1M| UErrorCode *status) { 472| | 473| | /* Put finds the position in the table for the new value. If the 474| | * key is already in the table, it is deleted, if there is a 475| | * non-nullptr keyDeleter. Then the key, the hash and the value are 476| | * all put at the position in their respective arrays. 477| | */ 478| 76.1M| int32_t hashcode; 479| 76.1M| UHashElement* e; 480| 76.1M| UHashTok emptytok; 481| | 482| 76.1M| if (U_FAILURE(*status)) { ------------------ | Branch (482:9): [True: 0, False: 76.1M] ------------------ 483| 0| goto err; 484| 0| } 485| 76.1M| U_ASSERT(hash != nullptr); ------------------ | | 35| 76.1M|# define U_ASSERT(exp) (void)0 ------------------ 486| 76.1M| if ((hint & HINT_VALUE_POINTER) ? ------------------ | | 140| 76.1M|#define HINT_VALUE_POINTER (2) ------------------ | Branch (486:9): [True: 60.2M, False: 15.9M] | Branch (486:9): [True: 0, False: 76.1M] ------------------ 487| 60.2M| value.pointer == nullptr : 488| 76.1M| value.integer == 0 && (hint & HINT_ALLOW_ZERO) == 0) { ------------------ | | 141| 0|#define HINT_ALLOW_ZERO (4) ------------------ | Branch (488:13): [True: 0, False: 15.9M] | Branch (488:35): [True: 0, False: 0] ------------------ 489| | /* Disallow storage of nullptr values, since nullptr is returned by 490| | * get() to indicate an absent key. Storing nullptr == removing. 491| | */ 492| 0| return _uhash_remove(hash, key); 493| 0| } 494| 76.1M| if (hash->count > hash->highWaterMark) { ------------------ | Branch (494:9): [True: 177k, False: 76.0M] ------------------ 495| 177k| _uhash_rehash(hash, status); 496| 177k| if (U_FAILURE(*status)) { ------------------ | Branch (496:13): [True: 0, False: 177k] ------------------ 497| 0| goto err; 498| 0| } 499| 177k| } 500| | 501| 76.1M| hashcode = (*hash->keyHasher)(key); 502| 76.1M| e = _uhash_find(hash, key, hashcode); 503| 76.1M| U_ASSERT(e != nullptr); ------------------ | | 35| 76.1M|# define U_ASSERT(exp) (void)0 ------------------ 504| | 505| 76.1M| if (IS_EMPTY_OR_DELETED(e->hashcode)) { ------------------ | | 120| 76.1M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) | | ------------------ | | | Branch (120:32): [True: 72.0M, False: 4.15M] | | ------------------ ------------------ 506| | /* Important: We must never actually fill the table up. If we 507| | * do so, then _uhash_find() will return nullptr, and we'll have 508| | * to check for nullptr after every call to _uhash_find(). To 509| | * avoid this we make sure there is always at least one empty 510| | * or deleted slot in the table. This only is a problem if we 511| | * are out of memory and rehash isn't working. 512| | */ 513| 72.0M| ++hash->count; 514| 72.0M| if (hash->count == hash->length) { ------------------ | Branch (514:13): [True: 0, False: 72.0M] ------------------ 515| | /* Don't allow count to reach length */ 516| 0| --hash->count; 517| 0| *status = U_MEMORY_ALLOCATION_ERROR; 518| 0| goto err; 519| 0| } 520| 72.0M| } 521| | 522| | /* We must in all cases handle storage properly. If there was an 523| | * old key, then it must be deleted (if the deleter != nullptr). 524| | * Make hashcodes stored in table positive. 525| | */ 526| 76.1M| return _uhash_setElement(hash, e, hashcode & 0x7FFFFFFF, key, value, hint); 527| | 528| 0| err: 529| | /* If the deleters are non-nullptr, this method adopts its key and/or 530| | * value arguments, and we must be sure to delete the key and/or 531| | * value in all cases, even upon failure. 532| | */ 533| 0| HASH_DELETE_KEY_VALUE(hash, key.pointer, value.pointer); ------------------ | | 124| 0|#define HASH_DELETE_KEY_VALUE(hash, keypointer, valuepointer) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 125| 0| if (hash->keyDeleter != nullptr && keypointer != nullptr) { \ | | ------------------ | | | Branch (125:9): [True: 0, False: 0] | | | Branch (125:40): [True: 0, False: 0] | | ------------------ | | 126| 0| (*hash->keyDeleter)(keypointer); \ | | 127| 0| } \ | | 128| 0| if (hash->valueDeleter != nullptr && valuepointer != nullptr) { \ | | ------------------ | | | Branch (128:9): [True: 0, False: 0] | | | Branch (128:42): [True: 0, False: 0] | | ------------------ | | 129| 0| (*hash->valueDeleter)(valuepointer); \ | | 130| 0| } \ | | 131| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 534| 0| emptytok.pointer = nullptr; emptytok.integer = 0; 535| 0| return emptytok; 536| 76.1M|} uhash.cpp:_ZL17_uhash_setElementP10UHashtableP12UHashElementi8UElementS3_a: 150| 95.1M| UHashTok key, UHashTok value, int8_t hint) { 151| | 152| 95.1M| UHashTok oldValue = e->value; 153| 95.1M| if (hash->keyDeleter != nullptr && e->key.pointer != nullptr && ------------------ | Branch (153:9): [True: 95.1M, False: 2.47k] | Branch (153:40): [True: 23.1M, False: 72.0M] ------------------ 154| 95.1M| e->key.pointer != key.pointer) { /* Avoid double deletion */ ------------------ | Branch (154:9): [True: 23.1M, False: 0] ------------------ 155| 23.1M| (*hash->keyDeleter)(e->key.pointer); 156| 23.1M| } 157| 95.1M| if (hash->valueDeleter != nullptr) { ------------------ | Branch (157:9): [True: 79.2M, False: 15.9M] ------------------ 158| 79.2M| if (oldValue.pointer != nullptr && ------------------ | Branch (158:13): [True: 23.1M, False: 56.0M] ------------------ 159| 79.2M| oldValue.pointer != value.pointer) { /* Avoid double deletion */ ------------------ | Branch (159:13): [True: 23.1M, False: 0] ------------------ 160| 23.1M| (*hash->valueDeleter)(oldValue.pointer); 161| 23.1M| } 162| 79.2M| oldValue.pointer = nullptr; 163| 79.2M| } 164| | /* Compilers should copy the UHashTok union correctly, but even if 165| | * they do, memory heap tools (e.g. BoundsChecker) can get 166| | * confused when a pointer is cloaked in a union and then copied. 167| | * TO ALLEVIATE THIS, we use hints (based on what API the user is 168| | * calling) to copy pointers when we know the user thinks 169| | * something is a pointer. */ 170| 95.1M| if (hint & HINT_KEY_POINTER) { ------------------ | | 139| 95.1M|#define HINT_KEY_POINTER (1) ------------------ | Branch (170:9): [True: 76.1M, False: 19.0M] ------------------ 171| 76.1M| e->key.pointer = key.pointer; 172| 76.1M| } else { 173| 19.0M| e->key = key; 174| 19.0M| } 175| 95.1M| if (hint & HINT_VALUE_POINTER) { ------------------ | | 140| 95.1M|#define HINT_VALUE_POINTER (2) ------------------ | Branch (175:9): [True: 60.2M, False: 34.9M] ------------------ 176| 60.2M| e->value.pointer = value.pointer; 177| 60.2M| } else { 178| 34.9M| e->value = value; 179| 34.9M| } 180| 95.1M| e->hashcode = hashcode; 181| 95.1M| return oldValue; 182| 95.1M|} uhash.cpp:_ZL28_uhash_internalRemoveElementP10UHashtableP12UHashElement: 188| 19.0M|_uhash_internalRemoveElement(UHashtable *hash, UHashElement* e) { 189| 19.0M| UHashTok empty; 190| 19.0M| U_ASSERT(!IS_EMPTY_OR_DELETED(e->hashcode)); ------------------ | | 35| 19.0M|# define U_ASSERT(exp) (void)0 ------------------ 191| 19.0M| --hash->count; 192| 19.0M| empty.pointer = nullptr; empty.integer = 0; 193| 19.0M| return _uhash_setElement(hash, e, HASH_DELETED, empty, empty, 0); ------------------ | | 117| 19.0M|#define HASH_DELETED ((int32_t) 0x80000000) ------------------ 194| 19.0M|} u_charsToUChars_78: 185| 3.45k|u_charsToUChars(const char *cs, char16_t *us, int32_t length) { 186| 3.45k| char16_t u; 187| 3.45k| uint8_t c; 188| | 189| | /* 190| | * Allow the entire ASCII repertoire to be mapped _to_ Unicode. 191| | * For EBCDIC systems, this works for characters with codes from 192| | * codepages 37 and 1047 or compatible. 193| | */ 194| 85.1k| while(length>0) { ------------------ | Branch (194:11): [True: 81.7k, False: 3.45k] ------------------ 195| 81.7k| c=(uint8_t)(*cs++); 196| 81.7k| u=(char16_t)CHAR_TO_UCHAR(c); ------------------ | | 174| 81.7k|#define CHAR_TO_UCHAR(c) c ------------------ 197| 81.7k| U_ASSERT((u!=0 || c==0)); /* only invariant chars converted? */ ------------------ | | 35| 81.7k|# define U_ASSERT(exp) (void)0 ------------------ 198| 81.7k| *us++=u; 199| 81.7k| --length; 200| 81.7k| } 201| 3.45k|} u_UCharsToChars_78: 204| 39.5k|u_UCharsToChars(const char16_t *us, char *cs, int32_t length) { 205| 39.5k| char16_t u; 206| | 207| 178k| while(length>0) { ------------------ | Branch (207:11): [True: 138k, False: 39.5k] ------------------ 208| 138k| u=*us++; 209| 138k| if(!UCHAR_IS_INVARIANT(u)) { ------------------ | | 168| 138k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 138k, False: 0] | | | Branch (168:47): [True: 138k, False: 0] | | ------------------ ------------------ 210| 0| U_ASSERT(false); /* Variant characters were used. These are not portable in ICU. */ ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 211| 0| u=0; 212| 0| } 213| 138k| *cs++=(char)UCHAR_TO_CHAR(u); ------------------ | | 175| 138k|#define UCHAR_TO_CHAR(c) c ------------------ 214| 138k| --length; 215| 138k| } 216| 39.5k|} uprv_isInvariantUString_78: 263| 64.9k|uprv_isInvariantUString(const char16_t *s, int32_t length) { 264| 64.9k| char16_t c; 265| | 266| 255k| for(;;) { 267| 255k| if(length<0) { ------------------ | Branch (267:12): [True: 0, False: 255k] ------------------ 268| | /* NUL-terminated */ 269| 0| c=*s++; 270| 0| if(c==0) { ------------------ | Branch (270:16): [True: 0, False: 0] ------------------ 271| 0| break; 272| 0| } 273| 255k| } else { 274| | /* count length */ 275| 255k| if(length==0) { ------------------ | Branch (275:16): [True: 64.8k, False: 190k] ------------------ 276| 64.8k| break; 277| 64.8k| } 278| 190k| --length; 279| 190k| c=*s++; 280| 190k| } 281| | 282| | /* 283| | * no assertions here because these functions are legitimately called 284| | * for strings with variant characters 285| | */ 286| 190k| if(!UCHAR_IS_INVARIANT(c)) { ------------------ | | 168| 190k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 190k, False: 47] | | | Branch (168:47): [True: 190k, False: 9] | | ------------------ ------------------ 287| 56| return false; /* found a variant char */ 288| 56| } 289| 190k| } 290| 64.8k| return true; 291| 64.9k|} uprv_compareInvAscii_78: 460| 78.6k| const char16_t *localString, int32_t localLength) { 461| 78.6k| (void)ds; 462| 78.6k| int32_t minLength; 463| 78.6k| UChar32 c1, c2; 464| 78.6k| uint8_t c; 465| | 466| 78.6k| if(outString==nullptr || outLength<-1 || localString==nullptr || localLength<-1) { ------------------ | Branch (466:8): [True: 0, False: 78.6k] | Branch (466:30): [True: 0, False: 78.6k] | Branch (466:46): [True: 0, False: 78.6k] | Branch (466:70): [True: 0, False: 78.6k] ------------------ 467| 0| return 0; 468| 0| } 469| | 470| 78.6k| if(outLength<0) { ------------------ | Branch (470:8): [True: 0, False: 78.6k] ------------------ 471| 0| outLength=(int32_t)uprv_strlen(outString); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 472| 0| } 473| 78.6k| if(localLength<0) { ------------------ | Branch (473:8): [True: 0, False: 78.6k] ------------------ 474| 0| localLength=u_strlen(localString); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 475| 0| } 476| | 477| 78.6k| minLength= outLength0) { ------------------ | Branch (479:11): [True: 203k, False: 413] ------------------ 480| 203k| c=(uint8_t)*outString++; 481| 203k| if(UCHAR_IS_INVARIANT(c)) { ------------------ | | 168| 203k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 203k, False: 0] | | | Branch (168:47): [True: 203k, False: 0] | | ------------------ ------------------ 482| 203k| c1=c; 483| 203k| } else { 484| 0| c1=-1; 485| 0| } 486| | 487| 203k| c2=*localString++; 488| 203k| if(!UCHAR_IS_INVARIANT(c2)) { ------------------ | | 168| 203k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 203k, False: 0] | | | Branch (168:47): [True: 203k, False: 0] | | ------------------ ------------------ 489| 0| c2=-2; 490| 0| } 491| | 492| 203k| if((c1-=c2)!=0) { ------------------ | Branch (492:12): [True: 78.2k, False: 125k] ------------------ 493| 78.2k| return c1; 494| 78.2k| } 495| | 496| 125k| --minLength; 497| 125k| } 498| | 499| | /* strings start with same prefix, compare lengths */ 500| 413| return outLength-localLength; 501| 78.6k|} locale_getKeywordsStart_78: 526| 30.0k|locale_getKeywordsStart(std::string_view localeID) { 527| 30.0k| if (size_t pos = localeID.find('@'); pos != std::string_view::npos) { ------------------ | Branch (527:42): [True: 1.62k, False: 28.4k] ------------------ 528| 1.62k| return localeID.data() + pos; 529| 1.62k| } 530| |#if (U_CHARSET_FAMILY == U_EBCDIC_FAMILY) 531| | else { 532| | /* We do this because the @ sign is variant, and the @ sign used on one 533| | EBCDIC machine won't be compiled the same way on other EBCDIC based 534| | machines. */ 535| | static const uint8_t ebcdicSigns[] = { 0x7C, 0x44, 0x66, 0x80, 0xAC, 0xAE, 0xAF, 0xB5, 0xEC, 0xEF, 0x00 }; 536| | const uint8_t *charToFind = ebcdicSigns; 537| | while(*charToFind) { 538| | if (size_t pos = localeID.find(*charToFind); pos != std::string_view::npos) { 539| | return localeID.data() + pos; 540| | } 541| | charToFind++; 542| | } 543| | } 544| |#endif 545| 28.4k| return nullptr; 546| 30.0k|} _Z26ulocimp_getKeywordValue_78PKcNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEER10UErrorCode: 751| 4.87k|{ 752| 4.87k| return ByteSinkUtil::viaByteSinkToCharString( 753| 4.87k| [&](ByteSink& sink, UErrorCode& status) { 754| 4.87k| ulocimp_getKeywordValue(localeID, keywordName, sink, status); 755| 4.87k| }, 756| 4.87k| status); 757| 4.87k|} _Z26ulocimp_getKeywordValue_78PKcNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERN6icu_788ByteSinkER10UErrorCode: 764| 4.87k|{ 765| 4.87k| if (U_FAILURE(status)) { return; } ------------------ | Branch (765:9): [True: 0, False: 4.87k] ------------------ 766| | 767| 4.87k| if (localeID == nullptr || keywordName.empty()) { ------------------ | Branch (767:9): [True: 0, False: 4.87k] | Branch (767:32): [True: 0, False: 4.87k] ------------------ 768| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 769| 0| return; 770| 0| } 771| | 772| 4.87k| const char* startSearchHere = nullptr; 773| 4.87k| const char* nextSeparator = nullptr; 774| | 775| 4.87k| CharString tempBuffer; 776| 4.87k| const char* tmpLocaleID; 777| | 778| 4.87k| CharString canonKeywordName = locale_canonKeywordName(keywordName, status); 779| 4.87k| if (U_FAILURE(status)) { ------------------ | Branch (779:9): [True: 0, False: 4.87k] ------------------ 780| 0| return; 781| 0| } 782| | 783| 4.87k| if (localeID != nullptr && _hasBCP47Extension(localeID)) { ------------------ | Branch (783:9): [True: 4.87k, False: 0] | Branch (783:32): [True: 0, False: 4.87k] ------------------ 784| 0| tempBuffer = ulocimp_forLanguageTag(localeID, -1, nullptr, status); ------------------ | | 1198| 0|#define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 785| 0| tmpLocaleID = U_SUCCESS(status) && !tempBuffer.isEmpty() ? tempBuffer.data() : localeID; ------------------ | Branch (785:23): [True: 0, False: 0] | Branch (785:44): [True: 0, False: 0] ------------------ 786| 4.87k| } else { 787| 4.87k| tmpLocaleID=localeID; 788| 4.87k| } 789| | 790| 4.87k| startSearchHere = locale_getKeywordsStart(tmpLocaleID); ------------------ | | 138| 4.87k|#define locale_getKeywordsStart U_ICU_ENTRY_POINT_RENAME(locale_getKeywordsStart) | | ------------------ | | | | 123| 4.87k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.87k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.87k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 791| 4.87k| if(startSearchHere == nullptr) { ------------------ | Branch (791:8): [True: 4.06k, False: 813] ------------------ 792| | /* no keywords, return at once */ 793| 4.06k| return; 794| 4.06k| } 795| | 796| | /* find the first keyword */ 797| 2.01k| while(startSearchHere) { ------------------ | Branch (797:11): [True: 1.26k, False: 751] ------------------ 798| 1.26k| const char* keyValueTail; 799| | 800| 1.26k| startSearchHere++; /* skip @ or ; */ 801| 1.26k| nextSeparator = uprv_strchr(startSearchHere, '='); ------------------ | | 40| 1.26k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 1.26k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 802| 1.26k| if(!nextSeparator) { ------------------ | Branch (802:12): [True: 0, False: 1.26k] ------------------ 803| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* key must have =value */ 804| 0| return; 805| 0| } 806| | /* strip leading & trailing spaces (TC decided to tolerate these) */ 807| 1.26k| while(*startSearchHere == ' ') { ------------------ | Branch (807:15): [True: 0, False: 1.26k] ------------------ 808| 0| startSearchHere++; 809| 0| } 810| 1.26k| keyValueTail = nextSeparator; 811| 1.26k| while (keyValueTail > startSearchHere && *(keyValueTail-1) == ' ') { ------------------ | Branch (811:16): [True: 1.26k, False: 0] | Branch (811:50): [True: 0, False: 1.26k] ------------------ 812| 0| keyValueTail--; 813| 0| } 814| | /* now keyValueTail points to first char after the keyName */ 815| | /* copy & normalize keyName from locale */ 816| 1.26k| if (startSearchHere == keyValueTail) { ------------------ | Branch (816:13): [True: 0, False: 1.26k] ------------------ 817| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* empty keyword name in passed-in locale */ 818| 0| return; 819| 0| } 820| 1.26k| CharString localeKeywordName; 821| 4.30k| while (startSearchHere < keyValueTail) { ------------------ | Branch (821:16): [True: 3.04k, False: 1.26k] ------------------ 822| 3.04k| if (!UPRV_ISALPHANUM(*startSearchHere)) { ------------------ | Branch (822:15): [True: 0, False: 3.04k] ------------------ 823| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed keyword name */ 824| 0| return; 825| 0| } 826| 3.04k| localeKeywordName.append(uprv_tolower(*startSearchHere++), status); ------------------ | | 68| 3.04k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 3.04k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 3.04k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 3.04k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 3.04k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 827| 3.04k| } 828| 1.26k| if (U_FAILURE(status)) { ------------------ | Branch (828:13): [True: 0, False: 1.26k] ------------------ 829| 0| return; 830| 0| } 831| | 832| 1.26k| startSearchHere = uprv_strchr(nextSeparator, ';'); ------------------ | | 40| 1.26k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 1.26k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 833| | 834| 1.26k| if (canonKeywordName == localeKeywordName) { ------------------ | Branch (834:13): [True: 62, False: 1.20k] ------------------ 835| | /* current entry matches the keyword. */ 836| 62| nextSeparator++; /* skip '=' */ 837| | /* First strip leading & trailing spaces (TC decided to tolerate these) */ 838| 62| while(*nextSeparator == ' ') { ------------------ | Branch (838:19): [True: 0, False: 62] ------------------ 839| 0| nextSeparator++; 840| 0| } 841| 62| keyValueTail = (startSearchHere)? startSearchHere: nextSeparator + uprv_strlen(nextSeparator); ------------------ | | 37| 28|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 28|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (841:28): [True: 34, False: 28] ------------------ 842| 62| while(keyValueTail > nextSeparator && *(keyValueTail-1) == ' ') { ------------------ | Branch (842:19): [True: 62, False: 0] | Branch (842:51): [True: 0, False: 62] ------------------ 843| 0| keyValueTail--; 844| 0| } 845| | /* Now copy the value, but check well-formedness */ 846| 62| if (nextSeparator == keyValueTail) { ------------------ | Branch (846:17): [True: 0, False: 62] ------------------ 847| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* empty key value name in passed-in locale */ 848| 0| return; 849| 0| } 850| 2.44k| while (nextSeparator < keyValueTail) { ------------------ | Branch (850:20): [True: 2.38k, False: 62] ------------------ 851| 2.38k| if (!UPRV_ISALPHANUM(*nextSeparator) && !UPRV_OK_VALUE_PUNCTUATION(*nextSeparator)) { ------------------ | Branch (851:19): [True: 314, False: 2.06k] | Branch (851:55): [True: 0, False: 314] ------------------ 852| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed key value */ 853| 0| return; 854| 0| } 855| | /* Should we lowercase value to return here? Tests expect as-is. */ 856| 2.38k| sink.Append(nextSeparator++, 1); 857| 2.38k| } 858| 62| return; 859| 62| } 860| 1.26k| } 861| 813|} _Z21ulocimp_getSubtags_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEPN6icu_7810CharStringES6_S6_S6_PPKcR10UErrorCode: 1514| 27.7k| UErrorCode& status) { 1515| 27.7k| if (U_FAILURE(status)) { return; } ------------------ | Branch (1515:9): [True: 0, False: 27.7k] ------------------ 1516| | 1517| 27.7k| std::optional languageSink; 1518| 27.7k| std::optional scriptSink; 1519| 27.7k| std::optional regionSink; 1520| 27.7k| std::optional variantSink; 1521| | 1522| 27.7k| if (language != nullptr) { languageSink.emplace(language); } ------------------ | Branch (1522:9): [True: 27.7k, False: 0] ------------------ 1523| 27.7k| if (script != nullptr) { scriptSink.emplace(script); } ------------------ | Branch (1523:9): [True: 27.7k, False: 0] ------------------ 1524| 27.7k| if (region != nullptr) { regionSink.emplace(region); } ------------------ | Branch (1524:9): [True: 27.2k, False: 492] ------------------ 1525| 27.7k| if (variant != nullptr) { variantSink.emplace(variant); } ------------------ | Branch (1525:9): [True: 25.1k, False: 2.56k] ------------------ 1526| | 1527| 27.7k| ulocimp_getSubtags( ------------------ | | 1209| 27.7k|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 27.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 27.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 27.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1528| 27.7k| localeID, 1529| 27.7k| languageSink.has_value() ? &*languageSink : nullptr, ------------------ | Branch (1529:13): [True: 27.7k, False: 0] ------------------ 1530| 27.7k| scriptSink.has_value() ? &*scriptSink : nullptr, ------------------ | Branch (1530:13): [True: 27.7k, False: 0] ------------------ 1531| 27.7k| regionSink.has_value() ? &*regionSink : nullptr, ------------------ | Branch (1531:13): [True: 27.2k, False: 492] ------------------ 1532| 27.7k| variantSink.has_value() ? &*variantSink : nullptr, ------------------ | Branch (1532:13): [True: 25.1k, False: 2.56k] ------------------ 1533| 27.7k| pEnd, 1534| 27.7k| status); 1535| 27.7k|} _Z21ulocimp_getSubtags_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEPN6icu_788ByteSinkES6_S6_S6_PPKcR10UErrorCode: 1545| 30.7k| UErrorCode& status) { 1546| 30.7k| if (U_FAILURE(status)) { return; } ------------------ | Branch (1546:9): [True: 0, False: 30.7k] ------------------ 1547| | 1548| 30.7k| if (pEnd != nullptr) { ------------------ | Branch (1548:9): [True: 25.1k, False: 5.60k] ------------------ 1549| 25.1k| *pEnd = localeID.data(); 1550| 25.1k| } else if (language == nullptr && ------------------ | Branch (1550:16): [True: 3.03k, False: 2.56k] ------------------ 1551| 5.60k| script == nullptr && ------------------ | Branch (1551:16): [True: 3.03k, False: 0] ------------------ 1552| 5.60k| region == nullptr && ------------------ | Branch (1552:16): [True: 3.03k, False: 0] ------------------ 1553| 5.60k| variant == nullptr) { ------------------ | Branch (1553:16): [True: 0, False: 3.03k] ------------------ 1554| 0| return; 1555| 0| } 1556| | 1557| 30.7k| if (localeID.empty()) { return; } ------------------ | Branch (1557:9): [True: 15.5k, False: 15.2k] ------------------ 1558| | 1559| 15.2k| bool hasRegion = false; 1560| | 1561| 15.2k| { 1562| 15.2k| size_t len = _getLanguage(localeID, language, status); 1563| 15.2k| if (U_FAILURE(status)) { return; } ------------------ | Branch (1563:13): [True: 0, False: 15.2k] ------------------ 1564| 15.2k| if (len > 0) { ------------------ | Branch (1564:13): [True: 15.2k, False: 68] ------------------ 1565| 15.2k| localeID.remove_prefix(len); 1566| 15.2k| } 1567| 15.2k| } 1568| | 1569| 15.2k| if (pEnd != nullptr) { ------------------ | Branch (1569:9): [True: 9.67k, False: 5.60k] ------------------ 1570| 9.67k| *pEnd = localeID.data(); 1571| 9.67k| } else if (script == nullptr && ------------------ | Branch (1571:16): [True: 3.03k, False: 2.56k] ------------------ 1572| 5.60k| region == nullptr && ------------------ | Branch (1572:16): [True: 3.03k, False: 0] ------------------ 1573| 5.60k| variant == nullptr) { ------------------ | Branch (1573:16): [True: 0, False: 3.03k] ------------------ 1574| 0| return; 1575| 0| } 1576| | 1577| 15.2k| if (localeID.empty()) { return; } ------------------ | Branch (1577:9): [True: 9.17k, False: 6.09k] ------------------ 1578| | 1579| 6.09k| if (_isIDSeparator(localeID.front())) { ------------------ | Branch (1579:9): [True: 5.50k, False: 595] ------------------ 1580| 5.50k| std::string_view sub = localeID; 1581| 5.50k| sub.remove_prefix(1); 1582| 5.50k| size_t len = _getScript(sub, script); 1583| 5.50k| if (len > 0) { ------------------ | Branch (1583:13): [True: 2.41k, False: 3.08k] ------------------ 1584| 2.41k| localeID.remove_prefix(len + 1); 1585| 2.41k| if (pEnd != nullptr) { *pEnd = localeID.data(); } ------------------ | Branch (1585:17): [True: 397, False: 2.01k] ------------------ 1586| 2.41k| } 1587| 5.50k| } 1588| | 1589| 6.09k| if ((region == nullptr && variant == nullptr && pEnd == nullptr) || localeID.empty()) { return; } ------------------ | Branch (1589:10): [True: 2.69k, False: 3.40k] | Branch (1589:31): [True: 489, False: 2.20k] | Branch (1589:53): [True: 489, False: 0] | Branch (1589:73): [True: 1.44k, False: 4.16k] ------------------ 1590| | 1591| 4.16k| if (_isIDSeparator(localeID.front())) { ------------------ | Branch (1591:9): [True: 3.56k, False: 597] ------------------ 1592| 3.56k| std::string_view sub = localeID; 1593| 3.56k| sub.remove_prefix(1); 1594| 3.56k| size_t len = _getRegion(sub, region); 1595| 3.56k| if (len > 0) { ------------------ | Branch (1595:13): [True: 2.38k, False: 1.18k] ------------------ 1596| 2.38k| hasRegion = true; 1597| 2.38k| localeID.remove_prefix(len + 1); 1598| 2.38k| if (pEnd != nullptr) { *pEnd = localeID.data(); } ------------------ | Branch (1598:17): [True: 1.13k, False: 1.25k] ------------------ 1599| 2.38k| } 1600| 3.56k| } 1601| | 1602| 4.16k| if ((variant == nullptr && pEnd == nullptr) || localeID.empty()) { return; } ------------------ | Branch (1602:10): [True: 561, False: 3.60k] | Branch (1602:32): [True: 561, False: 0] | Branch (1602:52): [True: 1.38k, False: 2.21k] ------------------ 1603| | 1604| 2.21k| bool hasVariant = false; 1605| | 1606| 2.21k| if (_isIDSeparator(localeID.front()) && !_isBCP47Extension(localeID)) { ------------------ | Branch (1606:9): [True: 1.50k, False: 716] | Branch (1606:45): [True: 1.50k, False: 0] ------------------ 1607| 1.50k| std::string_view sub = localeID; 1608| | /* If there was no country ID, skip a possible extra IDSeparator */ 1609| 1.50k| size_t skip = !hasRegion && localeID.size() > 1 && _isIDSeparator(localeID[1]) ? 2 : 1; ------------------ | Branch (1609:23): [True: 1.18k, False: 318] | Branch (1609:37): [True: 1.18k, False: 0] | Branch (1609:60): [True: 1.18k, False: 0] ------------------ 1610| 1.50k| sub.remove_prefix(skip); 1611| 1.50k| size_t len = _getVariant(sub, localeID[0], variant, false, status); 1612| 1.50k| if (U_FAILURE(status)) { return; } ------------------ | Branch (1612:13): [True: 0, False: 1.50k] ------------------ 1613| 1.50k| if (len > 0) { ------------------ | Branch (1613:13): [True: 1.50k, False: 0] ------------------ 1614| 1.50k| hasVariant = true; 1615| 1.50k| localeID.remove_prefix(skip + len); 1616| 1.50k| if (pEnd != nullptr) { *pEnd = localeID.data(); } ------------------ | Branch (1616:17): [True: 541, False: 962] ------------------ 1617| 1.50k| } 1618| 1.50k| } 1619| | 1620| 2.21k| if ((variant == nullptr && pEnd == nullptr) || localeID.empty()) { return; } ------------------ | Branch (1620:10): [True: 0, False: 2.21k] | Branch (1620:32): [True: 0, False: 0] | Branch (1620:52): [True: 1.40k, False: 813] ------------------ 1621| | 1622| 813| if (_isBCP47Extension(localeID)) { ------------------ | Branch (1622:9): [True: 0, False: 813] ------------------ 1623| 0| localeID.remove_prefix(2); 1624| 0| constexpr char vaposix[] = "-va-posix"; 1625| 0| constexpr size_t length = sizeof vaposix - 1; 1626| 0| for (size_t next;; localeID.remove_prefix(next)) { 1627| 0| next = localeID.find('-', 1); 1628| 0| if (next == std::string_view::npos) { break; } ------------------ | Branch (1628:17): [True: 0, False: 0] ------------------ 1629| 0| next = localeID.find('-', next + 1); 1630| 0| bool finished = next == std::string_view::npos; 1631| 0| std::string_view sub = localeID; 1632| 0| if (!finished) { sub.remove_suffix(sub.length() - next); } ------------------ | Branch (1632:17): [True: 0, False: 0] ------------------ 1633| | 1634| 0| if (sub.length() == length && uprv_strnicmp(sub.data(), vaposix, length) == 0) { ------------------ | | 1544| 0|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1634:17): [True: 0, False: 0] | Branch (1634:43): [True: 0, False: 0] ------------------ 1635| 0| if (variant != nullptr) { ------------------ | Branch (1635:21): [True: 0, False: 0] ------------------ 1636| 0| if (hasVariant) { variant->Append("_", 1); } ------------------ | Branch (1636:25): [True: 0, False: 0] ------------------ 1637| 0| constexpr char posix[] = "POSIX"; 1638| 0| variant->Append(posix, sizeof posix - 1); 1639| 0| } 1640| 0| if (pEnd != nullptr) { *pEnd = localeID.data() + length; } ------------------ | Branch (1640:21): [True: 0, False: 0] ------------------ 1641| 0| } 1642| | 1643| 0| if (finished) { break; } ------------------ | Branch (1643:17): [True: 0, False: 0] ------------------ 1644| 0| } 1645| 0| } 1646| 813|} _Z18ulocimp_getName_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEERN6icu_788ByteSinkER10UErrorCode: 2171| 15.4k|{ 2172| 15.4k| _canonicalize(localeID, sink, 0, err); 2173| 15.4k|} _Z22ulocimp_getBaseName_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEER10UErrorCode: 2195| 9.72k|{ 2196| 9.72k| return ByteSinkUtil::viaByteSinkToCharString( 2197| 9.72k| [&](ByteSink& sink, UErrorCode& status) { 2198| 9.72k| ulocimp_getBaseName(localeID, sink, status); 2199| 9.72k| }, 2200| 9.72k| err); 2201| 9.72k|} _Z22ulocimp_getBaseName_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEERN6icu_788ByteSinkER10UErrorCode: 2207| 9.72k|{ 2208| 9.72k| _canonicalize(localeID, sink, _ULOC_STRIP_KEYWORDS, err); ------------------ | | 1785| 9.72k|#define _ULOC_STRIP_KEYWORDS 0x2 ------------------ 2209| 9.72k|} _Z23ulocimp_canonicalize_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEER10UErrorCode: 2231| 1|{ 2232| 1| return ByteSinkUtil::viaByteSinkToCharString( 2233| 1| [&](ByteSink& sink, UErrorCode& status) { 2234| 1| ulocimp_canonicalize(localeID, sink, status); 2235| 1| }, 2236| 1| err); 2237| 1|} _Z23ulocimp_canonicalize_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEERN6icu_788ByteSinkER10UErrorCode: 2243| 1|{ 2244| 1| _canonicalize(localeID, sink, _ULOC_CANONICALIZE, err); ------------------ | | 1786| 1|#define _ULOC_CANONICALIZE 0x1 ------------------ 2245| 1|} uloc_getDefault_78: 2336| 4.97k|{ 2337| 4.97k| return locale_get_default(); ------------------ | | 139| 4.97k|#define locale_get_default U_ICU_ENTRY_POINT_RENAME(locale_get_default) | | ------------------ | | | | 123| 4.97k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.97k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.97k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2338| 4.97k|} _Z34ulocimp_toLegacyKeyWithFallback_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEE: 2456| 2.23k|{ 2457| 2.23k| std::optional legacyKey = ulocimp_toLegacyKey(keyword); ------------------ | | 1219| 2.23k|#define ulocimp_toLegacyKey U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyKey) | | ------------------ | | | | 123| 2.23k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.23k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.23k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2458| 2.23k| if (!legacyKey.has_value() && isWellFormedLegacyKey(keyword)) { ------------------ | Branch (2458:9): [True: 1.30k, False: 929] | Branch (2458:35): [True: 1.30k, False: 0] ------------------ 2459| | // Checks if the specified locale key is well-formed with the legacy locale syntax. 2460| | // 2461| | // Note: 2462| | // LDML/CLDR provides some definition of keyword syntax in 2463| | // * http://www.unicode.org/reports/tr35/#Unicode_locale_identifier and 2464| | // * http://www.unicode.org/reports/tr35/#Old_Locale_Extension_Syntax 2465| | // Keys can only consist of [0-9a-zA-Z]. 2466| 1.30k| return keyword; 2467| 1.30k| } 2468| 929| return legacyKey; 2469| 2.23k|} _Z35ulocimp_toLegacyTypeWithFallback_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_: 2482| 869|{ 2483| 869| std::optional legacyType = ulocimp_toLegacyType(keyword, value); ------------------ | | 1221| 869|#define ulocimp_toLegacyType U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyType) | | ------------------ | | | | 123| 869|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 869|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 869|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2484| 869| if (!legacyType.has_value() && isWellFormedLegacyType(value)) { ------------------ | Branch (2484:9): [True: 712, False: 157] | Branch (2484:36): [True: 712, False: 0] ------------------ 2485| | // Checks if the specified locale type is well-formed with the legacy locale syntax. 2486| | // 2487| | // Note: 2488| | // LDML/CLDR provides some definition of keyword syntax in 2489| | // * http://www.unicode.org/reports/tr35/#Unicode_locale_identifier and 2490| | // * http://www.unicode.org/reports/tr35/#Old_Locale_Extension_Syntax 2491| | // Values (types) can only consist of [0-9a-zA-Z], plus for legacy values 2492| | // we allow [/_-+] in the middle (e.g. "Etc/GMT+1", "Asia/Tel_Aviv") 2493| 712| return value; 2494| 712| } 2495| 157| return legacyType; 2496| 869|} uloc.cpp:_ZN12_GLOBAL__N_123locale_canonKeywordNameENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEER10UErrorCode: 556| 4.87k|{ 557| 4.87k| if (U_FAILURE(status)) { return {}; } ------------------ | Branch (557:7): [True: 0, False: 4.87k] ------------------ 558| 4.87k| CharString result; 559| | 560| 43.8k| for (char c : keywordName) { ------------------ | Branch (560:15): [True: 43.8k, False: 4.87k] ------------------ 561| 43.8k| if (!UPRV_ISALPHANUM(c)) { ------------------ | Branch (561:9): [True: 0, False: 43.8k] ------------------ 562| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed keyword name */ 563| 0| return {}; 564| 0| } 565| 43.8k| result.append(uprv_tolower(c), status); ------------------ | | 68| 43.8k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 43.8k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 43.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 43.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 43.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 566| 43.8k| } 567| 4.87k| if (result.isEmpty()) { ------------------ | Branch (567:7): [True: 0, False: 4.87k] ------------------ 568| 0| status = U_ILLEGAL_ARGUMENT_ERROR; /* empty keyword name */ 569| 0| return {}; 570| 0| } 571| | 572| 4.87k| return result; 573| 4.87k|} uloc.cpp:_ZN12_GLOBAL__N_118_hasBCP47ExtensionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 510| 30.0k|inline bool _hasBCP47Extension(std::string_view id) { 511| 30.0k| return id.find('@') == std::string_view::npos && getShortestSubtagLength(id) == 1; ------------------ | Branch (511:12): [True: 28.4k, False: 1.62k] | Branch (511:54): [True: 0, False: 28.4k] ------------------ 512| 30.0k|} uloc.cpp:_ZN12_GLOBAL__N_123getShortestSubtagLengthENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 485| 28.4k|int32_t getShortestSubtagLength(std::string_view localeID) { 486| 28.4k| int32_t localeIDLength = static_cast(localeID.length()); 487| 28.4k| int32_t length = localeIDLength; 488| 28.4k| int32_t tmpLength = 0; 489| 28.4k| int32_t i; 490| 28.4k| bool reset = true; 491| | 492| 80.3k| for (i = 0; i < localeIDLength; i++) { ------------------ | Branch (492:17): [True: 51.9k, False: 28.4k] ------------------ 493| 51.9k| if (localeID[i] != '_' && localeID[i] != '-') { ------------------ | Branch (493:13): [True: 46.9k, False: 4.93k] | Branch (493:35): [True: 46.9k, False: 0] ------------------ 494| 46.9k| if (reset) { ------------------ | Branch (494:17): [True: 17.2k, False: 29.7k] ------------------ 495| 17.2k| tmpLength = 0; 496| 17.2k| reset = false; 497| 17.2k| } 498| 46.9k| tmpLength++; 499| 46.9k| } else { 500| 4.93k| if (tmpLength != 0 && tmpLength < length) { ------------------ | Branch (500:17): [True: 4.92k, False: 10] | Branch (500:35): [True: 1.94k, False: 2.98k] ------------------ 501| 1.94k| length = tmpLength; 502| 1.94k| } 503| 4.93k| reset = true; 504| 4.93k| } 505| 51.9k| } 506| | 507| 28.4k| return length; 508| 28.4k|} uloc.cpp:_ZN12_GLOBAL__N_115UPRV_ISALPHANUMEc: 516| 59.1k|inline bool UPRV_ISALPHANUM(char c) { return uprv_isASCIILetter(c) || UPRV_ISDIGIT(c); } ------------------ | | 1514| 59.1k|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 59.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 59.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 59.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (516:46): [True: 57.1k, False: 2.03k] | Branch (516:71): [True: 1.71k, False: 314] ------------------ uloc.cpp:_ZN12_GLOBAL__N_112UPRV_ISDIGITEc: 515| 2.03k|inline bool UPRV_ISDIGIT(char c) { return c >= '0' && c <= '9'; } ------------------ | Branch (515:43): [True: 1.71k, False: 314] | Branch (515:55): [True: 1.71k, False: 0] ------------------ uloc.cpp:_ZN12_GLOBAL__N_125UPRV_OK_VALUE_PUNCTUATIONEc: 518| 314|inline bool UPRV_OK_VALUE_PUNCTUATION(char c) { return c == '_' || c == '-' || c == '+' || c == '/'; } ------------------ | Branch (518:56): [True: 0, False: 314] | Branch (518:68): [True: 314, False: 0] | Branch (518:80): [True: 0, False: 0] | Branch (518:92): [True: 0, False: 0] ------------------ uloc.cpp:_ZN12_GLOBAL__N_110_findIndexEPKPKcS1_: 1178| 1.16k|{ 1179| 1.16k| const char* const* anchor = list; 1180| 1.16k| int32_t pass = 0; 1181| | 1182| | /* Make two passes through two nullptr-terminated arrays at 'list' */ 1183| 3.08k| while (pass++ < 2) { ------------------ | Branch (1183:12): [True: 2.13k, False: 955] ------------------ 1184| 578k| while (*list) { ------------------ | Branch (1184:16): [True: 576k, False: 1.92k] ------------------ 1185| 576k| if (uprv_strcmp(key, *list) == 0) { ------------------ | | 38| 576k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 576k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1185:17): [True: 210, False: 576k] ------------------ 1186| 210| return static_cast(list - anchor); 1187| 210| } 1188| 576k| list++; 1189| 576k| } 1190| 1.92k| ++list; /* skip final nullptr *CWB*/ 1191| 1.92k| } 1192| 955| return std::nullopt; 1193| 1.16k|} uloc.cpp:_ZN12_GLOBAL__N_112_getLanguageENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPN6icu_788ByteSinkER10UErrorCode: 1219| 15.2k|size_t _getLanguage(std::string_view localeID, ByteSink* sink, UErrorCode& status) { 1220| 15.2k| size_t skip = 0; 1221| 15.2k| if (localeID.size() == 4 && uprv_strnicmp(localeID.data(), "root", 4) == 0) { ------------------ | | 1544| 196|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 196|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 196|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 196|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1221:9): [True: 196, False: 15.0k] | Branch (1221:33): [True: 119, False: 77] ------------------ 1222| 119| skip = 4; 1223| 119| localeID.remove_prefix(skip); 1224| 15.1k| } else if (localeID.size() >= 3 && uprv_strnicmp(localeID.data(), "und", 3) == 0 && ------------------ | | 1544| 6.79k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 6.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1224:16): [True: 6.79k, False: 8.35k] | Branch (1224:40): [True: 25, False: 6.77k] ------------------ 1225| 15.1k| (localeID.size() == 3 || ------------------ | Branch (1225:17): [True: 4, False: 21] ------------------ 1226| 25| localeID[3] == '-' || ------------------ | Branch (1226:17): [True: 0, False: 21] ------------------ 1227| 25| localeID[3] == '_' || ------------------ | Branch (1227:17): [True: 5, False: 16] ------------------ 1228| 25| localeID[3] == '@')) { ------------------ | Branch (1228:17): [True: 1, False: 15] ------------------ 1229| 10| skip = 3; 1230| 10| localeID.remove_prefix(skip); 1231| 10| } 1232| | 1233| 15.2k| constexpr int32_t MAXLEN = ULOC_LANG_CAPACITY - 1; // Minus NUL. ------------------ | | 251| 15.2k|#define ULOC_LANG_CAPACITY 12 ------------------ 1234| | 1235| | /* if it starts with i- or x- then copy that prefix */ 1236| 15.2k| size_t len = _isIDPrefix(localeID) ? 2 : 0; ------------------ | Branch (1236:18): [True: 0, False: 15.2k] ------------------ 1237| 47.7k| while (len < localeID.size() && !_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len])) { ------------------ | Branch (1237:12): [True: 38.5k, False: 9.17k] | Branch (1237:37): [True: 37.9k, False: 595] | Branch (1237:70): [True: 32.4k, False: 5.50k] ------------------ 1238| 32.4k| if (len == MAXLEN) { ------------------ | Branch (1238:13): [True: 0, False: 32.4k] ------------------ 1239| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1240| 0| return 0; 1241| 0| } 1242| 32.4k| len++; 1243| 32.4k| } 1244| | 1245| 15.2k| if (sink == nullptr || len == 0) { return skip + len; } ------------------ | Branch (1245:9): [True: 3.03k, False: 12.2k] | Branch (1245:28): [True: 185, False: 12.0k] ------------------ 1246| | 1247| 12.0k| int32_t minCapacity = uprv_max(static_cast(len), 4); // Minimum 3 letters plus NUL. ------------------ | | 1526| 12.0k|#define uprv_max U_ICU_ENTRY_POINT_RENAME(uprv_max) | | ------------------ | | | | 123| 12.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1248| 12.0k| char scratch[MAXLEN]; 1249| 12.0k| int32_t capacity = 0; 1250| 12.0k| char* buffer = sink->GetAppendBuffer( 1251| 12.0k| minCapacity, minCapacity, scratch, UPRV_LENGTHOF(scratch), &capacity); ------------------ | | 99| 12.0k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1252| | 1253| 37.6k| for (size_t i = 0; i < len; ++i) { ------------------ | Branch (1253:24): [True: 25.5k, False: 12.0k] ------------------ 1254| 25.5k| buffer[i] = uprv_tolower(localeID[i]); ------------------ | | 68| 25.5k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 25.5k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 25.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 25.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 25.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1255| 25.5k| } 1256| 12.0k| if (localeID.size() >= 2 && _isIDSeparator(localeID[1])) { ------------------ | Branch (1256:9): [True: 12.0k, False: 0] | Branch (1256:33): [True: 0, False: 12.0k] ------------------ 1257| 0| buffer[1] = '-'; 1258| 0| } 1259| | 1260| 12.0k| if (len == 3) { ------------------ | Branch (1260:9): [True: 868, False: 11.1k] ------------------ 1261| | /* convert 3 character code to 2 character code if possible *CWB*/ 1262| 868| U_ASSERT(capacity >= 4); ------------------ | | 35| 868|# define U_ASSERT(exp) (void)0 ------------------ 1263| 868| buffer[3] = '\0'; 1264| 868| std::optional offset = _findIndex(LANGUAGES_3, buffer); 1265| 868| if (offset.has_value()) { ------------------ | Branch (1265:13): [True: 210, False: 658] ------------------ 1266| 210| const char* const alias = LANGUAGES[*offset]; 1267| 210| sink->Append(alias, static_cast(uprv_strlen(alias))); ------------------ | | 37| 210|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 210|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1268| 210| return skip + len; 1269| 210| } 1270| 868| } 1271| | 1272| 11.8k| sink->Append(buffer, static_cast(len)); 1273| 11.8k| return skip + len; 1274| 12.0k|} uloc.cpp:_ZN12_GLOBAL__N_111_isIDPrefixENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 1152| 15.2k|inline bool _isIDPrefix(std::string_view s) { 1153| 15.2k| return s.size() >= 2 && _isPrefixLetter(s[0]) && _isIDSeparator(s[1]); ------------------ | Branch (1153:12): [True: 15.1k, False: 123] | Branch (1153:29): [True: 87, False: 15.0k] | Branch (1153:54): [True: 0, False: 87] ------------------ 1154| 15.2k|} uloc.cpp:_ZN12_GLOBAL__N_115_isPrefixLetterEc: 1148| 15.1k|inline bool _isPrefixLetter(char a) { return a == 'x' || a == 'X' || a == 'i' || a == 'I'; } ------------------ | Branch (1148:46): [True: 19, False: 15.1k] | Branch (1148:58): [True: 0, False: 15.1k] | Branch (1148:70): [True: 68, False: 15.0k] | Branch (1148:82): [True: 0, False: 15.0k] ------------------ uloc.cpp:_ZN12_GLOBAL__N_113_isTerminatorEc: 1159| 65.5k|inline bool _isTerminator(char a) { return a == '.' || a == '@'; } ------------------ | Branch (1159:44): [True: 0, False: 65.5k] | Branch (1159:56): [True: 864, False: 64.6k] ------------------ uloc.cpp:_ZN12_GLOBAL__N_110_getScriptENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPN6icu_788ByteSinkE: 1276| 5.50k|size_t _getScript(std::string_view localeID, ByteSink* sink) { 1277| 5.50k| constexpr int32_t LENGTH = 4; 1278| | 1279| 5.50k| size_t len = 0; 1280| 19.3k| while (len < localeID.size() && !_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len]) && ------------------ | Branch (1280:12): [True: 16.2k, False: 3.09k] | Branch (1280:37): [True: 16.2k, False: 53] | Branch (1280:70): [True: 14.3k, False: 1.86k] ------------------ 1281| 19.3k| uprv_isASCIILetter(localeID[len])) { ------------------ | | 1514| 14.3k|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 14.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 14.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 14.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1281:13): [True: 13.8k, False: 497] ------------------ 1282| 13.8k| if (len == LENGTH) { return 0; } ------------------ | Branch (1282:13): [True: 0, False: 13.8k] ------------------ 1283| 13.8k| len++; 1284| 13.8k| } 1285| 5.50k| if (len != LENGTH) { return 0; } ------------------ | Branch (1285:9): [True: 3.08k, False: 2.41k] ------------------ 1286| | 1287| 2.41k| if (sink == nullptr) { return len; } ------------------ | Branch (1287:9): [True: 1.26k, False: 1.15k] ------------------ 1288| | 1289| 1.15k| char scratch[LENGTH]; 1290| 1.15k| int32_t capacity = 0; 1291| 1.15k| char* buffer = sink->GetAppendBuffer( 1292| 1.15k| LENGTH, LENGTH, scratch, UPRV_LENGTHOF(scratch), &capacity); ------------------ | | 99| 1.15k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1293| | 1294| 1.15k| buffer[0] = uprv_toupper(localeID[0]); ------------------ | | 1547| 1.15k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 1.15k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.15k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.15k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1295| 4.60k| for (int32_t i = 1; i < LENGTH; ++i) { ------------------ | Branch (1295:25): [True: 3.45k, False: 1.15k] ------------------ 1296| 3.45k| buffer[i] = uprv_tolower(localeID[i]); ------------------ | | 68| 3.45k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 3.45k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 3.45k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 3.45k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 3.45k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 3.45k| } 1298| | 1299| 1.15k| sink->Append(buffer, LENGTH); 1300| 1.15k| return len; 1301| 2.41k|} uloc.cpp:_ZN12_GLOBAL__N_110_getRegionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPN6icu_788ByteSinkE: 1303| 3.56k|size_t _getRegion(std::string_view localeID, ByteSink* sink) { 1304| 3.56k| constexpr int32_t MINLEN = 2; 1305| 3.56k| constexpr int32_t MAXLEN = ULOC_COUNTRY_CAPACITY - 1; // Minus NUL. ------------------ | | 258| 3.56k|#define ULOC_COUNTRY_CAPACITY 4 ------------------ 1306| | 1307| 3.56k| size_t len = 0; 1308| 8.73k| while (len < localeID.size() && !_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len])) { ------------------ | Branch (1308:12): [True: 6.78k, False: 1.94k] | Branch (1308:37): [True: 6.66k, False: 119] | Branch (1308:70): [True: 5.16k, False: 1.50k] ------------------ 1309| 5.16k| if (len == MAXLEN) { return 0; } ------------------ | Branch (1309:13): [True: 0, False: 5.16k] ------------------ 1310| 5.16k| len++; 1311| 5.16k| } 1312| 3.56k| if (len < MINLEN) { return 0; } ------------------ | Branch (1312:9): [True: 1.18k, False: 2.38k] ------------------ 1313| | 1314| 2.38k| if (sink == nullptr) { return len; } ------------------ | Branch (1314:9): [True: 690, False: 1.69k] ------------------ 1315| | 1316| 1.69k| char scratch[ULOC_COUNTRY_CAPACITY]; 1317| 1.69k| int32_t capacity = 0; 1318| 1.69k| char* buffer = sink->GetAppendBuffer( 1319| 1.69k| ULOC_COUNTRY_CAPACITY, ------------------ | | 258| 1.69k|#define ULOC_COUNTRY_CAPACITY 4 ------------------ 1320| 1.69k| ULOC_COUNTRY_CAPACITY, ------------------ | | 258| 1.69k|#define ULOC_COUNTRY_CAPACITY 4 ------------------ 1321| 1.69k| scratch, 1322| 1.69k| UPRV_LENGTHOF(scratch), ------------------ | | 99| 1.69k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1323| 1.69k| &capacity); 1324| | 1325| 5.37k| for (size_t i = 0; i < len; ++i) { ------------------ | Branch (1325:24): [True: 3.68k, False: 1.69k] ------------------ 1326| 3.68k| buffer[i] = uprv_toupper(localeID[i]); ------------------ | | 1547| 3.68k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 3.68k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.68k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.68k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1327| 3.68k| } 1328| | 1329| 1.69k| if (len == 3) { ------------------ | Branch (1329:9): [True: 297, False: 1.39k] ------------------ 1330| | /* convert 3 character code to 2 character code if possible *CWB*/ 1331| 297| U_ASSERT(capacity >= 4); ------------------ | | 35| 297|# define U_ASSERT(exp) (void)0 ------------------ 1332| 297| buffer[3] = '\0'; 1333| 297| std::optional offset = _findIndex(COUNTRIES_3, buffer); 1334| 297| if (offset.has_value()) { ------------------ | Branch (1334:13): [True: 0, False: 297] ------------------ 1335| 0| const char* const alias = COUNTRIES[*offset]; 1336| 0| sink->Append(alias, static_cast(uprv_strlen(alias))); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1337| 0| return len; 1338| 0| } 1339| 297| } 1340| | 1341| 1.69k| sink->Append(buffer, static_cast(len)); 1342| 1.69k| return len; 1343| 1.69k|} uloc.cpp:_ZN12_GLOBAL__N_117_isBCP47ExtensionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 1161| 6.12k|inline bool _isBCP47Extension(std::string_view p) { 1162| 6.12k| return p.size() >= 3 && ------------------ | Branch (1162:12): [True: 6.12k, False: 0] ------------------ 1163| 6.12k| p[0] == '-' && ------------------ | Branch (1163:12): [True: 0, False: 6.12k] ------------------ 1164| 6.12k| (p[1] == 't' || p[1] == 'T' || ------------------ | Branch (1164:13): [True: 0, False: 0] | Branch (1164:28): [True: 0, False: 0] ------------------ 1165| 0| p[1] == 'u' || p[1] == 'U' || ------------------ | Branch (1165:13): [True: 0, False: 0] | Branch (1165:28): [True: 0, False: 0] ------------------ 1166| 0| p[1] == 'x' || p[1] == 'X') && ------------------ | Branch (1166:13): [True: 0, False: 0] | Branch (1166:28): [True: 0, False: 0] ------------------ 1167| 6.12k| p[2] == '-'; ------------------ | Branch (1167:12): [True: 0, False: 0] ------------------ 1168| 6.12k|} uloc.cpp:_ZN12_GLOBAL__N_111_getVariantENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEcPN6icu_788ByteSinkEbR10UErrorCode: 1354| 1.50k| UErrorCode& status) { 1355| 1.50k| if (U_FAILURE(status) || localeID.empty()) return 0; ------------------ | Branch (1355:9): [True: 0, False: 1.50k] | Branch (1355:30): [True: 0, False: 1.50k] ------------------ 1356| | 1357| | // Reasonable upper limit for variants 1358| | // There are no strict limitation of the syntax of variant in the legacy 1359| | // locale format. If the locale is constructed from unicode_locale_id 1360| | // as defined in UTS35, then we know each unicode_variant_subtag 1361| | // could have max length of 8 ((alphanum{5,8} | digit alphanum{3}) 1362| | // 179 would allow 20 unicode_variant_subtag with sep in the 1363| | // unicode_locale_id 1364| | // 8*20 + 1*(20-1) = 179 1365| 1.50k| constexpr int32_t MAX_VARIANTS_LENGTH = 179; 1366| | 1367| | /* get one or more variant tags and separate them with '_' */ 1368| 1.50k| size_t index = 0; 1369| 1.50k| if (_isIDSeparator(prev)) { ------------------ | Branch (1369:9): [True: 1.50k, False: 0] ------------------ 1370| | /* get a variant string after a '-' or '_' */ 1371| 5.31k| for (std::string_view sub = localeID;;) { 1372| 5.31k| size_t next = sub.find_first_of(".@_-"); 1373| | // For historical reasons, a trailing separator is included in the variant. 1374| 5.31k| bool finished = next == std::string_view::npos || next + 1 == sub.length(); ------------------ | Branch (1374:29): [True: 1.40k, False: 3.90k] | Branch (1374:63): [True: 0, False: 3.90k] ------------------ 1375| 5.31k| size_t limit = finished ? sub.length() : next; ------------------ | Branch (1375:28): [True: 1.40k, False: 3.90k] ------------------ 1376| 5.31k| index += limit; 1377| 5.31k| if (index > MAX_VARIANTS_LENGTH) { ------------------ | Branch (1377:17): [True: 0, False: 5.31k] ------------------ 1378| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1379| 0| return 0; 1380| 0| } 1381| | 1382| 5.31k| if (sink != nullptr) { ------------------ | Branch (1382:17): [True: 5.31k, False: 0] ------------------ 1383| 5.31k| if (needSeparator) { ------------------ | Branch (1383:21): [True: 3.80k, False: 1.50k] ------------------ 1384| 3.80k| sink->Append("_", 1); 1385| 3.80k| } else { 1386| 1.50k| needSeparator = true; 1387| 1.50k| } 1388| | 1389| 5.31k| int32_t length = static_cast(limit); 1390| 5.31k| int32_t minCapacity = uprv_min(length, MAX_VARIANTS_LENGTH); ------------------ | | 1529| 5.31k|#define uprv_min U_ICU_ENTRY_POINT_RENAME(uprv_min) | | ------------------ | | | | 123| 5.31k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.31k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.31k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1391| 5.31k| char scratch[MAX_VARIANTS_LENGTH]; 1392| 5.31k| int32_t capacity = 0; 1393| 5.31k| char* buffer = sink->GetAppendBuffer( 1394| 5.31k| minCapacity, minCapacity, scratch, UPRV_LENGTHOF(scratch), &capacity); ------------------ | | 99| 5.31k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1395| | 1396| 35.3k| for (size_t i = 0; i < limit; ++i) { ------------------ | Branch (1396:36): [True: 30.0k, False: 5.31k] ------------------ 1397| 30.0k| buffer[i] = uprv_toupper(sub[i]); ------------------ | | 1547| 30.0k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 30.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 30.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 30.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1398| 30.0k| } 1399| 5.31k| sink->Append(buffer, length); 1400| 5.31k| } 1401| | 1402| 5.31k| if (finished) { return index; } ------------------ | Branch (1402:17): [True: 1.40k, False: 3.90k] ------------------ 1403| 3.90k| sub.remove_prefix(next); 1404| 3.90k| if (_isTerminator(sub.front()) || _isBCP47Extension(sub)) { return index; } ------------------ | Branch (1404:17): [True: 97, False: 3.80k] | Branch (1404:47): [True: 0, False: 3.80k] ------------------ 1405| 3.80k| sub.remove_prefix(1); 1406| 3.80k| index++; 1407| 3.80k| } 1408| 1.50k| } 1409| | 1410| 0| size_t skip = 0; 1411| | /* if there is no variant tag after a '-' or '_' then look for '@' */ 1412| 0| if (prev == '@') { ------------------ | Branch (1412:9): [True: 0, False: 0] ------------------ 1413| | /* keep localeID */ 1414| 0| } else if (const char* p = locale_getKeywordsStart(localeID); p != nullptr) { ------------------ | | 138| 0|#define locale_getKeywordsStart U_ICU_ENTRY_POINT_RENAME(locale_getKeywordsStart) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1414:67): [True: 0, False: 0] ------------------ 1415| 0| skip = 1 + p - localeID.data(); /* point after the '@' */ 1416| 0| localeID.remove_prefix(skip); 1417| 0| } else { 1418| 0| return 0; 1419| 0| } 1420| 0| for (; index < localeID.size() && !_isTerminator(localeID[index]); index++) { ------------------ | Branch (1420:12): [True: 0, False: 0] | Branch (1420:39): [True: 0, False: 0] ------------------ 1421| 0| if (index >= MAX_VARIANTS_LENGTH) { // same as length > MAX_VARIANTS_LENGTH ------------------ | Branch (1421:13): [True: 0, False: 0] ------------------ 1422| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1423| 0| return 0; 1424| 0| } 1425| 0| if (needSeparator) { ------------------ | Branch (1425:13): [True: 0, False: 0] ------------------ 1426| 0| if (sink != nullptr) { ------------------ | Branch (1426:17): [True: 0, False: 0] ------------------ 1427| 0| sink->Append("_", 1); 1428| 0| } 1429| 0| needSeparator = false; 1430| 0| } 1431| 0| if (sink != nullptr) { ------------------ | Branch (1431:13): [True: 0, False: 0] ------------------ 1432| 0| char c = uprv_toupper(localeID[index]); ------------------ | | 1547| 0|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1433| 0| if (c == '-' || c == ',') c = '_'; ------------------ | Branch (1433:17): [True: 0, False: 0] | Branch (1433:29): [True: 0, False: 0] ------------------ 1434| 0| sink->Append(&c, 1); 1435| 0| } 1436| 0| } 1437| 0| return skip + index; 1438| 0|} uloc.cpp:_ZN12_GLOBAL__N_113_canonicalizeENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEERN6icu_788ByteSinkEjR10UErrorCode: 1806| 25.1k| UErrorCode& err) { 1807| 25.1k| if (U_FAILURE(err)) { ------------------ | Branch (1807:9): [True: 0, False: 25.1k] ------------------ 1808| 0| return; 1809| 0| } 1810| | 1811| 25.1k| int32_t j, fieldCount=0; 1812| 25.1k| CharString tempBuffer; // if localeID has a BCP47 extension, tmpLocaleID points to this 1813| 25.1k| CharString localeIDWithHyphens; // if localeID has a BPC47 extension and have _, tmpLocaleID points to this 1814| 25.1k| std::string_view origLocaleID; 1815| 25.1k| std::string_view tmpLocaleID; 1816| 25.1k| size_t keywordAssign = std::string_view::npos; 1817| 25.1k| size_t separatorIndicator = std::string_view::npos; 1818| | 1819| 25.1k| if (_hasBCP47Extension(localeID)) { ------------------ | Branch (1819:9): [True: 0, False: 25.1k] ------------------ 1820| 0| std::string_view localeIDPtr = localeID; 1821| | 1822| | // convert all underbars to hyphens, unless the "BCP47 extension" comes at the beginning of the string 1823| 0| if (localeID.size() >= 2 && localeID.find('_') != std::string_view::npos && localeID[1] != '-' && localeID[1] != '_') { ------------------ | Branch (1823:13): [True: 0, False: 0] | Branch (1823:37): [True: 0, False: 0] | Branch (1823:85): [True: 0, False: 0] | Branch (1823:107): [True: 0, False: 0] ------------------ 1824| 0| localeIDWithHyphens.append(localeID, err); 1825| 0| if (U_SUCCESS(err)) { ------------------ | Branch (1825:17): [True: 0, False: 0] ------------------ 1826| 0| for (char* p = localeIDWithHyphens.data(); *p != '\0'; ++p) { ------------------ | Branch (1826:60): [True: 0, False: 0] ------------------ 1827| 0| if (*p == '_') { ------------------ | Branch (1827:25): [True: 0, False: 0] ------------------ 1828| 0| *p = '-'; 1829| 0| } 1830| 0| } 1831| 0| localeIDPtr = localeIDWithHyphens.toStringPiece(); 1832| 0| } 1833| 0| } 1834| | 1835| 0| tempBuffer = ulocimp_forLanguageTag(localeIDPtr.data(), static_cast(localeIDPtr.size()), nullptr, err); ------------------ | | 1198| 0|#define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1836| 0| tmpLocaleID = U_SUCCESS(err) && !tempBuffer.isEmpty() ? static_cast(tempBuffer.toStringPiece()) : localeIDPtr; ------------------ | Branch (1836:23): [True: 0, False: 0] | Branch (1836:41): [True: 0, False: 0] ------------------ 1837| 25.1k| } else { 1838| 25.1k| tmpLocaleID=localeID; 1839| 25.1k| } 1840| | 1841| 25.1k| origLocaleID=tmpLocaleID; 1842| | 1843| | /* get all pieces, one after another, and separate with '_' */ 1844| 25.1k| CharString tag; 1845| 25.1k| CharString script; 1846| 25.1k| CharString country; 1847| 25.1k| CharString variant; 1848| 25.1k| const char* end = nullptr; 1849| 25.1k| ulocimp_getSubtags( ------------------ | | 1209| 25.1k|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 25.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 25.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 25.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1850| 25.1k| tmpLocaleID, 1851| 25.1k| &tag, 1852| 25.1k| &script, 1853| 25.1k| &country, 1854| 25.1k| &variant, 1855| 25.1k| &end, 1856| 25.1k| err); 1857| 25.1k| if (U_FAILURE(err)) { ------------------ | Branch (1857:9): [True: 0, False: 25.1k] ------------------ 1858| 0| return; 1859| 0| } 1860| 25.1k| U_ASSERT(end != nullptr); ------------------ | | 35| 25.1k|# define U_ASSERT(exp) (void)0 ------------------ 1861| 25.1k| if (end > tmpLocaleID.data()) { ------------------ | Branch (1861:9): [True: 9.63k, False: 15.5k] ------------------ 1862| 9.63k| tmpLocaleID.remove_prefix(end - tmpLocaleID.data()); 1863| 9.63k| } 1864| | 1865| 25.1k| if (tag.length() == I_DEFAULT_LENGTH && origLocaleID.length() >= I_DEFAULT_LENGTH && ------------------ | Branch (1865:9): [True: 0, False: 25.1k] | Branch (1865:45): [True: 0, False: 0] ------------------ 1866| 25.1k| uprv_strncmp(origLocaleID.data(), i_default, I_DEFAULT_LENGTH) == 0) { ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1866:13): [True: 0, False: 0] ------------------ 1867| 0| tag.clear(); 1868| 0| tag.append(uloc_getDefault(), err); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1869| 25.1k| } else { 1870| 25.1k| if (!script.isEmpty()) { ------------------ | Branch (1870:13): [True: 397, False: 24.7k] ------------------ 1871| 397| ++fieldCount; 1872| 397| tag.append('_', err); 1873| 397| tag.append(script, err); 1874| 397| } 1875| 25.1k| if (!country.isEmpty()) { ------------------ | Branch (1875:13): [True: 1.13k, False: 24.0k] ------------------ 1876| 1.13k| ++fieldCount; 1877| 1.13k| tag.append('_', err); 1878| 1.13k| tag.append(country, err); 1879| 1.13k| } 1880| 25.1k| if (!variant.isEmpty()) { ------------------ | Branch (1880:13): [True: 541, False: 24.6k] ------------------ 1881| 541| ++fieldCount; 1882| 541| if (country.isEmpty()) { ------------------ | Branch (1882:17): [True: 352, False: 189] ------------------ 1883| 352| tag.append('_', err); 1884| 352| } 1885| 541| tag.append('_', err); 1886| 541| tag.append(variant, err); 1887| 541| } 1888| 25.1k| } 1889| | 1890| | /* Copy POSIX-style charset specifier, if any [mr.utf8] */ 1891| 25.1k| if (!OPTION_SET(options, _ULOC_CANONICALIZE) && !tmpLocaleID.empty() && tmpLocaleID.front() == '.') { ------------------ | | 1786| 25.1k|#define _ULOC_CANONICALIZE 0x1 ------------------ | Branch (1891:9): [True: 25.1k, False: 1] | Branch (1891:53): [True: 813, False: 24.3k] | Branch (1891:77): [True: 0, False: 813] ------------------ 1892| 0| tag.append('.', err); 1893| 0| tmpLocaleID.remove_prefix(1); 1894| 0| size_t length; 1895| 0| if (size_t atPos = tmpLocaleID.find('@'); atPos != std::string_view::npos) { ------------------ | Branch (1895:51): [True: 0, False: 0] ------------------ 1896| 0| length = atPos; 1897| 0| } else { 1898| 0| length = tmpLocaleID.length(); 1899| 0| } 1900| | // The longest charset name we found in IANA charset registry 1901| | // https://www.iana.org/assignments/character-sets/ is 1902| | // "Extended_UNIX_Code_Packed_Format_for_Japanese" in length 45. 1903| | // we therefore restrict the length here to be 64 which is a power of 2 1904| | // number that is longer than 45. 1905| 0| constexpr size_t kMaxCharsetLength = 64; 1906| 0| if (length > kMaxCharsetLength) { ------------------ | Branch (1906:13): [True: 0, False: 0] ------------------ 1907| 0| err = U_ILLEGAL_ARGUMENT_ERROR; /* malformed keyword name */ 1908| 0| return; 1909| 0| } 1910| 0| if (length > 0) { ------------------ | Branch (1910:13): [True: 0, False: 0] ------------------ 1911| 0| tag.append(tmpLocaleID.data(), static_cast(length), err); 1912| 0| tmpLocaleID.remove_prefix(length); 1913| 0| } 1914| 0| } 1915| | 1916| | /* Scan ahead to next '@' and determine if it is followed by '=' and/or ';' 1917| | After this, tmpLocaleID either starts at '@' or is empty. */ 1918| 25.1k| if (const char* start = locale_getKeywordsStart(tmpLocaleID); start != nullptr) { ------------------ | | 138| 25.1k|#define locale_getKeywordsStart U_ICU_ENTRY_POINT_RENAME(locale_getKeywordsStart) | | ------------------ | | | | 123| 25.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 25.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 25.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1918:67): [True: 813, False: 24.3k] ------------------ 1919| 813| if (start > tmpLocaleID.data()) { ------------------ | Branch (1919:13): [True: 0, False: 813] ------------------ 1920| 0| tmpLocaleID.remove_prefix(start - tmpLocaleID.data()); 1921| 0| } 1922| 813| keywordAssign = tmpLocaleID.find('='); 1923| 813| separatorIndicator = tmpLocaleID.find(';'); 1924| 24.3k| } else { 1925| 24.3k| tmpLocaleID = {}; 1926| 24.3k| } 1927| | 1928| | /* Copy POSIX-style variant, if any [mr@FOO] */ 1929| 25.1k| if (!OPTION_SET(options, _ULOC_CANONICALIZE) && ------------------ | | 1786| 25.1k|#define _ULOC_CANONICALIZE 0x1 ------------------ | Branch (1929:9): [True: 25.1k, False: 1] ------------------ 1930| 25.1k| !tmpLocaleID.empty() && keywordAssign == std::string_view::npos) { ------------------ | Branch (1930:9): [True: 813, False: 24.3k] | Branch (1930:33): [True: 0, False: 813] ------------------ 1931| 0| tag.append(tmpLocaleID, err); 1932| 0| tmpLocaleID = {}; 1933| 0| } 1934| | 1935| 25.1k| if (OPTION_SET(options, _ULOC_CANONICALIZE)) { ------------------ | | 1786| 25.1k|#define _ULOC_CANONICALIZE 0x1 ------------------ | Branch (1935:9): [True: 1, False: 25.1k] ------------------ 1936| | /* Handle @FOO variant if @ is present and not followed by = */ 1937| 1| if (!tmpLocaleID.empty() && keywordAssign == std::string_view::npos) { ------------------ | Branch (1937:13): [True: 0, False: 1] | Branch (1937:37): [True: 0, False: 0] ------------------ 1938| | /* Add missing '_' if needed */ 1939| 0| if (fieldCount < 2 || (fieldCount < 3 && !script.isEmpty())) { ------------------ | Branch (1939:17): [True: 0, False: 0] | Branch (1939:36): [True: 0, False: 0] | Branch (1939:54): [True: 0, False: 0] ------------------ 1940| 0| do { 1941| 0| tag.append('_', err); 1942| 0| ++fieldCount; 1943| 0| } while(fieldCount<2); ------------------ | Branch (1943:25): [True: 0, False: 0] ------------------ 1944| 0| } 1945| | 1946| 0| CharStringByteSink s(&tag); 1947| 0| std::string_view sub = tmpLocaleID; 1948| 0| sub.remove_prefix(1); 1949| 0| _getVariant(sub, '@', &s, !variant.isEmpty(), err); 1950| 0| if (U_FAILURE(err)) { return; } ------------------ | Branch (1950:17): [True: 0, False: 0] ------------------ 1951| 0| } 1952| | 1953| | /* Look up the ID in the canonicalization map */ 1954| 11| for (j=0; j keywordAssign)) { ------------------ | Branch (1971:14): [True: 0, False: 0] | Branch (1971:62): [True: 0, False: 0] ------------------ 1972| 0| sink.Append("@", 1); 1973| 0| ++fieldCount; 1974| 0| tmpLocaleID.remove_prefix(1); 1975| 0| ulocimp_getKeywords(tmpLocaleID, '@', sink, true, err); ------------------ | | 1201| 0|#define ulocimp_getKeywords U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywords) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1976| 0| } 1977| 15.4k| } 1978| 25.1k|} uloc.cpp:_ZN12_GLOBAL__N_110OPTION_SETEjj: 1790| 100k|inline bool OPTION_SET(uint32_t options, uint32_t mask) { return (options & mask) != 0; } uloc.cpp:_ZN12_GLOBAL__N_121isWellFormedLegacyKeyENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 2421| 1.30k|{ 2422| 1.30k| return std::all_of(key.begin(), key.end(), UPRV_ISALPHANUM); 2423| 1.30k|} uloc.cpp:_ZN12_GLOBAL__N_122isWellFormedLegacyTypeENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 2427| 712|{ 2428| 712| int32_t alphaNumLen = 0; 2429| 8.08k| for (char c : legacyType) { ------------------ | Branch (2429:17): [True: 8.08k, False: 712] ------------------ 2430| 8.08k| if (c == '_' || c == '/' || c == '-') { ------------------ | Branch (2430:13): [True: 0, False: 8.08k] | Branch (2430:25): [True: 0, False: 8.08k] | Branch (2430:37): [True: 837, False: 7.24k] ------------------ 2431| 837| if (alphaNumLen == 0) { ------------------ | Branch (2431:17): [True: 0, False: 837] ------------------ 2432| 0| return false; 2433| 0| } 2434| 837| alphaNumLen = 0; 2435| 7.24k| } else if (UPRV_ISALPHANUM(c)) { ------------------ | Branch (2435:20): [True: 7.24k, False: 0] ------------------ 2436| 7.24k| alphaNumLen++; 2437| 7.24k| } else { 2438| 0| return false; 2439| 0| } 2440| 8.08k| } 2441| 712| return alphaNumLen != 0; 2442| 712|} uloc.cpp:_ZZ26ulocimp_getKeywordValue_78PKcNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEER10UErrorCodeENK3$_0clERN6icu_788ByteSinkES7_: 753| 4.87k| [&](ByteSink& sink, UErrorCode& status) { 754| 4.87k| ulocimp_getKeywordValue(localeID, keywordName, sink, status); ------------------ | | 1200| 4.87k|#define ulocimp_getKeywordValue U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywordValue) | | ------------------ | | | | 123| 4.87k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.87k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.87k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 755| 4.87k| }, uloc.cpp:_ZZ22ulocimp_getBaseName_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEER10UErrorCodeENK3$_0clERN6icu_788ByteSinkES5_: 2197| 9.72k| [&](ByteSink& sink, UErrorCode& status) { 2198| 9.72k| ulocimp_getBaseName(localeID, sink, status); ------------------ | | 1199| 9.72k|#define ulocimp_getBaseName U_ICU_ENTRY_POINT_RENAME(ulocimp_getBaseName) | | ------------------ | | | | 123| 9.72k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.72k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.72k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2199| 9.72k| }, uloc.cpp:_ZZ23ulocimp_canonicalize_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEER10UErrorCodeENK3$_0clERN6icu_788ByteSinkES5_: 2233| 1| [&](ByteSink& sink, UErrorCode& status) { 2234| 1| ulocimp_canonicalize(localeID, sink, status); ------------------ | | 1197| 1|#define ulocimp_canonicalize U_ICU_ENTRY_POINT_RENAME(ulocimp_canonicalize) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2235| 1| }, _Z22ulocimp_toLegacyKey_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEE: 462| 2.23k|ulocimp_toLegacyKey(std::string_view key) { 463| 2.23k| if (!init()) { ------------------ | Branch (463:9): [True: 0, False: 2.23k] ------------------ 464| 0| return std::nullopt; 465| 0| } 466| | 467| 2.23k| LocExtKeyData* keyData = static_cast(uhash_get(gLocExtKeyMap, &key)); ------------------ | | 1007| 2.23k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 2.23k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.23k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.23k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 468| 2.23k| if (keyData != nullptr) { ------------------ | Branch (468:9): [True: 929, False: 1.30k] ------------------ 469| 929| return keyData->legacyId; 470| 929| } 471| | 472| 1.30k| return std::nullopt; 473| 2.23k|} _Z23ulocimp_toLegacyType_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_: 509| 869|ulocimp_toLegacyType(std::string_view key, std::string_view type) { 510| 869| if (!init()) { ------------------ | Branch (510:9): [True: 0, False: 869] ------------------ 511| 0| return std::nullopt; 512| 0| } 513| | 514| 869| LocExtKeyData* keyData = static_cast(uhash_get(gLocExtKeyMap, &key)); ------------------ | | 1007| 869|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 869|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 869|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 869|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 515| 869| if (keyData != nullptr) { ------------------ | Branch (515:9): [True: 363, False: 506] ------------------ 516| 363| LocExtType* t = static_cast(uhash_get(keyData->typeMap.getAlias(), &type)); ------------------ | | 1007| 363|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 363|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 363|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 363|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 517| 363| if (t != nullptr) { ------------------ | Branch (517:13): [True: 133, False: 230] ------------------ 518| 133| return t->legacyId; 519| 133| } 520| 230| if (keyData->specialTypes != SPECIALTYPE_NONE) { ------------------ | Branch (520:13): [True: 68, False: 162] ------------------ 521| 68| bool matched = false; 522| 68| if (keyData->specialTypes & SPECIALTYPE_CODEPOINTS) { ------------------ | Branch (522:17): [True: 38, False: 30] ------------------ 523| 38| matched = isSpecialTypeCodepoints(type); 524| 38| } 525| 68| if (!matched && keyData->specialTypes & SPECIALTYPE_REORDER_CODE) { ------------------ | Branch (525:17): [True: 63, False: 5] | Branch (525:29): [True: 30, False: 33] ------------------ 526| 30| matched = isSpecialTypeReorderCode(type); 527| 30| } 528| 68| if (!matched && keyData->specialTypes & SPECIALTYPE_RG_KEY_VALUE) { ------------------ | Branch (528:17): [True: 44, False: 24] | Branch (528:29): [True: 0, False: 44] ------------------ 529| 0| matched = isSpecialTypeRgKeyValue(type); 530| 0| } 531| 68| if (matched) { ------------------ | Branch (531:17): [True: 24, False: 44] ------------------ 532| 24| return type; 533| 24| } 534| 68| } 535| 230| } 536| | 537| 712| return std::nullopt; 538| 869|} uloc_keytype.cpp:_ZN12_GLOBAL__N_14initEv: 384| 3.10k|init() { 385| 3.10k| UErrorCode sts = U_ZERO_ERROR; 386| 3.10k| umtx_initOnce(gLocExtKeyMapInitOnce, &initFromResourceBundle, sts); 387| 3.10k| if (U_FAILURE(sts)) { ------------------ | Branch (387:9): [True: 0, False: 3.10k] ------------------ 388| 0| return false; 389| 0| } 390| 3.10k| return true; 391| 3.10k|} uloc_keytype.cpp:_ZN12_GLOBAL__N_122initFromResourceBundleER10UErrorCode: 91| 1|initFromResourceBundle(UErrorCode& sts) { 92| 1| U_NAMESPACE_USE ------------------ | | 112| 1|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 93| 1| ucln_common_registerCleanup(UCLN_COMMON_LOCALE_KEY_TYPE, uloc_key_type_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 94| | 95| 1| gLocExtKeyMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1030| 1|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gLocExtKeyMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1013| 1|#define uhash_hashIStringView U_ICU_ENTRY_POINT_RENAME(uhash_hashIStringView) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gLocExtKeyMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 995| 1|#define uhash_compareIStringView U_ICU_ENTRY_POINT_RENAME(uhash_compareIStringView) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 96| | 97| 1| LocalUResourceBundlePointer keyTypeDataRes(ures_openDirect(nullptr, "keyTypeData", &sts)); ------------------ | | 1693| 1|#define ures_openDirect U_ICU_ENTRY_POINT_RENAME(ures_openDirect) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 98| 1| LocalUResourceBundlePointer keyMapRes(ures_getByKey(keyTypeDataRes.getAlias(), "keyMap", nullptr, &sts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 99| 1| LocalUResourceBundlePointer typeMapRes(ures_getByKey(keyTypeDataRes.getAlias(), "typeMap", nullptr, &sts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 100| | 101| 1| if (U_FAILURE(sts)) { ------------------ | Branch (101:9): [True: 0, False: 1] ------------------ 102| 0| return; 103| 0| } 104| | 105| 1| UErrorCode tmpSts = U_ZERO_ERROR; 106| 1| LocalUResourceBundlePointer typeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "typeAlias", nullptr, &tmpSts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 1| tmpSts = U_ZERO_ERROR; 108| 1| LocalUResourceBundlePointer bcpTypeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "bcpTypeAlias", nullptr, &tmpSts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 109| | 110| | // initialize pools storing dynamically allocated objects 111| 1| gKeyTypeStringPool = new icu::MemoryPool; 112| 1| if (gKeyTypeStringPool == nullptr) { ------------------ | Branch (112:9): [True: 0, False: 1] ------------------ 113| 0| sts = U_MEMORY_ALLOCATION_ERROR; 114| 0| return; 115| 0| } 116| 1| gLocExtKeyDataEntries = new icu::MemoryPool; 117| 1| if (gLocExtKeyDataEntries == nullptr) { ------------------ | Branch (117:9): [True: 0, False: 1] ------------------ 118| 0| sts = U_MEMORY_ALLOCATION_ERROR; 119| 0| return; 120| 0| } 121| 1| gLocExtTypeEntries = new icu::MemoryPool; 122| 1| if (gLocExtTypeEntries == nullptr) { ------------------ | Branch (122:9): [True: 0, False: 1] ------------------ 123| 0| sts = U_MEMORY_ALLOCATION_ERROR; 124| 0| return; 125| 0| } 126| 1| gTypeAliasEntries = new icu::MemoryPool; 127| 1| if (gTypeAliasEntries == nullptr) { ------------------ | Branch (127:9): [True: 0, False: 1] ------------------ 128| 0| sts = U_MEMORY_ALLOCATION_ERROR; 129| 0| return; 130| 0| } 131| | 132| | // iterate through keyMap resource 133| 1| LocalUResourceBundlePointer keyMapEntry; 134| | 135| 38| while (ures_hasNext(keyMapRes.getAlias())) { ------------------ | | 1689| 38|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 38|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 38|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 38|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (135:12): [True: 37, False: 1] ------------------ 136| 37| keyMapEntry.adoptInstead(ures_getNextResource(keyMapRes.getAlias(), keyMapEntry.orphan(), &sts)); ------------------ | | 1672| 37|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 137| 37| if (U_FAILURE(sts)) { ------------------ | Branch (137:13): [True: 0, False: 37] ------------------ 138| 0| break; 139| 0| } 140| 37| const char* legacyKeyId = ures_getKey(keyMapEntry.getAlias()); ------------------ | | 1666| 37|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 141| 37| UnicodeString uBcpKeyId = ures_getUnicodeString(keyMapEntry.getAlias(), &sts); 142| 37| if (U_FAILURE(sts)) { ------------------ | Branch (142:13): [True: 0, False: 37] ------------------ 143| 0| break; 144| 0| } 145| | 146| | // empty value indicates that BCP key is same with the legacy key. 147| 37| const char* bcpKeyId = legacyKeyId; 148| 37| if (!uBcpKeyId.isEmpty()) { ------------------ | Branch (148:13): [True: 17, False: 20] ------------------ 149| 17| icu::CharString* bcpKeyIdBuf = gKeyTypeStringPool->create(); 150| 17| if (bcpKeyIdBuf == nullptr) { ------------------ | Branch (150:17): [True: 0, False: 17] ------------------ 151| 0| sts = U_MEMORY_ALLOCATION_ERROR; 152| 0| break; 153| 0| } 154| 17| bcpKeyIdBuf->appendInvariantChars(uBcpKeyId, sts); 155| 17| if (U_FAILURE(sts)) { ------------------ | Branch (155:17): [True: 0, False: 17] ------------------ 156| 0| break; 157| 0| } 158| 17| bcpKeyId = bcpKeyIdBuf->data(); 159| 17| } 160| | 161| 37| bool isTZ = uprv_strcmp(legacyKeyId, "timezone") == 0; ------------------ | | 38| 37|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 37|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 162| | 163| 37| UHashtable* typeDataMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1030| 37|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ UHashtable* typeDataMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1013| 37|#define uhash_hashIStringView U_ICU_ENTRY_POINT_RENAME(uhash_hashIStringView) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ UHashtable* typeDataMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 995| 37|#define uhash_compareIStringView U_ICU_ENTRY_POINT_RENAME(uhash_compareIStringView) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 37| if (U_FAILURE(sts)) { ------------------ | Branch (164:13): [True: 0, False: 37] ------------------ 165| 0| break; 166| 0| } 167| 37| uint32_t specialTypes = SPECIALTYPE_NONE; 168| | 169| 37| LocalUResourceBundlePointer typeAliasResByKey; 170| 37| LocalUResourceBundlePointer bcpTypeAliasResByKey; 171| | 172| 37| if (typeAliasRes.isValid()) { ------------------ | Branch (172:13): [True: 37, False: 0] ------------------ 173| 37| tmpSts = U_ZERO_ERROR; 174| 37| typeAliasResByKey.adoptInstead(ures_getByKey(typeAliasRes.getAlias(), legacyKeyId, nullptr, &tmpSts)); ------------------ | | 1661| 37|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 175| 37| if (U_FAILURE(tmpSts)) { ------------------ | Branch (175:17): [True: 35, False: 2] ------------------ 176| 35| typeAliasResByKey.orphan(); 177| 35| } 178| 37| } 179| 37| if (bcpTypeAliasRes.isValid()) { ------------------ | Branch (179:13): [True: 37, False: 0] ------------------ 180| 37| tmpSts = U_ZERO_ERROR; 181| 37| bcpTypeAliasResByKey.adoptInstead(ures_getByKey(bcpTypeAliasRes.getAlias(), bcpKeyId, nullptr, &tmpSts)); ------------------ | | 1661| 37|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 182| 37| if (U_FAILURE(tmpSts)) { ------------------ | Branch (182:17): [True: 35, False: 2] ------------------ 183| 35| bcpTypeAliasResByKey.orphan(); 184| 35| } 185| 37| } 186| | 187| | // look up type map for the key, and walk through the mapping data 188| 37| LocalUResourceBundlePointer typeMapResByKey(ures_getByKey(typeMapRes.getAlias(), legacyKeyId, nullptr, &sts)); ------------------ | | 1661| 37|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 189| 37| if (U_FAILURE(sts)) { ------------------ | Branch (189:13): [True: 0, False: 37] ------------------ 190| | // We fail here if typeMap does not have an entry corresponding to every entry in keyMap (should 191| | // not happen for valid keyTypeData), or if ures_getByKeyfails fails for some other reason 192| | // (e.g. data file cannot be loaded, using stubdata, over-aggressive data filtering has removed 193| | // something like timezoneTypes.res, etc.). Error code is already set. See ICU-21669. 194| 0| UPRV_UNREACHABLE_ASSERT; ------------------ | | 55| 0|# define UPRV_UNREACHABLE_ASSERT (void)0 ------------------ 195| 37| } else { 196| 37| LocalUResourceBundlePointer typeMapEntry; 197| | 198| 1.09k| while (ures_hasNext(typeMapResByKey.getAlias())) { ------------------ | | 1689| 1.09k|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 1.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (198:20): [True: 1.05k, False: 37] ------------------ 199| 1.05k| typeMapEntry.adoptInstead(ures_getNextResource(typeMapResByKey.getAlias(), typeMapEntry.orphan(), &sts)); ------------------ | | 1672| 1.05k|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 1.05k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.05k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.05k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 1.05k| if (U_FAILURE(sts)) { ------------------ | Branch (200:21): [True: 0, False: 1.05k] ------------------ 201| 0| break; 202| 0| } 203| 1.05k| const char* legacyTypeId = ures_getKey(typeMapEntry.getAlias()); ------------------ | | 1666| 1.05k|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 1.05k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.05k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.05k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 204| | 205| | // special types 206| 1.05k| if (uprv_strcmp(legacyTypeId, "CODEPOINTS") == 0) { ------------------ | | 38| 1.05k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.05k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (206:21): [True: 1, False: 1.05k] ------------------ 207| 1| specialTypes |= SPECIALTYPE_CODEPOINTS; 208| 1| continue; 209| 1| } 210| 1.05k| if (uprv_strcmp(legacyTypeId, "REORDER_CODE") == 0) { ------------------ | | 38| 1.05k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.05k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (210:21): [True: 1, False: 1.05k] ------------------ 211| 1| specialTypes |= SPECIALTYPE_REORDER_CODE; 212| 1| continue; 213| 1| } 214| 1.05k| if (uprv_strcmp(legacyTypeId, "RG_KEY_VALUE") == 0) { ------------------ | | 38| 1.05k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.05k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (214:21): [True: 1, False: 1.05k] ------------------ 215| 1| specialTypes |= SPECIALTYPE_RG_KEY_VALUE; 216| 1| continue; 217| 1| } 218| | 219| 1.05k| if (isTZ) { ------------------ | Branch (219:21): [True: 447, False: 604] ------------------ 220| | // a timezone key uses a colon instead of a slash in the resource. 221| | // e.g. America:Los_Angeles 222| 447| if (uprv_strchr(legacyTypeId, ':') != nullptr) { ------------------ | | 40| 447|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 447|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (222:25): [True: 447, False: 0] ------------------ 223| 447| icu::CharString* legacyTypeIdBuf = 224| 447| gKeyTypeStringPool->create(legacyTypeId, sts); 225| 447| if (legacyTypeIdBuf == nullptr) { ------------------ | Branch (225:29): [True: 0, False: 447] ------------------ 226| 0| sts = U_MEMORY_ALLOCATION_ERROR; 227| 0| break; 228| 0| } 229| 447| if (U_FAILURE(sts)) { ------------------ | Branch (229:29): [True: 0, False: 447] ------------------ 230| 0| break; 231| 0| } 232| 447| std::replace( 233| 447| legacyTypeIdBuf->data(), 234| 447| legacyTypeIdBuf->data() + legacyTypeIdBuf->length(), 235| 447| ':', '/'); 236| 447| legacyTypeId = legacyTypeIdBuf->data(); 237| 447| } 238| 447| } 239| | 240| 1.05k| UnicodeString uBcpTypeId = ures_getUnicodeString(typeMapEntry.getAlias(), &sts); 241| 1.05k| if (U_FAILURE(sts)) { ------------------ | Branch (241:21): [True: 0, False: 1.05k] ------------------ 242| 0| break; 243| 0| } 244| | 245| | // empty value indicates that BCP type is same with the legacy type. 246| 1.05k| const char* bcpTypeId = legacyTypeId; 247| 1.05k| if (!uBcpTypeId.isEmpty()) { ------------------ | Branch (247:21): [True: 484, False: 567] ------------------ 248| 484| icu::CharString* bcpTypeIdBuf = gKeyTypeStringPool->create(); 249| 484| if (bcpTypeIdBuf == nullptr) { ------------------ | Branch (249:25): [True: 0, False: 484] ------------------ 250| 0| sts = U_MEMORY_ALLOCATION_ERROR; 251| 0| break; 252| 0| } 253| 484| bcpTypeIdBuf->appendInvariantChars(uBcpTypeId, sts); 254| 484| if (U_FAILURE(sts)) { ------------------ | Branch (254:25): [True: 0, False: 484] ------------------ 255| 0| break; 256| 0| } 257| 484| bcpTypeId = bcpTypeIdBuf->data(); 258| 484| } 259| | 260| | // Note: legacy type value should never be 261| | // equivalent to bcp type value of a different 262| | // type under the same key. So we use a single 263| | // map for lookup. 264| 1.05k| LocExtType* t = gLocExtTypeEntries->create(); 265| 1.05k| if (t == nullptr) { ------------------ | Branch (265:21): [True: 0, False: 1.05k] ------------------ 266| 0| sts = U_MEMORY_ALLOCATION_ERROR; 267| 0| break; 268| 0| } 269| 1.05k| t->bcpId = bcpTypeId; 270| 1.05k| t->legacyId = legacyTypeId; 271| | 272| 1.05k| uhash_put(typeDataMap, &t->legacyId, t, &sts); ------------------ | | 1032| 1.05k|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 1.05k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.05k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.05k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 273| 1.05k| if (bcpTypeId != legacyTypeId) { ------------------ | Branch (273:21): [True: 484, False: 567] ------------------ 274| | // different type value 275| 484| uhash_put(typeDataMap, &t->bcpId, t, &sts); ------------------ | | 1032| 484|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 484|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 484|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 484|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 276| 484| } 277| 1.05k| if (U_FAILURE(sts)) { ------------------ | Branch (277:21): [True: 0, False: 1.05k] ------------------ 278| 0| break; 279| 0| } 280| | 281| | // also put aliases in the map 282| 1.05k| if (typeAliasResByKey.isValid()) { ------------------ | Branch (282:21): [True: 452, False: 599] ------------------ 283| 452| LocalUResourceBundlePointer typeAliasDataEntry; 284| | 285| 452| ures_resetIterator(typeAliasResByKey.getAlias()); ------------------ | | 1698| 452|#define ures_resetIterator U_ICU_ENTRY_POINT_RENAME(ures_resetIterator) | | ------------------ | | | | 123| 452|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 452|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 452|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 286| 69.2k| while (ures_hasNext(typeAliasResByKey.getAlias()) && U_SUCCESS(sts)) { ------------------ | | 1689| 69.2k|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 69.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 69.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 69.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (286:28): [True: 68.8k, False: 452] | Branch (286:74): [True: 68.8k, False: 0] ------------------ 287| 68.8k| int32_t toLen; 288| 68.8k| typeAliasDataEntry.adoptInstead(ures_getNextResource(typeAliasResByKey.getAlias(), typeAliasDataEntry.orphan(), &sts)); ------------------ | | 1672| 68.8k|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 68.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 68.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 68.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 289| 68.8k| const char16_t* to = ures_getString(typeAliasDataEntry.getAlias(), &toLen, &sts); ------------------ | | 1675| 68.8k|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 68.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 68.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 68.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 290| 68.8k| if (U_FAILURE(sts)) { ------------------ | Branch (290:29): [True: 0, False: 68.8k] ------------------ 291| 0| break; 292| 0| } 293| | // check if this is an alias of canonical legacy type 294| 68.8k| if (uprv_compareInvWithUChar( ------------------ | | 329| 68.8k|# define uprv_compareInvWithUChar uprv_compareInvAscii | | ------------------ | | | | 1402| 68.8k|#define uprv_compareInvAscii U_ICU_ENTRY_POINT_RENAME(uprv_compareInvAscii) | | | | ------------------ | | | | | | 123| 68.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 68.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 68.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (294:29): [True: 155, False: 68.6k] ------------------ 295| 68.8k| nullptr, 296| 68.8k| t->legacyId.data(), 297| 68.8k| static_cast(t->legacyId.size()), 298| 68.8k| to, 299| 68.8k| toLen) == 0) { 300| 155| const char* from = ures_getKey(typeAliasDataEntry.getAlias()); ------------------ | | 1666| 155|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 155|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 155|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 155|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 301| 155| TypeAlias* alias = gTypeAliasEntries->create(TypeAlias{{}, from}); 302| 155| if (isTZ) { ------------------ | Branch (302:33): [True: 154, False: 1] ------------------ 303| | // replace colon with slash if necessary 304| 154| if (uprv_strchr(from, ':') != nullptr) { ------------------ | | 40| 154|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 154|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (304:37): [True: 109, False: 45] ------------------ 305| 109| icu::CharString* fromBuf = 306| 109| gKeyTypeStringPool->create(from, sts); 307| 109| if (fromBuf == nullptr) { ------------------ | Branch (307:41): [True: 0, False: 109] ------------------ 308| 0| sts = U_MEMORY_ALLOCATION_ERROR; 309| 0| break; 310| 0| } 311| 109| if (U_FAILURE(sts)) { ------------------ | Branch (311:41): [True: 0, False: 109] ------------------ 312| 0| break; 313| 0| } 314| 109| std::replace( 315| 109| fromBuf->data(), 316| 109| fromBuf->data() + fromBuf->length(), 317| 109| ':', '/'); 318| 109| alias->from = fromBuf->toStringPiece(); 319| 109| } 320| 154| } 321| 155| uhash_put(typeDataMap, &alias->from, t, &sts); ------------------ | | 1032| 155|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 155|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 155|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 155|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 322| 155| } 323| 68.8k| } 324| 452| if (U_FAILURE(sts)) { ------------------ | Branch (324:25): [True: 0, False: 452] ------------------ 325| 0| break; 326| 0| } 327| 452| } 328| | 329| 1.05k| if (bcpTypeAliasResByKey.isValid()) { ------------------ | Branch (329:21): [True: 465, False: 586] ------------------ 330| 465| LocalUResourceBundlePointer bcpTypeAliasDataEntry; 331| | 332| 465| ures_resetIterator(bcpTypeAliasResByKey.getAlias()); ------------------ | | 1698| 465|#define ures_resetIterator U_ICU_ENTRY_POINT_RENAME(ures_resetIterator) | | ------------------ | | | | 123| 465|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 465|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 465|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 333| 10.3k| while (ures_hasNext(bcpTypeAliasResByKey.getAlias()) && U_SUCCESS(sts)) { ------------------ | | 1689| 10.3k|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 10.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 10.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 10.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (333:28): [True: 9.85k, False: 465] | Branch (333:77): [True: 9.85k, False: 0] ------------------ 334| 9.85k| int32_t toLen; 335| 9.85k| bcpTypeAliasDataEntry.adoptInstead(ures_getNextResource(bcpTypeAliasResByKey.getAlias(), bcpTypeAliasDataEntry.orphan(), &sts)); ------------------ | | 1672| 9.85k|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 9.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 336| 9.85k| const char16_t* to = ures_getString(bcpTypeAliasDataEntry.getAlias(), &toLen, &sts); ------------------ | | 1675| 9.85k|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 9.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 337| 9.85k| if (U_FAILURE(sts)) { ------------------ | Branch (337:29): [True: 0, False: 9.85k] ------------------ 338| 0| break; 339| 0| } 340| | // check if this is an alias of bcp type 341| 9.85k| if (uprv_compareInvWithUChar( ------------------ | | 329| 9.85k|# define uprv_compareInvWithUChar uprv_compareInvAscii | | ------------------ | | | | 1402| 9.85k|#define uprv_compareInvAscii U_ICU_ENTRY_POINT_RENAME(uprv_compareInvAscii) | | | | ------------------ | | | | | | 123| 9.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 9.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 9.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (341:29): [True: 23, False: 9.82k] ------------------ 342| 9.85k| nullptr, 343| 9.85k| t->bcpId.data(), 344| 9.85k| static_cast(t->bcpId.size()), 345| 9.85k| to, 346| 9.85k| toLen) == 0) { 347| 23| const char* from = ures_getKey(bcpTypeAliasDataEntry.getAlias()); ------------------ | | 1666| 23|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 23|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 23|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 23|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 348| 23| TypeAlias* alias = gTypeAliasEntries->create(TypeAlias{{}, from}); 349| 23| uhash_put(typeDataMap, &alias->from, t, &sts); ------------------ | | 1032| 23|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 23|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 23|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 23|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 350| 23| } 351| 9.85k| } 352| 465| if (U_FAILURE(sts)) { ------------------ | Branch (352:25): [True: 0, False: 465] ------------------ 353| 0| break; 354| 0| } 355| 465| } 356| 1.05k| } 357| 37| } 358| 37| if (U_FAILURE(sts)) { ------------------ | Branch (358:13): [True: 0, False: 37] ------------------ 359| 0| break; 360| 0| } 361| | 362| 37| LocExtKeyData* keyData = gLocExtKeyDataEntries->create(); 363| 37| if (keyData == nullptr) { ------------------ | Branch (363:13): [True: 0, False: 37] ------------------ 364| 0| sts = U_MEMORY_ALLOCATION_ERROR; 365| 0| break; 366| 0| } 367| 37| keyData->bcpId = bcpKeyId; 368| 37| keyData->legacyId = legacyKeyId; 369| 37| keyData->specialTypes = specialTypes; 370| 37| keyData->typeMap.adoptInstead(typeDataMap); 371| | 372| 37| uhash_put(gLocExtKeyMap, &keyData->legacyId, keyData, &sts); ------------------ | | 1032| 37|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 373| 37| if (legacyKeyId != bcpKeyId) { ------------------ | Branch (373:13): [True: 17, False: 20] ------------------ 374| | // different key value 375| 17| uhash_put(gLocExtKeyMap, &keyData->bcpId, keyData, &sts); ------------------ | | 1032| 17|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 17|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 17|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 17|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 376| 17| } 377| 37| if (U_FAILURE(sts)) { ------------------ | Branch (377:13): [True: 0, False: 37] ------------------ 378| 0| break; 379| 0| } 380| 37| } 381| 1|} uloc_keytype.cpp:_ZN12_GLOBAL__N_123isSpecialTypeCodepointsENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 394| 38|isSpecialTypeCodepoints(std::string_view val) { 395| 38| int32_t subtagLen = 0; 396| 234| for (char c : val) { ------------------ | Branch (396:17): [True: 234, False: 11] ------------------ 397| 234| if (c == '-') { ------------------ | Branch (397:13): [True: 24, False: 210] ------------------ 398| 24| if (subtagLen < 4 || subtagLen > 6) { ------------------ | Branch (398:17): [True: 6, False: 18] | Branch (398:34): [True: 3, False: 15] ------------------ 399| 9| return false; 400| 9| } 401| 15| subtagLen = 0; 402| 210| } else if ((c >= '0' && c <= '9') || ------------------ | Branch (402:21): [True: 210, False: 0] | Branch (402:33): [True: 18, False: 192] ------------------ 403| 210| (c >= 'A' && c <= 'F') || // A-F/a-f are contiguous ------------------ | Branch (403:22): [True: 192, False: 0] | Branch (403:34): [True: 0, False: 192] ------------------ 404| 210| (c >= 'a' && c <= 'f')) { // also in EBCDIC ------------------ | Branch (404:22): [True: 192, False: 0] | Branch (404:34): [True: 174, False: 18] ------------------ 405| 192| subtagLen++; 406| 192| } else { 407| 18| return false; 408| 18| } 409| 234| } 410| 11| return subtagLen >= 4 && subtagLen <= 6; ------------------ | Branch (410:12): [True: 7, False: 4] | Branch (410:30): [True: 5, False: 2] ------------------ 411| 38|} uloc_keytype.cpp:_ZN12_GLOBAL__N_124isSpecialTypeReorderCodeENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 414| 30|isSpecialTypeReorderCode(std::string_view val) { 415| 30| int32_t subtagLen = 0; 416| 221| for (char c : val) { ------------------ | Branch (416:17): [True: 221, False: 19] ------------------ 417| 221| if (c == '-') { ------------------ | Branch (417:13): [True: 27, False: 194] ------------------ 418| 27| if (subtagLen < 3 || subtagLen > 8) { ------------------ | Branch (418:17): [True: 0, False: 27] | Branch (418:34): [True: 0, False: 27] ------------------ 419| 0| return false; 420| 0| } 421| 27| subtagLen = 0; 422| 194| } else if (uprv_isASCIILetter(c)) { ------------------ | | 1514| 194|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 194|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 194|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 194|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (422:20): [True: 183, False: 11] ------------------ 423| 183| subtagLen++; 424| 183| } else { 425| 11| return false; 426| 11| } 427| 221| } 428| 19| return subtagLen >= 3 && subtagLen <= 8; ------------------ | Branch (428:12): [True: 19, False: 0] | Branch (428:30): [True: 19, False: 0] ------------------ 429| 30|} _Z25ultag_isLanguageSubtag_78PKci: 431| 4.95k|ultag_isLanguageSubtag(const char* s, int32_t len) { 432| | /* 433| | * unicode_language_subtag = alpha{2,3} | alpha{5,8}; 434| | * NOTE: Per ICUTC 2019/01/23- accepting alpha 4 435| | * See ICU-20372 436| | */ 437| 4.95k| if (len < 0) { ------------------ | Branch (437:9): [True: 0, False: 4.95k] ------------------ 438| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 439| 0| } 440| 4.95k| if (len >= 2 && len <= 8 && _isAlphaString(s, len)) { ------------------ | Branch (440:9): [True: 4.90k, False: 52] | Branch (440:21): [True: 4.90k, False: 1] | Branch (440:33): [True: 4.89k, False: 7] ------------------ 441| 4.89k| return true; 442| 4.89k| } 443| 60| return false; 444| 4.95k|} _Z23ultag_isScriptSubtag_78PKci: 466| 1.46k|ultag_isScriptSubtag(const char* s, int32_t len) { 467| | /* 468| | * script = 4ALPHA ; ISO 15924 code 469| | */ 470| 1.46k| if (len < 0) { ------------------ | Branch (470:9): [True: 0, False: 1.46k] ------------------ 471| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 472| 0| } 473| 1.46k| if (len == 4 && _isAlphaString(s, len)) { ------------------ | Branch (473:9): [True: 240, False: 1.22k] | Branch (473:21): [True: 201, False: 39] ------------------ 474| 201| return true; 475| 201| } 476| 1.26k| return false; 477| 1.46k|} _Z23ultag_isRegionSubtag_78PKci: 480| 1.42k|ultag_isRegionSubtag(const char* s, int32_t len) { 481| | /* 482| | * region = 2ALPHA ; ISO 3166-1 code 483| | * / 3DIGIT ; UN M.49 code 484| | */ 485| 1.42k| if (len < 0) { ------------------ | Branch (485:9): [True: 0, False: 1.42k] ------------------ 486| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 487| 0| } 488| 1.42k| if (len == 2 && _isAlphaString(s, len)) { ------------------ | Branch (488:9): [True: 468, False: 959] | Branch (488:21): [True: 465, False: 3] ------------------ 489| 465| return true; 490| 465| } 491| 962| if (len == 3 && _isNumericString(s, len)) { ------------------ | Branch (491:9): [True: 105, False: 857] | Branch (491:21): [True: 99, False: 6] ------------------ 492| 99| return true; 493| 99| } 494| 863| return false; 495| 962|} _Z27ultag_isUnicodeLocaleKey_78PKci: 631| 5.23k|ultag_isUnicodeLocaleKey(const char* s, int32_t len) { 632| | /* 633| | * key = alphanum alpha ; 634| | */ 635| 5.23k| if (len < 0) { ------------------ | Branch (635:9): [True: 0, False: 5.23k] ------------------ 636| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 637| 0| } 638| 5.23k| if (len == 2 && (ISALPHA(*s) || ISNUMERIC(*s)) && ISALPHA(s[1])) { ------------------ | Branch (638:9): [True: 2.81k, False: 2.41k] | Branch (638:22): [True: 2.50k, False: 312] | Branch (638:37): [True: 312, False: 0] | Branch (638:55): [True: 2.74k, False: 68] ------------------ 639| 2.74k| return true; 640| 2.74k| } 641| 2.48k| return false; 642| 5.23k|} _Z25ulocimp_forLanguageTag_78PKciPiR10UErrorCode: 2675| 5.04k| UErrorCode& status) { 2676| 5.04k| return icu::ByteSinkUtil::viaByteSinkToCharString( 2677| 5.04k| [&](icu::ByteSink& sink, UErrorCode& status) { 2678| 5.04k| ulocimp_forLanguageTag(langtag, tagLen, sink, parsedLength, status); 2679| 5.04k| }, 2680| 5.04k| status); 2681| 5.04k|} _Z25ulocimp_forLanguageTag_78PKciRN6icu_788ByteSinkEPiR10UErrorCode: 2688| 5.02k| UErrorCode& status) { 2689| 5.02k| if (U_FAILURE(status)) { return; } ------------------ | Branch (2689:9): [True: 0, False: 5.02k] ------------------ 2690| | 2691| 5.02k| bool isEmpty = true; 2692| 5.02k| const char *subtag, *p; 2693| 5.02k| int32_t len; 2694| 5.02k| int32_t i, n; 2695| 5.02k| bool noRegion = true; 2696| | 2697| 5.02k| icu::LocalULanguageTagPointer lt(ultag_parse(langtag, tagLen, parsedLength, status)); 2698| 5.02k| if (U_FAILURE(status)) { ------------------ | Branch (2698:9): [True: 0, False: 5.02k] ------------------ 2699| 0| return; 2700| 0| } 2701| | 2702| | /* language */ 2703| 5.02k| subtag = ultag_getExtlangSize(lt.getAlias()) > 0 ? ultag_getExtlang(lt.getAlias(), 0) : ultag_getLanguage(lt.getAlias()); ------------------ | Branch (2703:14): [True: 102, False: 4.92k] ------------------ 2704| 5.02k| if (uprv_compareInvCharsAsAscii(subtag, LANG_UND) != 0) { ------------------ | | 153| 5.02k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 5.02k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 5.02k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ | Branch (2704:9): [True: 5.02k, False: 6] ------------------ 2705| 5.02k| len = static_cast(uprv_strlen(subtag)); ------------------ | | 37| 5.02k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 5.02k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2706| 5.02k| if (len > 0) { ------------------ | Branch (2706:13): [True: 4.88k, False: 134] ------------------ 2707| 4.88k| sink.Append(subtag, len); 2708| 4.88k| isEmpty = false; 2709| 4.88k| } 2710| 5.02k| } 2711| | 2712| | /* script */ 2713| 5.02k| subtag = ultag_getScript(lt.getAlias()); 2714| 5.02k| len = static_cast(uprv_strlen(subtag)); ------------------ | | 37| 5.02k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 5.02k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2715| 5.02k| if (len > 0) { ------------------ | Branch (2715:9): [True: 201, False: 4.82k] ------------------ 2716| 201| sink.Append("_", 1); 2717| 201| isEmpty = false; 2718| | 2719| | /* write out the script in title case */ 2720| 201| char c = uprv_toupper(*subtag); ------------------ | | 1547| 201|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 201|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 201|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 201|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2721| 201| sink.Append(&c, 1); 2722| 201| sink.Append(subtag + 1, len - 1); 2723| 201| } 2724| | 2725| | /* region */ 2726| 5.02k| subtag = ultag_getRegion(lt.getAlias()); 2727| 5.02k| len = static_cast(uprv_strlen(subtag)); ------------------ | | 37| 5.02k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 5.02k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2728| 5.02k| if (len > 0) { ------------------ | Branch (2728:9): [True: 564, False: 4.46k] ------------------ 2729| 564| sink.Append("_", 1); 2730| 564| isEmpty = false; 2731| | 2732| | /* write out the region in upper case */ 2733| 564| p = subtag; 2734| 1.79k| while (*p) { ------------------ | Branch (2734:16): [True: 1.22k, False: 564] ------------------ 2735| 1.22k| char c = uprv_toupper(*p); ------------------ | | 1547| 1.22k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 1.22k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.22k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.22k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2736| 1.22k| sink.Append(&c, 1); 2737| 1.22k| p++; 2738| 1.22k| } 2739| 564| noRegion = false; 2740| 564| } 2741| | 2742| | /* variants */ 2743| 5.02k| _sortVariants(lt.getAlias()->variants); 2744| 5.02k| n = ultag_getVariantsSize(lt.getAlias()); 2745| 5.02k| if (n > 0) { ------------------ | Branch (2745:9): [True: 289, False: 4.73k] ------------------ 2746| 289| if (noRegion) { ------------------ | Branch (2746:13): [True: 194, False: 95] ------------------ 2747| 194| sink.Append("_", 1); 2748| 194| isEmpty = false; 2749| 194| } 2750| | 2751| 1.30k| for (i = 0; i < n; i++) { ------------------ | Branch (2751:21): [True: 1.02k, False: 289] ------------------ 2752| 1.02k| subtag = ultag_getVariant(lt.getAlias(), i); 2753| 1.02k| sink.Append("_", 1); 2754| | 2755| | /* write out the variant in upper case */ 2756| 1.02k| p = subtag; 2757| 6.70k| while (*p) { ------------------ | Branch (2757:20): [True: 5.68k, False: 1.02k] ------------------ 2758| 5.68k| char c = uprv_toupper(*p); ------------------ | | 1547| 5.68k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 5.68k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.68k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.68k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2759| 5.68k| sink.Append(&c, 1); 2760| 5.68k| p++; 2761| 5.68k| } 2762| 1.02k| } 2763| 289| } 2764| | 2765| | /* keywords */ 2766| 5.02k| n = ultag_getExtensionsSize(lt.getAlias()); 2767| 5.02k| subtag = ultag_getPrivateUse(lt.getAlias()); 2768| 5.02k| if (n > 0 || uprv_strlen(subtag) > 0) { ------------------ | | 37| 4.20k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 4.20k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (2768:9): [True: 826, False: 4.20k] | Branch (2768:18): [True: 76, False: 4.12k] ------------------ 2769| 902| if (isEmpty && n > 0) { ------------------ | Branch (2769:13): [True: 46, False: 856] | Branch (2769:24): [True: 1, False: 45] ------------------ 2770| | /* need a language */ 2771| 1| sink.Append(LANG_UND, LANG_UND_LEN); ------------------ | | 87| 1|#define LANG_UND_LEN 3 ------------------ 2772| 1| } 2773| 902| _appendKeywords(lt.getAlias(), sink, status); 2774| 902| } 2775| 5.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_114_isAlphaStringEPKci: 385| 5.81k|_isAlphaString(const char* s, int32_t len) { 386| 5.81k| int32_t i; 387| 18.0k| for (i = 0; i < len; i++) { ------------------ | Branch (387:17): [True: 12.4k, False: 5.66k] ------------------ 388| 12.4k| if (!ISALPHA(*(s + i))) { ------------------ | Branch (388:13): [True: 154, False: 12.2k] ------------------ 389| 154| return false; 390| 154| } 391| 12.4k| } 392| 5.66k| return true; 393| 5.81k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116_isNumericStringEPKci: 396| 105|_isNumericString(const char* s, int32_t len) { 397| 105| int32_t i; 398| 406| for (i = 0; i < len; i++) { ------------------ | Branch (398:17): [True: 307, False: 99] ------------------ 399| 307| if (!ISNUMERIC(*(s + i))) { ------------------ | Branch (399:13): [True: 6, False: 301] ------------------ 400| 6| return false; 401| 6| } 402| 307| } 403| 99| return true; 404| 105|} uloc_tag.cpp:_ZN12_GLOBAL__N_116_isVariantSubtagEPKci: 500| 1.92k|_isVariantSubtag(const char* s, int32_t len) { 501| | /* 502| | * variant = 5*8alphanum ; registered variants 503| | * / (DIGIT 3alphanum) 504| | */ 505| 1.92k| if (len < 0) { ------------------ | Branch (505:9): [True: 0, False: 1.92k] ------------------ 506| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 507| 0| } 508| 1.92k| if (_isAlphaNumericStringLimitedLength(s, len, 5, 8)) { ------------------ | Branch (508:9): [True: 785, False: 1.14k] ------------------ 509| 785| return true; 510| 785| } 511| 1.14k| if (len == 4 && ISNUMERIC(*s) && _isAlphaNumericString(s + 1, 3)) { ------------------ | Branch (511:9): [True: 248, False: 892] | Branch (511:21): [True: 242, False: 6] | Branch (511:38): [True: 237, False: 5] ------------------ 512| 237| return true; 513| 237| } 514| 903| return false; 515| 1.14k|} uloc_tag.cpp:_ZN12_GLOBAL__N_121_isAlphaNumericStringEPKci: 407| 6.96k|_isAlphaNumericString(const char* s, int32_t len) { 408| 6.96k| int32_t i; 409| 32.0k| for (i = 0; i < len; i++) { ------------------ | Branch (409:17): [True: 25.1k, False: 6.93k] ------------------ 410| 25.1k| if (!ISALPHA(*(s + i)) && !ISNUMERIC(*(s + i))) { ------------------ | Branch (410:13): [True: 3.44k, False: 21.6k] | Branch (410:35): [True: 32, False: 3.41k] ------------------ 411| 32| return false; 412| 32| } 413| 25.1k| } 414| 6.93k| return true; 415| 6.96k|} uloc_tag.cpp:_ZN12_GLOBAL__N_118_isExtensionSubtagEPKci: 586| 5.66k|_isExtensionSubtag(const char* s, int32_t len) { 587| | /* 588| | * extension = singleton 1*("-" (2*8alphanum)) 589| | */ 590| 5.66k| return _isAlphaNumericStringLimitedLength(s, len, 2, 8); 591| 5.66k|} uloc_tag.cpp:_ZN12_GLOBAL__N_124_isPrivateuseValueSubtagEPKci: 603| 327|_isPrivateuseValueSubtag(const char* s, int32_t len) { 604| | /* 605| | * privateuse = "x" 1*("-" (1*8alphanum)) 606| | */ 607| 327| return _isAlphaNumericStringLimitedLength(s, len, 1, 8); 608| 327|} uloc_tag.cpp:_ZN12_GLOBAL__N_134_isAlphaNumericStringLimitedLengthEPKciii: 418| 7.91k|_isAlphaNumericStringLimitedLength(const char* s, int32_t len, int32_t min, int32_t max) { 419| 7.91k| if (len < 0) { ------------------ | Branch (419:9): [True: 0, False: 7.91k] ------------------ 420| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 421| 0| } 422| 7.91k| if (len >= min && len <= max && _isAlphaNumericString(s, len)) { ------------------ | Branch (422:9): [True: 6.73k, False: 1.18k] | Branch (422:23): [True: 6.72k, False: 12] | Branch (422:37): [True: 6.69k, False: 27] ------------------ 423| 6.69k| return true; 424| 6.69k| } 425| 1.22k| return false; 426| 7.91k|} uloc_tag.cpp:_ZN12_GLOBAL__N_19ISNUMERICEc: 75| 4.37k|inline bool ISNUMERIC(char c) { return c >= '0' && c <= '9'; } ------------------ | Branch (75:40): [True: 4.34k, False: 34] | Branch (75:52): [True: 4.32k, False: 12] ------------------ uloc_tag.cpp:_ZN12_GLOBAL__N_117_addVariantToListEPPNS_16VariantListEntryEN6icu_7812LocalPointerIS0_EE: 872| 1.02k|_addVariantToList(VariantListEntry **first, icu::LocalPointer var) { 873| 1.02k| if (*first == nullptr) { ------------------ | Branch (873:9): [True: 289, False: 733] ------------------ 874| 289| var->next = nullptr; 875| 289| *first = var.orphan(); 876| 733| } else { 877| 733| VariantListEntry *prev, *cur; 878| 733| int32_t cmp; 879| | 880| | /* variants order should be preserved */ 881| 733| prev = nullptr; 882| 733| cur = *first; 883| 3.23k| while (true) { ------------------ | Branch (883:16): [Folded - Ignored] ------------------ 884| 3.23k| if (cur == nullptr) { ------------------ | Branch (884:17): [True: 731, False: 2.50k] ------------------ 885| 731| var->next = nullptr; 886| 731| prev->next = var.orphan(); 887| 731| break; 888| 731| } 889| | 890| | /* Checking for duplicate variant */ 891| 2.50k| cmp = uprv_compareInvCharsAsAscii(var->variant, cur->variant); ------------------ | | 153| 2.50k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 2.50k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 2.50k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 892| 2.50k| if (cmp == 0) { ------------------ | Branch (892:17): [True: 2, False: 2.50k] ------------------ 893| | /* duplicated variant */ 894| 2| return false; 895| 2| } 896| 2.50k| prev = cur; 897| 2.50k| cur = cur->next; 898| 2.50k| } 899| 733| } 900| | 901| 1.02k| return true; 902| 1.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_119_addAttributeToListEPPNS_18AttributeListEntryES1_: 905| 755|_addAttributeToList(AttributeListEntry **first, AttributeListEntry *attr) { 906| 755| bool bAdded = true; 907| | 908| 755| if (*first == nullptr) { ------------------ | Branch (908:9): [True: 92, False: 663] ------------------ 909| 92| attr->next = nullptr; 910| 92| *first = attr; 911| 663| } else { 912| 663| AttributeListEntry *prev, *cur; 913| 663| int32_t cmp; 914| | 915| | /* reorder variants in alphabetical order */ 916| 663| prev = nullptr; 917| 663| cur = *first; 918| 3.39k| while (true) { ------------------ | Branch (918:16): [Folded - Ignored] ------------------ 919| 3.39k| if (cur == nullptr) { ------------------ | Branch (919:17): [True: 105, False: 3.28k] ------------------ 920| 105| prev->next = attr; 921| 105| attr->next = nullptr; 922| 105| break; 923| 105| } 924| 3.28k| cmp = uprv_compareInvCharsAsAscii(attr->attribute, cur->attribute); ------------------ | | 153| 3.28k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 3.28k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 3.28k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 925| 3.28k| if (cmp < 0) { ------------------ | Branch (925:17): [True: 199, False: 3.08k] ------------------ 926| 199| if (prev == nullptr) { ------------------ | Branch (926:21): [True: 24, False: 175] ------------------ 927| 24| *first = attr; 928| 175| } else { 929| 175| prev->next = attr; 930| 175| } 931| 199| attr->next = cur; 932| 199| break; 933| 199| } 934| 3.08k| if (cmp == 0) { ------------------ | Branch (934:17): [True: 359, False: 2.72k] ------------------ 935| | /* duplicated variant */ 936| 359| bAdded = false; 937| 359| break; 938| 359| } 939| 2.72k| prev = cur; 940| 2.72k| cur = cur->next; 941| 2.72k| } 942| 663| } 943| | 944| 755| return bAdded; 945| 755|} uloc_tag.cpp:_ZN12_GLOBAL__N_121_isExtensionSingletonEPKci: 566| 5.77k|_isExtensionSingleton(const char* s, int32_t len) { 567| | /* 568| | * extension = singleton 1*("-" (2*8alphanum)) 569| | * 570| | * singleton = DIGIT ; 0 - 9 571| | * / %x41-57 ; A - W 572| | * / %x59-5A ; Y - Z 573| | * / %x61-77 ; a - w 574| | * / %x79-7A ; y - z 575| | */ 576| 5.77k| if (len < 0) { ------------------ | Branch (576:9): [True: 0, False: 5.77k] ------------------ 577| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 578| 0| } 579| 5.77k| if (len == 1 && (ISALPHA(*s) || ISNUMERIC(*s)) && (uprv_tolower(*s) != PRIVATEUSE)) { ------------------ | | 68| 1.25k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 1.25k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 1.25k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 1.25k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.25k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (len == 1 && (ISALPHA(*s) || ISNUMERIC(*s)) && (uprv_tolower(*s) != PRIVATEUSE)) { ------------------ | | 66| 1.25k|#define PRIVATEUSE 'x' ------------------ | Branch (579:9): [True: 1.26k, False: 4.51k] | Branch (579:22): [True: 1.19k, False: 62] | Branch (579:37): [True: 60, False: 2] | Branch (579:55): [True: 1.18k, False: 70] ------------------ 580| 1.18k| return true; 581| 1.18k| } 582| 4.58k| return false; 583| 5.77k|} uloc_tag.cpp:_ZN12_GLOBAL__N_119_addExtensionToListEPPNS_18ExtensionListEntryES1_b: 948| 5.06k|_addExtensionToList(ExtensionListEntry **first, ExtensionListEntry *ext, bool localeToBCP) { 949| 5.06k| bool bAdded = true; 950| | 951| 5.06k| if (*first == nullptr) { ------------------ | Branch (951:9): [True: 2.30k, False: 2.76k] ------------------ 952| 2.30k| ext->next = nullptr; 953| 2.30k| *first = ext; 954| 2.76k| } else { 955| 2.76k| ExtensionListEntry *prev, *cur; 956| 2.76k| int32_t cmp; 957| | 958| | /* reorder variants in alphabetical order */ 959| 2.76k| prev = nullptr; 960| 2.76k| cur = *first; 961| 6.85k| while (true) { ------------------ | Branch (961:16): [Folded - Ignored] ------------------ 962| 6.85k| if (cur == nullptr) { ------------------ | Branch (962:17): [True: 720, False: 6.13k] ------------------ 963| 720| prev->next = ext; 964| 720| ext->next = nullptr; 965| 720| break; 966| 720| } 967| 6.13k| if (localeToBCP) { ------------------ | Branch (967:17): [True: 0, False: 6.13k] ------------------ 968| | /* special handling for locale to bcp conversion */ 969| 0| int32_t len, curlen; 970| | 971| 0| len = static_cast(uprv_strlen(ext->key)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 972| 0| curlen = static_cast(uprv_strlen(cur->key)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 973| | 974| 0| if (len == 1 && curlen == 1) { ------------------ | Branch (974:21): [True: 0, False: 0] | Branch (974:33): [True: 0, False: 0] ------------------ 975| 0| if (*(ext->key) == *(cur->key)) { ------------------ | Branch (975:25): [True: 0, False: 0] ------------------ 976| 0| cmp = 0; 977| 0| } else if (*(ext->key) == PRIVATEUSE) { ------------------ | | 66| 0|#define PRIVATEUSE 'x' ------------------ | Branch (977:32): [True: 0, False: 0] ------------------ 978| 0| cmp = 1; 979| 0| } else if (*(cur->key) == PRIVATEUSE) { ------------------ | | 66| 0|#define PRIVATEUSE 'x' ------------------ | Branch (979:32): [True: 0, False: 0] ------------------ 980| 0| cmp = -1; 981| 0| } else { 982| 0| cmp = *(ext->key) - *(cur->key); 983| 0| } 984| 0| } else if (len == 1) { ------------------ | Branch (984:28): [True: 0, False: 0] ------------------ 985| 0| cmp = *(ext->key) - LDMLEXT; ------------------ | | 67| 0|#define LDMLEXT 'u' ------------------ 986| 0| } else if (curlen == 1) { ------------------ | Branch (986:28): [True: 0, False: 0] ------------------ 987| 0| cmp = LDMLEXT - *(cur->key); ------------------ | | 67| 0|#define LDMLEXT 'u' ------------------ 988| 0| } else { 989| 0| cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); ------------------ | | 153| 0|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 990| | /* Both are u extension keys - we need special handling for 'attribute' */ 991| 0| if (cmp != 0) { ------------------ | Branch (991:25): [True: 0, False: 0] ------------------ 992| 0| if (uprv_strcmp(cur->key, LOCALE_ATTRIBUTE_KEY) == 0) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (992:29): [True: 0, False: 0] ------------------ 993| 0| cmp = 1; 994| 0| } else if (uprv_strcmp(ext->key, LOCALE_ATTRIBUTE_KEY) == 0) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (994:36): [True: 0, False: 0] ------------------ 995| 0| cmp = -1; 996| 0| } 997| 0| } 998| 0| } 999| 6.13k| } else { 1000| 6.13k| cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); ------------------ | | 153| 6.13k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 6.13k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 6.13k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 1001| 6.13k| } 1002| 6.13k| if (cmp < 0) { ------------------ | Branch (1002:17): [True: 633, False: 5.49k] ------------------ 1003| 633| if (prev == nullptr) { ------------------ | Branch (1003:21): [True: 388, False: 245] ------------------ 1004| 388| *first = ext; 1005| 388| } else { 1006| 245| prev->next = ext; 1007| 245| } 1008| 633| ext->next = cur; 1009| 633| break; 1010| 633| } 1011| 5.49k| if (cmp == 0) { ------------------ | Branch (1011:17): [True: 1.40k, False: 4.09k] ------------------ 1012| | /* duplicated extension key */ 1013| 1.40k| bAdded = false; 1014| 1.40k| break; 1015| 1.40k| } 1016| 4.09k| prev = cur; 1017| 4.09k| cur = cur->next; 1018| 4.09k| } 1019| 2.76k| } 1020| | 1021| 5.06k| return bAdded; 1022| 5.06k|} uloc_tag.cpp:_ZN12_GLOBAL__N_111ultag_parseEPKciPiR10UErrorCode: 1979| 5.02k|ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode& status) { 1980| 5.02k| if (U_FAILURE(status)) { return nullptr; } ------------------ | Branch (1980:9): [True: 0, False: 5.02k] ------------------ 1981| | 1982| 5.02k| char *tagBuf; 1983| 5.02k| int16_t next; 1984| 5.02k| char *pSubtag, *pNext, *pLastGoodPosition; 1985| 5.02k| int32_t subtagLen; 1986| 5.02k| int32_t extlangIdx; 1987| 5.02k| icu::LocalPointer pExtension; 1988| 5.02k| char *pExtValueSubtag, *pExtValueSubtagEnd; 1989| 5.02k| int32_t i; 1990| 5.02k| bool privateuseVar = false; 1991| 5.02k| int32_t legacyLen = 0; 1992| | 1993| 5.02k| if (parsedLen != nullptr) { ------------------ | Branch (1993:9): [True: 5.02k, False: 0] ------------------ 1994| 5.02k| *parsedLen = 0; 1995| 5.02k| } 1996| | 1997| 5.02k| if (tagLen < 0) { ------------------ | Branch (1997:9): [True: 5.02k, False: 0] ------------------ 1998| 5.02k| tagLen = static_cast(uprv_strlen(tag)); ------------------ | | 37| 5.02k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 5.02k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1999| 5.02k| } 2000| | 2001| | /* copy the entire string */ 2002| 5.02k| tagBuf = static_cast(uprv_malloc(tagLen + 1)); ------------------ | | 1524| 5.02k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 5.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2003| 5.02k| if (tagBuf == nullptr) { ------------------ | Branch (2003:9): [True: 0, False: 5.02k] ------------------ 2004| 0| status = U_MEMORY_ALLOCATION_ERROR; 2005| 0| return nullptr; 2006| 0| } 2007| | 2008| 5.02k| if (tagLen > 0) { ------------------ | Branch (2008:9): [True: 4.95k, False: 74] ------------------ 2009| 4.95k| uprv_memcpy(tagBuf, tag, tagLen); ------------------ | | 42| 4.95k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.95k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 4.95k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 4.95k| _Pragma("clang diagnostic push") \ | | 45| 4.95k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 4.95k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4.95k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 4.95k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4.95k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 4.95k| _Pragma("clang diagnostic pop") \ | | 49| 4.95k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 4.95k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 4.95k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.95k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2010| 4.95k| } 2011| 5.02k| *(tagBuf + tagLen) = 0; 2012| | 2013| | /* create a ULanguageTag */ 2014| 5.02k| icu::LocalULanguageTagPointer t( 2015| 5.02k| static_cast(uprv_malloc(sizeof(ULanguageTag)))); ------------------ | | 1524| 5.02k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 5.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2016| 5.02k| if (t.isNull()) { ------------------ | Branch (2016:9): [True: 0, False: 5.02k] ------------------ 2017| 0| uprv_free(tagBuf); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2018| 0| status = U_MEMORY_ALLOCATION_ERROR; 2019| 0| return nullptr; 2020| 0| } 2021| 5.02k| _initializeULanguageTag(t.getAlias()); 2022| 5.02k| t->buf = tagBuf; 2023| | 2024| 5.02k| if (tagLen < MINLEN) { ------------------ | | 64| 5.02k|#define MINLEN 2 ------------------ | Branch (2024:9): [True: 74, False: 4.95k] ------------------ 2025| | /* the input tag is too short - return empty ULanguageTag */ 2026| 74| return t.orphan(); 2027| 74| } 2028| | 2029| 4.95k| size_t parsedLenDelta = 0; 2030| | // Legacy tag will be consider together. Legacy tag with intervening 2031| | // script and region such as art-DE-lojban or art-Latn-lojban won't be 2032| | // matched. 2033| | /* check if the tag is legacy */ 2034| 128k| for (i = 0; i < UPRV_LENGTHOF(LEGACY); i += 2) { ------------------ | | 99| 128k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (2034:17): [True: 123k, False: 4.95k] ------------------ 2035| 123k| int32_t checkLegacyLen = static_cast(uprv_strlen(LEGACY[i])); ------------------ | | 37| 123k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 123k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2036| 123k| if (tagLen < checkLegacyLen) { ------------------ | Branch (2036:13): [True: 95.4k, False: 28.3k] ------------------ 2037| 95.4k| continue; 2038| 95.4k| } 2039| 28.3k| if (tagLen > checkLegacyLen && tagBuf[checkLegacyLen] != '-') { ------------------ | Branch (2039:13): [True: 24.8k, False: 3.50k] | Branch (2039:40): [True: 20.2k, False: 4.60k] ------------------ 2040| | // make sure next char is '-'. 2041| 20.2k| continue; 2042| 20.2k| } 2043| 8.10k| if (uprv_strnicmp(LEGACY[i], tagBuf, checkLegacyLen) == 0) { ------------------ | | 1544| 8.10k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 8.10k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.10k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.10k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2043:13): [True: 0, False: 8.10k] ------------------ 2044| 0| int32_t newTagLength; 2045| | 2046| 0| legacyLen = checkLegacyLen; /* back up for output parsedLen */ 2047| 0| int32_t replacementLen = static_cast(uprv_strlen(LEGACY[i+1])); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2048| 0| newTagLength = replacementLen + tagLen - checkLegacyLen; 2049| 0| int32_t oldTagLength = tagLen; 2050| 0| if (tagLen < newTagLength) { ------------------ | Branch (2050:17): [True: 0, False: 0] ------------------ 2051| 0| uprv_free(tagBuf); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2052| | // Change t->buf after the free and before return to avoid the second double free in 2053| | // the destructor of t when t is out of scope. 2054| 0| t->buf = tagBuf = static_cast(uprv_malloc(newTagLength + 1)); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2055| 0| if (tagBuf == nullptr) { ------------------ | Branch (2055:21): [True: 0, False: 0] ------------------ 2056| 0| status = U_MEMORY_ALLOCATION_ERROR; 2057| 0| return nullptr; 2058| 0| } 2059| 0| tagLen = newTagLength; 2060| 0| } 2061| 0| parsedLenDelta = checkLegacyLen - replacementLen; 2062| 0| uprv_strcpy(t->buf, LEGACY[i + 1]); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2063| 0| if (checkLegacyLen != tagLen) { ------------------ | Branch (2063:17): [True: 0, False: 0] ------------------ 2064| 0| uprv_memcpy(t->buf + replacementLen, tag + checkLegacyLen, ------------------ | | 42| 0|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 0| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 0| _Pragma("clang diagnostic push") \ | | 45| 0| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 0| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 0| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 0| _Pragma("clang diagnostic pop") \ | | 49| 0| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2065| 0| oldTagLength - checkLegacyLen); 2066| | // NUL-terminate after memcpy(). 2067| 0| t->buf[replacementLen + oldTagLength - checkLegacyLen] = 0; 2068| 0| } 2069| 0| break; 2070| 0| } 2071| 8.10k| } 2072| | 2073| 4.95k| if (legacyLen == 0) { ------------------ | Branch (2073:9): [True: 4.95k, False: 0] ------------------ 2074| 133k| for (i = 0; i < UPRV_LENGTHOF(REDUNDANT); i += 2) { ------------------ | | 99| 133k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (2074:21): [True: 128k, False: 4.95k] ------------------ 2075| 128k| const char* redundantTag = REDUNDANT[i]; 2076| 128k| size_t redundantTagLen = uprv_strlen(redundantTag); ------------------ | | 37| 128k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 128k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2077| | // The preferred tag for a redundant tag is always shorter than redundant 2078| | // tag. A redundant tag may or may not be followed by other subtags. 2079| | // (i.e. "zh-yue" or "zh-yue-u-co-pinyin"). 2080| 128k| if (uprv_strnicmp(redundantTag, tagBuf, static_cast(redundantTagLen)) == 0) { ------------------ | | 1544| 128k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 128k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 128k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 128k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2080:17): [True: 0, False: 128k] ------------------ 2081| 0| const char* redundantTagEnd = tagBuf + redundantTagLen; 2082| 0| if (*redundantTagEnd == '\0' || *redundantTagEnd == SEP) { ------------------ | | 65| 0|#define SEP '-' ------------------ | Branch (2082:21): [True: 0, False: 0] | Branch (2082:50): [True: 0, False: 0] ------------------ 2083| 0| const char* preferredTag = REDUNDANT[i + 1]; 2084| 0| size_t preferredTagLen = uprv_strlen(preferredTag); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2085| 0| uprv_memcpy(t->buf, preferredTag, preferredTagLen); ------------------ | | 42| 0|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 0| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 0| _Pragma("clang diagnostic push") \ | | 45| 0| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 0| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 0| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 0| _Pragma("clang diagnostic pop") \ | | 49| 0| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2086| 0| if (*redundantTagEnd == SEP) { ------------------ | | 65| 0|#define SEP '-' ------------------ | Branch (2086:25): [True: 0, False: 0] ------------------ 2087| 0| uprv_memmove(tagBuf + preferredTagLen, ------------------ | | 51| 0|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 0| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 0| _Pragma("clang diagnostic push") \ | | 54| 0| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 0| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 0| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 0| _Pragma("clang diagnostic pop") \ | | 58| 0| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2088| 0| redundantTagEnd, 2089| 0| tagLen - redundantTagLen + 1); 2090| 0| } else { 2091| 0| tagBuf[preferredTagLen] = '\0'; 2092| 0| } 2093| | // parsedLen should be the length of the input 2094| | // before redundantTag is replaced by preferredTag. 2095| | // Save the delta to add it back later. 2096| 0| parsedLenDelta = redundantTagLen - preferredTagLen; 2097| 0| break; 2098| 0| } 2099| 0| } 2100| 128k| } 2101| 4.95k| } 2102| | 2103| | /* 2104| | * langtag = language 2105| | * ["-" script] 2106| | * ["-" region] 2107| | * *("-" variant) 2108| | * *("-" extension) 2109| | * ["-" privateuse] 2110| | */ 2111| | 2112| 4.95k| next = LANG | PRIV; ------------------ | | 1959| 4.95k|#define LANG 0x0001 ------------------ next = LANG | PRIV; ------------------ | | 1966| 4.95k|#define PRIV 0x0080 ------------------ 2113| 4.95k| pNext = pLastGoodPosition = tagBuf; 2114| 4.95k| extlangIdx = 0; 2115| 4.95k| pExtValueSubtag = nullptr; 2116| 4.95k| pExtValueSubtagEnd = nullptr; 2117| | 2118| 18.5k| while (pNext) { ------------------ | Branch (2118:12): [True: 13.7k, False: 4.74k] ------------------ 2119| 13.7k| char *pSep; 2120| | 2121| 13.7k| pSubtag = pNext; 2122| | 2123| | /* locate next separator char */ 2124| 13.7k| pSep = pSubtag; 2125| 52.1k| while (*pSep) { ------------------ | Branch (2125:16): [True: 47.3k, False: 4.79k] ------------------ 2126| 47.3k| if (*pSep == SEP) { ------------------ | | 65| 47.3k|#define SEP '-' ------------------ | Branch (2126:17): [True: 8.96k, False: 38.3k] ------------------ 2127| 8.96k| break; 2128| 8.96k| } 2129| 38.3k| pSep++; 2130| 38.3k| } 2131| 13.7k| if (*pSep == 0) { ------------------ | Branch (2131:13): [True: 4.79k, False: 8.96k] ------------------ 2132| | /* last subtag */ 2133| 4.79k| pNext = nullptr; 2134| 8.96k| } else { 2135| 8.96k| pNext = pSep + 1; 2136| 8.96k| } 2137| 13.7k| subtagLen = static_cast(pSep - pSubtag); 2138| | 2139| 13.7k| if (next & LANG) { ------------------ | | 1959| 13.7k|#define LANG 0x0001 ------------------ | Branch (2139:13): [True: 4.95k, False: 8.81k] ------------------ 2140| 4.95k| if (ultag_isLanguageSubtag(pSubtag, subtagLen)) { ------------------ | | 1225| 4.95k|#define ultag_isLanguageSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isLanguageSubtag) | | ------------------ | | | | 123| 4.95k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.95k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.95k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2140:17): [True: 4.89k, False: 60] ------------------ 2141| 4.89k| *pSep = 0; /* terminate */ 2142| | // TODO: move deprecated language code handling here. 2143| 4.89k| t->language = T_CString_toLowerCase(pSubtag); ------------------ | | 69| 4.89k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 4.89k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.89k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.89k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2144| | 2145| 4.89k| pLastGoodPosition = pSep; 2146| 4.89k| next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1961| 4.89k|#define SCRT 0x0004 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1962| 4.89k|#define REGN 0x0008 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1963| 4.89k|#define VART 0x0010 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1964| 4.89k|#define EXTS 0x0020 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1966| 4.89k|#define PRIV 0x0080 ------------------ 2147| 4.89k| if (subtagLen <= 3) ------------------ | Branch (2147:21): [True: 4.83k, False: 63] ------------------ 2148| 4.83k| next |= EXTL; ------------------ | | 1960| 4.83k|#define EXTL 0x0002 ------------------ 2149| 4.89k| continue; 2150| 4.89k| } 2151| 4.95k| } 2152| 8.87k| if (next & EXTL) { ------------------ | | 1960| 8.87k|#define EXTL 0x0002 ------------------ | Branch (2152:13): [True: 1.52k, False: 7.35k] ------------------ 2153| 1.52k| if (_isExtlangSubtag(pSubtag, subtagLen)) { ------------------ | Branch (2153:17): [True: 105, False: 1.41k] ------------------ 2154| 105| *pSep = 0; 2155| 105| t->extlang[extlangIdx++] = T_CString_toLowerCase(pSubtag); ------------------ | | 69| 105|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 105|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 105|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 105|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2156| | 2157| 105| pLastGoodPosition = pSep; 2158| 105| if (extlangIdx < 3) { ------------------ | Branch (2158:21): [True: 104, False: 1] ------------------ 2159| 104| next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1960| 104|#define EXTL 0x0002 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1961| 104|#define SCRT 0x0004 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1962| 104|#define REGN 0x0008 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1963| 104|#define VART 0x0010 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1964| 104|#define EXTS 0x0020 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1966| 104|#define PRIV 0x0080 ------------------ 2160| 104| } else { 2161| 1| next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1961| 1|#define SCRT 0x0004 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1962| 1|#define REGN 0x0008 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1963| 1|#define VART 0x0010 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1964| 1|#define EXTS 0x0020 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1966| 1|#define PRIV 0x0080 ------------------ 2162| 1| } 2163| 105| continue; 2164| 105| } 2165| 1.52k| } 2166| 8.76k| if (next & SCRT) { ------------------ | | 1961| 8.76k|#define SCRT 0x0004 ------------------ | Branch (2166:13): [True: 1.46k, False: 7.30k] ------------------ 2167| 1.46k| if (ultag_isScriptSubtag(pSubtag, subtagLen)) { ------------------ | | 1228| 1.46k|#define ultag_isScriptSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isScriptSubtag) | | ------------------ | | | | 123| 1.46k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.46k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.46k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2167:17): [True: 201, False: 1.26k] ------------------ 2168| 201| char *p = pSubtag; 2169| | 2170| 201| *pSep = 0; 2171| | 2172| | /* to title case */ 2173| 201| *p = uprv_toupper(*p); ------------------ | | 1547| 201|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 201|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 201|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 201|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2174| 201| p++; 2175| 804| for (; *p; p++) { ------------------ | Branch (2175:24): [True: 603, False: 201] ------------------ 2176| 603| *p = uprv_tolower(*p); ------------------ | | 68| 603|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 603|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 603|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 603|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 603|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2177| 603| } 2178| | 2179| 201| t->script = pSubtag; 2180| | 2181| 201| pLastGoodPosition = pSep; 2182| 201| next = REGN | VART | EXTS | PRIV; ------------------ | | 1962| 201|#define REGN 0x0008 ------------------ next = REGN | VART | EXTS | PRIV; ------------------ | | 1963| 201|#define VART 0x0010 ------------------ next = REGN | VART | EXTS | PRIV; ------------------ | | 1964| 201|#define EXTS 0x0020 ------------------ next = REGN | VART | EXTS | PRIV; ------------------ | | 1966| 201|#define PRIV 0x0080 ------------------ 2183| 201| continue; 2184| 201| } 2185| 1.46k| } 2186| 8.56k| if (next & REGN) { ------------------ | | 1962| 8.56k|#define REGN 0x0008 ------------------ | Branch (2186:13): [True: 1.42k, False: 7.14k] ------------------ 2187| 1.42k| if (ultag_isRegionSubtag(pSubtag, subtagLen)) { ------------------ | | 1227| 1.42k|#define ultag_isRegionSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isRegionSubtag) | | ------------------ | | | | 123| 1.42k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.42k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.42k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2187:17): [True: 564, False: 863] ------------------ 2188| 564| *pSep = 0; 2189| | // TODO: move deprecated region code handling here. 2190| 564| t->region = T_CString_toUpperCase(pSubtag); ------------------ | | 70| 564|#define T_CString_toUpperCase U_ICU_ENTRY_POINT_RENAME(T_CString_toUpperCase) | | ------------------ | | | | 123| 564|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 564|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 564|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2191| | 2192| 564| pLastGoodPosition = pSep; 2193| 564| next = VART | EXTS | PRIV; ------------------ | | 1963| 564|#define VART 0x0010 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1964| 564|#define EXTS 0x0020 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1966| 564|#define PRIV 0x0080 ------------------ 2194| 564| continue; 2195| 564| } 2196| 1.42k| } 2197| 8.00k| if (next & VART) { ------------------ | | 1963| 8.00k|#define VART 0x0010 ------------------ | Branch (2197:13): [True: 1.92k, False: 6.07k] ------------------ 2198| 1.92k| if (_isVariantSubtag(pSubtag, subtagLen) || ------------------ | Branch (2198:17): [True: 1.02k, False: 903] ------------------ 2199| 1.92k| (privateuseVar && _isPrivateuseVariantSubtag(pSubtag, subtagLen))) { ------------------ | Branch (2199:17): [True: 0, False: 903] | Branch (2199:34): [True: 0, False: 0] ------------------ 2200| 1.02k| icu::LocalPointer var(new VariantListEntry, status); 2201| 1.02k| if (U_FAILURE(status)) { ------------------ | Branch (2201:21): [True: 0, False: 1.02k] ------------------ 2202| 0| return nullptr; 2203| 0| } 2204| 1.02k| *pSep = 0; 2205| 1.02k| var->variant = T_CString_toUpperCase(pSubtag); ------------------ | | 70| 1.02k|#define T_CString_toUpperCase U_ICU_ENTRY_POINT_RENAME(T_CString_toUpperCase) | | ------------------ | | | | 123| 1.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2206| 1.02k| if (!_addVariantToList(&(t->variants), std::move(var))) { ------------------ | Branch (2206:21): [True: 2, False: 1.02k] ------------------ 2207| | /* duplicated variant entry */ 2208| 2| break; 2209| 2| } 2210| 1.02k| pLastGoodPosition = pSep; 2211| 1.02k| next = VART | EXTS | PRIV; ------------------ | | 1963| 1.02k|#define VART 0x0010 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1964| 1.02k|#define EXTS 0x0020 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1966| 1.02k|#define PRIV 0x0080 ------------------ 2212| 1.02k| continue; 2213| 1.02k| } 2214| 1.92k| } 2215| 6.98k| if (next & EXTS) { ------------------ | | 1964| 6.98k|#define EXTS 0x0020 ------------------ | Branch (2215:13): [True: 5.77k, False: 1.20k] ------------------ 2216| 5.77k| if (_isExtensionSingleton(pSubtag, subtagLen)) { ------------------ | Branch (2216:17): [True: 1.18k, False: 4.58k] ------------------ 2217| 1.18k| if (pExtension.isValid()) { ------------------ | Branch (2217:21): [True: 352, False: 837] ------------------ 2218| 352| if (pExtValueSubtag == nullptr || pExtValueSubtagEnd == nullptr) { ------------------ | Branch (2218:25): [True: 0, False: 352] | Branch (2218:55): [True: 0, False: 352] ------------------ 2219| | /* the previous extension is incomplete */ 2220| 0| delete pExtension.orphan(); 2221| 0| break; 2222| 0| } 2223| | 2224| | /* terminate the previous extension value */ 2225| 352| *pExtValueSubtagEnd = 0; 2226| 352| pExtension->value = T_CString_toLowerCase(pExtValueSubtag); ------------------ | | 69| 352|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 352|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 352|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 352|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2227| | 2228| | /* insert the extension to the list */ 2229| 352| if (_addExtensionToList(&(t->extensions), pExtension.getAlias(), false)) { ------------------ | Branch (2229:25): [True: 349, False: 3] ------------------ 2230| 349| pExtension.orphan(); 2231| 349| pLastGoodPosition = pExtValueSubtagEnd; 2232| 349| } else { 2233| | /* stop parsing here */ 2234| 3| delete pExtension.orphan(); 2235| 3| break; 2236| 3| } 2237| 352| } 2238| | 2239| | /* create a new extension */ 2240| 1.18k| pExtension.adoptInsteadAndCheckErrorCode(new ExtensionListEntry, status); 2241| 1.18k| if (U_FAILURE(status)) { ------------------ | Branch (2241:21): [True: 0, False: 1.18k] ------------------ 2242| 0| return nullptr; 2243| 0| } 2244| 1.18k| *pSep = 0; 2245| 1.18k| pExtension->key = T_CString_toLowerCase(pSubtag); ------------------ | | 69| 1.18k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 1.18k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.18k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.18k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2246| 1.18k| pExtension->value = nullptr; /* will be set later */ 2247| | 2248| | /* 2249| | * reset the start and the end location of extension value 2250| | * subtags for this extension 2251| | */ 2252| 1.18k| pExtValueSubtag = nullptr; 2253| 1.18k| pExtValueSubtagEnd = nullptr; 2254| | 2255| 1.18k| next = EXTV; ------------------ | | 1965| 1.18k|#define EXTV 0x0040 ------------------ 2256| 1.18k| continue; 2257| 1.18k| } 2258| 5.77k| } 2259| 5.79k| if (next & EXTV) { ------------------ | | 1965| 5.79k|#define EXTV 0x0040 ------------------ | Branch (2259:13): [True: 5.66k, False: 126] ------------------ 2260| 5.66k| if (_isExtensionSubtag(pSubtag, subtagLen)) { ------------------ | Branch (2260:17): [True: 5.59k, False: 77] ------------------ 2261| 5.59k| if (pExtValueSubtag == nullptr) { ------------------ | Branch (2261:21): [True: 1.14k, False: 4.45k] ------------------ 2262| | /* if the start position of this extension's value is not yet, 2263| | this one is the first value subtag */ 2264| 1.14k| pExtValueSubtag = pSubtag; 2265| 1.14k| } 2266| | 2267| | /* Mark the end of this subtag */ 2268| 5.59k| pExtValueSubtagEnd = pSep; 2269| 5.59k| next = EXTS | EXTV | PRIV; ------------------ | | 1964| 5.59k|#define EXTS 0x0020 ------------------ next = EXTS | EXTV | PRIV; ------------------ | | 1965| 5.59k|#define EXTV 0x0040 ------------------ next = EXTS | EXTV | PRIV; ------------------ | | 1966| 5.59k|#define PRIV 0x0080 ------------------ 2270| | 2271| 5.59k| continue; 2272| 5.59k| } 2273| 5.66k| } 2274| 203| if (next & PRIV) { ------------------ | | 1966| 203|#define PRIV 0x0080 ------------------ | Branch (2274:13): [True: 196, False: 7] ------------------ 2275| 196| if (uprv_tolower(*pSubtag) == PRIVATEUSE && subtagLen == 1) { ------------------ | | 68| 196|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 196|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 196|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 196|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 196|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (uprv_tolower(*pSubtag) == PRIVATEUSE && subtagLen == 1) { ------------------ | | 66| 392|#define PRIVATEUSE 'x' ------------------ | Branch (2275:17): [True: 116, False: 80] | Branch (2275:57): [True: 115, False: 1] ------------------ 2276| 115| char *pPrivuseVal; 2277| | 2278| 115| if (pExtension.isValid()) { ------------------ | Branch (2278:21): [True: 36, False: 79] ------------------ 2279| | /* Process the last extension */ 2280| 36| if (pExtValueSubtag == nullptr || pExtValueSubtagEnd == nullptr) { ------------------ | Branch (2280:25): [True: 0, False: 36] | Branch (2280:55): [True: 0, False: 36] ------------------ 2281| | /* the previous extension is incomplete */ 2282| 0| delete pExtension.orphan(); 2283| 0| break; 2284| 36| } else { 2285| | /* terminate the previous extension value */ 2286| 36| *pExtValueSubtagEnd = 0; 2287| 36| pExtension->value = T_CString_toLowerCase(pExtValueSubtag); ------------------ | | 69| 36|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 36|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 36|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 36|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2288| | 2289| | /* insert the extension to the list */ 2290| 36| if (_addExtensionToList(&(t->extensions), pExtension.getAlias(), false)) { ------------------ | Branch (2290:29): [True: 35, False: 1] ------------------ 2291| 35| pExtension.orphan(); 2292| 35| pLastGoodPosition = pExtValueSubtagEnd; 2293| 35| } else { 2294| | /* stop parsing here */ 2295| 1| delete pExtension.orphan(); 2296| 1| break; 2297| 1| } 2298| 36| } 2299| 36| } 2300| | 2301| | /* The rest of part will be private use value subtags */ 2302| 114| if (pNext == nullptr) { ------------------ | Branch (2302:21): [True: 1, False: 113] ------------------ 2303| | /* empty private use subtag */ 2304| 1| break; 2305| 1| } 2306| | /* back up the private use value start position */ 2307| 113| pPrivuseVal = pNext; 2308| | 2309| | /* validate private use value subtags */ 2310| 436| while (pNext) { ------------------ | Branch (2310:24): [True: 327, False: 109] ------------------ 2311| 327| pSubtag = pNext; 2312| 327| pSep = pSubtag; 2313| 1.44k| while (*pSep) { ------------------ | Branch (2313:28): [True: 1.33k, False: 111] ------------------ 2314| 1.33k| if (*pSep == SEP) { ------------------ | | 65| 1.33k|#define SEP '-' ------------------ | Branch (2314:29): [True: 216, False: 1.11k] ------------------ 2315| 216| break; 2316| 216| } 2317| 1.11k| pSep++; 2318| 1.11k| } 2319| 327| if (*pSep == 0) { ------------------ | Branch (2319:25): [True: 111, False: 216] ------------------ 2320| | /* last subtag */ 2321| 111| pNext = nullptr; 2322| 216| } else { 2323| 216| pNext = pSep + 1; 2324| 216| } 2325| 327| subtagLen = static_cast(pSep - pSubtag); 2326| | 2327| 327| if (uprv_strncmp(pSubtag, PRIVUSE_VARIANT_PREFIX, uprv_strlen(PRIVUSE_VARIANT_PREFIX)) == 0) { ------------------ | | 44| 327|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 327|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (2327:25): [True: 0, False: 327] ------------------ 2328| 0| *pSep = 0; 2329| 0| next = VART; ------------------ | | 1963| 0|#define VART 0x0010 ------------------ 2330| 0| privateuseVar = true; 2331| 0| break; 2332| 327| } else if (_isPrivateuseValueSubtag(pSubtag, subtagLen)) { ------------------ | Branch (2332:32): [True: 323, False: 4] ------------------ 2333| 323| pLastGoodPosition = pSep; 2334| 323| } else { 2335| 4| break; 2336| 4| } 2337| 327| } 2338| | 2339| 113| if (next == VART) { ------------------ | | 1963| 113|#define VART 0x0010 ------------------ | Branch (2339:21): [True: 0, False: 113] ------------------ 2340| 0| continue; 2341| 0| } 2342| | 2343| 113| if (pLastGoodPosition - pPrivuseVal > 0) { ------------------ | Branch (2343:21): [True: 111, False: 2] ------------------ 2344| 111| *pLastGoodPosition = 0; 2345| 111| t->privateuse = T_CString_toLowerCase(pPrivuseVal); ------------------ | | 69| 111|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 111|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 111|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 111|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2346| 111| } 2347| | /* No more subtags, exiting the parse loop */ 2348| 113| break; 2349| 113| } 2350| 81| break; 2351| 196| } 2352| | 2353| | /* If we fell through here, it means this subtag is illegal - quit parsing */ 2354| 7| break; 2355| 203| } 2356| | 2357| 4.95k| if (pExtension.isValid()) { ------------------ | Branch (2357:9): [True: 798, False: 4.15k] ------------------ 2358| | /* Process the last extension */ 2359| 798| if (pExtValueSubtag == nullptr || pExtValueSubtagEnd == nullptr) { ------------------ | Branch (2359:13): [True: 46, False: 752] | Branch (2359:43): [True: 0, False: 752] ------------------ 2360| | /* the previous extension is incomplete */ 2361| 46| delete pExtension.orphan(); 2362| 752| } else { 2363| | /* terminate the previous extension value */ 2364| 752| *pExtValueSubtagEnd = 0; 2365| 752| pExtension->value = T_CString_toLowerCase(pExtValueSubtag); ------------------ | | 69| 752|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 752|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 752|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 752|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2366| | /* insert the extension to the list */ 2367| 752| if (_addExtensionToList(&(t->extensions), pExtension.getAlias(), false)) { ------------------ | Branch (2367:17): [True: 746, False: 6] ------------------ 2368| 746| pExtension.orphan(); 2369| 746| pLastGoodPosition = pExtValueSubtagEnd; 2370| 746| } else { 2371| 6| delete pExtension.orphan(); 2372| 6| } 2373| 752| } 2374| 798| } 2375| | 2376| 4.95k| if (parsedLen != nullptr) { ------------------ | Branch (2376:9): [True: 4.95k, False: 0] ------------------ 2377| 4.95k| *parsedLen = static_cast(pLastGoodPosition - t->buf + parsedLenDelta); 2378| 4.95k| } 2379| | 2380| 4.95k| return t.orphan(); 2381| 4.95k|} uloc_tag.cpp:_ZN12_GLOBAL__N_123_initializeULanguageTagEPNS_12ULanguageTagE: 1025| 5.02k|_initializeULanguageTag(ULanguageTag* langtag) { 1026| 5.02k| int32_t i; 1027| | 1028| 5.02k| langtag->buf = nullptr; 1029| | 1030| 5.02k| langtag->language = EMPTY; 1031| 20.1k| for (i = 0; i < MAXEXTLANG; i++) { ------------------ | | 51| 20.1k|#define MAXEXTLANG 3 ------------------ | Branch (1031:17): [True: 15.0k, False: 5.02k] ------------------ 1032| 15.0k| langtag->extlang[i] = nullptr; 1033| 15.0k| } 1034| | 1035| 5.02k| langtag->script = EMPTY; 1036| 5.02k| langtag->region = EMPTY; 1037| | 1038| 5.02k| langtag->variants = nullptr; 1039| 5.02k| langtag->extensions = nullptr; 1040| | 1041| 5.02k| langtag->legacy = EMPTY; 1042| 5.02k| langtag->privateuse = EMPTY; 1043| 5.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116_isExtlangSubtagEPKci: 449| 1.52k|_isExtlangSubtag(const char* s, int32_t len) { 450| | /* 451| | * extlang = 3ALPHA ; selected ISO 639 codes 452| | * *2("-" 3ALPHA) ; permanently reserved 453| | */ 454| 1.52k| if (len < 0) { ------------------ | Branch (454:9): [True: 0, False: 1.52k] ------------------ 455| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 456| 0| } 457| 1.52k| if (len == 3 && _isAlphaString(s, len)) { ------------------ | Branch (457:9): [True: 210, False: 1.31k] | Branch (457:21): [True: 105, False: 105] ------------------ 458| 105| return true; 459| 105| } 460| 1.41k| return false; 461| 1.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_120ultag_getExtlangSizeEPKNS_12ULanguageTagE: 2445| 5.02k|ultag_getExtlangSize(const ULanguageTag* langtag) { 2446| 5.02k| int32_t size = 0; 2447| 5.02k| int32_t i; 2448| 20.1k| for (i = 0; i < MAXEXTLANG; i++) { ------------------ | | 51| 20.1k|#define MAXEXTLANG 3 ------------------ | Branch (2448:17): [True: 15.0k, False: 5.02k] ------------------ 2449| 15.0k| if (langtag->extlang[i]) { ------------------ | Branch (2449:13): [True: 105, False: 14.9k] ------------------ 2450| 105| size++; 2451| 105| } 2452| 15.0k| } 2453| 5.02k| return size; 2454| 5.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116ultag_getExtlangEPKNS_12ULanguageTagEi: 2437| 102|ultag_getExtlang(const ULanguageTag* langtag, int32_t idx) { 2438| 102| if (idx >= 0 && idx < MAXEXTLANG) { ------------------ | | 51| 102|#define MAXEXTLANG 3 ------------------ | Branch (2438:9): [True: 102, False: 0] | Branch (2438:21): [True: 102, False: 0] ------------------ 2439| 102| return langtag->extlang[idx]; 2440| 102| } 2441| 0| return nullptr; 2442| 102|} uloc_tag.cpp:_ZN12_GLOBAL__N_117ultag_getLanguageEPKNS_12ULanguageTagE: 2419| 4.92k|ultag_getLanguage(const ULanguageTag* langtag) { 2420| 4.92k| return langtag->language; 2421| 4.92k|} uloc_tag.cpp:_ZN12_GLOBAL__N_115ultag_getScriptEPKNS_12ULanguageTagE: 2457| 5.02k|ultag_getScript(const ULanguageTag* langtag) { 2458| 5.02k| return langtag->script; 2459| 5.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_115ultag_getRegionEPKNS_12ULanguageTagE: 2462| 5.02k|ultag_getRegion(const ULanguageTag* langtag) { 2463| 5.02k| return langtag->region; 2464| 5.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_113_sortVariantsEPNS_16VariantListEntryE: 1158| 5.02k|void _sortVariants(VariantListEntry* first) { 1159| 6.04k| for (VariantListEntry* var1 = first; var1 != nullptr; var1 = var1->next) { ------------------ | Branch (1159:42): [True: 1.02k, False: 5.02k] ------------------ 1160| 3.52k| for (VariantListEntry* var2 = var1->next; var2 != nullptr; var2 = var2->next) { ------------------ | Branch (1160:51): [True: 2.50k, False: 1.02k] ------------------ 1161| | // Swap var1->variant and var2->variant. 1162| 2.50k| if (uprv_compareInvCharsAsAscii(var1->variant, var2->variant) > 0) { ------------------ | | 153| 2.50k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 2.50k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 2.50k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ | Branch (1162:17): [True: 822, False: 1.68k] ------------------ 1163| 822| const char* temp = var1->variant; 1164| 822| var1->variant = var2->variant; 1165| 822| var2->variant = temp; 1166| 822| } 1167| 2.50k| } 1168| 1.02k| } 1169| 5.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_121ultag_getVariantsSizeEPKNS_12ULanguageTagE: 2483| 5.60k|ultag_getVariantsSize(const ULanguageTag* langtag) { 2484| 5.60k| int32_t size = 0; 2485| 5.60k| VariantListEntry *cur = langtag->variants; 2486| 6.64k| while (true) { ------------------ | Branch (2486:12): [Folded - Ignored] ------------------ 2487| 6.64k| if (cur == nullptr) { ------------------ | Branch (2487:13): [True: 5.60k, False: 1.04k] ------------------ 2488| 5.60k| break; 2489| 5.60k| } 2490| 1.04k| size++; 2491| 1.04k| cur = cur->next; 2492| 1.04k| } 2493| 5.60k| return size; 2494| 5.60k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116ultag_getVariantEPKNS_12ULanguageTagEi: 2467| 1.02k|ultag_getVariant(const ULanguageTag* langtag, int32_t idx) { 2468| 1.02k| const char *var = nullptr; 2469| 1.02k| VariantListEntry *cur = langtag->variants; 2470| 1.02k| int32_t i = 0; 2471| 3.52k| while (cur) { ------------------ | Branch (2471:12): [True: 3.52k, False: 0] ------------------ 2472| 3.52k| if (i == idx) { ------------------ | Branch (2472:13): [True: 1.02k, False: 2.50k] ------------------ 2473| 1.02k| var = cur->variant; 2474| 1.02k| break; 2475| 1.02k| } 2476| 2.50k| cur = cur->next; 2477| 2.50k| i++; 2478| 2.50k| } 2479| 1.02k| return var; 2480| 1.02k|} uloc_tag.cpp:_ZN12_GLOBAL__N_123ultag_getExtensionsSizeEPKNS_12ULanguageTagE: 2529| 5.92k|ultag_getExtensionsSize(const ULanguageTag* langtag) { 2530| 5.92k| int32_t size = 0; 2531| 5.92k| ExtensionListEntry *cur = langtag->extensions; 2532| 8.18k| while (true) { ------------------ | Branch (2532:12): [Folded - Ignored] ------------------ 2533| 8.18k| if (cur == nullptr) { ------------------ | Branch (2533:13): [True: 5.92k, False: 2.26k] ------------------ 2534| 5.92k| break; 2535| 5.92k| } 2536| 2.26k| size++; 2537| 2.26k| cur = cur->next; 2538| 2.26k| } 2539| 5.92k| return size; 2540| 5.92k|} uloc_tag.cpp:_ZN12_GLOBAL__N_119ultag_getPrivateUseEPKNS_12ULanguageTagE: 2543| 5.92k|ultag_getPrivateUse(const ULanguageTag* langtag) { 2544| 5.92k| return langtag->privateuse; 2545| 5.92k|} uloc_tag.cpp:_ZN12_GLOBAL__N_115_appendKeywordsEPNS_12ULanguageTagERN6icu_788ByteSinkER10UErrorCode: 1781| 902|_appendKeywords(ULanguageTag* langtag, icu::ByteSink& sink, UErrorCode& status) { 1782| 902| if (U_FAILURE(status)) { return; } ------------------ | Branch (1782:9): [True: 0, False: 902] ------------------ 1783| | 1784| 902| int32_t i, n; 1785| 902| int32_t len; 1786| 902| ExtensionListEntry *kwdFirst = nullptr; 1787| 902| ExtensionListEntry *kwd; 1788| 902| const char *key, *type; 1789| 902| icu::MemoryPool extPool; 1790| 902| icu::MemoryPool kwdBuf; 1791| 902| bool posixVariant = false; 1792| | 1793| 902| n = ultag_getExtensionsSize(langtag); 1794| | 1795| | /* resolve locale keywords and reordering keys */ 1796| 2.03k| for (i = 0; i < n; i++) { ------------------ | Branch (1796:17): [True: 1.13k, False: 902] ------------------ 1797| 1.13k| key = ultag_getExtensionKey(langtag, i); 1798| 1.13k| type = ultag_getExtensionValue(langtag, i); 1799| 1.13k| if (*key == LDMLEXT) { ------------------ | | 67| 1.13k|#define LDMLEXT 'u' ------------------ | Branch (1799:13): [True: 573, False: 557] ------------------ 1800| | /* Determine if variants already exists */ 1801| 573| if (ultag_getVariantsSize(langtag)) { ------------------ | Branch (1801:17): [True: 23, False: 550] ------------------ 1802| 23| posixVariant = true; 1803| 23| } 1804| | 1805| 573| _appendLDMLExtensionAsKeywords(type, &kwdFirst, extPool, kwdBuf, posixVariant, status); 1806| 573| if (U_FAILURE(status)) { ------------------ | Branch (1806:17): [True: 0, False: 573] ------------------ 1807| 0| break; 1808| 0| } 1809| 573| } else { 1810| 557| kwd = extPool.create(); 1811| 557| if (kwd == nullptr) { ------------------ | Branch (1811:17): [True: 0, False: 557] ------------------ 1812| 0| status = U_MEMORY_ALLOCATION_ERROR; 1813| 0| break; 1814| 0| } 1815| 557| kwd->key = key; 1816| 557| kwd->value = type; 1817| 557| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1817:17): [True: 0, False: 557] ------------------ 1818| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1819| 0| break; 1820| 0| } 1821| 557| } 1822| 1.13k| } 1823| | 1824| 902| if (U_SUCCESS(status)) { ------------------ | Branch (1824:9): [True: 902, False: 0] ------------------ 1825| 902| type = ultag_getPrivateUse(langtag); 1826| 902| if (static_cast(uprv_strlen(type)) > 0) { ------------------ | | 37| 902|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 902|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1826:13): [True: 111, False: 791] ------------------ 1827| | /* add private use as a keyword */ 1828| 111| kwd = extPool.create(); 1829| 111| if (kwd == nullptr) { ------------------ | Branch (1829:17): [True: 0, False: 111] ------------------ 1830| 0| status = U_MEMORY_ALLOCATION_ERROR; 1831| 111| } else { 1832| 111| kwd->key = PRIVATEUSE_KEY; 1833| 111| kwd->value = type; 1834| 111| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1834:21): [True: 0, False: 111] ------------------ 1835| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1836| 0| } 1837| 111| } 1838| 111| } 1839| 902| } 1840| | 1841| | /* If a POSIX variant was in the extensions, write it out before writing the keywords. */ 1842| | 1843| 902| if (U_SUCCESS(status) && posixVariant) { ------------------ | Branch (1843:9): [True: 902, False: 0] | Branch (1843:30): [True: 0, False: 902] ------------------ 1844| 0| len = static_cast(uprv_strlen(_POSIX)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1845| 0| sink.Append(_POSIX, len); 1846| 0| } 1847| | 1848| 902| if (U_SUCCESS(status) && kwdFirst != nullptr) { ------------------ | Branch (1848:9): [True: 902, False: 0] | Branch (1848:30): [True: 902, False: 0] ------------------ 1849| | /* write out the sorted keywords */ 1850| 902| bool firstValue = true; 1851| 902| kwd = kwdFirst; 1852| 1.59k| do { 1853| 1.59k| if (firstValue) { ------------------ | Branch (1853:17): [True: 902, False: 694] ------------------ 1854| 902| sink.Append("@", 1); 1855| 902| firstValue = false; 1856| 902| } else { 1857| 694| sink.Append(";", 1); 1858| 694| } 1859| | 1860| | /* key */ 1861| 1.59k| len = static_cast(uprv_strlen(kwd->key)); ------------------ | | 37| 1.59k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1.59k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1862| 1.59k| sink.Append(kwd->key, len); 1863| 1.59k| sink.Append("=", 1); 1864| | 1865| | /* type */ 1866| 1.59k| len = static_cast(uprv_strlen(kwd->value)); ------------------ | | 37| 1.59k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1.59k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1867| 1.59k| sink.Append(kwd->value, len); 1868| | 1869| 1.59k| kwd = kwd->next; 1870| 1.59k| } while (kwd); ------------------ | Branch (1870:18): [True: 694, False: 902] ------------------ 1871| 902| } 1872| 902|} uloc_tag.cpp:_ZN12_GLOBAL__N_121ultag_getExtensionKeyEPKNS_12ULanguageTagEi: 2497| 1.13k|ultag_getExtensionKey(const ULanguageTag* langtag, int32_t idx) { 2498| 1.13k| const char *key = nullptr; 2499| 1.13k| ExtensionListEntry *cur = langtag->extensions; 2500| 1.13k| int32_t i = 0; 2501| 1.70k| while (cur) { ------------------ | Branch (2501:12): [True: 1.70k, False: 0] ------------------ 2502| 1.70k| if (i == idx) { ------------------ | Branch (2502:13): [True: 1.13k, False: 573] ------------------ 2503| 1.13k| key = cur->key; 2504| 1.13k| break; 2505| 1.13k| } 2506| 573| cur = cur->next; 2507| 573| i++; 2508| 573| } 2509| 1.13k| return key; 2510| 1.13k|} uloc_tag.cpp:_ZN12_GLOBAL__N_123ultag_getExtensionValueEPKNS_12ULanguageTagEi: 2513| 1.13k|ultag_getExtensionValue(const ULanguageTag* langtag, int32_t idx) { 2514| 1.13k| const char *val = nullptr; 2515| 1.13k| ExtensionListEntry *cur = langtag->extensions; 2516| 1.13k| int32_t i = 0; 2517| 1.70k| while (cur) { ------------------ | Branch (2517:12): [True: 1.70k, False: 0] ------------------ 2518| 1.70k| if (i == idx) { ------------------ | Branch (2518:13): [True: 1.13k, False: 573] ------------------ 2519| 1.13k| val = cur->value; 2520| 1.13k| break; 2521| 1.13k| } 2522| 573| cur = cur->next; 2523| 573| i++; 2524| 573| } 2525| 1.13k| return val; 2526| 1.13k|} uloc_tag.cpp:_ZN12_GLOBAL__N_130_appendLDMLExtensionAsKeywordsEPKcPPNS_18ExtensionListEntryERN6icu_7810MemoryPoolIS2_Li8EEERNS6_INS5_10CharStringELi8EEERbR10UErrorCode: 1523| 573|_appendLDMLExtensionAsKeywords(const char* ldmlext, ExtensionListEntry** appendTo, icu::MemoryPool& extPool, icu::MemoryPool& kwdBuf, bool& posixVariant, UErrorCode& status) { 1524| 573| if (U_FAILURE(status)) { return; } ------------------ | Branch (1524:9): [True: 0, False: 573] ------------------ 1525| | 1526| 573| const char *pTag; /* beginning of current subtag */ 1527| 573| const char *pKwds; /* beginning of key-type pairs */ 1528| 573| bool variantExists = posixVariant; 1529| | 1530| 573| ExtensionListEntry *kwdFirst = nullptr; /* first LDML keyword */ 1531| 573| ExtensionListEntry *kwd, *nextKwd; 1532| | 1533| 573| int32_t len; 1534| | 1535| | /* Reset the posixVariant value */ 1536| 573| posixVariant = false; 1537| | 1538| 573| pTag = ldmlext; 1539| 573| pKwds = nullptr; 1540| | 1541| 573| { 1542| 573| AttributeListEntry *attrFirst = nullptr; /* first attribute */ 1543| 573| AttributeListEntry *attr, *nextAttr; 1544| | 1545| 573| icu::MemoryPool strPool; 1546| 573| icu::MemoryPool attrPool; 1547| | 1548| | /* Iterate through u extension attributes */ 1549| 1.32k| while (*pTag) { ------------------ | Branch (1549:16): [True: 1.26k, False: 61] ------------------ 1550| | /* locate next separator char */ 1551| 6.25k| for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); ------------------ | | 65| 5.86k|#define SEP '-' ------------------ | Branch (1551:27): [True: 5.86k, False: 393] | Branch (1551:44): [True: 4.98k, False: 874] ------------------ 1552| | 1553| 1.26k| if (ultag_isUnicodeLocaleKey(pTag, len)) { ------------------ | | 1233| 1.26k|#define ultag_isUnicodeLocaleKey U_ICU_ENTRY_POINT_RENAME(ultag_isUnicodeLocaleKey) | | ------------------ | | | | 123| 1.26k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.26k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.26k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1553:17): [True: 512, False: 755] ------------------ 1554| 512| pKwds = pTag; 1555| 512| break; 1556| 512| } 1557| | 1558| | /* add this attribute to the list */ 1559| 755| attr = attrPool.create(); 1560| 755| if (attr == nullptr) { ------------------ | Branch (1560:17): [True: 0, False: 755] ------------------ 1561| 0| status = U_MEMORY_ALLOCATION_ERROR; 1562| 0| return; 1563| 0| } 1564| | 1565| 755| if (icu::CharString* str = strPool.create(pTag, len, status)) { ------------------ | Branch (1565:34): [True: 755, False: 0] ------------------ 1566| 755| if (U_FAILURE(status)) { return; } ------------------ | Branch (1566:21): [True: 0, False: 755] ------------------ 1567| 755| attr->attribute = str->data(); 1568| 755| } else { 1569| 0| status = U_MEMORY_ALLOCATION_ERROR; 1570| 0| return; 1571| 0| } 1572| | 1573| | // duplicate attribute is ignored, causes no error. 1574| 755| _addAttributeToList(&attrFirst, attr); 1575| | 1576| | /* next tag */ 1577| 755| pTag += len; 1578| 755| if (*pTag) { ------------------ | Branch (1578:17): [True: 694, False: 61] ------------------ 1579| | /* next to the separator */ 1580| 694| pTag++; 1581| 694| } 1582| 755| } 1583| | 1584| 573| if (attrFirst) { ------------------ | Branch (1584:13): [True: 92, False: 481] ------------------ 1585| | /* emit attributes as an LDML keyword, e.g. attribute=attr1-attr2 */ 1586| | 1587| 92| kwd = extPool.create(); 1588| 92| if (kwd == nullptr) { ------------------ | Branch (1588:17): [True: 0, False: 92] ------------------ 1589| 0| status = U_MEMORY_ALLOCATION_ERROR; 1590| 0| return; 1591| 0| } 1592| | 1593| 92| icu::CharString* value = kwdBuf.create(); 1594| 92| if (value == nullptr) { ------------------ | Branch (1594:17): [True: 0, False: 92] ------------------ 1595| 0| status = U_MEMORY_ALLOCATION_ERROR; 1596| 0| return; 1597| 0| } 1598| | 1599| | /* attribute subtags sorted in alphabetical order as type */ 1600| 92| attr = attrFirst; 1601| 488| while (attr != nullptr) { ------------------ | Branch (1601:20): [True: 396, False: 92] ------------------ 1602| 396| nextAttr = attr->next; 1603| 396| if (attr != attrFirst) { ------------------ | Branch (1603:21): [True: 304, False: 92] ------------------ 1604| 304| value->append('-', status); 1605| 304| } 1606| 396| value->append(attr->attribute, status); 1607| 396| attr = nextAttr; 1608| 396| } 1609| 92| if (U_FAILURE(status)) { ------------------ | Branch (1609:17): [True: 0, False: 92] ------------------ 1610| 0| return; 1611| 0| } 1612| | 1613| 92| kwd->key = LOCALE_ATTRIBUTE_KEY; 1614| 92| kwd->value = value->data(); 1615| | 1616| 92| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1616:17): [True: 0, False: 92] ------------------ 1617| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1618| 0| return; 1619| 0| } 1620| 92| } 1621| 573| } 1622| | 1623| 573| if (pKwds) { ------------------ | Branch (1623:9): [True: 512, False: 61] ------------------ 1624| 512| const char *pBcpKey = nullptr; /* u extension key subtag */ 1625| 512| const char *pBcpType = nullptr; /* beginning of u extension type subtag(s) */ 1626| 512| int32_t bcpKeyLen = 0; 1627| 512| int32_t bcpTypeLen = 0; 1628| 512| bool isDone = false; 1629| | 1630| 512| pTag = pKwds; 1631| | /* BCP47 representation of LDML key/type pairs */ 1632| 4.99k| while (!isDone) { ------------------ | Branch (1632:16): [True: 4.47k, False: 512] ------------------ 1633| 4.47k| const char *pNextBcpKey = nullptr; 1634| 4.47k| int32_t nextBcpKeyLen = 0; 1635| 4.47k| bool emitKeyword = false; 1636| | 1637| 4.47k| if (*pTag) { ------------------ | Branch (1637:17): [True: 3.96k, False: 512] ------------------ 1638| | /* locate next separator char */ 1639| 16.2k| for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); ------------------ | | 65| 15.7k|#define SEP '-' ------------------ | Branch (1639:31): [True: 15.7k, False: 512] | Branch (1639:48): [True: 12.3k, False: 3.45k] ------------------ 1640| | 1641| 3.96k| if (ultag_isUnicodeLocaleKey(pTag, len)) { ------------------ | | 1233| 3.96k|#define ultag_isUnicodeLocaleKey U_ICU_ENTRY_POINT_RENAME(ultag_isUnicodeLocaleKey) | | ------------------ | | | | 123| 3.96k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.96k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.96k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1641:21): [True: 2.23k, False: 1.73k] ------------------ 1642| 2.23k| if (pBcpKey) { ------------------ | Branch (1642:25): [True: 1.72k, False: 512] ------------------ 1643| 1.72k| emitKeyword = true; 1644| 1.72k| pNextBcpKey = pTag; 1645| 1.72k| nextBcpKeyLen = len; 1646| 1.72k| } else { 1647| 512| pBcpKey = pTag; 1648| 512| bcpKeyLen = len; 1649| 512| } 1650| 2.23k| } else { 1651| 1.73k| U_ASSERT(pBcpKey != nullptr); ------------------ | | 35| 1.73k|# define U_ASSERT(exp) (void)0 ------------------ 1652| | /* within LDML type subtags */ 1653| 1.73k| if (pBcpType) { ------------------ | Branch (1653:25): [True: 863, False: 869] ------------------ 1654| 863| bcpTypeLen += (len + 1); 1655| 869| } else { 1656| 869| pBcpType = pTag; 1657| 869| bcpTypeLen = len; 1658| 869| } 1659| 1.73k| } 1660| | 1661| | /* next tag */ 1662| 3.96k| pTag += len; 1663| 3.96k| if (*pTag) { ------------------ | Branch (1663:21): [True: 3.45k, False: 512] ------------------ 1664| | /* next to the separator */ 1665| 3.45k| pTag++; 1666| 3.45k| } 1667| 3.96k| } else { 1668| | /* processing last one */ 1669| 512| emitKeyword = true; 1670| 512| isDone = true; 1671| 512| } 1672| | 1673| 4.47k| if (emitKeyword) { ------------------ | Branch (1673:17): [True: 2.23k, False: 2.24k] ------------------ 1674| 2.23k| const char *pKey = nullptr; /* LDML key */ 1675| 2.23k| const char *pType = nullptr; /* LDML type */ 1676| | 1677| 2.23k| U_ASSERT(pBcpKey != nullptr); ------------------ | | 35| 2.23k|# define U_ASSERT(exp) (void)0 ------------------ 1678| | 1679| | /* BCP key length is always 2 for now */ 1680| 2.23k| if (bcpKeyLen != 2) { ------------------ | Branch (1680:21): [True: 0, False: 2.23k] ------------------ 1681| | /* the BCP key is invalid */ 1682| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1683| 0| return; 1684| 0| } 1685| | 1686| | /* u extension key to LDML key */ 1687| 2.23k| std::optional legacyKey = ulocimp_toLegacyKeyWithFallback( ------------------ | | 1220| 2.23k|#define ulocimp_toLegacyKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyKeyWithFallback) | | ------------------ | | | | 123| 2.23k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.23k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.23k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1688| 2.23k| {pBcpKey, static_cast(bcpKeyLen)}); 1689| 2.23k| if (!legacyKey.has_value()) { ------------------ | Branch (1689:21): [True: 0, False: 2.23k] ------------------ 1690| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1691| 0| return; 1692| 0| } 1693| 2.23k| if (legacyKey->data() == pBcpKey) { ------------------ | Branch (1693:21): [True: 1.30k, False: 929] ------------------ 1694| | /* 1695| | The key returned by toLegacyKey points to the input buffer. 1696| | We normalize the result key to lower case. 1697| | */ 1698| 1.30k| icu::CharString* key = kwdBuf.create(pBcpKey, bcpKeyLen, status); 1699| 1.30k| if (key == nullptr) { ------------------ | Branch (1699:25): [True: 0, False: 1.30k] ------------------ 1700| 0| status = U_MEMORY_ALLOCATION_ERROR; 1701| 0| return; 1702| 0| } 1703| 1.30k| if (U_FAILURE(status)) { ------------------ | Branch (1703:25): [True: 0, False: 1.30k] ------------------ 1704| 0| return; 1705| 0| } 1706| 1.30k| T_CString_toLowerCase(key->data()); ------------------ | | 69| 1.30k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 1.30k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.30k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.30k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1707| 1.30k| pKey = key->data(); 1708| 1.30k| } else { 1709| 929| pKey = legacyKey->data(); 1710| 929| } 1711| | 1712| 2.23k| if (pBcpType) { ------------------ | Branch (1712:21): [True: 869, False: 1.36k] ------------------ 1713| | /* BCP type to locale type */ 1714| 869| std::optional legacyType = ulocimp_toLegacyTypeWithFallback( ------------------ | | 1222| 869|#define ulocimp_toLegacyTypeWithFallback U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyTypeWithFallback) | | ------------------ | | | | 123| 869|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 869|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 869|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1715| 869| pKey, {pBcpType, static_cast(bcpTypeLen)}); 1716| 869| if (!legacyType.has_value()) { ------------------ | Branch (1716:25): [True: 0, False: 869] ------------------ 1717| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1718| 0| return; 1719| 0| } 1720| 869| if (legacyType->data() == pBcpType) { ------------------ | Branch (1720:25): [True: 736, False: 133] ------------------ 1721| | /* 1722| | The type returned by toLegacyType points to the input buffer. 1723| | We normalize the result type to lower case. 1724| | */ 1725| 736| icu::CharString* type = kwdBuf.create(pBcpType, bcpTypeLen, status); 1726| 736| if (type == nullptr) { ------------------ | Branch (1726:29): [True: 0, False: 736] ------------------ 1727| 0| status = U_MEMORY_ALLOCATION_ERROR; 1728| 0| return; 1729| 0| } 1730| 736| if (U_FAILURE(status)) { ------------------ | Branch (1730:29): [True: 0, False: 736] ------------------ 1731| 0| return; 1732| 0| } 1733| 736| T_CString_toLowerCase(type->data()); ------------------ | | 69| 736|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 736|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 736|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 736|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1734| 736| pType = type->data(); 1735| 736| } else { 1736| 133| pType = legacyType->data(); 1737| 133| } 1738| 1.36k| } else { 1739| | /* typeless - default type value is "yes" */ 1740| 1.36k| pType = LOCALE_TYPE_YES; 1741| 1.36k| } 1742| | 1743| | /* Special handling for u-va-posix, since we want to treat this as a variant, 1744| | not as a keyword */ 1745| 2.23k| if (!variantExists && !uprv_strcmp(pKey, POSIX_KEY) && !uprv_strcmp(pType, POSIX_VALUE) ) { ------------------ | | 38| 2.19k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 2.19k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ if (!variantExists && !uprv_strcmp(pKey, POSIX_KEY) && !uprv_strcmp(pType, POSIX_VALUE) ) { ------------------ | | 38| 14|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 14|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1745:21): [True: 2.19k, False: 36] | Branch (1745:39): [True: 14, False: 2.18k] | Branch (1745:72): [True: 0, False: 14] ------------------ 1746| 0| posixVariant = true; 1747| 2.23k| } else { 1748| | /* create an ExtensionListEntry for this keyword */ 1749| 2.23k| kwd = extPool.create(); 1750| 2.23k| if (kwd == nullptr) { ------------------ | Branch (1750:25): [True: 0, False: 2.23k] ------------------ 1751| 0| status = U_MEMORY_ALLOCATION_ERROR; 1752| 0| return; 1753| 0| } 1754| | 1755| 2.23k| kwd->key = pKey; 1756| 2.23k| kwd->value = pType; 1757| | 1758| 2.23k| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1758:25): [True: 1.39k, False: 836] ------------------ 1759| | // duplicate keyword is allowed, Only the first 1760| | // is honored. 1761| 1.39k| } 1762| 2.23k| } 1763| | 1764| 2.23k| pBcpKey = pNextBcpKey; 1765| 2.23k| bcpKeyLen = pNextBcpKey != nullptr ? nextBcpKeyLen : 0; ------------------ | Branch (1765:29): [True: 1.72k, False: 512] ------------------ 1766| 2.23k| pBcpType = nullptr; 1767| 2.23k| bcpTypeLen = 0; 1768| 2.23k| } 1769| 4.47k| } 1770| 512| } 1771| | 1772| 573| kwd = kwdFirst; 1773| 1.50k| while (kwd != nullptr) { ------------------ | Branch (1773:12): [True: 928, False: 573] ------------------ 1774| 928| nextKwd = kwd->next; 1775| 928| _addExtensionToList(appendTo, kwd, false); 1776| 928| kwd = nextKwd; 1777| 928| } 1778| 573|} uloc_tag.cpp:_ZN12_GLOBAL__N_111ultag_closeEPNS_12ULanguageTagE: 2389| 5.02k|ultag_close(ULanguageTag* langtag) { 2390| | 2391| 5.02k| if (langtag == nullptr) { ------------------ | Branch (2391:9): [True: 0, False: 5.02k] ------------------ 2392| 0| return; 2393| 0| } 2394| | 2395| 5.02k| uprv_free(langtag->buf); ------------------ | | 1503| 5.02k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 5.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2396| | 2397| 5.02k| if (langtag->variants) { ------------------ | Branch (2397:9): [True: 289, False: 4.73k] ------------------ 2398| 289| VariantListEntry *curVar = langtag->variants; 2399| 1.30k| while (curVar) { ------------------ | Branch (2399:16): [True: 1.02k, False: 289] ------------------ 2400| 1.02k| VariantListEntry *nextVar = curVar->next; 2401| 1.02k| delete curVar; 2402| 1.02k| curVar = nextVar; 2403| 1.02k| } 2404| 289| } 2405| | 2406| 5.02k| if (langtag->extensions) { ------------------ | Branch (2406:9): [True: 826, False: 4.20k] ------------------ 2407| 826| ExtensionListEntry *curExt = langtag->extensions; 2408| 1.95k| while (curExt) { ------------------ | Branch (2408:16): [True: 1.13k, False: 826] ------------------ 2409| 1.13k| ExtensionListEntry *nextExt = curExt->next; 2410| 1.13k| delete curExt; 2411| 1.13k| curExt = nextExt; 2412| 1.13k| } 2413| 826| } 2414| | 2415| 5.02k| uprv_free(langtag); ------------------ | | 1503| 5.02k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 5.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2416| 5.02k|} uloc_tag.cpp:_ZZ25ulocimp_forLanguageTag_78PKciPiR10UErrorCodeENK3$_0clERN6icu_788ByteSinkES3_: 2677| 5.02k| [&](icu::ByteSink& sink, UErrorCode& status) { 2678| 5.02k| ulocimp_forLanguageTag(langtag, tagLen, sink, parsedLength, status); ------------------ | | 1198| 5.02k|#define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag) | | ------------------ | | | | 123| 5.02k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.02k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.02k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2679| 5.02k| }, uloc.cpp:_ZN12_GLOBAL__N_114_isIDSeparatorEc: 49| 88.1k|inline bool _isIDSeparator(char a) { return a == '_' || a == '-'; } ------------------ | Branch (49:45): [True: 22.1k, False: 66.0k] | Branch (49:57): [True: 0, False: 66.0k] ------------------ uprv_max_78: 17| 12.0k|{ 18| 12.0k| return (x > y ? x : y); ------------------ | Branch (18:13): [True: 94, False: 11.9k] ------------------ 19| 12.0k|} uprv_min_78: 23| 5.31k|{ 24| 5.31k| return (x > y ? y : x); ------------------ | Branch (24:13): [True: 0, False: 5.31k] ------------------ 25| 5.31k|} umutablecptrie_open_78: 1740| 1|umutablecptrie_open(uint32_t initialValue, uint32_t errorValue, UErrorCode *pErrorCode) { 1741| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1741:9): [True: 0, False: 1] ------------------ 1742| 0| return nullptr; 1743| 0| } 1744| 1| LocalPointer trie( 1745| 1| new MutableCodePointTrie(initialValue, errorValue, *pErrorCode), *pErrorCode); 1746| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1746:9): [True: 0, False: 1] ------------------ 1747| 0| return nullptr; 1748| 0| } 1749| 1| return reinterpret_cast(trie.orphan()); 1750| 1|} umutablecptrie_close_78: 1769| 1|umutablecptrie_close(UMutableCPTrie *trie) { 1770| 1| delete reinterpret_cast(trie); 1771| 1|} umutablecptrie_get_78: 1798| 3.63k|umutablecptrie_get(const UMutableCPTrie *trie, UChar32 c) { 1799| 3.63k| return reinterpret_cast(trie)->get(c); 1800| 3.63k|} umutablecptrie_set_78: 1822| 2.38k|umutablecptrie_set(UMutableCPTrie *trie, UChar32 c, uint32_t value, UErrorCode *pErrorCode) { 1823| 2.38k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1823:9): [True: 0, False: 2.38k] ------------------ 1824| 0| return; 1825| 0| } 1826| 2.38k| reinterpret_cast(trie)->set(c, value, *pErrorCode); 1827| 2.38k|} umutablecptrie_buildImmutable_78: 1841| 1| UErrorCode *pErrorCode) { 1842| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1842:9): [True: 0, False: 1] ------------------ 1843| 0| return nullptr; 1844| 0| } 1845| 1| return reinterpret_cast(trie)->build(type, valueWidth, *pErrorCode); 1846| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrieC2EjjR10UErrorCode: 131| 1| origInitialValue(iniValue), initialValue(iniValue), errorValue(errValue), 132| 1| highStart(0), highValue(initialValue) 133| |#ifdef UCPTRIE_DEBUG 134| | , name("open") 135| |#endif 136| 1| { 137| 1| if (U_FAILURE(errorCode)) { return; } ------------------ | Branch (137:9): [True: 0, False: 1] ------------------ 138| 1| index = static_cast(uprv_malloc(BMP_I_LIMIT * 4)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 139| 1| data = static_cast(uprv_malloc(INITIAL_DATA_LENGTH * 4)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 140| 1| if (index == nullptr || data == nullptr) { ------------------ | Branch (140:9): [True: 0, False: 1] | Branch (140:29): [True: 0, False: 1] ------------------ 141| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 142| 0| return; 143| 0| } 144| 1| indexCapacity = BMP_I_LIMIT; 145| 1| dataCapacity = INITIAL_DATA_LENGTH; 146| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrieD2Ev: 177| 1|MutableCodePointTrie::~MutableCodePointTrie() { 178| 1| uprv_free(index); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 179| 1| uprv_free(data); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 180| 1| uprv_free(index16); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 181| 1|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_120MutableCodePointTrie3getEi: 270| 3.76k|uint32_t MutableCodePointTrie::get(UChar32 c) const { 271| 3.76k| if (static_cast(c) > MAX_UNICODE) { ------------------ | Branch (271:9): [True: 0, False: 3.76k] ------------------ 272| 0| return errorValue; 273| 0| } 274| 3.76k| if (c >= highStart) { ------------------ | Branch (274:9): [True: 935, False: 2.83k] ------------------ 275| 935| return highValue; 276| 935| } 277| 2.83k| int32_t i = c >> UCPTRIE_SHIFT_3; 278| 2.83k| if (flags[i] == ALL_SAME) { ------------------ | Branch (278:9): [True: 727, False: 2.10k] ------------------ 279| 727| return index[i]; 280| 2.10k| } else { 281| 2.10k| return data[index[i] + (c & UCPTRIE_SMALL_DATA_MASK)]; 282| 2.10k| } 283| 2.83k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie3setEijR10UErrorCode: 467| 2.38k|void MutableCodePointTrie::set(UChar32 c, uint32_t value, UErrorCode &errorCode) { 468| 2.38k| if (U_FAILURE(errorCode)) { ------------------ | Branch (468:9): [True: 0, False: 2.38k] ------------------ 469| 0| return; 470| 0| } 471| 2.38k| if (static_cast(c) > MAX_UNICODE) { ------------------ | Branch (471:9): [True: 0, False: 2.38k] ------------------ 472| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 473| 0| return; 474| 0| } 475| | 476| 2.38k| int32_t block; 477| 2.38k| if (!ensureHighStart(c) || (block = getDataBlock(c >> UCPTRIE_SHIFT_3)) < 0) { ------------------ | Branch (477:9): [True: 0, False: 2.38k] | Branch (477:32): [True: 0, False: 2.38k] ------------------ 478| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 479| 0| return; 480| 0| } 481| | 482| 2.38k| data[block + (c & UCPTRIE_SMALL_DATA_MASK)] = value; 483| 2.38k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie15ensureHighStartEi: 383| 2.38k|bool MutableCodePointTrie::ensureHighStart(UChar32 c) { 384| 2.38k| if (c >= highStart) { ------------------ | Branch (384:9): [True: 28, False: 2.35k] ------------------ 385| | // Round up to a UCPTRIE_CP_PER_INDEX_2_ENTRY boundary to simplify compaction. 386| 28| c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 387| 28| int32_t i = highStart >> UCPTRIE_SHIFT_3; 388| 28| int32_t iLimit = c >> UCPTRIE_SHIFT_3; 389| 28| if (iLimit > indexCapacity) { ------------------ | Branch (389:13): [True: 1, False: 27] ------------------ 390| 1| uint32_t* newIndex = static_cast(uprv_malloc(I_LIMIT * 4)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 391| 1| if (newIndex == nullptr) { return false; } ------------------ | Branch (391:17): [True: 0, False: 1] ------------------ 392| 1| uprv_memcpy(newIndex, index, i * 4); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 393| 1| uprv_free(index); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 394| 1| index = newIndex; 395| 1| indexCapacity = I_LIMIT; 396| 1| } 397| 10.8k| do { 398| 10.8k| flags[i] = ALL_SAME; 399| 10.8k| index[i] = initialValue; 400| 10.8k| } while(++i < iLimit); ------------------ | Branch (400:17): [True: 10.8k, False: 28] ------------------ 401| 28| highStart = c; 402| 28| } 403| 2.38k| return true; 404| 2.38k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie12getDataBlockEi: 440| 2.38k|int32_t MutableCodePointTrie::getDataBlock(int32_t i) { 441| 2.38k| if (flags[i] == MIXED) { ------------------ | Branch (441:9): [True: 1.77k, False: 612] ------------------ 442| 1.77k| return index[i]; 443| 1.77k| } 444| 612| if (i < BMP_I_LIMIT) { ------------------ | Branch (444:9): [True: 424, False: 188] ------------------ 445| 424| int32_t newBlock = allocDataBlock(UCPTRIE_FAST_DATA_BLOCK_LENGTH); 446| 424| if (newBlock < 0) { return newBlock; } ------------------ | Branch (446:13): [True: 0, False: 424] ------------------ 447| 424| int32_t iStart = i & ~(SMALL_DATA_BLOCKS_PER_BMP_BLOCK -1); 448| 424| int32_t iLimit = iStart + SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 449| 1.69k| do { 450| 1.69k| U_ASSERT(flags[iStart] == ALL_SAME); ------------------ | | 35| 1.69k|# define U_ASSERT(exp) (void)0 ------------------ 451| 1.69k| writeBlock(data + newBlock, index[iStart]); 452| 1.69k| flags[iStart] = MIXED; 453| 1.69k| index[iStart++] = newBlock; 454| 1.69k| newBlock += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 455| 1.69k| } while (iStart < iLimit); ------------------ | Branch (455:18): [True: 1.27k, False: 424] ------------------ 456| 424| return index[i]; 457| 424| } else { 458| 188| int32_t newBlock = allocDataBlock(UCPTRIE_SMALL_DATA_BLOCK_LENGTH); 459| 188| if (newBlock < 0) { return newBlock; } ------------------ | Branch (459:13): [True: 0, False: 188] ------------------ 460| 188| writeBlock(data + newBlock, index[i]); 461| 188| flags[i] = MIXED; 462| 188| index[i] = newBlock; 463| 188| return newBlock; 464| 188| } 465| 612|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie14allocDataBlockEi: 406| 612|int32_t MutableCodePointTrie::allocDataBlock(int32_t blockLength) { 407| 612| int32_t newBlock = dataLength; 408| 612| int32_t newTop = newBlock + blockLength; 409| 612| if (newTop > dataCapacity) { ------------------ | Branch (409:9): [True: 1, False: 611] ------------------ 410| 1| int32_t capacity; 411| 1| if (dataCapacity < MEDIUM_DATA_LENGTH) { ------------------ | Branch (411:13): [True: 1, False: 0] ------------------ 412| 1| capacity = MEDIUM_DATA_LENGTH; 413| 1| } else if (dataCapacity < MAX_DATA_LENGTH) { ------------------ | Branch (413:20): [True: 0, False: 0] ------------------ 414| 0| capacity = MAX_DATA_LENGTH; 415| 0| } else { 416| | // Should never occur. 417| | // Either MAX_DATA_LENGTH is incorrect, 418| | // or the code writes more values than should be possible. 419| 0| return -1; 420| 0| } 421| 1| uint32_t* newData = static_cast(uprv_malloc(capacity * 4)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| 1| if (newData == nullptr) { ------------------ | Branch (422:13): [True: 0, False: 1] ------------------ 423| 0| return -1; 424| 0| } 425| 1| uprv_memcpy(newData, data, (size_t)dataLength * 4); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 426| 1| uprv_free(data); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 427| 1| data = newData; 428| 1| dataCapacity = capacity; 429| 1| } 430| 612| dataLength = newTop; 431| 612| return newBlock; 432| 612|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110writeBlockEPjj: 376| 1.88k|writeBlock(uint32_t *block, uint32_t value) { 377| 1.88k| uint32_t *limit = block + UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 378| 32.0k| while (block < limit) { ------------------ | Branch (378:12): [True: 30.1k, False: 1.88k] ------------------ 379| 30.1k| *block++ = value; 380| 30.1k| } 381| 1.88k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie5buildE11UCPTrieType17UCPTrieValueWidthR10UErrorCode: 1576| 1|UCPTrie *MutableCodePointTrie::build(UCPTrieType type, UCPTrieValueWidth valueWidth, UErrorCode &errorCode) { 1577| 1| if (U_FAILURE(errorCode)) { ------------------ | Branch (1577:9): [True: 0, False: 1] ------------------ 1578| 0| return nullptr; 1579| 0| } 1580| 1| if (type < UCPTRIE_TYPE_FAST || UCPTRIE_TYPE_SMALL < type || ------------------ | Branch (1580:9): [True: 0, False: 1] | Branch (1580:37): [True: 0, False: 1] ------------------ 1581| 1| valueWidth < UCPTRIE_VALUE_BITS_16 || UCPTRIE_VALUE_BITS_8 < valueWidth) { ------------------ | Branch (1581:13): [True: 0, False: 1] | Branch (1581:51): [True: 0, False: 1] ------------------ 1582| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 1583| 0| return nullptr; 1584| 0| } 1585| | 1586| | // The mutable trie always stores 32-bit values. 1587| | // When we build a UCPTrie for a smaller value width, we first mask off unused bits 1588| | // before compacting the data. 1589| 1| switch (valueWidth) { 1590| 1| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (1590:5): [True: 1, False: 0] ------------------ 1591| 1| break; 1592| 0| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (1592:5): [True: 0, False: 1] ------------------ 1593| 0| maskValues(0xffff); 1594| 0| break; 1595| 0| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (1595:5): [True: 0, False: 1] ------------------ 1596| 0| maskValues(0xff); 1597| 0| break; 1598| 0| default: ------------------ | Branch (1598:5): [True: 0, False: 1] ------------------ 1599| 0| break; 1600| 1| } 1601| | 1602| 1| UChar32 fastLimit = type == UCPTRIE_TYPE_FAST ? BMP_LIMIT : UCPTRIE_SMALL_LIMIT; ------------------ | Branch (1602:25): [True: 0, False: 1] ------------------ 1603| 1| int32_t indexLength = compactTrie(fastLimit >> UCPTRIE_SHIFT_3, errorCode); 1604| 1| if (U_FAILURE(errorCode)) { ------------------ | Branch (1604:9): [True: 0, False: 1] ------------------ 1605| 0| clear(); 1606| 0| return nullptr; 1607| 0| } 1608| | 1609| | // Ensure data table alignment: The index length must be even for uint32_t data. 1610| 1| if (valueWidth == UCPTRIE_VALUE_BITS_32 && (indexLength & 1) != 0) { ------------------ | Branch (1610:9): [True: 1, False: 0] | Branch (1610:48): [True: 1, False: 0] ------------------ 1611| 1| index16[indexLength++] = 0xffee; // arbitrary value 1612| 1| } 1613| | 1614| | // Make the total trie structure length a multiple of 4 bytes by padding the data table, 1615| | // and store special values as the last two data values. 1616| 1| int32_t length = indexLength * 2; 1617| 1| if (valueWidth == UCPTRIE_VALUE_BITS_16) { ------------------ | Branch (1617:9): [True: 0, False: 1] ------------------ 1618| 0| if (((indexLength ^ dataLength) & 1) != 0) { ------------------ | Branch (1618:13): [True: 0, False: 0] ------------------ 1619| | // padding 1620| 0| data[dataLength++] = errorValue; 1621| 0| } 1622| 0| if (data[dataLength - 1] != errorValue || data[dataLength - 2] != highValue) { ------------------ | Branch (1622:13): [True: 0, False: 0] | Branch (1622:51): [True: 0, False: 0] ------------------ 1623| 0| data[dataLength++] = highValue; 1624| 0| data[dataLength++] = errorValue; 1625| 0| } 1626| 0| length += dataLength * 2; 1627| 1| } else if (valueWidth == UCPTRIE_VALUE_BITS_32) { ------------------ | Branch (1627:16): [True: 1, False: 0] ------------------ 1628| | // 32-bit data words never need padding to a multiple of 4 bytes. 1629| 1| if (data[dataLength - 1] != errorValue || data[dataLength - 2] != highValue) { ------------------ | Branch (1629:13): [True: 0, False: 1] | Branch (1629:51): [True: 0, False: 1] ------------------ 1630| 0| if (data[dataLength - 1] != highValue) { ------------------ | Branch (1630:17): [True: 0, False: 0] ------------------ 1631| 0| data[dataLength++] = highValue; 1632| 0| } 1633| 0| data[dataLength++] = errorValue; 1634| 0| } 1635| 1| length += dataLength * 4; 1636| 1| } else { 1637| 0| int32_t and3 = (length + dataLength) & 3; 1638| 0| if (and3 == 0 && data[dataLength - 1] == errorValue && data[dataLength - 2] == highValue) { ------------------ | Branch (1638:13): [True: 0, False: 0] | Branch (1638:26): [True: 0, False: 0] | Branch (1638:64): [True: 0, False: 0] ------------------ 1639| | // all set 1640| 0| } else if(and3 == 3 && data[dataLength - 1] == highValue) { ------------------ | Branch (1640:19): [True: 0, False: 0] | Branch (1640:32): [True: 0, False: 0] ------------------ 1641| 0| data[dataLength++] = errorValue; 1642| 0| } else { 1643| 0| while (and3 != 2) { ------------------ | Branch (1643:20): [True: 0, False: 0] ------------------ 1644| 0| data[dataLength++] = highValue; 1645| 0| and3 = (and3 + 1) & 3; 1646| 0| } 1647| 0| data[dataLength++] = highValue; 1648| 0| data[dataLength++] = errorValue; 1649| 0| } 1650| 0| length += dataLength; 1651| 0| } 1652| | 1653| | // Calculate the total length of the UCPTrie as a single memory block. 1654| 1| length += sizeof(UCPTrie); 1655| 1| U_ASSERT((length & 3) == 0); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1656| | 1657| 1| uint8_t* bytes = static_cast(uprv_malloc(length)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1658| 1| if (bytes == nullptr) { ------------------ | Branch (1658:9): [True: 0, False: 1] ------------------ 1659| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1660| 0| clear(); 1661| 0| return nullptr; 1662| 0| } 1663| 1| UCPTrie *trie = reinterpret_cast(bytes); 1664| 1| uprv_memset(trie, 0, sizeof(UCPTrie)); ------------------ | | 100| 1|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1665| 1| trie->indexLength = indexLength; 1666| 1| trie->dataLength = dataLength; 1667| | 1668| 1| trie->highStart = highStart; 1669| | // Round up shifted12HighStart to a multiple of 0x1000 for easy testing from UTF-8 lead bytes. 1670| | // Runtime code needs to then test for the real highStart as well. 1671| 1| trie->shifted12HighStart = (highStart + 0xfff) >> 12; 1672| 1| trie->type = type; 1673| 1| trie->valueWidth = valueWidth; 1674| | 1675| 1| trie->index3NullOffset = index3NullOffset; 1676| 1| trie->dataNullOffset = dataNullOffset; 1677| 1| trie->nullValue = initialValue; 1678| | 1679| 1| bytes += sizeof(UCPTrie); 1680| | 1681| | // Fill the index and data arrays. 1682| 1| uint16_t* dest16 = reinterpret_cast(bytes); 1683| 1| trie->index = dest16; 1684| | 1685| 1| if (highStart <= fastLimit) { ------------------ | Branch (1685:9): [True: 0, False: 1] ------------------ 1686| | // Condense only the fast index from the mutable-trie index. 1687| 0| for (int32_t i = 0, j = 0; j < indexLength; i += SMALL_DATA_BLOCKS_PER_BMP_BLOCK, ++j) { ------------------ | Branch (1687:36): [True: 0, False: 0] ------------------ 1688| 0| *dest16++ = static_cast(index[i]); // dest16[j] 1689| 0| } 1690| 1| } else { 1691| 1| uprv_memcpy(dest16, index16, indexLength * 2); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1692| 1| dest16 += indexLength; 1693| 1| } 1694| 1| bytes += indexLength * 2; 1695| | 1696| | // Write the data array. 1697| 1| const uint32_t *p = data; 1698| 1| switch (valueWidth) { 1699| 0| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (1699:5): [True: 0, False: 1] ------------------ 1700| | // Write 16-bit data values. 1701| 0| trie->data.ptr16 = dest16; 1702| 0| for (int32_t i = dataLength; i > 0; --i) { ------------------ | Branch (1702:38): [True: 0, False: 0] ------------------ 1703| 0| *dest16++ = static_cast(*p++); 1704| 0| } 1705| 0| break; 1706| 1| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (1706:5): [True: 1, False: 0] ------------------ 1707| | // Write 32-bit data values. 1708| 1| trie->data.ptr32 = reinterpret_cast(bytes); 1709| 1| uprv_memcpy(bytes, p, (size_t)dataLength * 4); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1710| 1| break; 1711| 0| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (1711:5): [True: 0, False: 1] ------------------ 1712| | // Write 8-bit data values. 1713| 0| trie->data.ptr8 = bytes; 1714| 0| for (int32_t i = dataLength; i > 0; --i) { ------------------ | Branch (1714:38): [True: 0, False: 0] ------------------ 1715| 0| *bytes++ = static_cast(*p++); 1716| 0| } 1717| 0| break; 1718| 0| default: ------------------ | Branch (1718:5): [True: 0, False: 1] ------------------ 1719| | // Will not occur, valueWidth checked at the beginning. 1720| 0| break; 1721| 1| } 1722| | 1723| |#ifdef UCPTRIE_DEBUG 1724| | trie->name = name; 1725| | 1726| | ucptrie_printLengths(trie, ""); 1727| |#endif 1728| | 1729| 1| clear(); 1730| 1| return trie; 1731| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie11compactTrieEiR10UErrorCode: 1491| 1|int32_t MutableCodePointTrie::compactTrie(int32_t fastILimit, UErrorCode &errorCode) { 1492| | // Find the real highStart and round it up. 1493| 1| U_ASSERT((highStart & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1494| 1| highValue = get(MAX_UNICODE); 1495| 1| int32_t realHighStart = findHighStart(); 1496| 1| realHighStart = (realHighStart + (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) & 1497| 1| ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 1498| 1| if (realHighStart == UNICODE_LIMIT) { ------------------ | Branch (1498:9): [True: 0, False: 1] ------------------ 1499| 0| highValue = initialValue; 1500| 0| } 1501| | 1502| |#ifdef UCPTRIE_DEBUG 1503| | printf("UCPTrie: highStart U+%06lx highValue 0x%lx initialValue 0x%lx\n", 1504| | (long)realHighStart, (long)highValue, (long)initialValue); 1505| |#endif 1506| | 1507| | // We always store indexes and data values for the fast range. 1508| | // Pin highStart to the top of that range while building. 1509| 1| UChar32 fastLimit = fastILimit << UCPTRIE_SHIFT_3; 1510| 1| if (realHighStart < fastLimit) { ------------------ | Branch (1510:9): [True: 0, False: 1] ------------------ 1511| 0| for (int32_t i = (realHighStart >> UCPTRIE_SHIFT_3); i < fastILimit; ++i) { ------------------ | Branch (1511:62): [True: 0, False: 0] ------------------ 1512| 0| flags[i] = ALL_SAME; 1513| 0| index[i] = highValue; 1514| 0| } 1515| 0| highStart = fastLimit; 1516| 1| } else { 1517| 1| highStart = realHighStart; 1518| 1| } 1519| | 1520| 1| uint32_t asciiData[ASCII_LIMIT]; 1521| 129| for (int32_t i = 0; i < ASCII_LIMIT; ++i) { ------------------ | Branch (1521:25): [True: 128, False: 1] ------------------ 1522| 128| asciiData[i] = get(i); 1523| 128| } 1524| | 1525| | // First we look for which data blocks have the same value repeated over the whole block, 1526| | // deduplicate such blocks, find a good null data block (for faster enumeration), 1527| | // and get an upper bound for the necessary data array length. 1528| 1| AllSameBlocks allSameBlocks; 1529| 1| int32_t newDataCapacity = compactWholeDataBlocks(fastILimit, allSameBlocks); 1530| 1| if (newDataCapacity < 0) { ------------------ | Branch (1530:9): [True: 0, False: 1] ------------------ 1531| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1532| 0| return 0; 1533| 0| } 1534| 1| uint32_t* newData = static_cast(uprv_malloc(newDataCapacity * 4)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1535| 1| if (newData == nullptr) { ------------------ | Branch (1535:9): [True: 0, False: 1] ------------------ 1536| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1537| 0| return 0; 1538| 0| } 1539| 1| uprv_memcpy(newData, asciiData, sizeof(asciiData)); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1540| | 1541| 1| int32_t dataNullIndex = allSameBlocks.findMostUsed(); 1542| | 1543| 1| MixedBlocks mixedBlocks; 1544| 1| int32_t newDataLength = compactData(fastILimit, newData, newDataCapacity, 1545| 1| dataNullIndex, mixedBlocks, errorCode); 1546| 1| if (U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1546:9): [True: 0, False: 1] ------------------ 1547| 1| U_ASSERT(newDataLength <= newDataCapacity); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1548| 1| uprv_free(data); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1549| 1| data = newData; 1550| 1| dataCapacity = newDataCapacity; 1551| 1| dataLength = newDataLength; 1552| 1| if (dataLength > (0x3ffff + UCPTRIE_SMALL_DATA_BLOCK_LENGTH)) { ------------------ | Branch (1552:9): [True: 0, False: 1] ------------------ 1553| | // The offset of the last data block is too high to be stored in the index table. 1554| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 1555| 0| return 0; 1556| 0| } 1557| | 1558| 1| if (dataNullIndex >= 0) { ------------------ | Branch (1558:9): [True: 1, False: 0] ------------------ 1559| 1| dataNullOffset = index[dataNullIndex]; 1560| |#ifdef UCPTRIE_DEBUG 1561| | if (data[dataNullOffset] != initialValue) { 1562| | printf("UCPTrie initialValue %lx -> more common nullValue %lx\n", 1563| | (long)initialValue, (long)data[dataNullOffset]); 1564| | } 1565| |#endif 1566| 1| initialValue = data[dataNullOffset]; 1567| 1| } else { 1568| 0| dataNullOffset = UCPTRIE_NO_DATA_NULL_OFFSET; 1569| 0| } 1570| | 1571| 1| int32_t indexLength = compactIndex(fastILimit, mixedBlocks, errorCode); 1572| 1| highStart = realHighStart; 1573| 1| return indexLength; 1574| 1|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_120MutableCodePointTrie13findHighStartEv: 664| 1|UChar32 MutableCodePointTrie::findHighStart() const { 665| 1| int32_t i = highStart >> UCPTRIE_SHIFT_3; 666| 32| while (i > 0) { ------------------ | Branch (666:12): [True: 32, False: 0] ------------------ 667| 32| bool match; 668| 32| if (flags[--i] == ALL_SAME) { ------------------ | Branch (668:13): [True: 31, False: 1] ------------------ 669| 31| match = index[i] == highValue; 670| 31| } else /* MIXED */ { 671| 1| const uint32_t *p = data + index[i]; 672| 1| for (int32_t j = 0;; ++j) { 673| 1| if (j == UCPTRIE_SMALL_DATA_BLOCK_LENGTH) { ------------------ | Branch (673:21): [True: 0, False: 1] ------------------ 674| 0| match = true; 675| 0| break; 676| 0| } 677| 1| if (p[j] != highValue) { ------------------ | Branch (677:21): [True: 1, False: 0] ------------------ 678| 1| match = false; 679| 1| break; 680| 1| } 681| 1| } 682| 1| } 683| 32| if (!match) { ------------------ | Branch (683:13): [True: 1, False: 31] ------------------ 684| 1| return (i + 1) << UCPTRIE_SHIFT_3; 685| 1| } 686| 32| } 687| 0| return 0; 688| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_113AllSameBlocksC2Ev: 695| 1| AllSameBlocks() : length(0), mostRecent(-1) {} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie22compactWholeDataBlocksEiRNS0_13AllSameBlocksE: 927| 1|int32_t MutableCodePointTrie::compactWholeDataBlocks(int32_t fastILimit, AllSameBlocks &allSameBlocks) { 928| |#ifdef UCPTRIE_DEBUG 929| | bool overflow = false; 930| |#endif 931| | 932| | // ASCII data will be stored as a linear table, even if the following code 933| | // does not yet count it that way. 934| 1| int32_t newDataCapacity = ASCII_LIMIT; 935| | // Add room for a small data null block in case it would match the start of 936| | // a fast data block where dataNullOffset must not be set in that case. 937| 1| newDataCapacity += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 938| | // Add room for special values (errorValue, highValue) and padding. 939| 1| newDataCapacity += 4; 940| 1| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 941| 1| int32_t blockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 942| 1| int32_t inc = SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 943| 10.6k| for (int32_t i = 0; i < iLimit; i += inc) { ------------------ | Branch (943:25): [True: 10.6k, False: 1] ------------------ 944| 10.6k| if (i == fastILimit) { ------------------ | Branch (944:13): [True: 1, False: 10.6k] ------------------ 945| 1| blockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 946| 1| inc = 1; 947| 1| } 948| 10.6k| uint32_t value = index[i]; 949| 10.6k| if (flags[i] == MIXED) { ------------------ | Branch (949:13): [True: 1.72k, False: 8.96k] ------------------ 950| | // Really mixed? 951| 1.72k| const uint32_t *p = data + value; 952| 1.72k| value = *p; 953| 1.72k| if (allValuesSameAs(p + 1, blockLength - 1, value)) { ------------------ | Branch (953:17): [True: 799, False: 923] ------------------ 954| 799| flags[i] = ALL_SAME; 955| 799| index[i] = value; 956| | // Fall through to ALL_SAME handling. 957| 923| } else { 958| 923| newDataCapacity += blockLength; 959| 923| continue; 960| 923| } 961| 8.96k| } else { 962| 8.96k| U_ASSERT(flags[i] == ALL_SAME); ------------------ | | 35| 8.96k|# define U_ASSERT(exp) (void)0 ------------------ 963| 8.96k| if (inc > 1) { ------------------ | Branch (963:17): [True: 10, False: 8.95k] ------------------ 964| | // Do all of the fast-range data block's ALL_SAME parts have the same value? 965| 10| bool allSame = true; 966| 10| int32_t next_i = i + inc; 967| 40| for (int32_t j = i + 1; j < next_i; ++j) { ------------------ | Branch (967:41): [True: 30, False: 10] ------------------ 968| 30| U_ASSERT(flags[j] == ALL_SAME); ------------------ | | 35| 30|# define U_ASSERT(exp) (void)0 ------------------ 969| 30| if (index[j] != value) { ------------------ | Branch (969:25): [True: 0, False: 30] ------------------ 970| 0| allSame = false; 971| 0| break; 972| 0| } 973| 30| } 974| 10| if (!allSame) { ------------------ | Branch (974:21): [True: 0, False: 10] ------------------ 975| | // Turn it into a MIXED block. 976| 0| if (getDataBlock(i) < 0) { ------------------ | Branch (976:25): [True: 0, False: 0] ------------------ 977| 0| return -1; 978| 0| } 979| 0| newDataCapacity += blockLength; 980| 0| continue; 981| 0| } 982| 10| } 983| 8.96k| } 984| | // Is there another ALL_SAME block with the same value? 985| 9.76k| int32_t other = allSameBlocks.findOrAdd(i, inc, value); 986| 9.76k| if (other == AllSameBlocks::OVERFLOW) { ------------------ | Branch (986:13): [True: 0, False: 9.76k] ------------------ 987| | // The fixed-size array overflowed. Slow check for a duplicate block. 988| |#ifdef UCPTRIE_DEBUG 989| | if (!overflow) { 990| | puts("UCPTrie AllSameBlocks overflow"); 991| | overflow = true; 992| | } 993| |#endif 994| 0| int32_t jInc = SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 995| 0| for (int32_t j = 0;; j += jInc) { 996| 0| if (j == i) { ------------------ | Branch (996:21): [True: 0, False: 0] ------------------ 997| 0| allSameBlocks.add(i, inc, value); 998| 0| break; 999| 0| } 1000| 0| if (j == fastILimit) { ------------------ | Branch (1000:21): [True: 0, False: 0] ------------------ 1001| 0| jInc = 1; 1002| 0| } 1003| 0| if (flags[j] == ALL_SAME && index[j] == value) { ------------------ | Branch (1003:21): [True: 0, False: 0] | Branch (1003:45): [True: 0, False: 0] ------------------ 1004| 0| allSameBlocks.add(j, jInc + inc, value); 1005| 0| other = j; 1006| 0| break; 1007| | // We could keep counting blocks with the same value 1008| | // before we add the first one, which may improve compaction in rare cases, 1009| | // but it would make it slower. 1010| 0| } 1011| 0| } 1012| 0| } 1013| 9.76k| if (other >= 0) { ------------------ | Branch (1013:13): [True: 9.76k, False: 3] ------------------ 1014| 9.76k| flags[i] = SAME_AS; 1015| 9.76k| index[i] = other; 1016| 9.76k| } else { 1017| | // New unique same-value block. 1018| 3| newDataCapacity += blockLength; 1019| 3| } 1020| 9.76k| } 1021| 1| return newDataCapacity; 1022| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_115allValuesSameAsEPKjij: 584| 1.73k|bool allValuesSameAs(const uint32_t *p, int32_t length, uint32_t value) { 585| 1.73k| const uint32_t *pLimit = p + length; 586| 19.9k| while (p < pLimit && *p == value) { ++p; } ------------------ | Branch (586:12): [True: 19.1k, False: 801] | Branch (586:26): [True: 18.2k, False: 934] ------------------ 587| 1.73k| return p == pLimit; 588| 1.73k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_113AllSameBlocks9findOrAddEiij: 697| 9.76k| int32_t findOrAdd(int32_t index, int32_t count, uint32_t value) { 698| 9.76k| if (mostRecent >= 0 && values[mostRecent] == value) { ------------------ | Branch (698:13): [True: 9.76k, False: 1] | Branch (698:32): [True: 9.75k, False: 12] ------------------ 699| 9.75k| refCounts[mostRecent] += count; 700| 9.75k| return indexes[mostRecent]; 701| 9.75k| } 702| 24| for (int32_t i = 0; i < length; ++i) { ------------------ | Branch (702:29): [True: 21, False: 3] ------------------ 703| 21| if (values[i] == value) { ------------------ | Branch (703:17): [True: 10, False: 11] ------------------ 704| 10| mostRecent = i; 705| 10| refCounts[i] += count; 706| 10| return indexes[i]; 707| 10| } 708| 21| } 709| 3| if (length == CAPACITY) { ------------------ | Branch (709:13): [True: 0, False: 3] ------------------ 710| 0| return OVERFLOW; 711| 0| } 712| 3| mostRecent = length; 713| 3| indexes[length] = index; 714| 3| values[length] = value; 715| 3| refCounts[length++] = count; 716| 3| return NEW_UNIQUE; 717| 3| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_113AllSameBlocks12findMostUsedEv: 738| 1| int32_t findMostUsed() const { 739| 1| if (length == 0) { return -1; } ------------------ | Branch (739:13): [True: 0, False: 1] ------------------ 740| 1| int32_t max = -1; 741| 1| int32_t maxCount = 0; 742| 4| for (int32_t i = 0; i < length; ++i) { ------------------ | Branch (742:29): [True: 3, False: 1] ------------------ 743| 3| if (refCounts[i] > maxCount) { ------------------ | Branch (743:17): [True: 1, False: 2] ------------------ 744| 1| max = i; 745| 1| maxCount = refCounts[i]; 746| 1| } 747| 3| } 748| 1| return indexes[max]; 749| 1| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocksC2Ev: 766| 2| MixedBlocks() {} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie11compactDataEiPjiiRNS0_11MixedBlocksER10UErrorCode: 1084| 1| int32_t dataNullIndex, MixedBlocks &mixedBlocks, UErrorCode &errorCode) { 1085| |#ifdef UCPTRIE_DEBUG 1086| | int32_t countSame=0, sumOverlaps=0; 1087| | bool printData = dataLength == 29088 /* line.brk */ || 1088| | // dataLength == 30048 /* CanonIterData */ || 1089| | dataLength == 50400 /* zh.txt~stroke */; 1090| |#endif 1091| | 1092| | // The linear ASCII data has been copied into newData already. 1093| 1| int32_t newDataLength = 0; 1094| 3| for (int32_t i = 0; newDataLength < ASCII_LIMIT; ------------------ | Branch (1094:25): [True: 2, False: 1] ------------------ 1095| 2| newDataLength += UCPTRIE_FAST_DATA_BLOCK_LENGTH, i += SMALL_DATA_BLOCKS_PER_BMP_BLOCK) { 1096| 2| index[i] = newDataLength; 1097| |#ifdef UCPTRIE_DEBUG 1098| | if (printData) { 1099| | printBlock(newData + newDataLength, UCPTRIE_FAST_DATA_BLOCK_LENGTH, 0, newDataLength, 0, initialValue); 1100| | } 1101| |#endif 1102| 2| } 1103| | 1104| 1| int32_t blockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 1105| 1| if (!mixedBlocks.init(newDataCapacity, blockLength)) { ------------------ | Branch (1105:9): [True: 0, False: 1] ------------------ 1106| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1107| 0| return 0; 1108| 0| } 1109| 1| mixedBlocks.extend(newData, 0, 0, newDataLength); 1110| | 1111| 1| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 1112| 1| int32_t inc = SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 1113| 1| int32_t fastLength = 0; 1114| 10.6k| for (int32_t i = ASCII_I_LIMIT; i < iLimit; i += inc) { ------------------ | Branch (1114:37): [True: 10.6k, False: 1] ------------------ 1115| 10.6k| if (i == fastILimit) { ------------------ | Branch (1115:13): [True: 1, False: 10.6k] ------------------ 1116| 1| blockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 1117| 1| inc = 1; 1118| 1| fastLength = newDataLength; 1119| 1| if (!mixedBlocks.init(newDataCapacity, blockLength)) { ------------------ | Branch (1119:17): [True: 0, False: 1] ------------------ 1120| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1121| 0| return 0; 1122| 0| } 1123| 1| mixedBlocks.extend(newData, 0, 0, newDataLength); 1124| 1| } 1125| 10.6k| if (flags[i] == ALL_SAME) { ------------------ | Branch (1125:13): [True: 3, False: 10.6k] ------------------ 1126| 3| uint32_t value = index[i]; 1127| | // Find an earlier part of the data array of length blockLength 1128| | // that is filled with this value. 1129| 3| int32_t n = mixedBlocks.findAllSameBlock(newData, value); 1130| | // If we find a match, and the current block is the data null block, 1131| | // and it is not a fast block but matches the start of a fast block, 1132| | // then we need to continue looking. 1133| | // This is because this small block is shorter than the fast block, 1134| | // and not all of the rest of the fast block is filled with this value. 1135| | // Otherwise trie.getRange() would detect that the fast block starts at 1136| | // dataNullOffset and assume incorrectly that it is filled with the null value. 1137| 3| while (n >= 0 && i == dataNullIndex && i >= fastILimit && n < fastLength && ------------------ | Branch (1137:20): [True: 2, False: 1] | Branch (1137:30): [True: 0, False: 2] | Branch (1137:52): [True: 0, False: 0] | Branch (1137:71): [True: 0, False: 0] ------------------ 1138| 3| isStartOfSomeFastBlock(n, index, fastILimit)) { ------------------ | Branch (1138:21): [True: 0, False: 0] ------------------ 1139| 0| n = findAllSameBlock(newData, n + 1, newDataLength, value, blockLength); 1140| 0| } 1141| 3| if (n >= 0) { ------------------ | Branch (1141:17): [True: 2, False: 1] ------------------ 1142| 2| DEBUG_DO(++countSame); 1143| 2| index[i] = n; 1144| 2| } else { 1145| 1| n = getAllSameOverlap(newData, newDataLength, value, blockLength); 1146| 1| DEBUG_DO(sumOverlaps += n); 1147| |#ifdef UCPTRIE_DEBUG 1148| | if (printData) { 1149| | printBlock(nullptr, blockLength, value, i << UCPTRIE_SHIFT_3, n, initialValue); 1150| | } 1151| |#endif 1152| 1| index[i] = newDataLength - n; 1153| 1| int32_t prevDataLength = newDataLength; 1154| 58| while (n < blockLength) { ------------------ | Branch (1154:24): [True: 57, False: 1] ------------------ 1155| 57| newData[newDataLength++] = value; 1156| 57| ++n; 1157| 57| } 1158| 1| mixedBlocks.extend(newData, 0, prevDataLength, newDataLength); 1159| 1| } 1160| 10.6k| } else if (flags[i] == MIXED) { ------------------ | Branch (1160:20): [True: 921, False: 9.76k] ------------------ 1161| 921| const uint32_t *block = data + index[i]; 1162| 921| int32_t n = mixedBlocks.findBlock(newData, block, 0); 1163| 921| if (n >= 0) { ------------------ | Branch (1163:17): [True: 116, False: 805] ------------------ 1164| 116| DEBUG_DO(++countSame); 1165| 116| index[i] = n; 1166| 805| } else { 1167| 805| n = getOverlap(newData, newDataLength, block, 0, blockLength); 1168| 805| DEBUG_DO(sumOverlaps += n); 1169| |#ifdef UCPTRIE_DEBUG 1170| | if (printData) { 1171| | printBlock(block, blockLength, 0, i << UCPTRIE_SHIFT_3, n, initialValue); 1172| | } 1173| |#endif 1174| 805| index[i] = newDataLength - n; 1175| 805| int32_t prevDataLength = newDataLength; 1176| 12.0k| while (n < blockLength) { ------------------ | Branch (1176:24): [True: 11.2k, False: 805] ------------------ 1177| 11.2k| newData[newDataLength++] = block[n++]; 1178| 11.2k| } 1179| 805| mixedBlocks.extend(newData, 0, prevDataLength, newDataLength); 1180| 805| } 1181| 9.76k| } else /* SAME_AS */ { 1182| 9.76k| uint32_t j = index[i]; 1183| 9.76k| index[i] = index[j]; 1184| 9.76k| } 1185| 10.6k| } 1186| | 1187| |#ifdef UCPTRIE_DEBUG 1188| | /* we saved some space */ 1189| | printf("compacting UCPTrie: count of 32-bit data words %lu->%lu countSame=%ld sumOverlaps=%ld\n", 1190| | (long)dataLength, (long)newDataLength, (long)countSame, (long)sumOverlaps); 1191| |#endif 1192| 1| return newDataLength; 1193| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks4initEii: 771| 4| bool init(int32_t maxLength, int32_t newBlockLength) { 772| | // We store actual data indexes + 1 to reserve 0 for empty entries. 773| 4| int32_t maxDataIndex = maxLength - newBlockLength + 1; 774| 4| int32_t newLength; 775| 4| if (maxDataIndex <= 0xfff) { // 4k ------------------ | Branch (775:13): [True: 1, False: 3] ------------------ 776| 1| newLength = 6007; 777| 1| shift = 12; 778| 1| mask = 0xfff; 779| 3| } else if (maxDataIndex <= 0x7fff) { // 32k ------------------ | Branch (779:20): [True: 3, False: 0] ------------------ 780| 3| newLength = 50021; 781| 3| shift = 15; 782| 3| mask = 0x7fff; 783| 3| } else if (maxDataIndex <= 0x1ffff) { // 128k ------------------ | Branch (783:20): [True: 0, False: 0] ------------------ 784| 0| newLength = 200003; 785| 0| shift = 17; 786| 0| mask = 0x1ffff; 787| 0| } else { 788| | // maxDataIndex up to around MAX_DATA_LENGTH, ca. 1.1M 789| 0| newLength = 1500007; 790| 0| shift = 21; 791| 0| mask = 0x1fffff; 792| 0| } 793| 4| if (newLength > capacity) { ------------------ | Branch (793:13): [True: 1, False: 3] ------------------ 794| 1| uprv_free(table); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 795| 1| table = static_cast(uprv_malloc(newLength * 4)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 796| 1| if (table == nullptr) { ------------------ | Branch (796:17): [True: 0, False: 1] ------------------ 797| 0| return false; 798| 0| } 799| 1| capacity = newLength; 800| 1| } 801| 4| length = newLength; 802| 4| uprv_memset(table, 0, length * 4); ------------------ | | 100| 4|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 803| | 804| 4| blockLength = newBlockLength; 805| 4| return true; 806| 4| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks6extendIjEEvPKT_iii: 809| 808| void extend(const UInt *data, int32_t minStart, int32_t prevDataLength, int32_t newDataLength) { 810| 808| int32_t start = prevDataLength - blockLength; 811| 808| if (start >= minStart) { ------------------ | Branch (811:13): [True: 806, False: 2] ------------------ 812| 806| ++start; // Skip the last block that we added last time. 813| 806| } else { 814| 2| start = minStart; // Begin with the first full block. 815| 2| } 816| 14.6k| for (int32_t end = newDataLength - blockLength; start <= end; ++start) { ------------------ | Branch (816:57): [True: 13.8k, False: 808] ------------------ 817| 13.8k| uint32_t hashCode = makeHashCode(data, start); 818| 13.8k| addEntry(data, start, hashCode, start); 819| 13.8k| } 820| 808| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks12makeHashCodeIjEEjPKT_i: 845| 15.1k| uint32_t makeHashCode(const UInt *blockData, int32_t blockStart) const { 846| 15.1k| int32_t blockLimit = blockStart + blockLength; 847| 15.1k| uint32_t hashCode = blockData[blockStart++]; 848| 350k| do { 849| 350k| hashCode = 37 * hashCode + blockData[blockStart++]; 850| 350k| } while (blockStart < blockLimit); ------------------ | Branch (850:18): [True: 335k, False: 15.1k] ------------------ 851| 15.1k| return hashCode; 852| 15.1k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks8addEntryIjEEvPKT_iji: 863| 13.8k| void addEntry(const UInt *data, int32_t blockStart, uint32_t hashCode, int32_t dataIndex) { 864| 13.8k| U_ASSERT(0 <= dataIndex && dataIndex < (int32_t)mask); ------------------ | | 35| 13.8k|# define U_ASSERT(exp) (void)0 ------------------ 865| 13.8k| int32_t entryIndex = findEntry(data, data, blockStart, hashCode); 866| 13.8k| if (entryIndex < 0) { ------------------ | Branch (866:13): [True: 12.3k, False: 1.56k] ------------------ 867| 12.3k| table[~entryIndex] = (hashCode << shift) | (dataIndex + 1); 868| 12.3k| } 869| 13.8k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryIjjEEiPKT_PKT0_ij: 873| 14.7k| uint32_t hashCode) const { 874| 14.7k| uint32_t shiftedHashCode = hashCode << shift; 875| 14.7k| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 876| 587k| for (int32_t entryIndex = initialEntryIndex;;) { 877| 587k| uint32_t entry = table[entryIndex]; 878| 587k| if (entry == 0) { ------------------ | Branch (878:17): [True: 13.1k, False: 574k] ------------------ 879| 13.1k| return ~entryIndex; 880| 13.1k| } 881| 574k| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (881:17): [True: 559k, False: 15.5k] ------------------ 882| 559k| int32_t dataIndex = (entry & mask) - 1; 883| 559k| if (equalBlocks(data + dataIndex, blockData + blockStart, blockLength)) { ------------------ | Branch (883:21): [True: 1.67k, False: 557k] ------------------ 884| 1.67k| return entryIndex; 885| 1.67k| } 886| 559k| } 887| 573k| entryIndex = nextIndex(initialEntryIndex, entryIndex); 888| 573k| } 889| 14.7k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111equalBlocksIjjEEbPKT_PKT0_i: 575| 570k|bool equalBlocks(const UIntA *s, const UIntB *t, int32_t length) { 576| 3.19M| while (length > 0 && *s == *t) { ------------------ | Branch (576:12): [True: 3.19M, False: 2.37k] | Branch (576:26): [True: 2.62M, False: 568k] ------------------ 577| 2.62M| ++s; 578| 2.62M| ++t; 579| 2.62M| --length; 580| 2.62M| } 581| 570k| return length == 0; 582| 570k|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9nextIndexEii: 909| 573k| inline int32_t nextIndex(int32_t initialEntryIndex, int32_t entryIndex) const { 910| | // U_ASSERT(0 < initialEntryIndex && initialEntryIndex < length); 911| 573k| return (entryIndex + initialEntryIndex) % length; 912| 573k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks16findAllSameBlockEPKjj: 833| 3| int32_t findAllSameBlock(const uint32_t *data, uint32_t blockValue) const { 834| 3| uint32_t hashCode = makeHashCode(blockValue); 835| 3| int32_t entryIndex = findEntry(data, blockValue, hashCode); 836| 3| if (entryIndex >= 0) { ------------------ | Branch (836:13): [True: 2, False: 1] ------------------ 837| 2| return (table[entryIndex] & mask) - 1; 838| 2| } else { 839| 1| return -1; 840| 1| } 841| 3| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks12makeHashCodeEj: 854| 3| uint32_t makeHashCode(uint32_t blockValue) const { 855| 3| uint32_t hashCode = blockValue; 856| 96| for (int32_t i = 1; i < blockLength; ++i) { ------------------ | Branch (856:29): [True: 93, False: 3] ------------------ 857| 93| hashCode = 37 * hashCode + blockValue; 858| 93| } 859| 3| return hashCode; 860| 3| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryEPKjjj: 891| 3| int32_t findEntry(const uint32_t *data, uint32_t blockValue, uint32_t hashCode) const { 892| 3| uint32_t shiftedHashCode = hashCode << shift; 893| 3| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 894| 14| for (int32_t entryIndex = initialEntryIndex;;) { 895| 14| uint32_t entry = table[entryIndex]; 896| 14| if (entry == 0) { ------------------ | Branch (896:17): [True: 1, False: 13] ------------------ 897| 1| return ~entryIndex; 898| 1| } 899| 13| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (899:17): [True: 13, False: 0] ------------------ 900| 13| int32_t dataIndex = (entry & mask) - 1; 901| 13| if (allValuesSameAs(data + dataIndex, blockLength, blockValue)) { ------------------ | Branch (901:21): [True: 2, False: 11] ------------------ 902| 2| return entryIndex; 903| 2| } 904| 13| } 905| 11| entryIndex = nextIndex(initialEntryIndex, entryIndex); 906| 11| } 907| 3| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_117getAllSameOverlapEPKjiji: 644| 1| int32_t blockLength) { 645| 1| int32_t min = length - (blockLength - 1); 646| 1| int32_t i = length; 647| 8| while (min < i && p[i - 1] == value) { --i; } ------------------ | Branch (647:12): [True: 8, False: 0] | Branch (647:23): [True: 7, False: 1] ------------------ 648| 1| return length - i; 649| 1|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findBlockIjjEEiPKT_PKT0_i: 823| 921| int32_t findBlock(const UIntA *data, const UIntB *blockData, int32_t blockStart) const { 824| 921| uint32_t hashCode = makeHashCode(blockData, blockStart); 825| 921| int32_t entryIndex = findEntry(data, blockData, blockStart, hashCode); 826| 921| if (entryIndex >= 0) { ------------------ | Branch (826:13): [True: 116, False: 805] ------------------ 827| 116| return (table[entryIndex] & mask) - 1; 828| 805| } else { 829| 805| return -1; 830| 805| } 831| 921| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110getOverlapIjjEEiPKT_iPKT0_ii: 633| 805| const UIntB *q, int32_t qStart, int32_t blockLength) { 634| 805| int32_t overlap = blockLength - 1; 635| 805| U_ASSERT(overlap <= length); ------------------ | | 35| 805|# define U_ASSERT(exp) (void)0 ------------------ 636| 805| q += qStart; 637| 11.2k| while (overlap > 0 && !equalBlocks(p + (length - overlap), q, overlap)) { ------------------ | Branch (637:12): [True: 11.1k, False: 110] | Branch (637:27): [True: 10.4k, False: 695] ------------------ 638| 10.4k| --overlap; 639| 10.4k| } 640| 805| return overlap; 641| 805|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie12compactIndexEiRNS0_11MixedBlocksER10UErrorCode: 1196| 1| UErrorCode &errorCode) { 1197| 1| int32_t fastIndexLength = fastILimit >> (UCPTRIE_FAST_SHIFT - UCPTRIE_SHIFT_3); 1198| 1| if ((highStart >> UCPTRIE_FAST_SHIFT) <= fastIndexLength) { ------------------ | Branch (1198:9): [True: 0, False: 1] ------------------ 1199| | // Only the linear fast index, no multi-stage index tables. 1200| 0| index3NullOffset = UCPTRIE_NO_INDEX3_NULL_OFFSET; 1201| 0| return fastIndexLength; 1202| 0| } 1203| | 1204| | // Condense the fast index table. 1205| | // Also, does it contain an index-3 block with all dataNullOffset? 1206| 1| uint16_t fastIndex[UCPTRIE_BMP_INDEX_LENGTH]; // fastIndexLength 1207| 1| int32_t i3FirstNull = -1; 1208| 65| for (int32_t i = 0, j = 0; i < fastILimit; ++j) { ------------------ | Branch (1208:32): [True: 64, False: 1] ------------------ 1209| 64| uint32_t i3 = index[i]; 1210| 64| fastIndex[j] = static_cast(i3); 1211| 64| if (i3 == static_cast(dataNullOffset)) { ------------------ | Branch (1211:13): [True: 10, False: 54] ------------------ 1212| 10| if (i3FirstNull < 0) { ------------------ | Branch (1212:17): [True: 7, False: 3] ------------------ 1213| 7| i3FirstNull = j; 1214| 7| } else if (index3NullOffset < 0 && ------------------ | Branch (1214:24): [True: 3, False: 0] ------------------ 1215| 3| (j - i3FirstNull + 1) == UCPTRIE_INDEX_3_BLOCK_LENGTH) { ------------------ | Branch (1215:21): [True: 0, False: 3] ------------------ 1216| 0| index3NullOffset = i3FirstNull; 1217| 0| } 1218| 54| } else { 1219| 54| i3FirstNull = -1; 1220| 54| } 1221| | // Set the index entries that compactData() skipped. 1222| | // Needed when the multi-stage index covers the fast index range as well. 1223| 64| int32_t iNext = i + SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 1224| 256| while (++i < iNext) { ------------------ | Branch (1224:16): [True: 192, False: 64] ------------------ 1225| 192| i3 += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 1226| 192| index[i] = i3; 1227| 192| } 1228| 64| } 1229| | 1230| 1| if (!mixedBlocks.init(fastIndexLength, UCPTRIE_INDEX_3_BLOCK_LENGTH)) { ------------------ | Branch (1230:9): [True: 0, False: 1] ------------------ 1231| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1232| 0| return 0; 1233| 0| } 1234| 1| mixedBlocks.extend(fastIndex, 0, 0, fastIndexLength); 1235| | 1236| | // Examine index-3 blocks. For each determine one of: 1237| | // - same as the index-3 null block 1238| | // - same as a fast-index block 1239| | // - 16-bit indexes 1240| | // - 18-bit indexes 1241| | // We store this in the first flags entry for the index-3 block. 1242| | // 1243| | // Also determine an upper limit for the index-3 table length. 1244| 1| int32_t index3Capacity = 0; 1245| 1| i3FirstNull = index3NullOffset; 1246| 1| bool hasLongI3Blocks = false; 1247| | // If the fast index covers the whole BMP, then 1248| | // the multi-stage index is only for supplementary code points. 1249| | // Otherwise, the multi-stage index covers all of Unicode. 1250| 1| int32_t iStart = fastILimit < BMP_I_LIMIT ? 0 : BMP_I_LIMIT; ------------------ | Branch (1250:22): [True: 1, False: 0] ------------------ 1251| 1| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 1252| 341| for (int32_t i = iStart; i < iLimit;) { ------------------ | Branch (1252:30): [True: 340, False: 1] ------------------ 1253| 340| int32_t j = i; 1254| 340| int32_t jLimit = i + UCPTRIE_INDEX_3_BLOCK_LENGTH; 1255| 340| uint32_t oredI3 = 0; 1256| 340| bool isNull = true; 1257| 10.8k| do { 1258| 10.8k| uint32_t i3 = index[j]; 1259| 10.8k| oredI3 |= i3; 1260| 10.8k| if (i3 != static_cast(dataNullOffset)) { ------------------ | Branch (1260:17): [True: 1.12k, False: 9.75k] ------------------ 1261| 1.12k| isNull = false; 1262| 1.12k| } 1263| 10.8k| } while (++j < jLimit); ------------------ | Branch (1263:18): [True: 10.5k, False: 340] ------------------ 1264| 340| if (isNull) { ------------------ | Branch (1264:13): [True: 176, False: 164] ------------------ 1265| 176| flags[i] = I3_NULL; 1266| 176| if (i3FirstNull < 0) { ------------------ | Branch (1266:17): [True: 1, False: 175] ------------------ 1267| 1| if (oredI3 <= 0xffff) { ------------------ | Branch (1267:21): [True: 1, False: 0] ------------------ 1268| 1| index3Capacity += UCPTRIE_INDEX_3_BLOCK_LENGTH; 1269| 1| } else { 1270| 0| index3Capacity += INDEX_3_18BIT_BLOCK_LENGTH; 1271| 0| hasLongI3Blocks = true; 1272| 0| } 1273| 1| i3FirstNull = 0; 1274| 1| } 1275| 176| } else { 1276| 164| if (oredI3 <= 0xffff) { ------------------ | Branch (1276:17): [True: 164, False: 0] ------------------ 1277| 164| int32_t n = mixedBlocks.findBlock(fastIndex, index, i); 1278| 164| if (n >= 0) { ------------------ | Branch (1278:21): [True: 0, False: 164] ------------------ 1279| 0| flags[i] = I3_BMP; 1280| 0| index[i] = n; 1281| 164| } else { 1282| 164| flags[i] = I3_16; 1283| 164| index3Capacity += UCPTRIE_INDEX_3_BLOCK_LENGTH; 1284| 164| } 1285| 164| } else { 1286| 0| flags[i] = I3_18; 1287| 0| index3Capacity += INDEX_3_18BIT_BLOCK_LENGTH; 1288| 0| hasLongI3Blocks = true; 1289| 0| } 1290| 164| } 1291| 340| i = j; 1292| 340| } 1293| | 1294| 1| int32_t index2Capacity = (iLimit - iStart) >> UCPTRIE_SHIFT_2_3; 1295| | 1296| | // Length of the index-1 table, rounded up. 1297| 1| int32_t index1Length = (index2Capacity + UCPTRIE_INDEX_2_MASK) >> UCPTRIE_SHIFT_1_2; 1298| | 1299| | // Index table: Fast index, index-1, index-3, index-2. 1300| | // +1 for possible index table padding. 1301| 1| int32_t index16Capacity = fastIndexLength + index1Length + index3Capacity + index2Capacity + 1; 1302| 1| index16 = static_cast(uprv_malloc(index16Capacity * 2)); ------------------ | | 1524| 1|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1303| 1| if (index16 == nullptr) { ------------------ | Branch (1303:9): [True: 0, False: 1] ------------------ 1304| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1305| 0| return 0; 1306| 0| } 1307| 1| uprv_memcpy(index16, fastIndex, fastIndexLength * 2); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1308| | 1309| 1| if (!mixedBlocks.init(index16Capacity, UCPTRIE_INDEX_3_BLOCK_LENGTH)) { ------------------ | Branch (1309:9): [True: 0, False: 1] ------------------ 1310| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1311| 0| return 0; 1312| 0| } 1313| 1| MixedBlocks longI3Blocks; 1314| 1| if (hasLongI3Blocks) { ------------------ | Branch (1314:9): [True: 0, False: 1] ------------------ 1315| 0| if (!longI3Blocks.init(index16Capacity, INDEX_3_18BIT_BLOCK_LENGTH)) { ------------------ | Branch (1315:13): [True: 0, False: 0] ------------------ 1316| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1317| 0| return 0; 1318| 0| } 1319| 0| } 1320| | 1321| | // Compact the index-3 table and write an uncompacted version of the index-2 table. 1322| 1| uint16_t index2[UNICODE_LIMIT >> UCPTRIE_SHIFT_2]; // index2Capacity 1323| 1| int32_t i2Length = 0; 1324| 1| i3FirstNull = index3NullOffset; 1325| 1| int32_t index3Start = fastIndexLength + index1Length; 1326| 1| int32_t indexLength = index3Start; 1327| 341| for (int32_t i = iStart; i < iLimit; i += UCPTRIE_INDEX_3_BLOCK_LENGTH) { ------------------ | Branch (1327:30): [True: 340, False: 1] ------------------ 1328| 340| int32_t i3; 1329| 340| uint8_t f = flags[i]; 1330| 340| if (f == I3_NULL && i3FirstNull < 0) { ------------------ | Branch (1330:13): [True: 176, False: 164] | Branch (1330:29): [True: 1, False: 175] ------------------ 1331| | // First index-3 null block. Write & overlap it like a normal block, then remember it. 1332| 1| f = dataNullOffset <= 0xffff ? I3_16 : I3_18; ------------------ | Branch (1332:17): [True: 1, False: 0] ------------------ 1333| 1| i3FirstNull = 0; 1334| 1| } 1335| 340| if (f == I3_NULL) { ------------------ | Branch (1335:13): [True: 175, False: 165] ------------------ 1336| 175| i3 = index3NullOffset; 1337| 175| } else if (f == I3_BMP) { ------------------ | Branch (1337:20): [True: 0, False: 165] ------------------ 1338| 0| i3 = index[i]; 1339| 165| } else if (f == I3_16) { ------------------ | Branch (1339:20): [True: 165, False: 0] ------------------ 1340| 165| int32_t n = mixedBlocks.findBlock(index16, index, i); 1341| 165| if (n >= 0) { ------------------ | Branch (1341:17): [True: 0, False: 165] ------------------ 1342| 0| i3 = n; 1343| 165| } else { 1344| 165| if (indexLength == index3Start) { ------------------ | Branch (1344:21): [True: 1, False: 164] ------------------ 1345| | // No overlap at the boundary between the index-1 and index-3 tables. 1346| 1| n = 0; 1347| 164| } else { 1348| 164| n = getOverlap(index16, indexLength, 1349| 164| index, i, UCPTRIE_INDEX_3_BLOCK_LENGTH); 1350| 164| } 1351| 165| i3 = indexLength - n; 1352| 165| int32_t prevIndexLength = indexLength; 1353| 4.66k| while (n < UCPTRIE_INDEX_3_BLOCK_LENGTH) { ------------------ | Branch (1353:24): [True: 4.49k, False: 165] ------------------ 1354| 4.49k| index16[indexLength++] = index[i + n++]; 1355| 4.49k| } 1356| 165| mixedBlocks.extend(index16, index3Start, prevIndexLength, indexLength); 1357| 165| if (hasLongI3Blocks) { ------------------ | Branch (1357:21): [True: 0, False: 165] ------------------ 1358| 0| longI3Blocks.extend(index16, index3Start, prevIndexLength, indexLength); 1359| 0| } 1360| 165| } 1361| 165| } else { 1362| 0| U_ASSERT(f == I3_18); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1363| 0| U_ASSERT(hasLongI3Blocks); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1364| | // Encode an index-3 block that contains one or more data indexes exceeding 16 bits. 1365| 0| int32_t j = i; 1366| 0| int32_t jLimit = i + UCPTRIE_INDEX_3_BLOCK_LENGTH; 1367| 0| int32_t k = indexLength; 1368| 0| do { 1369| 0| ++k; 1370| 0| uint32_t v = index[j++]; 1371| 0| uint32_t upperBits = (v & 0x30000) >> 2; 1372| 0| index16[k++] = v; 1373| 0| v = index[j++]; 1374| 0| upperBits |= (v & 0x30000) >> 4; 1375| 0| index16[k++] = v; 1376| 0| v = index[j++]; 1377| 0| upperBits |= (v & 0x30000) >> 6; 1378| 0| index16[k++] = v; 1379| 0| v = index[j++]; 1380| 0| upperBits |= (v & 0x30000) >> 8; 1381| 0| index16[k++] = v; 1382| 0| v = index[j++]; 1383| 0| upperBits |= (v & 0x30000) >> 10; 1384| 0| index16[k++] = v; 1385| 0| v = index[j++]; 1386| 0| upperBits |= (v & 0x30000) >> 12; 1387| 0| index16[k++] = v; 1388| 0| v = index[j++]; 1389| 0| upperBits |= (v & 0x30000) >> 14; 1390| 0| index16[k++] = v; 1391| 0| v = index[j++]; 1392| 0| upperBits |= (v & 0x30000) >> 16; 1393| 0| index16[k++] = v; 1394| 0| index16[k - 9] = upperBits; 1395| 0| } while (j < jLimit); ------------------ | Branch (1395:22): [True: 0, False: 0] ------------------ 1396| 0| int32_t n = longI3Blocks.findBlock(index16, index16, indexLength); 1397| 0| if (n >= 0) { ------------------ | Branch (1397:17): [True: 0, False: 0] ------------------ 1398| 0| i3 = n | 0x8000; 1399| 0| } else { 1400| 0| if (indexLength == index3Start) { ------------------ | Branch (1400:21): [True: 0, False: 0] ------------------ 1401| | // No overlap at the boundary between the index-1 and index-3 tables. 1402| 0| n = 0; 1403| 0| } else { 1404| 0| n = getOverlap(index16, indexLength, 1405| 0| index16, indexLength, INDEX_3_18BIT_BLOCK_LENGTH); 1406| 0| } 1407| 0| i3 = (indexLength - n) | 0x8000; 1408| 0| int32_t prevIndexLength = indexLength; 1409| 0| if (n > 0) { ------------------ | Branch (1409:21): [True: 0, False: 0] ------------------ 1410| 0| int32_t start = indexLength; 1411| 0| while (n < INDEX_3_18BIT_BLOCK_LENGTH) { ------------------ | Branch (1411:28): [True: 0, False: 0] ------------------ 1412| 0| index16[indexLength++] = index16[start + n++]; 1413| 0| } 1414| 0| } else { 1415| 0| indexLength += INDEX_3_18BIT_BLOCK_LENGTH; 1416| 0| } 1417| 0| mixedBlocks.extend(index16, index3Start, prevIndexLength, indexLength); 1418| 0| if (hasLongI3Blocks) { ------------------ | Branch (1418:21): [True: 0, False: 0] ------------------ 1419| 0| longI3Blocks.extend(index16, index3Start, prevIndexLength, indexLength); 1420| 0| } 1421| 0| } 1422| 0| } 1423| 340| if (index3NullOffset < 0 && i3FirstNull >= 0) { ------------------ | Branch (1423:13): [True: 11, False: 329] | Branch (1423:37): [True: 1, False: 10] ------------------ 1424| 1| index3NullOffset = i3; 1425| 1| } 1426| | // Set the index-2 table entry. 1427| 340| index2[i2Length++] = i3; 1428| 340| } 1429| 1| U_ASSERT(i2Length == index2Capacity); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1430| 1| U_ASSERT(indexLength <= index3Start + index3Capacity); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1431| | 1432| 1| if (index3NullOffset < 0) { ------------------ | Branch (1432:9): [True: 0, False: 1] ------------------ 1433| 0| index3NullOffset = UCPTRIE_NO_INDEX3_NULL_OFFSET; 1434| 0| } 1435| 1| if (indexLength >= (UCPTRIE_NO_INDEX3_NULL_OFFSET + UCPTRIE_INDEX_3_BLOCK_LENGTH)) { ------------------ | Branch (1435:9): [True: 0, False: 1] ------------------ 1436| | // The index-3 offsets exceed 15 bits, or 1437| | // the last one cannot be distinguished from the no-null-block value. 1438| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 1439| 0| return 0; 1440| 0| } 1441| | 1442| | // Compact the index-2 table and write the index-1 table. 1443| 1| static_assert(UCPTRIE_INDEX_2_BLOCK_LENGTH == UCPTRIE_INDEX_3_BLOCK_LENGTH, 1444| 1| "must re-init mixedBlocks"); 1445| 1| int32_t blockLength = UCPTRIE_INDEX_2_BLOCK_LENGTH; 1446| 1| int32_t i1 = fastIndexLength; 1447| 12| for (int32_t i = 0; i < i2Length; i += blockLength) { ------------------ | Branch (1447:25): [True: 11, False: 1] ------------------ 1448| 11| int32_t n; 1449| 11| if ((i2Length - i) >= blockLength) { ------------------ | Branch (1449:13): [True: 10, False: 1] ------------------ 1450| | // normal block 1451| 10| U_ASSERT(blockLength == UCPTRIE_INDEX_2_BLOCK_LENGTH); ------------------ | | 35| 10|# define U_ASSERT(exp) (void)0 ------------------ 1452| 10| n = mixedBlocks.findBlock(index16, index2, i); 1453| 10| } else { 1454| | // highStart is inside the last index-2 block. Shorten it. 1455| 1| blockLength = i2Length - i; 1456| 1| n = findSameBlock(index16, index3Start, indexLength, 1457| 1| index2, i, blockLength); 1458| 1| } 1459| 11| int32_t i2; 1460| 11| if (n >= 0) { ------------------ | Branch (1460:13): [True: 0, False: 11] ------------------ 1461| 0| i2 = n; 1462| 11| } else { 1463| 11| if (indexLength == index3Start) { ------------------ | Branch (1463:17): [True: 0, False: 11] ------------------ 1464| | // No overlap at the boundary between the index-1 and index-3/2 tables. 1465| 0| n = 0; 1466| 11| } else { 1467| 11| n = getOverlap(index16, indexLength, index2, i, blockLength); 1468| 11| } 1469| 11| i2 = indexLength - n; 1470| 11| int32_t prevIndexLength = indexLength; 1471| 316| while (n < blockLength) { ------------------ | Branch (1471:20): [True: 305, False: 11] ------------------ 1472| 305| index16[indexLength++] = index2[i + n++]; 1473| 305| } 1474| 11| mixedBlocks.extend(index16, index3Start, prevIndexLength, indexLength); 1475| 11| } 1476| | // Set the index-1 table entry. 1477| 11| index16[i1++] = i2; 1478| 11| } 1479| 1| U_ASSERT(i1 == index3Start); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1480| 1| U_ASSERT(indexLength <= index16Capacity); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1481| | 1482| |#ifdef UCPTRIE_DEBUG 1483| | /* we saved some space */ 1484| | printf("compacting UCPTrie: count of 16-bit index words %lu->%lu\n", 1485| | (long)iLimit, (long)indexLength); 1486| |#endif 1487| | 1488| 1| return indexLength; 1489| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks6extendItEEvPKT_iii: 809| 177| void extend(const UInt *data, int32_t minStart, int32_t prevDataLength, int32_t newDataLength) { 810| 177| int32_t start = prevDataLength - blockLength; 811| 177| if (start >= minStart) { ------------------ | Branch (811:13): [True: 175, False: 2] ------------------ 812| 175| ++start; // Skip the last block that we added last time. 813| 175| } else { 814| 2| start = minStart; // Begin with the first full block. 815| 2| } 816| 4.97k| for (int32_t end = newDataLength - blockLength; start <= end; ++start) { ------------------ | Branch (816:57): [True: 4.80k, False: 177] ------------------ 817| 4.80k| uint32_t hashCode = makeHashCode(data, start); 818| 4.80k| addEntry(data, start, hashCode, start); 819| 4.80k| } 820| 177| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks12makeHashCodeItEEjPKT_i: 845| 4.81k| uint32_t makeHashCode(const UInt *blockData, int32_t blockStart) const { 846| 4.81k| int32_t blockLimit = blockStart + blockLength; 847| 4.81k| uint32_t hashCode = blockData[blockStart++]; 848| 149k| do { 849| 149k| hashCode = 37 * hashCode + blockData[blockStart++]; 850| 149k| } while (blockStart < blockLimit); ------------------ | Branch (850:18): [True: 144k, False: 4.81k] ------------------ 851| 4.81k| return hashCode; 852| 4.81k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks8addEntryItEEvPKT_iji: 863| 4.80k| void addEntry(const UInt *data, int32_t blockStart, uint32_t hashCode, int32_t dataIndex) { 864| 4.80k| U_ASSERT(0 <= dataIndex && dataIndex < (int32_t)mask); ------------------ | | 35| 4.80k|# define U_ASSERT(exp) (void)0 ------------------ 865| 4.80k| int32_t entryIndex = findEntry(data, data, blockStart, hashCode); 866| 4.80k| if (entryIndex < 0) { ------------------ | Branch (866:13): [True: 4.80k, False: 0] ------------------ 867| 4.80k| table[~entryIndex] = (hashCode << shift) | (dataIndex + 1); 868| 4.80k| } 869| 4.80k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryIttEEiPKT_PKT0_ij: 873| 4.81k| uint32_t hashCode) const { 874| 4.81k| uint32_t shiftedHashCode = hashCode << shift; 875| 4.81k| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 876| 5.07k| for (int32_t entryIndex = initialEntryIndex;;) { 877| 5.07k| uint32_t entry = table[entryIndex]; 878| 5.07k| if (entry == 0) { ------------------ | Branch (878:17): [True: 4.81k, False: 266] ------------------ 879| 4.81k| return ~entryIndex; 880| 4.81k| } 881| 266| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (881:17): [True: 0, False: 266] ------------------ 882| 0| int32_t dataIndex = (entry & mask) - 1; 883| 0| if (equalBlocks(data + dataIndex, blockData + blockStart, blockLength)) { ------------------ | Branch (883:21): [True: 0, False: 0] ------------------ 884| 0| return entryIndex; 885| 0| } 886| 0| } 887| 266| entryIndex = nextIndex(initialEntryIndex, entryIndex); 888| 266| } 889| 4.81k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111equalBlocksIttEEbPKT_PKT0_i: 575| 5.05k|bool equalBlocks(const UIntA *s, const UIntB *t, int32_t length) { 576| 5.68k| while (length > 0 && *s == *t) { ------------------ | Branch (576:12): [True: 5.68k, False: 4] | Branch (576:26): [True: 625, False: 5.05k] ------------------ 577| 625| ++s; 578| 625| ++t; 579| 625| --length; 580| 625| } 581| 5.05k| return length == 0; 582| 5.05k|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findBlockItjEEiPKT_PKT0_i: 823| 329| int32_t findBlock(const UIntA *data, const UIntB *blockData, int32_t blockStart) const { 824| 329| uint32_t hashCode = makeHashCode(blockData, blockStart); 825| 329| int32_t entryIndex = findEntry(data, blockData, blockStart, hashCode); 826| 329| if (entryIndex >= 0) { ------------------ | Branch (826:13): [True: 0, False: 329] ------------------ 827| 0| return (table[entryIndex] & mask) - 1; 828| 329| } else { 829| 329| return -1; 830| 329| } 831| 329| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryItjEEiPKT_PKT0_ij: 873| 329| uint32_t hashCode) const { 874| 329| uint32_t shiftedHashCode = hashCode << shift; 875| 329| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 876| 337| for (int32_t entryIndex = initialEntryIndex;;) { 877| 337| uint32_t entry = table[entryIndex]; 878| 337| if (entry == 0) { ------------------ | Branch (878:17): [True: 329, False: 8] ------------------ 879| 329| return ~entryIndex; 880| 329| } 881| 8| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (881:17): [True: 0, False: 8] ------------------ 882| 0| int32_t dataIndex = (entry & mask) - 1; 883| 0| if (equalBlocks(data + dataIndex, blockData + blockStart, blockLength)) { ------------------ | Branch (883:21): [True: 0, False: 0] ------------------ 884| 0| return entryIndex; 885| 0| } 886| 0| } 887| 8| entryIndex = nextIndex(initialEntryIndex, entryIndex); 888| 8| } 889| 329| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111equalBlocksItjEEbPKT_PKT0_i: 575| 4.41k|bool equalBlocks(const UIntA *s, const UIntB *t, int32_t length) { 576| 17.9k| while (length > 0 && *s == *t) { ------------------ | Branch (576:12): [True: 17.8k, False: 111] | Branch (576:26): [True: 13.5k, False: 4.29k] ------------------ 577| 13.5k| ++s; 578| 13.5k| ++t; 579| 13.5k| --length; 580| 13.5k| } 581| 4.41k| return length == 0; 582| 4.41k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110getOverlapItjEEiPKT_iPKT0_ii: 633| 164| const UIntB *q, int32_t qStart, int32_t blockLength) { 634| 164| int32_t overlap = blockLength - 1; 635| 164| U_ASSERT(overlap <= length); ------------------ | | 35| 164|# define U_ASSERT(exp) (void)0 ------------------ 636| 164| q += qStart; 637| 4.46k| while (overlap > 0 && !equalBlocks(p + (length - overlap), q, overlap)) { ------------------ | Branch (637:12): [True: 4.41k, False: 53] | Branch (637:27): [True: 4.29k, False: 111] ------------------ 638| 4.29k| --overlap; 639| 4.29k| } 640| 164| return overlap; 641| 164|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findBlockIttEEiPKT_PKT0_i: 823| 10| int32_t findBlock(const UIntA *data, const UIntB *blockData, int32_t blockStart) const { 824| 10| uint32_t hashCode = makeHashCode(blockData, blockStart); 825| 10| int32_t entryIndex = findEntry(data, blockData, blockStart, hashCode); 826| 10| if (entryIndex >= 0) { ------------------ | Branch (826:13): [True: 0, False: 10] ------------------ 827| 0| return (table[entryIndex] & mask) - 1; 828| 10| } else { 829| 10| return -1; 830| 10| } 831| 10| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110getOverlapIttEEiPKT_iPKT0_ii: 633| 11| const UIntB *q, int32_t qStart, int32_t blockLength) { 634| 11| int32_t overlap = blockLength - 1; 635| 11| U_ASSERT(overlap <= length); ------------------ | | 35| 11|# define U_ASSERT(exp) (void)0 ------------------ 636| 11| q += qStart; 637| 305| while (overlap > 0 && !equalBlocks(p + (length - overlap), q, overlap)) { ------------------ | Branch (637:12): [True: 298, False: 7] | Branch (637:27): [True: 294, False: 4] ------------------ 638| 294| --overlap; 639| 294| } 640| 11| return overlap; 641| 11|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_113findSameBlockEPKtiiS2_ii: 592| 1| const uint16_t *q, int32_t qStart, int32_t blockLength) { 593| | // Ensure that we do not even partially get past length. 594| 1| length -= blockLength; 595| | 596| 1| q += qStart; 597| 4.76k| while (pStart <= length) { ------------------ | Branch (597:12): [True: 4.76k, False: 1] ------------------ 598| 4.76k| if (equalBlocks(p + pStart, q, blockLength)) { ------------------ | Branch (598:13): [True: 0, False: 4.76k] ------------------ 599| 0| return pStart; 600| 0| } 601| 4.76k| ++pStart; 602| 4.76k| } 603| 1| return -1; 604| 1|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocksD2Ev: 767| 2| ~MixedBlocks() { 768| 2| uprv_free(table); ------------------ | | 1503| 2|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 769| 2| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie5clearEv: 261| 1|void MutableCodePointTrie::clear() { 262| 1| index3NullOffset = dataNullOffset = -1; 263| 1| dataLength = 0; 264| 1| highValue = initialValue = origInitialValue; 265| 1| highStart = 0; 266| 1| uprv_free(index16); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 267| 1| index16 = nullptr; 268| 1|} _ZN6icu_786UMutex8getMutexEv: 80| 4|std::mutex *UMutex::getMutex() { 81| 4| std::mutex *retPtr = fMutex.load(std::memory_order_acquire); 82| 4| if (retPtr == nullptr) { ------------------ | Branch (82:9): [True: 4, False: 0] ------------------ 83| 4| std::call_once(*pInitFlag, umtx_init); 84| 4| std::lock_guard guard(*initMutex); 85| 4| retPtr = fMutex.load(std::memory_order_acquire); 86| 4| if (retPtr == nullptr) { ------------------ | Branch (86:13): [True: 4, False: 0] ------------------ 87| 4| fMutex = new(fStorage) std::mutex(); 88| 4| retPtr = fMutex; 89| 4| fListLink = gListHead; 90| 4| gListHead = this; 91| 4| } 92| 4| } 93| 4| U_ASSERT(retPtr != nullptr); ------------------ | | 35| 4|# define U_ASSERT(exp) (void)0 ------------------ 94| 4| return retPtr; 95| 4|} umtx_lock_78: 112| 196k|umtx_lock(UMutex *mutex) { 113| 196k| if (mutex == nullptr) { ------------------ | Branch (113:9): [True: 1.99k, False: 194k] ------------------ 114| 1.99k| mutex = &globalMutex; 115| 1.99k| } 116| 196k| mutex->lock(); 117| 196k|} umtx_unlock_78: 122| 196k|{ 123| 196k| if (mutex == nullptr) { ------------------ | Branch (123:9): [True: 1.99k, False: 194k] ------------------ 124| 1.99k| mutex = &globalMutex; 125| 1.99k| } 126| 196k| mutex->unlock(); 127| 196k|} _ZN6icu_7820umtx_initImplPreInitERNS_9UInitOnceE: 145| 16|umtx_initImplPreInit(UInitOnce &uio) { 146| 16| std::call_once(*pInitFlag, umtx_init); 147| 16| std::unique_lock lock(*initMutex); 148| 16| if (umtx_loadAcquire(uio.fState) == 0) { ------------------ | Branch (148:9): [True: 16, False: 0] ------------------ 149| 16| umtx_storeRelease(uio.fState, 1); 150| 16| return true; // Caller will next call the init function. 151| 16| } else { 152| 0| while (umtx_loadAcquire(uio.fState) == 1) { ------------------ | Branch (152:16): [True: 0, False: 0] ------------------ 153| | // Another thread is currently running the initialization. 154| | // Wait until it completes. 155| 0| initCondition->wait(lock); 156| 0| } 157| 0| U_ASSERT(uio.fState == 2); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 158| 0| return false; 159| 0| } 160| 16|} _ZN6icu_7821umtx_initImplPostInitERNS_9UInitOnceE: 170| 16|umtx_initImplPostInit(UInitOnce &uio) { 171| 16| { 172| 16| std::unique_lock lock(*initMutex); 173| 16| umtx_storeRelease(uio.fState, 2); 174| 16| } 175| 16| initCondition->notify_all(); 176| 16|} umutex.cpp:_ZN6icu_78L9umtx_initEv: 72| 1|static void U_CALLCONV umtx_init() { 73| 1| initMutex = STATIC_NEW(std::mutex); ------------------ | | 144| 1|#define STATIC_NEW(type) [] () { \ | | 145| 1| alignas(type) static char storage[sizeof(type)]; \ | | 146| 1| return new(storage) type();} () ------------------ 74| 1| initCondition = STATIC_NEW(std::condition_variable); ------------------ | | 144| 1|#define STATIC_NEW(type) [] () { \ | | 145| 1| alignas(type) static char storage[sizeof(type)]; \ | | 146| 1| return new(storage) type();} () ------------------ 75| 1| ucln_common_registerCleanup(UCLN_COMMON_MUTEX, umtx_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 76| 1|} _ZN6icu_7816umtx_loadAcquireERNSt3__16atomicIiEE: 75| 284M|inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 76| 284M| return var.load(std::memory_order_acquire); 77| 284M|} _ZN6icu_7813umtx_initOnceERNS_9UInitOnceEPFvR10UErrorCodeES3_: 135| 23.7M|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(UErrorCode &), UErrorCode &errCode) { 136| 23.7M| if (U_FAILURE(errCode)) { ------------------ | Branch (136:9): [True: 1, False: 23.7M] ------------------ 137| 1| return; 138| 1| } 139| 23.7M| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (139:9): [True: 7, False: 23.7M] | Branch (139:46): [True: 7, False: 0] ------------------ 140| | // We run the initialization. 141| 7| (*fp)(errCode); 142| 7| uio.fErrCode = errCode; 143| 7| umtx_initImplPostInit(uio); 144| 23.7M| } else { 145| | // Someone else already ran the initialization. 146| 23.7M| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (146:13): [True: 0, False: 23.7M] ------------------ 147| 0| errCode = uio.fErrCode; 148| 0| } 149| 23.7M| } 150| 23.7M|} _ZN6icu_789UInitOnce5resetEv: 101| 15.4k| void reset() {fState = 0;} _ZN6icu_7813umtx_initOnceERNS_9UInitOnceEPFvvE: 123| 711|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)()) { 124| 711| if (umtx_loadAcquire(uio.fState) == 2) { ------------------ | Branch (124:9): [True: 710, False: 1] ------------------ 125| 710| return; 126| 710| } 127| 1| if (umtx_initImplPreInit(uio)) { ------------------ | Branch (127:9): [True: 1, False: 0] ------------------ 128| 1| (*fp)(); 129| 1| umtx_initImplPostInit(uio); 130| 1| } 131| 1|} _ZN6icu_786UMutex4lockEv: 229| 196k| void lock() { 230| 196k| std::mutex *m = fMutex.load(std::memory_order_acquire); 231| 196k| if (m == nullptr) { m = getMutex(); } ------------------ | Branch (231:13): [True: 4, False: 196k] ------------------ 232| 196k| m->lock(); 233| 196k| } _ZN6icu_786UMutex6unlockEv: 234| 196k| void unlock() { fMutex.load(std::memory_order_relaxed)->unlock(); } _ZN6icu_7817umtx_storeReleaseERNSt3__16atomicIiEEi: 79| 33|inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 80| 33| var.store(val, std::memory_order_release); 81| 33|} _ZN6icu_7815umtx_atomic_incEPNSt3__16atomicIiEE: 83| 1.56M|inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) { 84| 1.56M| return var->fetch_add(1) + 1; 85| 1.56M|} _ZN6icu_7815umtx_atomic_decEPNSt3__16atomicIiEE: 87| 21.9M|inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) { 88| 21.9M| return var->fetch_sub(1) - 1; 89| 21.9M|} _ZN6icu_7813umtx_initOnceIPKcEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES5_S7_: 166| 7.71k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 7.71k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 7.71k] ------------------ 168| 0| return; 169| 0| } 170| 7.71k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 1, False: 7.71k] | Branch (170:46): [True: 1, False: 0] ------------------ 171| | // We run the initialization. 172| 1| (*fp)(context, errCode); 173| 1| uio.fErrCode = errCode; 174| 1| umtx_initImplPostInit(uio); 175| 7.71k| } else { 176| | // Someone else already ran the initialization. 177| 7.71k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 7.71k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 7.71k| } 181| 7.71k|} _ZN6icu_7813umtx_initOnceIPNS_15Normalizer2ImplEEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES5_S7_: 166| 6.77M|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 6.77M| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 6.77M] ------------------ 168| 0| return; 169| 0| } 170| 6.77M| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 1, False: 6.77M] | Branch (170:46): [True: 1, False: 0] ------------------ 171| | // We run the initialization. 172| 1| (*fp)(context, errCode); 173| 1| uio.fErrCode = errCode; 174| 1| umtx_initImplPostInit(uio); 175| 6.77M| } else { 176| | // Someone else already ran the initialization. 177| 6.77M| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 6.77M] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 6.77M| } 181| 6.77M|} _ZN6icu_7813umtx_initOnceI15UPropertySourceEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES4_S6_: 166| 6.01k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 6.01k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 6.01k] ------------------ 168| 0| return; 169| 0| } 170| 6.01k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 4, False: 6.00k] | Branch (170:46): [True: 4, False: 0] ------------------ 171| | // We run the initialization. 172| 4| (*fp)(context, errCode); 173| 4| uio.fErrCode = errCode; 174| 4| umtx_initImplPostInit(uio); 175| 6.00k| } else { 176| | // Someone else already ran the initialization. 177| 6.00k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 6.00k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 6.00k| } 181| 6.01k|} _ZN6icu_7813umtx_initOnceI9UPropertyEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES4_S6_: 166| 4.23k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 4.23k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 4.23k] ------------------ 168| 0| return; 169| 0| } 170| 4.23k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 2, False: 4.23k] | Branch (170:46): [True: 2, False: 0] ------------------ 171| | // We run the initialization. 172| 2| (*fp)(context, errCode); 173| 2| uio.fErrCode = errCode; 174| 2| umtx_initImplPostInit(uio); 175| 4.23k| } else { 176| | // Someone else already ran the initialization. 177| 4.23k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 4.23k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 4.23k| } 181| 4.23k|} u_charFromName_78: 1521| 1.36k| UErrorCode *pErrorCode) { 1522| 1.36k| char upper[120] = {0}; 1523| 1.36k| char lower[120] = {0}; 1524| 1.36k| FindName findName; 1525| 1.36k| AlgorithmicRange *algRange; 1526| 1.36k| uint32_t *p; 1527| 1.36k| uint32_t i; 1528| 1.36k| UChar32 cp = 0; 1529| 1.36k| char c0; 1530| 1.36k| static constexpr UChar32 error = 0xffff; /* Undefined, but use this for backwards compatibility. */ 1531| | 1532| 1.36k| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1532:8): [True: 0, False: 1.36k] | Branch (1532:31): [True: 0, False: 1.36k] ------------------ 1533| 0| return error; 1534| 0| } 1535| | 1536| 1.36k| if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT || name==nullptr || *name==0) { ------------------ | Branch (1536:8): [True: 0, False: 1.36k] | Branch (1536:48): [True: 0, False: 1.36k] | Branch (1536:65): [True: 4, False: 1.36k] ------------------ 1537| 4| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1538| 4| return error; 1539| 4| } 1540| | 1541| 1.36k| if(!isDataLoaded(pErrorCode)) { ------------------ | Branch (1541:8): [True: 0, False: 1.36k] ------------------ 1542| 0| return error; 1543| 0| } 1544| | 1545| | /* construct the uppercase and lowercase of the name first */ 1546| 5.89k| for(i=0; i') { ------------------ | Branch (1564:13): [True: 1, False: 0] | Branch (1564:51): [True: 0, False: 1] ------------------ 1565| | // Parse a string like "" where HHHH is a hex code point. 1566| 0| uint32_t limit = i; 1567| 0| while (i >= 3 && lower[--i] != '-') {} ------------------ | Branch (1567:20): [True: 0, False: 0] | Branch (1567:30): [True: 0, False: 0] ------------------ 1568| | 1569| | // There should be 1 to 8 hex digits. 1570| 0| int32_t hexLength = limit - (i + 1); 1571| 0| if (i >= 2 && lower[i] == '-' && 1 <= hexLength && hexLength <= 8) { ------------------ | Branch (1571:17): [True: 0, False: 0] | Branch (1571:27): [True: 0, False: 0] | Branch (1571:46): [True: 0, False: 0] | Branch (1571:64): [True: 0, False: 0] ------------------ 1572| 0| uint32_t cIdx; 1573| | 1574| 0| lower[i] = 0; 1575| | 1576| 0| for (++i; i < limit; ++i) { ------------------ | Branch (1576:27): [True: 0, False: 0] ------------------ 1577| 0| if (lower[i] >= '0' && lower[i] <= '9') { ------------------ | Branch (1577:25): [True: 0, False: 0] | Branch (1577:44): [True: 0, False: 0] ------------------ 1578| 0| cp = (cp << 4) + lower[i] - '0'; 1579| 0| } else if (lower[i] >= 'a' && lower[i] <= 'f') { ------------------ | Branch (1579:32): [True: 0, False: 0] | Branch (1579:51): [True: 0, False: 0] ------------------ 1580| 0| cp = (cp << 4) + lower[i] - 'a' + 10; 1581| 0| } else { 1582| 0| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1583| 0| return error; 1584| 0| } 1585| | // Prevent signed-integer overflow and out-of-range code points. 1586| 0| if (cp > UCHAR_MAX_VALUE) { ------------------ | | 168| 0|#define UCHAR_MAX_VALUE 0x10ffff ------------------ | Branch (1586:25): [True: 0, False: 0] ------------------ 1587| 0| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1588| 0| return error; 1589| 0| } 1590| 0| } 1591| | 1592| | /* Now validate the category name. 1593| | We could use a binary search, or a trie, if 1594| | we really wanted to. */ 1595| 0| uint8_t cat = getCharCat(cp); 1596| 0| for (lower[i] = 0, cIdx = 0; cIdx < UPRV_LENGTHOF(charCatNames); ++cIdx) { ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1596:46): [True: 0, False: 0] ------------------ 1597| | 1598| 0| if (!uprv_strcmp(lower + 1, charCatNames[cIdx])) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1598:25): [True: 0, False: 0] ------------------ 1599| 0| if (cat == cIdx) { ------------------ | Branch (1599:29): [True: 0, False: 0] ------------------ 1600| 0| return cp; 1601| 0| } 1602| 0| break; 1603| 0| } 1604| 0| } 1605| 0| } 1606| 0| } 1607| | 1608| 1| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1609| 1| return error; 1610| 1| } 1611| | 1612| | /* try algorithmic names now */ 1613| 1.36k| p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset); 1614| 1.36k| i=*p; 1615| 1.36k| algRange=(AlgorithmicRange *)(p+1); 1616| 19.0k| while(i>0) { ------------------ | Branch (1616:11): [True: 17.7k, False: 1.36k] ------------------ 1617| 17.7k| if((cp=findAlgName(algRange, nameChoice, upper))!=0xffff) { ------------------ | Branch (1617:12): [True: 0, False: 17.7k] ------------------ 1618| 0| return cp; 1619| 0| } 1620| 17.7k| algRange=(AlgorithmicRange *)((uint8_t *)algRange+algRange->size); 1621| 17.7k| --i; 1622| 17.7k| } 1623| | 1624| | /* normal character name */ 1625| 1.36k| findName.otherName=upper; 1626| 1.36k| findName.code=error; 1627| 1.36k| enumNames(uCharNames, 0, UCHAR_MAX_VALUE + 1, DO_FIND_NAME, &findName, nameChoice); ------------------ | | 168| 1.36k|#define UCHAR_MAX_VALUE 0x10ffff ------------------ enumNames(uCharNames, 0, UCHAR_MAX_VALUE + 1, DO_FIND_NAME, &findName, nameChoice); ------------------ | | 104| 1.36k|#define DO_FIND_NAME nullptr ------------------ 1628| 1.36k| if (findName.code == error) { ------------------ | Branch (1628:9): [True: 72, False: 1.29k] ------------------ 1629| 72| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1630| 72| } 1631| 1.36k| return findName.code; 1632| 1.36k|} unames.cpp:_ZN6icu_78L12isDataLoadedEP10UErrorCode: 210| 1.36k|isDataLoaded(UErrorCode *pErrorCode) { 211| 1.36k| umtx_initOnce(gCharNamesInitOnce, &loadCharNames, *pErrorCode); 212| 1.36k| return U_SUCCESS(*pErrorCode); 213| 1.36k|} unames.cpp:_ZN6icu_78L13loadCharNamesER10UErrorCode: 195| 1|loadCharNames(UErrorCode &status) { 196| 1| U_ASSERT(uCharNamesData == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 197| 1| U_ASSERT(uCharNames == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 198| | 199| 1| uCharNamesData = udata_openChoice(nullptr, DATA_TYPE, DATA_NAME, isAcceptable, nullptr, &status); ------------------ | | 894| 1|#define udata_openChoice U_ICU_ENTRY_POINT_RENAME(udata_openChoice) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 1| if(U_FAILURE(status)) { ------------------ | Branch (200:8): [True: 0, False: 1] ------------------ 201| 0| uCharNamesData = nullptr; 202| 1| } else { 203| 1| uCharNames = (UCharNames *)udata_getMemory(uCharNamesData); ------------------ | | 891| 1|#define udata_getMemory U_ICU_ENTRY_POINT_RENAME(udata_getMemory) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 204| 1| } 205| 1| ucln_common_registerCleanup(UCLN_COMMON_UNAMES, unames_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 206| 1|} unames.cpp:_ZN6icu_78L12isAcceptableEPvPKcS2_PK9UDataInfo: 182| 1| const UDataInfo *pInfo) { 183| 1| return 184| 1| pInfo->size>=20 && ------------------ | Branch (184:9): [True: 1, False: 0] ------------------ 185| 1| pInfo->isBigEndian==U_IS_BIG_ENDIAN && ------------------ | | 353| 2|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (185:9): [True: 1, False: 0] ------------------ 186| 1| pInfo->charsetFamily==U_CHARSET_FAMILY && ------------------ | | 588| 1|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 2|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (186:9): [True: 1, False: 0] ------------------ 187| 1| pInfo->dataFormat[0]==0x75 && /* dataFormat="unam" */ ------------------ | Branch (187:9): [True: 1, False: 0] ------------------ 188| 1| pInfo->dataFormat[1]==0x6e && ------------------ | Branch (188:9): [True: 1, False: 0] ------------------ 189| 1| pInfo->dataFormat[2]==0x61 && ------------------ | Branch (189:9): [True: 1, False: 0] ------------------ 190| 1| pInfo->dataFormat[3]==0x6d && ------------------ | Branch (190:9): [True: 1, False: 0] ------------------ 191| 1| pInfo->formatVersion[0]==1; ------------------ | Branch (191:9): [True: 1, False: 0] ------------------ 192| 1|} unames.cpp:_ZN6icu_78L8getGroupEPNS_10UCharNamesEj: 483| 1.36k|getGroup(UCharNames *names, uint32_t code) { 484| 1.36k| const uint16_t *groups=GET_GROUPS(names); ------------------ | | 97| 1.36k|#define GET_GROUPS(names) (const uint16_t *)((const char *)names+names->groupsOffset) ------------------ 485| 1.36k| uint16_t groupMSB = static_cast(code >> GROUP_SHIFT), ------------------ | | 41| 1.36k|#define GROUP_SHIFT 5 ------------------ 486| 1.36k| start=0, 487| 1.36k| limit=*groups++, 488| 1.36k| number; 489| | 490| | /* binary search for the group of names that contains the one for code */ 491| 14.9k| while(start((start + limit) / 2); 493| 13.6k| if(groupMSBtype) { 1086| 16.3k| case 0: { ------------------ | Branch (1086:5): [True: 16.3k, False: 1.36k] ------------------ 1087| | /* name = prefix hex-digits */ 1088| 16.3k| const char* s = reinterpret_cast(range + 1); 1089| 16.3k| char c; 1090| | 1091| 16.3k| uint16_t i, count; 1092| | 1093| | /* compare prefix */ 1094| 16.3k| while((c=*s++)!=0) { ------------------ | Branch (1094:15): [True: 16.3k, False: 0] ------------------ 1095| 16.3k| if (c != *otherName++) { ------------------ | Branch (1095:17): [True: 16.3k, False: 16] ------------------ 1096| 16.3k| return 0xffff; 1097| 16.3k| } 1098| 16.3k| } 1099| | 1100| | /* read hexadecimal code point value */ 1101| 0| count=range->variant; 1102| 0| code=0; 1103| 0| for(i=0; istart <= static_cast(code) && static_cast(code) <= range->end) { ------------------ | Branch (1115:13): [True: 0, False: 0] | Branch (1115:32): [True: 0, False: 0] | Branch (1115:79): [True: 0, False: 0] ------------------ 1116| 0| return code; 1117| 0| } 1118| 0| break; 1119| 0| } 1120| 1.36k| case 1: { ------------------ | Branch (1120:5): [True: 1.36k, False: 16.3k] ------------------ 1121| 1.36k| char buffer[64]; 1122| 1.36k| uint16_t indexes[8]; 1123| 1.36k| const char *elementBases[8], *elements[8]; 1124| 1.36k| const uint16_t* factors = reinterpret_cast(range + 1); 1125| 1.36k| uint16_t count=range->variant; 1126| 1.36k| const char *s = reinterpret_cast(factors + count), *t; 1127| 1.36k| UChar32 start, limit; 1128| 1.36k| uint16_t i, idx; 1129| | 1130| 1.36k| char c; 1131| | 1132| | /* name = prefix factorized-elements */ 1133| | 1134| | /* compare prefix */ 1135| 1.36k| while((c=*s++)!=0) { ------------------ | Branch (1135:15): [True: 1.36k, False: 0] ------------------ 1136| 1.36k| if (c != *otherName++) { ------------------ | Branch (1136:17): [True: 1.36k, False: 3] ------------------ 1137| 1.36k| return 0xffff; 1138| 1.36k| } 1139| 1.36k| } 1140| | 1141| 0| start = static_cast(range->start); 1142| 0| limit = static_cast(range->end + 1); 1143| | 1144| | /* initialize the suffix elements for enumeration; indexes should all be set to 0 */ 1145| 0| writeFactorSuffix(factors, count, s, 0, 1146| 0| indexes, elementBases, elements, buffer, sizeof(buffer)); 1147| | 1148| | /* compare the first suffix */ 1149| 0| if(0==uprv_strcmp(otherName, buffer)) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1149:12): [True: 0, False: 0] ------------------ 1150| 0| return start; 1151| 0| } 1152| | 1153| | /* enumerate and compare the rest of the suffixes */ 1154| 0| while(++start(indexes[--i] + 1); 1159| 0| if(idx(start >> GROUP_SHIFT); ------------------ | | 41| 1.36k|#define GROUP_SHIFT 5 ------------------ 675| 1.36k| endGroupMSB = static_cast((limit - 1) >> GROUP_SHIFT); ------------------ | | 41| 1.36k|#define GROUP_SHIFT 5 ------------------ 676| | 677| | /* find the group that contains start, or the highest before it */ 678| 1.36k| group=getGroup(names, start); 679| | 680| 1.36k| if(startGroupMSB(group[GROUP_MSB]) << GROUP_SHIFT; ------------------ | | 41| 1.36k|#define GROUP_SHIFT 5 ------------------ 683| 1.36k| if(extLimit>limit) { ------------------ | Branch (683:12): [True: 0, False: 1.36k] ------------------ 684| 0| extLimit=limit; 685| 0| } 686| 1.36k| if(!enumExtNames(start, extLimit-1, fn, context)) { ------------------ | Branch (686:12): [True: 0, False: 1.36k] ------------------ 687| 0| return false; 688| 0| } 689| 1.36k| start=extLimit; 690| 1.36k| } 691| | 692| 1.36k| if(startGroupMSB==endGroupMSB) { ------------------ | Branch (692:8): [True: 0, False: 1.36k] ------------------ 693| 0| if(startGroupMSB==group[GROUP_MSB]) { ------------------ | Branch (693:12): [True: 0, False: 0] ------------------ 694| | /* if start and limit-1 are in the same group, then enumerate only in that one */ 695| 0| return enumGroupNames(names, group, start, limit-1, fn, context, nameChoice); 696| 0| } 697| 1.36k| } else { 698| 1.36k| const uint16_t *groups=GET_GROUPS(names); ------------------ | | 97| 1.36k|#define GET_GROUPS(names) (const uint16_t *)((const char *)names+names->groupsOffset) ------------------ 699| 1.36k| groupCount=*groups++; 700| 1.36k| groupLimit=groups+groupCount*GROUP_LENGTH; 701| | 702| 1.36k| if(startGroupMSB==group[GROUP_MSB]) { ------------------ | Branch (702:12): [True: 0, False: 1.36k] ------------------ 703| | /* enumerate characters in the partial start group */ 704| 0| if((start&GROUP_MASK)!=0) { ------------------ | | 43| 0|#define GROUP_MASK (LINES_PER_GROUP-1) | | ------------------ | | | | 42| 0|#define LINES_PER_GROUP (1L<(startGroupMSB) << GROUP_SHIFT) + LINES_PER_GROUP - 1, ------------------ | | 41| 0|#define GROUP_SHIFT 5 ------------------ start, (static_cast(startGroupMSB) << GROUP_SHIFT) + LINES_PER_GROUP - 1, ------------------ | | 42| 0|#define LINES_PER_GROUP (1L<group[GROUP_MSB]) { ------------------ | Branch (712:19): [True: 0, False: 1.36k] ------------------ 713| | /* make sure that we start enumerating with the first group after start */ 714| 0| const uint16_t *nextGroup=NEXT_GROUP(group); ------------------ | | 75| 0|#define NEXT_GROUP(group) ((group)+GROUP_LENGTH) ------------------ 715| 0| if (nextGroup < groupLimit && nextGroup[GROUP_MSB] > startGroupMSB && nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (715:17): [True: 0, False: 0] | Branch (715:43): [True: 0, False: 0] | Branch (715:83): [True: 0, False: 0] ------------------ 716| 0| UChar32 end = nextGroup[GROUP_MSB] << GROUP_SHIFT; ------------------ | | 41| 0|#define GROUP_SHIFT 5 ------------------ 717| 0| if (end > limit) { ------------------ | Branch (717:21): [True: 0, False: 0] ------------------ 718| 0| end = limit; 719| 0| } 720| 0| if (!enumExtNames(start, end - 1, fn, context)) { ------------------ | Branch (720:21): [True: 0, False: 0] ------------------ 721| 0| return false; 722| 0| } 723| 0| } 724| 0| group=nextGroup; 725| 0| } 726| | 727| | /* enumerate entire groups between the start- and end-groups */ 728| 1.74M| while(group(group[GROUP_MSB]) << GROUP_SHIFT; ------------------ | | 41| 1.74M|#define GROUP_SHIFT 5 ------------------ 731| 1.74M| if(!enumGroupNames(names, group, start, start+LINES_PER_GROUP-1, fn, context, nameChoice)) { ------------------ | | 42| 1.74M|#define LINES_PER_GROUP (1L< group[GROUP_MSB] + 1 && nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (735:17): [True: 1.73M, False: 72] | Branch (735:43): [True: 84.7k, False: 1.65M] | Branch (735:90): [True: 84.7k, False: 0] ------------------ 736| 84.7k| UChar32 end = nextGroup[GROUP_MSB] << GROUP_SHIFT; ------------------ | | 41| 84.7k|#define GROUP_SHIFT 5 ------------------ 737| 84.7k| if (end > limit) { ------------------ | Branch (737:21): [True: 0, False: 84.7k] ------------------ 738| 0| end = limit; 739| 0| } 740| 84.7k| if (!enumExtNames((group[GROUP_MSB] + 1) << GROUP_SHIFT, end - 1, fn, context)) { ------------------ | | 41| 84.7k|#define GROUP_SHIFT 5 ------------------ | Branch (740:21): [True: 0, False: 84.7k] ------------------ 741| 0| return false; 742| 0| } 743| 84.7k| } 744| 1.73M| group=nextGroup; 745| 1.73M| } 746| | 747| | /* enumerate within the end group (group[GROUP_MSB]==endGroupMSB) */ 748| 72| if(group start) { ------------------ | Branch (752:17): [True: 72, False: 0] ------------------ 753| 72| start = next; 754| 72| } 755| 72| } else { 756| 0| return true; 757| 0| } 758| 72| } 759| | 760| | /* we have not found a group, which means everything is made of 761| | extended names. */ 762| 72| if (nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (762:9): [True: 72, False: 0] ------------------ 763| 72| if (limit > UCHAR_MAX_VALUE + 1) { ------------------ | | 168| 72|#define UCHAR_MAX_VALUE 0x10ffff ------------------ | Branch (763:13): [True: 0, False: 72] ------------------ 764| 0| limit = UCHAR_MAX_VALUE + 1; ------------------ | | 168| 0|#define UCHAR_MAX_VALUE 0x10ffff ------------------ 765| 0| } 766| 72| return enumExtNames(start, limit - 1, fn, context); 767| 72| } 768| | 769| 0| return true; 770| 72|} unames.cpp:_ZN6icu_78L12enumExtNamesEiiPFaPvi15UCharNameChoicePKciES0_: 646| 86.1k|{ 647| 86.1k| if(fn!=DO_FIND_NAME) { ------------------ | | 104| 86.1k|#define DO_FIND_NAME nullptr ------------------ | Branch (647:8): [True: 0, False: 86.1k] ------------------ 648| 0| char buffer[200]; 649| 0| uint16_t length; 650| | 651| 0| while(start<=end) { ------------------ | Branch (651:15): [True: 0, False: 0] ------------------ 652| 0| buffer[length = getExtName(start, buffer, sizeof(buffer))] = 0; 653| | /* here, we assume that the buffer is large enough */ 654| 0| if(length>0) { ------------------ | Branch (654:16): [True: 0, False: 0] ------------------ 655| 0| if(!fn(context, start, U_EXTENDED_CHAR_NAME, buffer, length)) { ------------------ | Branch (655:20): [True: 0, False: 0] ------------------ 656| 0| return false; 657| 0| } 658| 0| } 659| 0| ++start; 660| 0| } 661| 0| } 662| | 663| 86.1k| return true; 664| 86.1k|} unames.cpp:_ZN6icu_78L14enumGroupNamesEPNS_10UCharNamesEPKtiiPFaPvi15UCharNameChoicePKciES4_S5_: 602| 1.74M| UCharNameChoice nameChoice) { 603| 1.74M| uint16_t offsets[LINES_PER_GROUP+2], lengths[LINES_PER_GROUP+2]; 604| 1.74M| const uint8_t* s = reinterpret_cast(names) + names->groupStringOffset + GET_GROUP_OFFSET(group); ------------------ | | 73| 1.74M|#define GET_GROUP_OFFSET(group) ((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW]) ------------------ 605| | 606| 1.74M| s=expandGroupLengths(s, offsets, lengths); 607| 1.74M| if(fn!=DO_FIND_NAME) { ------------------ | | 104| 1.74M|#define DO_FIND_NAME nullptr ------------------ | Branch (607:8): [True: 0, False: 1.74M] ------------------ 608| 0| char buffer[200]; 609| 0| uint16_t length; 610| | 611| 0| while(start<=end) { ------------------ | Branch (611:15): [True: 0, False: 0] ------------------ 612| 0| length=expandName(names, s+offsets[start&GROUP_MASK], lengths[start&GROUP_MASK], nameChoice, buffer, sizeof(buffer)); ------------------ | | 43| 0|#define GROUP_MASK (LINES_PER_GROUP-1) | | ------------------ | | | | 42| 0|#define LINES_PER_GROUP (1L<0) { ------------------ | Branch (617:16): [True: 0, False: 0] ------------------ 618| 0| if(!fn(context, start, nameChoice, buffer, length)) { ------------------ | Branch (618:20): [True: 0, False: 0] ------------------ 619| 0| return false; 620| 0| } 621| 0| } 622| 0| ++start; 623| 0| } 624| 1.74M| } else { 625| 1.74M| const char* otherName = static_cast(context)->otherName; 626| 57.3M| while(start<=end) { ------------------ | Branch (626:15): [True: 55.6M, False: 1.73M] ------------------ 627| 55.6M| if(compareName(names, s+offsets[start&GROUP_MASK], lengths[start&GROUP_MASK], nameChoice, otherName)) { ------------------ | | 43| 55.6M|#define GROUP_MASK (LINES_PER_GROUP-1) | | ------------------ | | | | 42| 55.6M|#define LINES_PER_GROUP (1L<(context)->code = start; 629| 1.29k| return false; 630| 1.29k| } 631| 55.6M| ++start; 632| 55.6M| } 633| 1.74M| } 634| 1.73M| return true; 635| 1.74M|} unames.cpp:_ZN6icu_78L11compareNameEPNS_10UCharNamesEPKht15UCharNameChoicePKc: 333| 55.6M| const char *otherName) { 334| 55.6M| uint16_t* tokens = reinterpret_cast(names) + 8; 335| 55.6M| uint16_t token, tokenCount=*tokens++; 336| 55.6M| uint8_t* tokenStrings = reinterpret_cast(names) + names->tokenStringOffset; 337| 55.6M| uint8_t c; 338| 55.6M| const char *origOtherName = otherName; 339| | 340| 55.6M| if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) { ------------------ | Branch (340:8): [True: 55.6M, False: 0] | Branch (340:43): [True: 0, False: 55.6M] ------------------ 341| | /* 342| | * skip the modern name if it is not requested _and_ 343| | * if the semicolon byte value is a character, not a token number 344| | */ 345| 0| if (static_cast(';') >= tokenCount || tokens[static_cast(';')] == static_cast(-1)) { ------------------ | Branch (345:13): [True: 0, False: 0] | Branch (345:56): [True: 0, False: 0] ------------------ 346| 0| int fieldIndex= nameChoice==U_ISO_COMMENT ? 2 : nameChoice; ------------------ | | 223| 0|#define U_ISO_COMMENT U_CHAR_NAME_CHOICE_COUNT ------------------ | Branch (346:29): [True: 0, False: 0] ------------------ 347| 0| do { 348| 0| while(nameLength>0) { ------------------ | Branch (348:23): [True: 0, False: 0] ------------------ 349| 0| --nameLength; 350| 0| if(*name++==';') { ------------------ | Branch (350:24): [True: 0, False: 0] ------------------ 351| 0| break; 352| 0| } 353| 0| } 354| 0| } while(--fieldIndex>0); ------------------ | Branch (354:21): [True: 0, False: 0] ------------------ 355| 0| } else { 356| | /* 357| | * the semicolon byte value is a token number, therefore 358| | * only modern names are stored in unames.dat and there is no 359| | * such requested alternate name here 360| | */ 361| 0| nameLength=0; 362| 0| } 363| 0| } 364| | 365| | /* compare each letter directly, and compare a token word per token */ 366| 55.6M| while(nameLength>0) { ------------------ | Branch (366:11): [True: 50.7M, False: 4.91M] ------------------ 367| 50.7M| --nameLength; 368| 50.7M| c=*name++; 369| | 370| 50.7M| if(c>=tokenCount) { ------------------ | Branch (370:12): [True: 0, False: 50.7M] ------------------ 371| 0| if(c!=';') { ------------------ | Branch (371:16): [True: 0, False: 0] ------------------ 372| | /* implicit letter */ 373| 0| if (static_cast(c) != *otherName++) { ------------------ | Branch (373:21): [True: 0, False: 0] ------------------ 374| 0| return false; 375| 0| } 376| 0| } else { 377| | /* finished */ 378| 0| break; 379| 0| } 380| 50.7M| } else { 381| 50.7M| token=tokens[c]; 382| 50.7M| if (token == static_cast(-2)) { ------------------ | Branch (382:17): [True: 9.66M, False: 41.1M] ------------------ 383| | /* this is a lead byte for a double-byte token */ 384| 9.66M| token=tokens[c<<8|*name++]; 385| 9.66M| --nameLength; 386| 9.66M| } 387| 50.7M| if (token == static_cast(-1)) { ------------------ | Branch (387:17): [True: 656k, False: 50.1M] ------------------ 388| 656k| if(c!=';') { ------------------ | Branch (388:20): [True: 656k, False: 0] ------------------ 389| | /* explicit letter */ 390| 656k| if (static_cast(c) != *otherName++) { ------------------ | Branch (390:25): [True: 617k, False: 38.7k] ------------------ 391| 617k| return false; 392| 617k| } 393| 656k| } else { 394| | /* stop, but skip the semicolon if we are seeking 395| | extended names and there was no 2.0 name but there 396| | is a 1.0 name. */ 397| 0| if(otherName == origOtherName && nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (397:24): [True: 0, False: 0] | Branch (397:54): [True: 0, False: 0] ------------------ 398| 0| if (static_cast(';') >= tokenCount || tokens[static_cast(';')] == static_cast(-1)) { ------------------ | Branch (398:29): [True: 0, False: 0] | Branch (398:72): [True: 0, False: 0] ------------------ 399| 0| continue; 400| 0| } 401| 0| } 402| | /* finished */ 403| 0| break; 404| 0| } 405| 50.1M| } else { 406| | /* write token word */ 407| 50.1M| uint8_t *tokenString=tokenStrings+token; 408| 50.6M| while((c=*tokenString++)!=0) { ------------------ | Branch (408:23): [True: 50.6M, False: 26] ------------------ 409| 50.6M| if (static_cast(c) != *otherName++) { ------------------ | Branch (409:25): [True: 50.1M, False: 542k] ------------------ 410| 50.1M| return false; 411| 50.1M| } 412| 50.6M| } 413| 50.1M| } 414| 50.7M| } 415| 50.7M| } 416| | 417| | /* complete match? */ 418| 4.91M| return *otherName == 0; 419| 55.6M|} unames.cpp:_ZN6icu_78L18expandGroupLengthsEPKhPtS2_: 516| 1.74M| uint16_t offsets[LINES_PER_GROUP+1], uint16_t lengths[LINES_PER_GROUP+1]) { 517| | /* read the lengths of the 32 strings in this group and get each string's offset */ 518| 1.74M| uint16_t i=0, offset=0, length=0; 519| 1.74M| uint8_t lengthByte; 520| | 521| | /* all 32 lengths must be read to get the offset of the first group string */ 522| 31.1M| while(i=12) { ------------------ | Branch (526:12): [True: 1.14M, False: 28.2M] ------------------ 527| | /* double-nibble length spread across two bytes */ 528| 1.14M| length = static_cast(((length & 0x3) << 4 | lengthByte >> 4) + 12); 529| 1.14M| lengthByte&=0xf; 530| 28.2M| } else if((lengthByte /* &0xf0 */)>=0xc0) { ------------------ | Branch (530:19): [True: 1.61M, False: 26.6M] ------------------ 531| | /* double-nibble length spread across this one byte */ 532| 1.61M| length = static_cast((lengthByte & 0x3f) + 12); 533| 26.6M| } else { 534| | /* single-nibble length in MSBs */ 535| 26.6M| length = static_cast(lengthByte >> 4); 536| 26.6M| lengthByte&=0xf; 537| 26.6M| } 538| | 539| 29.3M| *offsets++=offset; 540| 29.3M| *lengths++=length; 541| | 542| 29.3M| offset+=length; 543| 29.3M| ++i; 544| | 545| | /* read odd nibble - LSBs of lengthByte */ 546| 29.3M| if((lengthByte&0xf0)==0) { ------------------ | Branch (546:12): [True: 27.7M, False: 1.61M] ------------------ 547| | /* this nibble was not consumed for a double-nibble length above */ 548| 27.7M| length=lengthByte; 549| 27.7M| if(length<12) { ------------------ | Branch (549:16): [True: 26.6M, False: 1.14M] ------------------ 550| | /* single-nibble length in LSBs */ 551| 26.6M| *offsets++=offset; 552| 26.6M| *lengths++=length; 553| | 554| 26.6M| offset+=length; 555| 26.6M| ++i; 556| 26.6M| } 557| 27.7M| } else { 558| 1.61M| length=0; /* prevent double-nibble detection in the next iteration */ 559| 1.61M| } 560| 29.3M| } 561| | 562| | /* now, s is at the first group string */ 563| 1.74M| return s; 564| 1.74M|} _ZN6icu_788ByteSinkC2Ev: 59| 154k| ByteSink() { } _ZNK6icu_7820CheckedArrayByteSink10OverflowedEv: 240| 15.4k| UBool Overflowed() const { return overflowed_; } _ZNK6icu_7820CheckedArrayByteSink21NumberOfBytesAppendedEv: 248| 18.4k| int32_t NumberOfBytesAppended() const { return appended_; } _ZN6icu_789BytesTrieC2EPKv: 72| 27.6k| : ownedArray_(nullptr), bytes_(static_cast(trieBytes)), 73| 27.6k| pos_(bytes_), remainingMatchLength_(-1) {} _ZNK6icu_789BytesTrie8getValueEv: 246| 25.0k| inline int32_t getValue() const { 247| 25.0k| const uint8_t *pos=pos_; 248| 25.0k| int32_t leadByte=*pos++; 249| | // U_ASSERT(leadByte>=kMinValueLead); 250| 25.0k| return readValue(pos, leadByte>>1); 251| 25.0k| } _ZN6icu_789BytesTrie4stopEv: 399| 2.25k| inline void stop() { 400| 2.25k| pos_=nullptr; 401| 2.25k| } _ZN6icu_789BytesTrie9skipValueEPKhi: 406| 71.2k| static inline const uint8_t *skipValue(const uint8_t *pos, int32_t leadByte) { 407| | // U_ASSERT(leadByte>=kMinValueLead); 408| 71.2k| if(leadByte>=(kMinTwoByteValueLead<<1)) { ------------------ | Branch (408:12): [True: 41.4k, False: 29.7k] ------------------ 409| 41.4k| if(leadByte<(kMinThreeByteValueLead<<1)) { ------------------ | Branch (409:16): [True: 38.5k, False: 2.94k] ------------------ 410| 38.5k| ++pos; 411| 38.5k| } else if(leadByte<(kFourByteValueLead<<1)) { ------------------ | Branch (411:23): [True: 445, False: 2.50k] ------------------ 412| 445| pos+=2; 413| 2.50k| } else { 414| 2.50k| pos+=3+((leadByte>>1)&1); 415| 2.50k| } 416| 41.4k| } 417| 71.2k| return pos; 418| 71.2k| } _ZN6icu_789BytesTrie9skipValueEPKh: 419| 65.7k| static inline const uint8_t *skipValue(const uint8_t *pos) { 420| 65.7k| int32_t leadByte=*pos++; 421| 65.7k| return skipValue(pos, leadByte); 422| 65.7k| } _ZN6icu_789BytesTrie9skipDeltaEPKh: 427| 32.3k| static inline const uint8_t *skipDelta(const uint8_t *pos) { 428| 32.3k| int32_t delta=*pos++; 429| 32.3k| if(delta>=kMinTwoByteDeltaLead) { ------------------ | Branch (429:12): [True: 25.4k, False: 6.89k] ------------------ 430| 25.4k| if(delta(USTRINGTRIE_INTERMEDIATE_VALUE - (node & kValueIsFinal)); 443| 21.7k| } _ZN6icu_7814ConstChar16PtrC2EPKDs: 229| 798M|ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) : p_(p) {} _ZN6icu_7814ConstChar16PtrD2Ev: 237| 798M|ConstChar16Ptr::~ConstChar16Ptr() { 238| 798M| U_ALIASING_BARRIER(p_); ------------------ | | 35| 798M|# define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory") ------------------ 239| 798M|} _ZNK6icu_789Char16PtrcvPDsEv: 97| 28.2M| inline operator char16_t *() const { return get(); } _ZNK6icu_7814ConstChar16PtrcvPKDsEv: 205| 798M| inline operator const char16_t *() const { return get(); } _ZNK6icu_789Char16Ptr3getEv: 133| 28.2M|char16_t *Char16Ptr::get() const { return p_; } _ZNK6icu_7814ConstChar16Ptr3getEv: 241| 798M|const char16_t *ConstChar16Ptr::get() const { return p_; } _ZN6icu_788internal15toU16StringViewENSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 400| 1.38k|inline std::u16string_view toU16StringView(std::u16string_view sv) { return sv; } _ZN6icu_789Char16PtrC2EPDs: 121| 7.06M|Char16Ptr::Char16Ptr(char16_t *p) : p_(p) {} _ZN6icu_789Char16PtrD2Ev: 129| 7.06M|Char16Ptr::~Char16Ptr() { 130| 7.06M| U_ALIASING_BARRIER(p_); ------------------ | | 35| 7.06M|# define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory") ------------------ 131| 7.06M|} _ZN6icu_7812LocalPointerINS_17RuleBasedCollatorEEC2EPS1_: 200| 7.71k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseINS_17RuleBasedCollatorEEC2EPS1_: 82| 7.71k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_17RuleBasedCollatorEED2Ev: 245| 7.71k| ~LocalPointer() { 246| 7.71k| delete LocalPointerBase::ptr; 247| 7.71k| } _ZN6icu_7816LocalPointerBaseINS_17RuleBasedCollatorEED2Ev: 88| 7.71k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseINS_17RuleBasedCollatorEEptEv: 134| 32.7k| T *operator->() const { return ptr; } _ZN6icu_7812LocalPointerINS_10UnicodeSetEEC2EPS1_: 200| 4.10k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEEC2EPS1_: 82| 4.21k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_10UnicodeSetEED2Ev: 245| 4.21k| ~LocalPointer() { 246| 4.21k| delete LocalPointerBase::ptr; 247| 4.21k| } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEED2Ev: 88| 4.21k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7812LocalPointerINS_18CollationTailoringEEC2EPS1_: 200| 15.4k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseINS_18CollationTailoringEEC2EPS1_: 82| 15.4k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_18CollationTailoringEED2Ev: 245| 15.4k| ~LocalPointer() { 246| 15.4k| delete LocalPointerBase::ptr; 247| 15.4k| } _ZN6icu_7816LocalPointerBaseINS_18CollationTailoringEED2Ev: 88| 15.4k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseINS_18CollationTailoringEEptEv: 134| 47.8k| T *operator->() const { return ptr; } _ZN6icu_7816LocalPointerBaseINS_18CollationTailoringEE6orphanEv: 141| 8.19k| T *orphan() { 142| 8.19k| T *p=ptr; 143| 8.19k| ptr=nullptr; 144| 8.19k| return p; 145| 8.19k| } _ZNK6icu_7816LocalPointerBaseINS_18CollationTailoringEE6isNullEv: 94| 7.71k| UBool isNull() const { return ptr==nullptr; } _ZN6icu_7812LocalPointerINS_20CollationDataBuilderEEC2EPS1_R10UErrorCode: 214| 3.92k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 3.92k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 3.92k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 3.92k| } _ZN6icu_7816LocalPointerBaseINS_20CollationDataBuilderEEC2EPS1_: 82| 3.92k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_20CollationDataBuilderEED2Ev: 245| 3.92k| ~LocalPointer() { 246| 3.92k| delete LocalPointerBase::ptr; 247| 3.92k| } _ZN6icu_7816LocalPointerBaseINS_20CollationDataBuilderEED2Ev: 88| 3.92k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseINS_20CollationDataBuilderEEptEv: 134| 7.85k| T *operator->() const { return ptr; } _ZN6icu_7816LocalPointerBaseINS_20CollationDataBuilderEE6orphanEv: 141| 3.92k| T *orphan() { 142| 3.92k| T *p=ptr; 143| 3.92k| ptr=nullptr; 144| 3.92k| return p; 145| 3.92k| } _ZN6icu_7812LocalPointerINS_15ConditionalCE32EEC2EPS1_R10UErrorCode: 214| 713k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 713k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 713k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 713k| } _ZN6icu_7816LocalPointerBaseINS_15ConditionalCE32EEC2EPS1_: 82| 713k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_15ConditionalCE32EED2Ev: 245| 713k| ~LocalPointer() { 246| 713k| delete LocalPointerBase::ptr; 247| 713k| } _ZN6icu_7816LocalPointerBaseINS_15ConditionalCE32EED2Ev: 88| 713k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7816LocalPointerBaseINS_15ConditionalCE32EE6orphanEv: 141| 713k| T *orphan() { 142| 713k| T *p=ptr; 143| 713k| ptr=nullptr; 144| 713k| return p; 145| 713k| } _ZNK6icu_7816LocalPointerBaseINS_18CollationTailoringEEdeEv: 128| 1| T &operator*() const { return *ptr; } _ZNK6icu_7816LocalPointerBaseINS_18CollationTailoringEE8getAliasEv: 122| 1| T *getAlias() const { return ptr; } _ZN6icu_788internal16LocalOpenPointerI15UResourceBundleXadL_Z13ures_close_78EEEC2EPS2_: 567| 15.6k| explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseI15UResourceBundleEC2EPS1_: 82| 15.6k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_788internal16LocalOpenPointerI15UResourceBundleXadL_Z13ures_close_78EEED2Ev: 575| 15.6k| ~LocalOpenPointer() { if (ptr != nullptr) { closeFunction(ptr); } } ------------------ | Branch (575:31): [True: 15.5k, False: 107] ------------------ _ZN6icu_7816LocalPointerBaseI15UResourceBundleED2Ev: 88| 15.6k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseI15UResourceBundleE8getAliasEv: 122| 257k| T *getAlias() const { return ptr; } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEEC2EPS1_: 82| 268k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_13UnicodeStringEED2Ev: 245| 268k| ~LocalPointer() { 246| 268k| delete LocalPointerBase::ptr; 247| 268k| } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEED2Ev: 88| 268k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEE6orphanEv: 141| 268k| T *orphan() { 142| 268k| T *p=ptr; 143| 268k| ptr=nullptr; 144| 268k| return p; 145| 268k| } _ZN6icu_7816LocalPointerBaseI15UResourceBundleE6orphanEv: 141| 79.8k| T *orphan() { 142| 79.8k| T *p=ptr; 143| 79.8k| ptr=nullptr; 144| 79.8k| return p; 145| 79.8k| } _ZN6icu_788internal16LocalOpenPointerI10UHashtableXadL_Z14uhash_close_78EEEC2EPS2_: 567| 37| explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseI10UHashtableEC2EPS1_: 82| 37| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZNK6icu_7816LocalPointerBaseI10UHashtableE8getAliasEv: 122| 363| T *getAlias() const { return ptr; } _ZN6icu_788internal16LocalOpenPointerI15UResourceBundleXadL_Z13ures_close_78EEE12adoptInsteadEPS2_: 595| 79.8k| void adoptInstead(Type *p) { 596| 79.8k| if (ptr != nullptr) { closeFunction(ptr); } ------------------ | Branch (596:13): [True: 0, False: 79.8k] ------------------ 597| 79.8k| ptr=p; 598| 79.8k| } _ZN6icu_7812LocalPointerINS_10UnicodeSetEEC2EPS1_R10UErrorCode: 214| 102| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 102| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 102] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 102| } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEE8getAliasEv: 122| 106| T *getAlias() const { return ptr; } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEE6orphanEv: 141| 116| T *orphan() { 142| 116| T *p=ptr; 143| 116| ptr=nullptr; 144| 116| return p; 145| 116| } _ZNK6icu_7816LocalPointerBaseI15UResourceBundleE7isValidEv: 100| 2.17k| UBool isValid() const { return ptr!=nullptr; } _ZN6icu_788internal16LocalOpenPointerI10UHashtableXadL_Z14uhash_close_78EEE12adoptInsteadEPS2_: 595| 37| void adoptInstead(Type *p) { 596| 37| if (ptr != nullptr) { closeFunction(ptr); } ------------------ | Branch (596:13): [True: 0, False: 37] ------------------ 597| 37| ptr=p; 598| 37| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_116VariantListEntryEEC2EPS2_R10UErrorCode: 214| 1.02k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 1.02k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 1.02k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 1.02k| } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEEC2EPS2_: 82| 2.04k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEEptEv: 134| 4.54k| T *operator->() const { return ptr; } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEE6orphanEv: 141| 1.02k| T *orphan() { 142| 1.02k| T *p=ptr; 143| 1.02k| ptr=nullptr; 144| 1.02k| return p; 145| 1.02k| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_116VariantListEntryEEC2EOS3_: 224| 1.02k| LocalPointer(LocalPointer &&src) noexcept : LocalPointerBase(src.ptr) { 225| 1.02k| src.ptr=nullptr; 226| 1.02k| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_116VariantListEntryEED2Ev: 245| 2.04k| ~LocalPointer() { 246| 2.04k| delete LocalPointerBase::ptr; 247| 2.04k| } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEED2Ev: 88| 2.04k| ~LocalPointerBase() { /* delete ptr; */ } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_118ExtensionListEntryEEC2EPS2_: 200| 5.02k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEEC2EPS2_: 82| 5.02k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEE6isNullEv: 94| 5.02k| UBool isNull() const { return ptr==nullptr; } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEEptEv: 134| 18.0k| T *operator->() const { return ptr; } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEE6orphanEv: 141| 5.02k| T *orphan() { 142| 5.02k| T *p=ptr; 143| 5.02k| ptr=nullptr; 144| 5.02k| return p; 145| 5.02k| } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEE7isValidEv: 100| 6.25k| UBool isValid() const { return ptr!=nullptr; } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEE6orphanEv: 141| 1.18k| T *orphan() { 142| 1.18k| T *p=ptr; 143| 1.18k| ptr=nullptr; 144| 1.18k| return p; 145| 1.18k| } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEEptEv: 134| 3.51k| T *operator->() const { return ptr; } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEE8getAliasEv: 122| 1.14k| T *getAlias() const { return ptr; } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_118ExtensionListEntryEE29adoptInsteadAndCheckErrorCodeEPS2_R10UErrorCode: 319| 1.18k| void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) { 320| 1.18k| if(U_SUCCESS(errorCode)) { ------------------ | Branch (320:12): [True: 1.18k, False: 0] ------------------ 321| 1.18k| delete LocalPointerBase::ptr; 322| 1.18k| LocalPointerBase::ptr=p; 323| 1.18k| if(p==nullptr) { ------------------ | Branch (323:16): [True: 0, False: 1.18k] ------------------ 324| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 325| 0| } 326| 1.18k| } else { 327| 0| delete p; 328| 0| } 329| 1.18k| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_118ExtensionListEntryEED2Ev: 245| 5.02k| ~LocalPointer() { 246| 5.02k| delete LocalPointerBase::ptr; 247| 5.02k| } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEED2Ev: 88| 5.02k| ~LocalPointerBase() { /* delete ptr; */ } uloc_tag.cpp:_ZN6icu_788internal16LocalOpenPointerIN12_GLOBAL__N_112ULanguageTagEXadL_ZNS2_11ultag_closeEPS3_EEEC2ES4_: 567| 10.0k| explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase(p) {} uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEEC2EPS2_: 82| 10.0k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} uloc_tag.cpp:_ZN6icu_788internal16LocalOpenPointerIN12_GLOBAL__N_112ULanguageTagEXadL_ZNS2_11ultag_closeEPS3_EEED2Ev: 575| 10.0k| ~LocalOpenPointer() { if (ptr != nullptr) { closeFunction(ptr); } } ------------------ | Branch (575:31): [True: 5.02k, False: 5.02k] ------------------ uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEED2Ev: 88| 10.0k| ~LocalPointerBase() { /* delete ptr; */ } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEE8getAliasEv: 122| 47.1k| T *getAlias() const { return ptr; } umutablecptrie.cpp:_ZN6icu_7812LocalPointerINS_12_GLOBAL__N_120MutableCodePointTrieEEC2EPS2_R10UErrorCode: 214| 1| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 1| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 1] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 1| } umutablecptrie.cpp:_ZN6icu_7816LocalPointerBaseINS_12_GLOBAL__N_120MutableCodePointTrieEEC2EPS2_: 82| 1| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} umutablecptrie.cpp:_ZN6icu_7812LocalPointerINS_12_GLOBAL__N_120MutableCodePointTrieEED2Ev: 245| 1| ~LocalPointer() { 246| 1| delete LocalPointerBase::ptr; 247| 1| } umutablecptrie.cpp:_ZN6icu_7816LocalPointerBaseINS_12_GLOBAL__N_120MutableCodePointTrieEED2Ev: 88| 1| ~LocalPointerBase() { /* delete ptr; */ } umutablecptrie.cpp:_ZN6icu_7816LocalPointerBaseINS_12_GLOBAL__N_120MutableCodePointTrieEE6orphanEv: 141| 1| T *orphan() { 142| 1| T *p=ptr; 143| 1| ptr=nullptr; 144| 1| return p; 145| 1| } _ZN6icu_7812LocalPointerINS_13UnicodeStringEEC2EPS1_: 200| 268k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZNK6icu_7816LocalPointerBaseINS_13UnicodeStringEE6isNullEv: 94| 268k| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseI15UResourceBundleEptEv: 134| 3| T *operator->() const { return ptr; } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEE6isNullEv: 94| 14| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEEptEv: 134| 3.97k| T *operator->() const { return ptr; } _ZNK6icu_786Locale7getNameEv: 1228| 4.97k|{ 1229| 4.97k| return fullName; 1230| 4.97k|} _ZNK6icu_7811Normalizer29normalizeERKNS_13UnicodeStringER10UErrorCode: 221| 6.30M| normalize(const UnicodeString &src, UErrorCode &errorCode) const { 222| 6.30M| UnicodeString result; 223| 6.30M| normalize(src, result, errorCode); 224| 6.30M| return result; 225| 6.30M| } _ZN6icu_7813ParsePositionC2Ei: 70| 22.7k| : UObject(), 71| 22.7k| index(newIndex), 72| 22.7k| errorIndex(-1) 73| 22.7k| {} _ZNK6icu_7813ParsePosition8getIndexEv: 212| 2.01M|{ 213| 2.01M| return index; 214| 2.01M|} _ZN6icu_7813ParsePosition8setIndexEi: 218| 661k|{ 219| 661k| this->index = offset; 220| 661k|} _ZN6icu_7811ReplaceableC2Ev: 243| 1.14G|inline Replaceable::Replaceable() {} _ZN6icu_7811StringPieceC2Ev: 71| 1| StringPiece() : ptr_(nullptr), length_(0) { } _ZN6icu_7811StringPieceC2EPKci: 151| 4.98k| StringPiece(const char* offset, int32_t len) : ptr_(offset), length_(len) { } _ZNK6icu_7811StringPiececvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEv: 185| 20.4k| inline operator std::string_view() const { 186| 20.4k| return {data(), static_cast(size())}; 187| 20.4k| } _ZNK6icu_7811StringPiece4dataEv: 200| 35.3k| const char* data() const { return ptr_; } _ZNK6icu_7811StringPiece4sizeEv: 206| 20.4k| int32_t size() const { return length_; } _ZNK6icu_7811StringPiece6lengthEv: 212| 14.8k| int32_t length() const { return length_; } _ZN6icu_7817StringTrieBuilder4NodeC2Ei: 202| 124M| Node(int32_t initialHash) : hash(initialHash), offset(0) {} _ZNK6icu_7817StringTrieBuilder4Node8hashCodeEv: 203| 261M| inline int32_t hashCode() const { return hash; } _ZN6icu_7817StringTrieBuilder4Node8hashCodeEPKS1_: 205| 122M| static inline int32_t hashCode(const Node *node) { return node==nullptr ? 0 : node->hashCode(); } ------------------ | Branch (205:67): [True: 0, False: 122M] ------------------ _ZN6icu_7817StringTrieBuilder4Node26writeUnlessInsideRightEdgeEiiRS0_: 241| 9.62M| StringTrieBuilder &builder) { 242| | // Note: Edge numbers are negative, lastRight<=firstRight. 243| | // If offset>0 then this node and its sub-nodes have been written already 244| | // and we need not write them again. 245| | // If this node is part of the unwritten right branch edge, 246| | // then we wait until that is written. 247| 9.62M| if(offset<0 && (offset(c); 350| 23.7M| equal[length]=nullptr; 351| 23.7M| values[length]=value; 352| 23.7M| ++length; 353| 23.7M| hash=(hash*37u+c)*37u+value; 354| 23.7M| } _ZN6icu_7817StringTrieBuilder14ListBranchNode3addEiPNS0_4NodeE: 356| 43.2M| void add(int32_t c, Node *node) { 357| 43.2M| units[length] = static_cast(c); 358| 43.2M| equal[length]=node; 359| 43.2M| values[length]=0; 360| 43.2M| ++length; 361| 43.2M| hash=(hash*37u+c)*37u+hashCode(node); 362| 43.2M| } _ZN6icu_7817StringTrieBuilder15SplitBranchNodeC2EDsPNS0_4NodeES3_: 376| 2.76M| : BranchNode(((0x555555u*37u+middleUnit)*37u+ 377| 2.76M| hashCode(lessThanNode))*37u+hashCode(greaterOrEqualNode)), 378| 2.76M| unit(middleUnit), lessThan(lessThanNode), greaterOrEqual(greaterOrEqualNode) {} _ZN6icu_7817StringTrieBuilder14BranchHeadNodeC2EiPNS0_4NodeE: 393| 22.5M| : ValueNode((0x666666u*37u+len)*37u+hashCode(subNode)), 394| 22.5M| length(len), next(subNode) {} _ZNK6icu_7810UCharsTrie8Iterator9getStringEv: 361| 473k| const UnicodeString &getString() const { return str_; } _ZNK6icu_7810UCharsTrie8Iterator8getValueEv: 366| 161k| int32_t getValue() const { return value_; } _ZN6icu_7810UCharsTrieC2ENS_14ConstChar16PtrE: 70| 2.85M| : ownedArray_(nullptr), uchars_(trieUChars), 71| 2.85M| pos_(uchars_), remainingMatchLength_(-1) {} _ZN6icu_7810UCharsTrie5resetEv: 94| 99.0k| UCharsTrie &reset() { 95| 99.0k| pos_=uchars_; 96| 99.0k| remainingMatchLength_=-1; 97| 99.0k| return *this; 98| 99.0k| } _ZN6icu_7810UCharsTrie5StateC2Ev: 144| 3.12k| State() { uchars=nullptr; } _ZNK6icu_7810UCharsTrie9saveStateERNS0_5StateE: 160| 189k| const UCharsTrie &saveState(State &state) const { 161| 189k| state.uchars=uchars_; 162| 189k| state.pos=pos_; 163| 189k| state.remainingMatchLength=remainingMatchLength_; 164| 189k| return *this; 165| 189k| } _ZN6icu_7810UCharsTrie12resetToStateERKNS0_5StateE: 177| 25.1M| UCharsTrie &resetToState(const State &state) { 178| 25.1M| if(uchars_==state.uchars && uchars_!=nullptr) { ------------------ | Branch (178:12): [True: 25.1M, False: 0] | Branch (178:37): [True: 25.1M, False: 0] ------------------ 179| 25.1M| pos_=state.pos; 180| 25.1M| remainingMatchLength_=state.remainingMatchLength; 181| 25.1M| } 182| 25.1M| return *this; 183| 25.1M| } _ZN6icu_7810UCharsTrie5firstEi: 200| 2.17M| inline UStringTrieResult first(int32_t uchar) { 201| 2.17M| remainingMatchLength_=-1; 202| 2.17M| return nextImpl(uchars_, uchar); 203| 2.17M| } _ZNK6icu_7810UCharsTrie8getValueEv: 258| 1.41M| inline int32_t getValue() const { 259| 1.41M| const char16_t *pos=pos_; 260| 1.41M| int32_t leadUnit=*pos++; 261| | // U_ASSERT(leadUnit>=kMinValueLead); 262| 1.41M| return leadUnit&kValueIsFinal ? ------------------ | Branch (262:16): [True: 1.11M, False: 306k] ------------------ 263| 1.11M| readValue(pos, leadUnit&0x7fff) : readNodeValue(pos, leadUnit); 264| 1.41M| } _ZN6icu_7810UCharsTrie4stopEv: 414| 1.80M| inline void stop() { 415| 1.80M| pos_=nullptr; 416| 1.80M| } _ZN6icu_7810UCharsTrie9readValueEPKDsi: 420| 1.71M| static inline int32_t readValue(const char16_t *pos, int32_t leadUnit) { 421| 1.71M| int32_t value; 422| 1.71M| if(leadUnit=kMinTwoUnitValueLead) { ------------------ | Branch (432:12): [True: 1.67M, False: 2.58M] ------------------ 433| 1.67M| if(leadUnit>6)-1; 451| 304k| } else if(leadUnit=kMinTwoUnitNodeValueLead) { ------------------ | Branch (460:12): [True: 270k, False: 6.92k] ------------------ 461| 270k| if(leadUnit=kMinTwoUnitDeltaLead) { ------------------ | Branch (472:12): [True: 0, False: 578k] ------------------ 473| 0| if(delta==kThreeUnitDeltaLead) { ------------------ | Branch (473:16): [True: 0, False: 0] ------------------ 474| 0| delta=(pos[0]<<16)|pos[1]; 475| 0| pos+=2; 476| 0| } else { 477| 0| delta=((delta-kMinTwoUnitDeltaLead)<<16)|*pos++; 478| 0| } 479| 0| } 480| 578k| return pos+delta; 481| 578k| } _ZN6icu_7810UCharsTrie9skipDeltaEPKDs: 483| 490k| static const char16_t *skipDelta(const char16_t *pos) { 484| 490k| int32_t delta=*pos++; 485| 490k| if(delta>=kMinTwoUnitDeltaLead) { ------------------ | Branch (485:12): [True: 0, False: 490k] ------------------ 486| 0| if(delta==kThreeUnitDeltaLead) { ------------------ | Branch (486:16): [True: 0, False: 0] ------------------ 487| 0| pos+=2; 488| 0| } else { 489| 0| ++pos; 490| 0| } 491| 0| } 492| 490k| return pos; 493| 490k| } _ZN6icu_7810UCharsTrie11valueResultEi: 495| 985k| static inline UStringTrieResult valueResult(int32_t node) { 496| 985k| return static_cast(USTRINGTRIE_INTERMEDIATE_VALUE - (node >> 15)); 497| 985k| } _ZN6icu_7817UCharsTrieBuilder5clearEv: 128| 1.21M| UCharsTrieBuilder &clear() { 129| 1.21M| strings.remove(); 130| 1.21M| elementsLength=0; 131| 1.21M| ucharsLength=0; 132| 1.21M| return *this; 133| 1.21M| } _ZNK6icu_7817UCharsTrieBuilder23matchNodesCanHaveValuesEv: 151| 326k| virtual UBool matchNodesCanHaveValues() const override { return true; } _ZNK6icu_7817UCharsTrieBuilder31getMaxBranchLinearSubNodeLengthEv: 153| 28.0M| virtual int32_t getMaxBranchLinearSubNodeLength() const override { return UCharsTrie::kMaxBranchLinearSubNodeLength; } _ZNK6icu_7817UCharsTrieBuilder17getMinLinearMatchEv: 154| 16.4M| virtual int32_t getMinLinearMatch() const override { return UCharsTrie::kMinLinearMatch; } _ZNK6icu_7817UCharsTrieBuilder23getMaxLinearMatchLengthEv: 155| 36.5M| virtual int32_t getMaxLinearMatchLength() const override { return UCharsTrie::kMaxLinearMatchLength; } _ZN6icu_7810UnicodeSet10setPatternERKNS_13UnicodeStringE: 1830| 9.16k| void setPattern(const UnicodeString& newPat) { 1831| 9.16k| setPattern(newPat.getBuffer(), newPat.length()); 1832| 9.16k| } _ZNK6icu_7810UnicodeSet8isFrozenEv: 1848| 28.2M|inline UBool UnicodeSet::isFrozen() const { 1849| 28.2M| return bmpSet != nullptr || stringSpan != nullptr; ------------------ | Branch (1849:12): [True: 0, False: 28.2M] | Branch (1849:33): [True: 0, False: 28.2M] ------------------ 1850| 28.2M|} _ZNK6icu_7810UnicodeSet12containsSomeEii: 1852| 4.02M|inline UBool UnicodeSet::containsSome(UChar32 start, UChar32 end) const { 1853| 4.02M| return !containsNone(start, end); 1854| 4.02M|} _ZNK6icu_7810UnicodeSet7isBogusEv: 1864| 25.6M|inline UBool UnicodeSet::isBogus() const { 1865| 25.6M| return fFlags & kIsBogus; 1866| 25.6M|} _ZN6icu_7810UnicodeSet8fromUSetEPK4USet: 1872| 839|inline const UnicodeSet *UnicodeSet::fromUSet(const USet *uset) { 1873| 839| return reinterpret_cast(uset); 1874| 839|} _ZNK6icu_7810UnicodeSet6toUSetEv: 1880| 839|inline const USet *UnicodeSet::toUSet() const { 1881| 839| return reinterpret_cast(this); 1882| 839|} _ZNK6icu_7813UnicodeString8doEqualsERKS0_i: 3773| 78.1M| inline UBool doEquals(const UnicodeString &text, int32_t len) const { 3774| 78.1M| return doEquals(text.getArrayStart(), len); 3775| 78.1M| } _ZNK6icu_7813UnicodeString8pinIndexERi: 4138| 43.8M|{ 4139| | // pin index 4140| 43.8M| if(start < 0) { ------------------ | Branch (4140:6): [True: 0, False: 43.8M] ------------------ 4141| 0| start = 0; 4142| 43.8M| } else if(start > length()) { ------------------ | Branch (4142:13): [True: 0, False: 43.8M] ------------------ 4143| 0| start = length(); 4144| 0| } 4145| 43.8M|} _ZNK6icu_7813UnicodeString10pinIndicesERiS1_: 4150| 2.03G|{ 4151| | // pin indices 4152| 2.03G| int32_t len = length(); 4153| 2.03G| if(start < 0) { ------------------ | Branch (4153:6): [True: 0, False: 2.03G] ------------------ 4154| 0| start = 0; 4155| 2.03G| } else if(start > len) { ------------------ | Branch (4155:13): [True: 0, False: 2.03G] ------------------ 4156| 0| start = len; 4157| 0| } 4158| 2.03G| if(_length < 0) { ------------------ | Branch (4158:6): [True: 0, False: 2.03G] ------------------ 4159| 0| _length = 0; 4160| 2.03G| } else if(_length > (len - start)) { ------------------ | Branch (4160:13): [True: 24.2M, False: 2.01G] ------------------ 4161| 24.2M| _length = (len - start); 4162| 24.2M| } 4163| 2.03G|} _ZN6icu_7813UnicodeString13getArrayStartEv: 4166| 609M|UnicodeString::getArrayStart() { 4167| 609M| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4167:10): [True: 316M, False: 293M] ------------------ 4168| 316M| fUnion.fStackFields.fBuffer : fUnion.fFields.fArray; 4169| 609M|} _ZNK6icu_7813UnicodeString13getArrayStartEv: 4172| 4.12G|UnicodeString::getArrayStart() const { 4173| 4.12G| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4173:10): [True: 787M, False: 3.33G] ------------------ 4174| 3.33G| fUnion.fStackFields.fBuffer : fUnion.fFields.fArray; 4175| 4.12G|} _ZNK6icu_7813UnicodeString14hasShortLengthEv: 4202| 7.58G|UnicodeString::hasShortLength() const { 4203| 7.58G| return fUnion.fFields.fLengthAndFlags>=0; 4204| 7.58G|} _ZNK6icu_7813UnicodeString14getShortLengthEv: 4207| 4.72G|UnicodeString::getShortLength() const { 4208| | // fLengthAndFlags must be non-negative -> short length >= 0 4209| | // and arithmetic or logical shift does not matter. 4210| 4.72G| return fUnion.fFields.fLengthAndFlags>>kLengthShift; 4211| 4.72G|} _ZNK6icu_7813UnicodeString6lengthEv: 4214| 7.53G|UnicodeString::length() const { 4215| 7.53G| return hasShortLength() ? getShortLength() : fUnion.fFields.fLength; ------------------ | Branch (4215:10): [True: 4.57G, False: 2.96G] ------------------ 4216| 7.53G|} _ZNK6icu_7813UnicodeString11getCapacityEv: 4219| 692M|UnicodeString::getCapacity() const { 4220| 692M| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4220:10): [True: 416M, False: 276M] ------------------ 4221| 416M| US_STACKBUF_SIZE : fUnion.fFields.fCapacity; 4222| 692M|} _ZNK6icu_7813UnicodeString8hashCodeEv: 4226| 60.2M|{ return doHashCode(); } _ZNK6icu_7813UnicodeString7isBogusEv: 4230| 1.66G|{ return fUnion.fFields.fLengthAndFlags & kIsBogus; } _ZNK6icu_7813UnicodeString10isWritableEv: 4234| 646M|{ return !(fUnion.fFields.fLengthAndFlags & (kOpenGetBuffer | kIsBogus)); } _ZNK6icu_7813UnicodeString16isBufferWritableEv: 4238| 476M|{ 4239| 476M| return 4240| 476M| !(fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kIsBogus|kBufferIsReadonly)) && ------------------ | Branch (4240:7): [True: 476M, False: 3.92k] ------------------ 4241| 476M| (!(fUnion.fFields.fLengthAndFlags&kRefCounted) || refCount()==1); ------------------ | Branch (4241:8): [True: 227M, False: 249M] | Branch (4241:57): [True: 249M, False: 27.1k] ------------------ 4242| 476M|} _ZNK6icu_7813UnicodeString9getBufferEv: 4245| 960M|UnicodeString::getBuffer() const { 4246| 960M| if(fUnion.fFields.fLengthAndFlags&(kIsBogus|kOpenGetBuffer)) { ------------------ | Branch (4246:6): [True: 0, False: 960M] ------------------ 4247| 0| return nullptr; 4248| 960M| } else if(fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) { ------------------ | Branch (4248:13): [True: 117M, False: 842M] ------------------ 4249| 117M| return fUnion.fStackFields.fBuffer; 4250| 842M| } else { 4251| 842M| return fUnion.fFields.fArray; 4252| 842M| } 4253| 960M|} _ZNK6icu_7813UnicodeString9doCompareEiiRKS0_ii: 4264| 364M|{ 4265| 364M| if(srcText.isBogus()) { ------------------ | Branch (4265:6): [True: 0, False: 364M] ------------------ 4266| 0| return static_cast(!isBogus()); // 0 if both are bogus, 1 otherwise 4267| 364M| } else { 4268| 364M| srcText.pinIndices(srcStart, srcLength); 4269| 364M| return doCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength); 4270| 364M| } 4271| 364M|} _ZNK6icu_7813UnicodeString17doEqualsSubstringEiiRKS0_ii: 4279| 85.1M|{ 4280| 85.1M| if(srcText.isBogus()) { ------------------ | Branch (4280:6): [True: 0, False: 85.1M] ------------------ 4281| 0| return isBogus(); 4282| 85.1M| } else { 4283| 85.1M| srcText.pinIndices(srcStart, srcLength); 4284| 85.1M| return !isBogus() && doEqualsSubstring(start, thisLength, srcText.getArrayStart(), srcStart, srcLength); ------------------ | Branch (4284:12): [True: 85.1M, False: 0] | Branch (4284:26): [True: 42.6M, False: 42.4M] ------------------ 4285| 85.1M| } 4286| 85.1M|} _ZNK6icu_7813UnicodeStringeqERKS0_: 4290| 146M|{ 4291| 146M| if(isBogus()) { ------------------ | Branch (4291:6): [True: 0, False: 146M] ------------------ 4292| 0| return text.isBogus(); 4293| 146M| } else { 4294| 146M| int32_t len = length(), textLength = text.length(); 4295| 146M| return !text.isBogus() && len == textLength && doEquals(text, len); ------------------ | Branch (4295:12): [True: 146M, False: 0] | Branch (4295:31): [True: 78.1M, False: 68.4M] | Branch (4295:52): [True: 31.7M, False: 46.3M] ------------------ 4296| 146M| } 4297| 146M|} _ZNK6icu_7813UnicodeStringneERKS0_: 4301| 11.9M|{ return (! operator==(text)); } _ZNK6icu_7813UnicodeString7compareERKS0_: 4321| 363M|{ return doCompare(0, length(), text, 0, text.length()); } _ZNK6icu_7813UnicodeString7compareENS_14ConstChar16PtrEi: 4332| 1.28M|{ return doCompare(0, length(), srcChars, 0, srcLength); } _ZNK6icu_7813UnicodeString7compareEiiRKS0_ii: 4340| 1.15M|{ return doCompare(start, _length, srcText, srcStart, srcLength); } _ZNK6icu_7813UnicodeString7compareEiiPKDsii: 4354| 317k|{ return doCompare(start, _length, srcChars, srcStart, srcLength); } _ZNK6icu_7813UnicodeString7indexOfERKS0_iiii: 4506| 1.28M|{ 4507| 1.28M| if(!srcText.isBogus()) { ------------------ | Branch (4507:6): [True: 1.28M, False: 0] ------------------ 4508| 1.28M| srcText.pinIndices(srcStart, srcLength); 4509| 1.28M| if(srcLength > 0) { ------------------ | Branch (4509:8): [True: 1.28M, False: 0] ------------------ 4510| 1.28M| return indexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length); 4511| 1.28M| } 4512| 1.28M| } 4513| 0| return -1; 4514| 1.28M|} _ZNK6icu_7813UnicodeString7indexOfERKS0_: 4518| 1.28M|{ return indexOf(text, 0, text.length(), 0, length()); } _ZNK6icu_7813UnicodeString7indexOfEPKDsii: 4536| 8.07k| int32_t start) const { 4537| 8.07k| pinIndex(start); 4538| 8.07k| return indexOf(srcChars, 0, srcLength, start, length() - start); 4539| 8.07k|} _ZNK6icu_7813UnicodeString7indexOfEDsi: 4570| 26.0k| int32_t start) const { 4571| 26.0k| pinIndex(start); 4572| 26.0k| return doIndexOf(c, start, length() - start); 4573| 26.0k|} _ZNK6icu_7813UnicodeString11lastIndexOfEDs: 4645| 7.17k|{ return doLastIndexOf(c, 0, length()); } _ZNK6icu_7813UnicodeString10startsWithERKS0_: 4668| 45.2M|{ return doEqualsSubstring(0, text.length(), text, 0, text.length()); } _ZNK6icu_7813UnicodeString8endsWithERKS0_ii: 4700| 39.8M| int32_t srcLength) const { 4701| 39.8M| srcText.pinIndices(srcStart, srcLength); 4702| 39.8M| return doEqualsSubstring(length() - srcLength, srcLength, 4703| 39.8M| srcText, srcStart, srcLength); 4704| 39.8M|} _ZNK6icu_7813UnicodeString8endsWithENS_14ConstChar16PtrEi: 4708| 13.2k| int32_t srcLength) const { 4709| 13.2k| if(srcLength < 0) { ------------------ | Branch (4709:6): [True: 0, False: 13.2k] ------------------ 4710| 0| srcLength = u_strlen(toUCharPtr(srcChars)); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4711| 0| } 4712| 13.2k| return doEqualsSubstring(length() - srcLength, srcLength, srcChars, 0, srcLength); 4713| 13.2k|} _ZN6icu_7813UnicodeString7replaceEiiRKS0_ii: 4741| 7.27M|{ return doReplace(start, _length, srcText, srcStart, srcLength); } _ZNK6icu_7813UnicodeString9doExtractEiiRS0_: 4799| 7.10M|{ target.replace(0, target.length(), *this, start, _length); } _ZNK6icu_7813UnicodeString7extractEiiRS0_: 4812| 7.09M|{ doExtract(start, _length, target); } _ZNK6icu_7813UnicodeString20tempSubStringBetweenEii: 4840| 10.6k|UnicodeString::tempSubStringBetween(int32_t start, int32_t limit) const { 4841| 10.6k| return tempSubString(start, limit - start); 4842| 10.6k|} _ZNK6icu_7813UnicodeString8doCharAtEi: 4846| 2.47G|{ 4847| 2.47G| if (static_cast(offset) < static_cast(length())) { ------------------ | Branch (4847:7): [True: 2.47G, False: 0] ------------------ 4848| 2.47G| return getArrayStart()[offset]; 4849| 2.47G| } else { 4850| 0| return kInvalidUChar; 4851| 0| } 4852| 2.47G|} _ZNK6icu_7813UnicodeString6charAtEi: 4856| 111M|{ return doCharAt(offset); } _ZNK6icu_7813UnicodeStringixEi: 4860| 2.36G|{ return doCharAt(offset); } _ZNK6icu_7813UnicodeString7isEmptyEv: 4863| 243M|UnicodeString::isEmpty() const { 4864| | // Arithmetic or logical right shift does not matter: only testing for 0. 4865| 243M| return (fUnion.fFields.fLengthAndFlags>>kLengthShift) == 0; 4866| 243M|} _ZN6icu_7813UnicodeString13setZeroLengthEv: 4872| 130M|UnicodeString::setZeroLength() { 4873| 130M| fUnion.fFields.fLengthAndFlags &= kAllStorageFlags; 4874| 130M|} _ZN6icu_7813UnicodeString14setShortLengthEi: 4877| 1.33G|UnicodeString::setShortLength(int32_t len) { 4878| | // requires 0 <= len <= kMaxShortLength 4879| 1.33G| fUnion.fFields.fLengthAndFlags = 4880| 1.33G| static_cast((fUnion.fFields.fLengthAndFlags & kAllStorageFlags) | (len << kLengthShift)); 4881| 1.33G|} _ZN6icu_7813UnicodeString9setLengthEi: 4884| 1.34G|UnicodeString::setLength(int32_t len) { 4885| 1.34G| if(len <= kMaxShortLength) { ------------------ | Branch (4885:6): [True: 1.28G, False: 61.7M] ------------------ 4886| 1.28G| setShortLength(len); 4887| 1.28G| } else { 4888| 61.7M| fUnion.fFields.fLengthAndFlags |= kLengthIsLarge; 4889| 61.7M| fUnion.fFields.fLength = len; 4890| 61.7M| } 4891| 1.34G|} _ZN6icu_7813UnicodeString10setToEmptyEv: 4894| 2.70M|UnicodeString::setToEmpty() { 4895| 2.70M| fUnion.fFields.fLengthAndFlags = kShortString; 4896| 2.70M|} _ZN6icu_7813UnicodeString8setArrayEPDsii: 4899| 791M|UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) { 4900| 791M| setLength(len); 4901| 791M| fUnion.fFields.fArray = array; 4902| 791M| fUnion.fFields.fCapacity = capacity; 4903| 791M|} _ZN6icu_7813UnicodeString5setToERKS0_ii: 4917| 5.44M|{ 4918| 5.44M| unBogus(); 4919| 5.44M| return doReplace(0, length(), srcText, srcStart, srcLength); 4920| 5.44M|} _ZN6icu_7813UnicodeString5setToERKS0_i: 4925| 43.7M|{ 4926| 43.7M| unBogus(); 4927| 43.7M| srcText.pinIndex(srcStart); 4928| 43.7M| return doReplace(0, length(), srcText, srcStart, srcText.length() - srcStart); 4929| 43.7M|} _ZN6icu_7813UnicodeString5setToEPKDsi: 4940| 13.9k|{ 4941| 13.9k| unBogus(); 4942| 13.9k| return doReplace(0, length(), srcChars, 0, srcLength); 4943| 13.9k|} _ZN6icu_7813UnicodeString5setToEDs: 4947| 910|{ 4948| 910| unBogus(); 4949| 910| return doReplace(0, length(), &srcChar, 0, 1); 4950| 910|} _ZN6icu_7813UnicodeString5setToEi: 4954| 13.4M|{ 4955| 13.4M| unBogus(); 4956| 13.4M| return replace(0, length(), srcChar); 4957| 13.4M|} _ZN6icu_7813UnicodeString6appendERKS0_ii: 4963| 1.04M|{ return doAppend(srcText, srcStart, srcLength); } _ZN6icu_7813UnicodeString6appendERKS0_: 4967| 200M|{ return doAppend(srcText, 0, srcText.length()); } _ZN6icu_7813UnicodeString6appendENS_14ConstChar16PtrEi: 4978| 2.80M|{ return doAppend(srcChars, 0, srcLength); } _ZN6icu_7813UnicodeString6appendEDs: 4982| 53.3M|{ return doAppend(&srcChar, 0, 1); } _ZN6icu_7813UnicodeStringpLEi: 4989| 1.82M|UnicodeString::operator+= (UChar32 ch) { 4990| 1.82M| return append(ch); 4991| 1.82M|} _ZN6icu_7813UnicodeStringpLERKS0_: 4995| 3.12M|{ return doAppend(srcText, 0, srcText.length()); } _ZN6icu_7813UnicodeString6insertEiDs: 5025| 906|{ return doReplace(start, 0, &srcChar, 0, 1); } _ZN6icu_7813UnicodeString6removeEv: 5035| 74.5M|{ 5036| | // remove() of a bogus string makes the string empty and non-bogus 5037| 74.5M| if(isBogus()) { ------------------ | Branch (5037:6): [True: 37.9k, False: 74.5M] ------------------ 5038| 37.9k| setToEmpty(); 5039| 74.5M| } else { 5040| 74.5M| setZeroLength(); 5041| 74.5M| } 5042| 74.5M| return *this; 5043| 74.5M|} _ZN6icu_7813UnicodeString6removeEii: 5048| 16.3M|{ 5049| 16.3M| if(start <= 0 && _length == INT32_MAX) { ------------------ | Branch (5049:8): [True: 8.94M, False: 7.43M] | Branch (5049:22): [True: 0, False: 8.94M] ------------------ 5050| | // remove(guaranteed everything) of a bogus string makes the string empty and non-bogus 5051| 0| return remove(); 5052| 0| } 5053| 16.3M| return doReplace(start, _length, nullptr, 0, 0); 5054| 16.3M|} _ZN6icu_7813UnicodeString8truncateEi: 5069| 478k|{ 5070| 478k| if(isBogus() && targetLength == 0) { ------------------ | Branch (5070:6): [True: 0, False: 478k] | Branch (5070:19): [True: 0, False: 0] ------------------ 5071| | // truncate(0) of a bogus string makes the string empty and non-bogus 5072| 0| unBogus(); 5073| 0| return false; 5074| 478k| } else if (static_cast(targetLength) < static_cast(length())) { ------------------ | Branch (5074:14): [True: 476k, False: 1.73k] ------------------ 5075| 476k| setLength(targetLength); 5076| 476k| return true; 5077| 476k| } else { 5078| 1.73k| return false; 5079| 1.73k| } 5080| 478k|} _ZN6icu_7813UnicodeString7reverseEv: 5084| 2.75M|{ return doReverse(0, length()); } _ZN6icu_7813UnicodeStringC2Ev: 4182| 102M|UnicodeString::UnicodeString() { 4183| 102M| fUnion.fStackFields.fLengthAndFlags=kShortString; 4184| 102M|} _ZN6icu_7813UnicodeStringaSIA3_DsvEERS0_RKT_: 1960| 1.38k| inline UnicodeString &operator=(const S &src) { 1961| 1.38k| unBogus(); 1962| 1.38k| return doReplace(0, length(), internal::toU16StringView(src)); 1963| 1.38k| } _ZN6icu_7821ures_getUnicodeStringEPK15UResourceBundleP10UErrorCode: 813| 1.08k|ures_getUnicodeString(const UResourceBundle *resB, UErrorCode* status) { 814| 1.08k| UnicodeString result; 815| 1.08k| int32_t len = 0; 816| 1.08k| const char16_t *r = ConstChar16Ptr(ures_getString(resB, &len, status)); ------------------ | | 1675| 1.08k|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 1.08k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.08k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.08k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 817| 1.08k| if(U_SUCCESS(*status)) { ------------------ | Branch (817:8): [True: 1.08k, False: 0] ------------------ 818| 1.08k| result.setTo(true, r, len); 819| 1.08k| } else { 820| 0| result.setToBogus(); 821| 0| } 822| 1.08k| return result; 823| 1.08k|} _ZNK6icu_7818UnicodeSetIterator12getCodepointEv: 310| 44.4M|inline UChar32 UnicodeSetIterator::getCodepoint() const { 311| 44.4M| return codepoint; 312| 44.4M|} _ZNK6icu_7818UnicodeSetIterator8isStringEv: 306| 2.43M|inline UBool UnicodeSetIterator::isString() const { 307| 2.43M| return codepoint < 0; 308| 2.43M|} collator_rulebased_fuzzer.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 7.71k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } collationbuilder.cpp:_ZL9U_FAILURE10UErrorCode: 737| 98.1M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationbuilder.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 9.80M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } collationdata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3.19k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationdatabuilder.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 72.9M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } collationdatabuilder.cpp:_ZL9U_FAILURE10UErrorCode: 737| 30.1M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationfastlatinbuilder.cpp:_ZL9U_FAILURE10UErrorCode: 737| 5.44M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationfastlatinbuilder.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 7.94k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } collationiterator.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2.94M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationiterator.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 15.1M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } collationroot.cpp:_ZL9U_FAILURE10UErrorCode: 737| 23.1k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationruleparser.cpp:_ZL9U_FAILURE10UErrorCode: 737| 11.3M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationruleparser.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 974k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } collationsettings.cpp:_ZL9U_FAILURE10UErrorCode: 737| 19.9k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationtailoring.cpp:_ZL9U_FAILURE10UErrorCode: 737| 7.89k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rulebasedcollator.cpp:_ZL9U_FAILURE10UErrorCode: 737| 41.1k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rulebasedcollator.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 4.09k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ucol_res.cpp:_ZL9U_FAILURE10UErrorCode: 737| 9.72k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } utf16collationiterator.cpp:_ZL9U_FAILURE10UErrorCode: 737| 44.5k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationdatareader.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationkeys.cpp:_ZL9U_FAILURE10UErrorCode: 737| 16.3k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationsets.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3.92k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } collationsets.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 3.86M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } caniter.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 63.7M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } caniter.cpp:_ZL9U_FAILURE10UErrorCode: 737| 230M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } charstr.cpp:_ZL9U_FAILURE10UErrorCode: 737| 300k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } locid.cpp:_ZL9U_FAILURE10UErrorCode: 737| 92.6k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2.cpp:_ZL9U_FAILURE10UErrorCode: 737| 136M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 8.29M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } normalizer2impl.cpp:_ZL9U_FAILURE10UErrorCode: 737| 13.5M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2impl.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 6.77M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } putil.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } putil.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uarrsort.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1.28M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uchar.cpp:_ZL9U_FAILURE10UErrorCode: 737| 534k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucharstriebuilder.cpp:_ZL9U_FAILURE10UErrorCode: 737| 94.7M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucharstriebuilder.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 47.3M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ucharstrieiterator.cpp:_ZL9U_FAILURE10UErrorCode: 737| 562k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 5.46k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2.61k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } udatamem.cpp:_ZL9U_FAILURE10UErrorCode: 737| 77| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uhash.cpp:_ZL9U_FAILURE10UErrorCode: 737| 254M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc.cpp:_ZL9U_FAILURE10UErrorCode: 737| 157k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc_keytype.cpp:_ZL9U_FAILURE10UErrorCode: 737| 93.4k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc_keytype.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 79.7k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uloc_tag.cpp:_ZL9U_FAILURE10UErrorCode: 737| 27.2k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc_tag.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 3.89k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } umutablecptrie.cpp:_ZL9U_FAILURE10UErrorCode: 737| 4.77k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset.cpp:_ZL9U_FAILURE10UErrorCode: 737| 276k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset_props.cpp:_ZL9U_FAILURE10UErrorCode: 737| 355k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset_props.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 26.9k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } unistr.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 7.06M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uresbund.cpp:_ZL9U_FAILURE10UErrorCode: 737| 320k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uresbund.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 9.56k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uresdata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 708| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ustring.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 7.08M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } utrie2.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } utrie2_builder.cpp:_ZL9U_FAILURE10UErrorCode: 737| 16.1M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uvector.cpp:_ZL9U_FAILURE10UErrorCode: 737| 997k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uvectr32.cpp:_ZL9U_FAILURE10UErrorCode: 737| 30.4k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uvectr64.cpp:_ZL9U_FAILURE10UErrorCode: 737| 40.4k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } bytesinkutil.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 16.8k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } characterproperties.cpp:_ZL9U_FAILURE10UErrorCode: 737| 37.6k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } characterproperties.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 840| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } loadednormalizer2impl.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1.90M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } loadednormalizer2impl.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1.90M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ruleiter.cpp:_ZL9U_FAILURE10UErrorCode: 737| 425k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } stringtriebuilder.cpp:_ZL9U_FAILURE10UErrorCode: 737| 272M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } stringtriebuilder.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2.57M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ucase.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucmndata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } unames.cpp:_ZL9U_FAILURE10UErrorCode: 737| 4.09k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } unames.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1.36k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } _ZN6icu_7814UnicodeMatcherD2Ev: 23| 13.6M|UnicodeMatcher::~UnicodeMatcher() {} _ZN6icu_7813UnicodeFilterD2Ev: 25| 13.6M|UnicodeFilter::~UnicodeFilter() {} _ZN6icu_7814UnicodeFunctorD2Ev: 16| 13.6M|UnicodeFunctor::~UnicodeFunctor() {} _ZNK6icu_7810UnicodeSet10hasStringsEv: 120| 28.0k|UBool UnicodeSet::hasStrings() const { 121| 28.0k| return strings_ != nullptr && !strings_->isEmpty(); ------------------ | Branch (121:12): [True: 1.67k, False: 26.3k] | Branch (121:35): [True: 909, False: 770] ------------------ 122| 28.0k|} _ZNK6icu_7810UnicodeSet11stringsSizeEv: 124| 2.60M|int32_t UnicodeSet::stringsSize() const { 125| 2.60M| return strings_ == nullptr ? 0 : strings_->size(); ------------------ | Branch (125:12): [True: 2.60M, False: 5] ------------------ 126| 2.60M|} _ZNK6icu_7810UnicodeSet15stringsContainsERKNS_13UnicodeStringE: 128| 269k|UBool UnicodeSet::stringsContains(const UnicodeString &s) const { 129| 269k| return strings_ != nullptr && strings_->contains((void*) &s); ------------------ | Branch (129:12): [True: 265k, False: 4.14k] | Branch (129:35): [True: 1.27k, False: 264k] ------------------ 130| 269k|} _ZN6icu_7810UnicodeSetC2Ev: 139| 13.6M|UnicodeSet::UnicodeSet() { 140| 13.6M| list[0] = UNICODESET_HIGH; ------------------ | | 34| 13.6M|#define UNICODESET_HIGH 0x0110000 ------------------ 141| 13.6M| _dbgct(this); 142| 13.6M|} _ZN6icu_7810UnicodeSetC2Eii: 151| 2|UnicodeSet::UnicodeSet(UChar32 start, UChar32 end) { 152| 2| list[0] = UNICODESET_HIGH; ------------------ | | 34| 2|#define UNICODESET_HIGH 0x0110000 ------------------ 153| 2| add(start, end); 154| 2| _dbgct(this); 155| 2|} _ZN6icu_7810UnicodeSetD2Ev: 189| 13.6M|UnicodeSet::~UnicodeSet() { 190| 13.6M| _dbgdt(this); // first! 191| 13.6M| if (list != stackList) { ------------------ | Branch (191:9): [True: 654k, False: 13.0M] ------------------ 192| 654k| uprv_free(list); ------------------ | | 1503| 654k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 654k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 654k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 654k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 193| 654k| } 194| 13.6M| delete bmpSet; 195| 13.6M| if (buffer != stackList) { ------------------ | Branch (195:9): [True: 13.5M, False: 173k] ------------------ 196| 13.5M| uprv_free(buffer); ------------------ | | 1503| 13.5M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 13.5M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 13.5M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 13.5M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 197| 13.5M| } 198| 13.6M| delete strings_; 199| 13.6M| delete stringSpan; 200| 13.6M| releasePattern(); 201| 13.6M|} _ZN6icu_7810UnicodeSetaSERKS0_: 206| 7.86k|UnicodeSet& UnicodeSet::operator=(const UnicodeSet& o) { 207| 7.86k| return copyFrom(o, false); 208| 7.86k|} _ZN6icu_7810UnicodeSet8copyFromERKS0_a: 210| 8.70k|UnicodeSet& UnicodeSet::copyFrom(const UnicodeSet& o, UBool asThawed) { 211| 8.70k| if (this == &o) { ------------------ | Branch (211:9): [True: 0, False: 8.70k] ------------------ 212| 0| return *this; 213| 0| } 214| 8.70k| if (isFrozen()) { ------------------ | Branch (214:9): [True: 0, False: 8.70k] ------------------ 215| 0| return *this; 216| 0| } 217| 8.70k| if (o.isBogus()) { ------------------ | Branch (217:9): [True: 0, False: 8.70k] ------------------ 218| 0| setToBogus(); 219| 0| return *this; 220| 0| } 221| 8.70k| if (!ensureCapacity(o.len)) { ------------------ | Branch (221:9): [True: 0, False: 8.70k] ------------------ 222| | // ensureCapacity will mark the UnicodeSet as Bogus if OOM failure happens. 223| 0| return *this; 224| 0| } 225| 8.70k| len = o.len; 226| 8.70k| uprv_memcpy(list, o.list, (size_t)len*sizeof(UChar32)); ------------------ | | 42| 8.70k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 8.70k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 8.70k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 8.70k| _Pragma("clang diagnostic push") \ | | 45| 8.70k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 8.70k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 8.70k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 8.70k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 8.70k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 8.70k| _Pragma("clang diagnostic pop") \ | | 49| 8.70k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 8.70k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 8.70k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 8.70k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 227| 8.70k| if (o.bmpSet != nullptr && !asThawed) { ------------------ | Branch (227:9): [True: 839, False: 7.86k] | Branch (227:32): [True: 0, False: 839] ------------------ 228| 0| bmpSet = new BMPSet(*o.bmpSet, list, len); 229| 0| if (bmpSet == nullptr) { // Check for memory allocation error. ------------------ | Branch (229:13): [True: 0, False: 0] ------------------ 230| 0| setToBogus(); 231| 0| return *this; 232| 0| } 233| 0| } 234| 8.70k| if (o.hasStrings()) { ------------------ | Branch (234:9): [True: 0, False: 8.70k] ------------------ 235| 0| UErrorCode status = U_ZERO_ERROR; 236| 0| if ((strings_ == nullptr && !allocateStrings(status)) || ------------------ | Branch (236:14): [True: 0, False: 0] | Branch (236:37): [True: 0, False: 0] ------------------ 237| 0| (strings_->assign(*o.strings_, cloneUnicodeString, status), U_FAILURE(status))) { ------------------ | Branch (237:17): [True: 0, False: 0] ------------------ 238| 0| setToBogus(); 239| 0| return *this; 240| 0| } 241| 8.70k| } else if (hasStrings()) { ------------------ | Branch (241:16): [True: 16, False: 8.68k] ------------------ 242| 16| strings_->removeAllElements(); 243| 16| } 244| 8.70k| if (o.stringSpan != nullptr && !asThawed) { ------------------ | Branch (244:9): [True: 0, False: 8.70k] | Branch (244:36): [True: 0, False: 0] ------------------ 245| 0| stringSpan = new UnicodeSetStringSpan(*o.stringSpan, *strings_); 246| 0| if (stringSpan == nullptr) { // Check for memory allocation error. ------------------ | Branch (246:13): [True: 0, False: 0] ------------------ 247| 0| setToBogus(); 248| 0| return *this; 249| 0| } 250| 0| } 251| 8.70k| releasePattern(); 252| 8.70k| if (o.pat) { ------------------ | Branch (252:9): [True: 0, False: 8.70k] ------------------ 253| 0| setPattern(o.pat, o.patLen); 254| 0| } 255| 8.70k| return *this; 256| 8.70k|} _ZNK6icu_7810UnicodeSet7isEmptyEv: 331| 4.22k|UBool UnicodeSet::isEmpty() const { 332| 4.22k| return len == 1 && !hasStrings(); ------------------ | Branch (332:12): [True: 0, False: 4.22k] | Branch (332:24): [True: 0, False: 0] ------------------ 333| 4.22k|} _ZNK6icu_7810UnicodeSet8containsEi: 340| 129M|UBool UnicodeSet::contains(UChar32 c) const { 341| | // Set i to the index of the start item greater than ch 342| | // We know we will terminate without length test! 343| | // LATER: for large sets, add binary search 344| | //int32_t i = -1; 345| | //for (;;) { 346| | // if (c < list[++i]) break; 347| | //} 348| 129M| if (bmpSet != nullptr) { ------------------ | Branch (348:9): [True: 0, False: 129M] ------------------ 349| 0| return bmpSet->contains(c); 350| 0| } 351| 129M| if (stringSpan != nullptr) { ------------------ | Branch (351:9): [True: 0, False: 129M] ------------------ 352| 0| return stringSpan->contains(c); 353| 0| } 354| 129M| if (c >= UNICODESET_HIGH) { // Don't need to check LOW bound ------------------ | | 34| 129M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (354:9): [True: 0, False: 129M] ------------------ 355| 0| return false; 356| 0| } 357| 129M| int32_t i = findCodePoint(c); 358| 129M| return i & 1; // return true if odd 359| 129M|} _ZNK6icu_7810UnicodeSet13findCodePointEi: 370| 172M|int32_t UnicodeSet::findCodePoint(UChar32 c) const { 371| | /* Examples: 372| | findCodePoint(c) 373| | set list[] c=0 1 3 4 7 8 374| | === ============== =========== 375| | [] [110000] 0 0 0 0 0 0 376| | [\u0000-\u0003] [0, 4, 110000] 1 1 1 2 2 2 377| | [\u0004-\u0007] [4, 8, 110000] 0 0 0 1 1 2 378| | [:Any:] [0, 110000] 1 1 1 1 1 1 379| | */ 380| | 381| | // Return the smallest i such that c < list[i]. Assume 382| | // list[len - 1] == HIGH and that c is legal (0..HIGH-1). 383| 172M| if (c < list[0]) ------------------ | Branch (383:9): [True: 61.8M, False: 110M] ------------------ 384| 61.8M| return 0; 385| | // High runner test. c is often after the last range, so an 386| | // initial check for this condition pays off. 387| 110M| int32_t lo = 0; 388| 110M| int32_t hi = len - 1; 389| 110M| if (lo >= hi || c >= list[hi-1]) ------------------ | Branch (389:9): [True: 0, False: 110M] | Branch (389:21): [True: 25.2M, False: 85.5M] ------------------ 390| 25.2M| return hi; 391| | // invariant: c >= list[lo] 392| | // invariant: c < list[hi] 393| 625M| for (;;) { 394| 625M| int32_t i = (lo + hi) >> 1; 395| 625M| if (i == lo) { ------------------ | Branch (395:13): [True: 85.5M, False: 540M] ------------------ 396| 85.5M| break; // Found! 397| 540M| } else if (c < list[i]) { ------------------ | Branch (397:20): [True: 268M, False: 271M] ------------------ 398| 268M| hi = i; 399| 271M| } else { 400| 271M| lo = i; 401| 271M| } 402| 625M| } 403| 85.5M| return hi; 404| 110M|} _ZNK6icu_7810UnicodeSet12containsNoneEii: 473| 4.02M|UBool UnicodeSet::containsNone(UChar32 start, UChar32 end) const { 474| | //int32_t i = -1; 475| | //for (;;) { 476| | // if (start < list[++i]) break; 477| | //} 478| 4.02M| int32_t i = findCodePoint(start); 479| 4.02M| return ((i & 1) == 0 && end < list[i]); ------------------ | Branch (479:13): [True: 4.00M, False: 19.6k] | Branch (479:29): [True: 3.93M, False: 71.0k] ------------------ 480| 4.02M|} _ZN6icu_7810UnicodeSet3setEii: 748| 103|UnicodeSet& UnicodeSet::set(UChar32 start, UChar32 end) { 749| 103| clear(); 750| 103| complement(start, end); 751| 103| return *this; 752| 103|} _ZN6icu_7810UnicodeSet3addEii: 765| 1.97M|UnicodeSet& UnicodeSet::add(UChar32 start, UChar32 end) { 766| 1.97M| if (pinCodePoint(start) < pinCodePoint(end)) { ------------------ | Branch (766:9): [True: 1.21M, False: 763k] ------------------ 767| 1.21M| UChar32 limit = end + 1; 768| | // Fast path for adding a new range after the last one. 769| | // Odd list length: [..., lastStart, lastLimit, HIGH] 770| 1.21M| if ((len & 1) != 0) { ------------------ | Branch (770:13): [True: 1.21M, False: 243] ------------------ 771| | // If the list is empty, set lastLimit low enough to not be adjacent to 0. 772| 1.21M| UChar32 lastLimit = len == 1 ? -2 : list[len - 2]; ------------------ | Branch (772:33): [True: 30.5k, False: 1.18M] ------------------ 773| 1.21M| if (lastLimit <= start && !isFrozen() && !isBogus()) { ------------------ | Branch (773:17): [True: 1.21M, False: 444] | Branch (773:39): [True: 1.21M, False: 0] | Branch (773:54): [True: 1.21M, False: 0] ------------------ 774| 1.21M| if (lastLimit == start) { ------------------ | Branch (774:21): [True: 35, False: 1.21M] ------------------ 775| | // Extend the last range. 776| 35| list[len - 2] = limit; 777| 35| if (limit == UNICODESET_HIGH) { ------------------ | | 34| 35|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (777:25): [True: 12, False: 23] ------------------ 778| 12| --len; 779| 12| } 780| 1.21M| } else { 781| 1.21M| list[len - 1] = start; 782| 1.21M| if (limit < UNICODESET_HIGH) { ------------------ | | 34| 1.21M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (782:25): [True: 1.21M, False: 191] ------------------ 783| 1.21M| if (ensureCapacity(len + 2)) { ------------------ | Branch (783:29): [True: 1.21M, False: 0] ------------------ 784| 1.21M| list[len++] = limit; 785| 1.21M| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 1.21M|#define UNICODESET_HIGH 0x0110000 ------------------ 786| 1.21M| } 787| 1.21M| } else { // limit == UNICODESET_HIGH 788| 191| if (ensureCapacity(len + 1)) { ------------------ | Branch (788:29): [True: 191, False: 0] ------------------ 789| 191| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 191|#define UNICODESET_HIGH 0x0110000 ------------------ 790| 191| } 791| 191| } 792| 1.21M| } 793| 1.21M| releasePattern(); 794| 1.21M| return *this; 795| 1.21M| } 796| 1.21M| } 797| | // This is slow. Could be much faster using findCodePoint(start) 798| | // and modifying the list, dealing with adjacent & overlapping ranges. 799| 687| UChar32 range[3] = { start, limit, UNICODESET_HIGH }; ------------------ | | 34| 687|#define UNICODESET_HIGH 0x0110000 ------------------ 800| 687| add(range, 2, 0); 801| 763k| } else if (start == end) { ------------------ | Branch (801:16): [True: 763k, False: 0] ------------------ 802| 763k| add(start); 803| 763k| } 804| 764k| return *this; 805| 1.97M|} _ZN6icu_7810UnicodeSet3addEi: 833| 39.3M|UnicodeSet& UnicodeSet::add(UChar32 c) { 834| | // find smallest i such that c < list[i] 835| | // if odd, then it is IN the set 836| | // if even, then it is OUT of the set 837| 39.3M| int32_t i = findCodePoint(pinCodePoint(c)); 838| | 839| | // already in set? 840| 39.3M| if ((i & 1) != 0 || isFrozen() || isBogus()) return *this; ------------------ | Branch (840:9): [True: 16.3M, False: 22.9M] | Branch (840:26): [True: 0, False: 22.9M] | Branch (840:40): [True: 0, False: 22.9M] ------------------ 841| | 842| | // HIGH is 0x110000 843| | // assert(list[len-1] == HIGH); 844| | 845| | // empty = [HIGH] 846| | // [start_0, limit_0, start_1, limit_1, HIGH] 847| | 848| | // [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH] 849| | // ^ 850| | // list[i] 851| | 852| | // i == 0 means c is before the first range 853| | 854| |#ifdef DEBUG_US_ADD 855| | printf("Add of "); 856| | dump(c); 857| | printf(" found at %d", i); 858| | printf(": "); 859| | dump(list, len); 860| | printf(" => "); 861| |#endif 862| | 863| 22.9M| if (c == list[i]-1) { ------------------ | Branch (863:9): [True: 85.5k, False: 22.8M] ------------------ 864| | // c is before start of next range 865| 85.5k| list[i] = c; 866| | // if we touched the HIGH mark, then add a new one 867| 85.5k| if (c == (UNICODESET_HIGH - 1)) { ------------------ | | 34| 85.5k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (867:13): [True: 300, False: 85.2k] ------------------ 868| 300| if (!ensureCapacity(len+1)) { ------------------ | Branch (868:17): [True: 0, False: 300] ------------------ 869| | // ensureCapacity will mark the object as Bogus if OOM failure happens. 870| 0| return *this; 871| 0| } 872| 300| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 300|#define UNICODESET_HIGH 0x0110000 ------------------ 873| 300| } 874| 85.5k| if (i > 0 && c == list[i-1]) { ------------------ | Branch (874:13): [True: 73.6k, False: 11.8k] | Branch (874:22): [True: 52.1k, False: 21.5k] ------------------ 875| | // collapse adjacent ranges 876| | 877| | // [..., start_k-1, c, c, limit_k, ..., HIGH] 878| | // ^ 879| | // list[i] 880| | 881| | //for (int32_t k=i-1; k 0 && c == list[i-1]) { ------------------ | Branch (893:14): [True: 20.6M, False: 2.19M] | Branch (893:23): [True: 5.51M, False: 15.1M] ------------------ 894| | // c is after end of prior range 895| 5.51M| list[i-1]++; 896| | // no need to check for collapse here 897| 5.51M| } 898| | 899| 17.3M| else { 900| | // At this point we know the new char is not adjacent to 901| | // any existing ranges, and it is not 10FFFF. 902| | 903| | 904| | // [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH] 905| | // ^ 906| | // list[i] 907| | 908| | // [..., start_k-1, limit_k-1, c, c+1, start_k, limit_k, ..., HIGH] 909| | // ^ 910| | // list[i] 911| | 912| 17.3M| if (!ensureCapacity(len+2)) { ------------------ | Branch (912:13): [True: 0, False: 17.3M] ------------------ 913| | // ensureCapacity will mark the object as Bogus if OOM failure happens. 914| 0| return *this; 915| 0| } 916| | 917| 17.3M| UChar32 *p = list + i; 918| 17.3M| uprv_memmove(p + 2, p, (len - i) * sizeof(*p)); ------------------ | | 51| 17.3M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 17.3M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 17.3M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 17.3M| _Pragma("clang diagnostic push") \ | | 54| 17.3M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 17.3M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 17.3M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 17.3M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 17.3M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 17.3M| _Pragma("clang diagnostic pop") \ | | 58| 17.3M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 17.3M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 17.3M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 17.3M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 919| 17.3M| list[i] = c; 920| 17.3M| list[i+1] = c+1; 921| 17.3M| len += 2; 922| 17.3M| } 923| | 924| |#ifdef DEBUG_US_ADD 925| | dump(list, len); 926| | printf("\n"); 927| | 928| | for (i=1; i(cp)); 960| 805| } 961| 267k| return *this; 962| 267k|} _ZN6icu_7810UnicodeSet4_addERKNS_13UnicodeStringE: 968| 268k|void UnicodeSet::_add(const UnicodeString& s) { 969| 268k| if (isFrozen() || isBogus()) { ------------------ | Branch (969:9): [True: 0, False: 268k] | Branch (969:23): [True: 0, False: 268k] ------------------ 970| 0| return; 971| 0| } 972| 268k| UErrorCode ec = U_ZERO_ERROR; 973| 268k| if (strings_ == nullptr && !allocateStrings(ec)) { ------------------ | Branch (973:9): [True: 4.14k, False: 264k] | Branch (973:32): [True: 0, False: 4.14k] ------------------ 974| 0| setToBogus(); 975| 0| return; 976| 0| } 977| 268k| LocalPointer t(new UnicodeString(s)); 978| 268k| if (t.isNull()) { // Check for memory allocation error. ------------------ | Branch (978:9): [True: 0, False: 268k] ------------------ 979| 0| setToBogus(); 980| 0| return; 981| 0| } 982| 268k| strings_->sortedInsert(t.orphan(), compareUnicodeString, ec); 983| 268k| if (U_FAILURE(ec)) { ------------------ | Branch (983:9): [True: 0, False: 268k] ------------------ 984| 0| setToBogus(); 985| 0| } 986| 268k|} _ZN6icu_7810UnicodeSet11getSingleCPERKNS_13UnicodeStringE: 993| 267k|int32_t UnicodeSet::getSingleCP(const UnicodeString& s) { 994| 267k| int32_t sLength = s.length(); 995| 267k| if (sLength == 1) return s.charAt(0); ------------------ | Branch (995:9): [True: 785, False: 267k] ------------------ 996| 267k| if (sLength == 2) { ------------------ | Branch (996:9): [True: 53.2k, False: 213k] ------------------ 997| 53.2k| UChar32 cp = s.char32At(0); 998| 53.2k| if (cp > 0xFFFF) { // is surrogate pair ------------------ | Branch (998:13): [True: 20, False: 53.1k] ------------------ 999| 20| return cp; 1000| 20| } 1001| 53.2k| } 1002| 267k| return -1; 1003| 267k|} _ZN6icu_7810UnicodeSet6addAllERKNS_13UnicodeStringE: 1011| 665k|UnicodeSet& UnicodeSet::addAll(const UnicodeString& s) { 1012| 665k| UChar32 cp; 1013| 17.0M| for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 16.3M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 16.2M, False: 134k] | | ------------------ ------------------ | Branch (1013:25): [True: 16.3M, False: 665k] ------------------ 1014| 16.3M| cp = s.char32At(i); 1015| 16.3M| add(cp); 1016| 16.3M| } 1017| 665k| return *this; 1018| 665k|} _ZN6icu_7810UnicodeSet16removeAllStringsEv: 1059| 4.21k|UnicodeSet& UnicodeSet::removeAllStrings() { 1060| 4.21k| if (!isFrozen() && hasStrings()) { ------------------ | Branch (1060:9): [True: 4.21k, False: 0] | Branch (1060:24): [True: 37, False: 4.17k] ------------------ 1061| 37| strings_->removeAllElements(); 1062| 37| releasePattern(); 1063| 37| } 1064| 4.21k| return *this; 1065| 4.21k|} _ZN6icu_7810UnicodeSet6removeEii: 1151| 7.90k|UnicodeSet& UnicodeSet::remove(UChar32 start, UChar32 end) { 1152| 7.90k| if (pinCodePoint(start) <= pinCodePoint(end)) { ------------------ | Branch (1152:9): [True: 7.90k, False: 0] ------------------ 1153| 7.90k| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; ------------------ | | 34| 7.90k|#define UNICODESET_HIGH 0x0110000 ------------------ 1154| 7.90k| retain(range, 2, 2); 1155| 7.90k| } 1156| 7.90k| return *this; 1157| 7.90k|} _ZN6icu_7810UnicodeSet6removeEi: 1164| 13|UnicodeSet& UnicodeSet::remove(UChar32 c) { 1165| 13| return remove(c, c); 1166| 13|} _ZN6icu_7810UnicodeSet10complementEii: 1199| 103|UnicodeSet& UnicodeSet::complement(UChar32 start, UChar32 end) { 1200| 103| if (isFrozen() || isBogus()) { ------------------ | Branch (1200:9): [True: 0, False: 103] | Branch (1200:23): [True: 0, False: 103] ------------------ 1201| 0| return *this; 1202| 0| } 1203| 103| if (pinCodePoint(start) <= pinCodePoint(end)) { ------------------ | Branch (1203:9): [True: 103, False: 0] ------------------ 1204| 103| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; ------------------ | | 34| 103|#define UNICODESET_HIGH 0x0110000 ------------------ 1205| 103| exclusiveOr(range, 2, 0); 1206| 103| } 1207| 103| releasePattern(); 1208| 103| return *this; 1209| 103|} _ZN6icu_7810UnicodeSet10complementEv: 1219| 4.21k|UnicodeSet& UnicodeSet::complement() { 1220| 4.21k| if (isFrozen() || isBogus()) { ------------------ | Branch (1220:9): [True: 0, False: 4.21k] | Branch (1220:23): [True: 0, False: 4.21k] ------------------ 1221| 0| return *this; 1222| 0| } 1223| 4.21k| if (list[0] == UNICODESET_LOW) { ------------------ | | 37| 4.21k|#define UNICODESET_LOW 0x000000 ------------------ | Branch (1223:9): [True: 438, False: 3.77k] ------------------ 1224| 438| uprv_memmove(list, list + 1, (size_t)(len-1)*sizeof(UChar32)); ------------------ | | 51| 438|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 438|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 438| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 438| _Pragma("clang diagnostic push") \ | | 54| 438| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 438| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 438|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 438| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 438|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 438| _Pragma("clang diagnostic pop") \ | | 58| 438| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 438|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 438|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 438|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1225| 438| --len; 1226| 3.77k| } else { 1227| 3.77k| if (!ensureCapacity(len+1)) { ------------------ | Branch (1227:13): [True: 0, False: 3.77k] ------------------ 1228| 0| return *this; 1229| 0| } 1230| 3.77k| uprv_memmove(list + 1, list, (size_t)len*sizeof(UChar32)); ------------------ | | 51| 3.77k|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.77k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 3.77k| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 3.77k| _Pragma("clang diagnostic push") \ | | 54| 3.77k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 3.77k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.77k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 3.77k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.77k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 3.77k| _Pragma("clang diagnostic pop") \ | | 58| 3.77k| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 3.77k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 3.77k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.77k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1231| 3.77k| list[0] = UNICODESET_LOW; ------------------ | | 37| 3.77k|#define UNICODESET_LOW 0x000000 ------------------ 1232| 3.77k| ++len; 1233| 3.77k| } 1234| 4.21k| releasePattern(); 1235| 4.21k| return *this; 1236| 4.21k|} _ZN6icu_7810UnicodeSet6addAllERKS0_: 1272| 891k|UnicodeSet& UnicodeSet::addAll(const UnicodeSet& c) { 1273| 891k| if ( c.len>0 && c.list!=nullptr ) { ------------------ | Branch (1273:10): [True: 891k, False: 0] | Branch (1273:21): [True: 891k, False: 0] ------------------ 1274| 891k| add(c.list, c.len, 0); 1275| 891k| } 1276| | 1277| | // Add strings in order 1278| 891k| if ( c.strings_!=nullptr ) { ------------------ | Branch (1278:10): [True: 1.16k, False: 890k] ------------------ 1279| 3.52k| for (int32_t i=0; isize(); ++i) { ------------------ | Branch (1279:27): [True: 2.35k, False: 1.16k] ------------------ 1280| 2.35k| const UnicodeString* s = static_cast(c.strings_->elementAt(i)); 1281| 2.35k| if (!stringsContains(*s)) { ------------------ | Branch (1281:17): [True: 2.08k, False: 276] ------------------ 1282| 2.08k| _add(*s); 1283| 2.08k| } 1284| 2.35k| } 1285| 1.16k| } 1286| 891k| return *this; 1287| 891k|} _ZN6icu_7810UnicodeSet9retainAllERKS0_: 1298| 1.05k|UnicodeSet& UnicodeSet::retainAll(const UnicodeSet& c) { 1299| 1.05k| if (isFrozen() || isBogus()) { ------------------ | Branch (1299:9): [True: 0, False: 1.05k] | Branch (1299:23): [True: 0, False: 1.05k] ------------------ 1300| 0| return *this; 1301| 0| } 1302| 1.05k| retain(c.list, c.len, 0); 1303| 1.05k| if (hasStrings()) { ------------------ | Branch (1303:9): [True: 205, False: 845] ------------------ 1304| 205| if (!c.hasStrings()) { ------------------ | Branch (1304:13): [True: 91, False: 114] ------------------ 1305| 91| strings_->removeAllElements(); 1306| 114| } else { 1307| 114| strings_->retainAll(*c.strings_); 1308| 114| } 1309| 205| } 1310| 1.05k| return *this; 1311| 1.05k|} _ZN6icu_7810UnicodeSet9removeAllERKS0_: 1322| 486|UnicodeSet& UnicodeSet::removeAll(const UnicodeSet& c) { 1323| 486| if (isFrozen() || isBogus()) { ------------------ | Branch (1323:9): [True: 0, False: 486] | Branch (1323:23): [True: 0, False: 486] ------------------ 1324| 0| return *this; 1325| 0| } 1326| 486| retain(c.list, c.len, 2); 1327| 486| if (hasStrings() && c.hasStrings()) { ------------------ | Branch (1327:9): [True: 335, False: 151] | Branch (1327:25): [True: 192, False: 143] ------------------ 1328| 192| strings_->removeAll(*c.strings_); 1329| 192| } 1330| 486| return *this; 1331| 486|} _ZN6icu_7810UnicodeSet5clearEv: 1362| 2.61M|UnicodeSet& UnicodeSet::clear() { 1363| 2.61M| if (isFrozen()) { ------------------ | Branch (1363:9): [True: 0, False: 2.61M] ------------------ 1364| 0| return *this; 1365| 0| } 1366| 2.61M| list[0] = UNICODESET_HIGH; ------------------ | | 34| 2.61M|#define UNICODESET_HIGH 0x0110000 ------------------ 1367| 2.61M| len = 1; 1368| 2.61M| releasePattern(); 1369| 2.61M| if (strings_ != nullptr) { ------------------ | Branch (1369:9): [True: 911, False: 2.61M] ------------------ 1370| 911| strings_->removeAllElements(); 1371| 911| } 1372| | // Remove bogus 1373| 2.61M| fFlags = 0; 1374| 2.61M| return *this; 1375| 2.61M|} _ZNK6icu_7810UnicodeSet13getRangeCountEv: 1383| 2.61M|int32_t UnicodeSet::getRangeCount() const { 1384| 2.61M| return len/2; 1385| 2.61M|} _ZNK6icu_7810UnicodeSet13getRangeStartEi: 1393| 33.4M|UChar32 UnicodeSet::getRangeStart(int32_t index) const { 1394| 33.4M| return list[index*2]; 1395| 33.4M|} _ZNK6icu_7810UnicodeSet11getRangeEndEi: 1403| 33.4M|UChar32 UnicodeSet::getRangeEnd(int32_t index) const { 1404| 33.4M| return list[index*2 + 1] - 1; 1405| 33.4M|} _ZN6icu_7810UnicodeSet7compactEv: 1415| 3.94k|UnicodeSet& UnicodeSet::compact() { 1416| 3.94k| if (isFrozen() || isBogus()) { ------------------ | Branch (1416:9): [True: 0, False: 3.94k] | Branch (1416:23): [True: 0, False: 3.94k] ------------------ 1417| 0| return *this; 1418| 0| } 1419| | // Delete buffer first to defragment memory less. 1420| 3.94k| if (buffer != stackList) { ------------------ | Branch (1420:9): [True: 15, False: 3.92k] ------------------ 1421| 15| uprv_free(buffer); ------------------ | | 1503| 15|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 15|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1422| 15| buffer = nullptr; 1423| 15| bufferCapacity = 0; 1424| 15| } 1425| 3.94k| if (list == stackList) { ------------------ | Branch (1425:9): [True: 3, False: 3.93k] ------------------ 1426| | // pass 1427| 3.93k| } else if (len <= INITIAL_CAPACITY) { ------------------ | Branch (1427:16): [True: 0, False: 3.93k] ------------------ 1428| 0| uprv_memcpy(stackList, list, len * sizeof(UChar32)); ------------------ | | 42| 0|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 0| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 0| _Pragma("clang diagnostic push") \ | | 45| 0| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 0| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 0| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 0| _Pragma("clang diagnostic pop") \ | | 49| 0| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1429| 0| uprv_free(list); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1430| 0| list = stackList; 1431| 0| capacity = INITIAL_CAPACITY; 1432| 3.93k| } else if ((len + 7) < capacity) { ------------------ | Branch (1432:16): [True: 3.93k, False: 0] ------------------ 1433| | // If we have more than a little unused capacity, shrink it to len. 1434| 3.93k| UChar32* temp = static_cast(uprv_realloc(list, sizeof(UChar32) * len)); ------------------ | | 1536| 3.93k|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 3.93k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.93k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.93k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1435| 3.93k| if (temp) { ------------------ | Branch (1435:13): [True: 3.93k, False: 0] ------------------ 1436| 3.93k| list = temp; 1437| 3.93k| capacity = len; 1438| 3.93k| } 1439| | // else what the heck happened?! We allocated less memory! 1440| | // Oh well. We'll keep our original array. 1441| 3.93k| } 1442| 3.94k| if (strings_ != nullptr && strings_->isEmpty()) { ------------------ | Branch (1442:9): [True: 0, False: 3.94k] | Branch (1442:32): [True: 0, False: 0] ------------------ 1443| 0| delete strings_; 1444| 0| strings_ = nullptr; 1445| 0| } 1446| 3.94k| return *this; 1447| 3.94k|} _ZN6icu_7810UnicodeSetC2EPKtiNS0_14ESerializationER10UErrorCode: 1457| 1| UErrorCode &ec) { 1458| | 1459| 1| if(U_FAILURE(ec)) { ------------------ | Branch (1459:6): [True: 0, False: 1] ------------------ 1460| 0| setToBogus(); 1461| 0| return; 1462| 0| } 1463| | 1464| 1| if( (serialization != kSerialized) ------------------ | Branch (1464:7): [True: 0, False: 1] ------------------ 1465| 1| || (data==nullptr) ------------------ | Branch (1465:10): [True: 0, False: 1] ------------------ 1466| 1| || (dataLen < 1)) { ------------------ | Branch (1466:10): [True: 0, False: 1] ------------------ 1467| 0| ec = U_ILLEGAL_ARGUMENT_ERROR; 1468| 0| setToBogus(); 1469| 0| return; 1470| 0| } 1471| | 1472| | // bmp? 1473| 1| int32_t headerSize = ((data[0]&0x8000)) ?2:1; ------------------ | Branch (1473:24): [True: 1, False: 0] ------------------ 1474| 1| int32_t bmpLength = (headerSize==1)?data[0]:data[1]; ------------------ | Branch (1474:23): [True: 0, False: 1] ------------------ 1475| | 1476| 1| int32_t newLength = (((data[0]&0x7FFF)-bmpLength)/2)+bmpLength; 1477| |#ifdef DEBUG_SERIALIZE 1478| | printf("dataLen %d headerSize %d bmpLen %d len %d. data[0]=%X/%X/%X/%X\n", dataLen,headerSize,bmpLength,newLength, data[0],data[1],data[2],data[3]); 1479| |#endif 1480| 1| if(!ensureCapacity(newLength + 1)) { // +1 for HIGH ------------------ | Branch (1480:6): [True: 0, False: 1] ------------------ 1481| 0| return; 1482| 0| } 1483| | // copy bmp 1484| 1| int32_t i; 1485| 441| for(i = 0; i< bmpLength;i++) { ------------------ | Branch (1485:14): [True: 440, False: 1] ------------------ 1486| 440| list[i] = data[i+headerSize]; 1487| |#ifdef DEBUG_SERIALIZE 1488| | printf("<<16@%d[%d] %X\n", i+headerSize, i, list[i]); 1489| |#endif 1490| 440| } 1491| | // copy smp 1492| 205| for(i=bmpLength;i(data[headerSize + bmpLength + (i - bmpLength) * 2 + 0]) << 16) + 1494| 204| static_cast(data[headerSize + bmpLength + (i - bmpLength) * 2 + 1]); 1495| |#ifdef DEBUG_SERIALIZE 1496| | printf("<<32@%d+[%d] %lX\n", headerSize+bmpLength+i, i, list[i]); 1497| |#endif 1498| 204| } 1499| 1| U_ASSERT(i == newLength); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1500| 1| if (i == 0 || list[i - 1] != UNICODESET_HIGH) { ------------------ | | 34| 1|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1500:7): [True: 0, False: 1] | Branch (1500:17): [True: 1, False: 0] ------------------ 1501| 1| list[i++] = UNICODESET_HIGH; ------------------ | | 34| 1|#define UNICODESET_HIGH 0x0110000 ------------------ 1502| 1| } 1503| 1| len = i; 1504| 1|} _ZN6icu_7810UnicodeSet15allocateStringsER10UErrorCode: 1606| 4.14k|UBool UnicodeSet::allocateStrings(UErrorCode &status) { 1607| 4.14k| if (U_FAILURE(status)) { ------------------ | Branch (1607:9): [True: 0, False: 4.14k] ------------------ 1608| 0| return false; 1609| 0| } 1610| 4.14k| strings_ = new UVector(uprv_deleteUObject, ------------------ | | 1489| 4.14k|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 4.14k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.14k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.14k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 4.14k| uhash_compareUnicodeString, 1, status); ------------------ | | 999| 4.14k|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 4.14k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.14k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.14k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1612| 4.14k| if (strings_ == nullptr) { // Check for memory allocation error. ------------------ | Branch (1612:9): [True: 0, False: 4.14k] ------------------ 1613| 0| status = U_MEMORY_ALLOCATION_ERROR; 1614| 0| return false; 1615| 0| } 1616| 4.14k| if (U_FAILURE(status)) { ------------------ | Branch (1616:9): [True: 0, False: 4.14k] ------------------ 1617| 0| delete strings_; 1618| 0| strings_ = nullptr; 1619| 0| return false; 1620| 0| } 1621| 4.14k| return true; 1622| 4.14k|} _ZN6icu_7810UnicodeSet12nextCapacityEi: 1624| 736k|int32_t UnicodeSet::nextCapacity(int32_t minCapacity) { 1625| | // Grow exponentially to reduce the frequency of allocations. 1626| 736k| if (minCapacity < INITIAL_CAPACITY) { ------------------ | Branch (1626:9): [True: 229k, False: 507k] ------------------ 1627| 229k| return minCapacity + INITIAL_CAPACITY; 1628| 507k| } else if (minCapacity <= 2500) { ------------------ | Branch (1628:16): [True: 506k, False: 64] ------------------ 1629| 506k| return 5 * minCapacity; 1630| 506k| } else { 1631| 64| int32_t newCapacity = 2 * minCapacity; 1632| 64| if (newCapacity > MAX_LENGTH) { ------------------ | Branch (1632:13): [True: 0, False: 64] ------------------ 1633| 0| newCapacity = MAX_LENGTH; 1634| 0| } 1635| 64| return newCapacity; 1636| 64| } 1637| 736k|} _ZN6icu_7810UnicodeSet14ensureCapacityEi: 1639| 18.5M|bool UnicodeSet::ensureCapacity(int32_t newLen) { 1640| 18.5M| if (newLen > MAX_LENGTH) { ------------------ | Branch (1640:9): [True: 0, False: 18.5M] ------------------ 1641| 0| newLen = MAX_LENGTH; 1642| 0| } 1643| 18.5M| if (newLen <= capacity) { ------------------ | Branch (1643:9): [True: 18.0M, False: 489k] ------------------ 1644| 18.0M| return true; 1645| 18.0M| } 1646| 489k| int32_t newCapacity = nextCapacity(newLen); 1647| 489k| UChar32* temp = static_cast(uprv_malloc(newCapacity * sizeof(UChar32))); ------------------ | | 1524| 489k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 489k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 489k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 489k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1648| 489k| if (temp == nullptr) { ------------------ | Branch (1648:9): [True: 0, False: 489k] ------------------ 1649| 0| setToBogus(); // set the object to bogus state if an OOM failure occurred. 1650| 0| return false; 1651| 0| } 1652| | // Copy only the actual contents. 1653| 489k| uprv_memcpy(temp, list, len * sizeof(UChar32)); ------------------ | | 42| 489k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 489k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 489k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 489k| _Pragma("clang diagnostic push") \ | | 45| 489k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 489k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 489k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 489k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 489k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 489k| _Pragma("clang diagnostic pop") \ | | 49| 489k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 489k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 489k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 489k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1654| 489k| if (list != stackList) { ------------------ | Branch (1654:9): [True: 8.95k, False: 480k] ------------------ 1655| 8.95k| uprv_free(list); ------------------ | | 1503| 8.95k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 8.95k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.95k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.95k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1656| 8.95k| } 1657| 489k| list = temp; 1658| 489k| capacity = newCapacity; 1659| 489k| return true; 1660| 489k|} _ZN6icu_7810UnicodeSet20ensureBufferCapacityEi: 1662| 901k|bool UnicodeSet::ensureBufferCapacity(int32_t newLen) { 1663| 901k| if (newLen > MAX_LENGTH) { ------------------ | Branch (1663:9): [True: 0, False: 901k] ------------------ 1664| 0| newLen = MAX_LENGTH; 1665| 0| } 1666| 901k| if (newLen <= bufferCapacity) { ------------------ | Branch (1666:9): [True: 654k, False: 247k] ------------------ 1667| 654k| return true; 1668| 654k| } 1669| 247k| int32_t newCapacity = nextCapacity(newLen); 1670| 247k| UChar32* temp = static_cast(uprv_malloc(newCapacity * sizeof(UChar32))); ------------------ | | 1524| 247k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 247k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 247k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 247k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1671| 247k| if (temp == nullptr) { ------------------ | Branch (1671:9): [True: 0, False: 247k] ------------------ 1672| 0| setToBogus(); 1673| 0| return false; 1674| 0| } 1675| | // The buffer has no contents to be copied. 1676| | // It is always filled from scratch after this call. 1677| 247k| if (buffer != stackList) { ------------------ | Branch (1677:9): [True: 246k, False: 644] ------------------ 1678| 246k| uprv_free(buffer); ------------------ | | 1503| 246k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 246k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 246k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 246k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1679| 246k| } 1680| 247k| buffer = temp; 1681| 247k| bufferCapacity = newCapacity; 1682| 247k| return true; 1683| 247k|} _ZN6icu_7810UnicodeSet11swapBuffersEv: 1688| 901k|void UnicodeSet::swapBuffers() { 1689| | // swap list and buffer 1690| 901k| UChar32* temp = list; 1691| 901k| list = buffer; 1692| 901k| buffer = temp; 1693| | 1694| 901k| int32_t c = capacity; 1695| 901k| capacity = bufferCapacity; 1696| 901k| bufferCapacity = c; 1697| 901k|} _ZN6icu_7810UnicodeSet11exclusiveOrEPKiia: 1715| 103|void UnicodeSet::exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity) { 1716| 103| if (isFrozen() || isBogus()) { ------------------ | Branch (1716:9): [True: 0, False: 103] | Branch (1716:23): [True: 0, False: 103] ------------------ 1717| 0| return; 1718| 0| } 1719| 103| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1719:9): [True: 0, False: 103] ------------------ 1720| 0| return; 1721| 0| } 1722| | 1723| 103| int32_t i = 0, j = 0, k = 0; 1724| 103| UChar32 a = list[i++]; 1725| 103| UChar32 b; 1726| 103| if (polarity == 1 || polarity == 2) { ------------------ | Branch (1726:9): [True: 0, False: 103] | Branch (1726:26): [True: 0, False: 103] ------------------ 1727| 0| b = UNICODESET_LOW; ------------------ | | 37| 0|#define UNICODESET_LOW 0x000000 ------------------ 1728| 0| if (other[j] == UNICODESET_LOW) { // skip base if already LOW ------------------ | | 37| 0|#define UNICODESET_LOW 0x000000 ------------------ | Branch (1728:13): [True: 0, False: 0] ------------------ 1729| 0| ++j; 1730| 0| b = other[j]; 1731| 0| } 1732| 103| } else { 1733| 103| b = other[j++]; 1734| 103| } 1735| | // simplest of all the routines 1736| | // sort the values, discarding identicals! 1737| 207| for (;;) { 1738| 207| if (a < b) { ------------------ | Branch (1738:13): [True: 0, False: 207] ------------------ 1739| 0| buffer[k++] = a; 1740| 0| a = list[i++]; 1741| 207| } else if (b < a) { ------------------ | Branch (1741:20): [True: 104, False: 103] ------------------ 1742| 104| buffer[k++] = b; 1743| 104| b = other[j++]; 1744| 104| } else if (a != UNICODESET_HIGH) { // at this point, a == b ------------------ | | 34| 103|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1744:20): [True: 0, False: 103] ------------------ 1745| | // discard both values! 1746| 0| a = list[i++]; 1747| 0| b = other[j++]; 1748| 103| } else { // DONE! 1749| 103| buffer[k++] = UNICODESET_HIGH; ------------------ | | 34| 103|#define UNICODESET_HIGH 0x0110000 ------------------ 1750| 103| len = k; 1751| 103| break; 1752| 103| } 1753| 207| } 1754| 103| swapBuffers(); 1755| 103| releasePattern(); 1756| 103|} _ZN6icu_7810UnicodeSet3addEPKiia: 1763| 892k|void UnicodeSet::add(const UChar32* other, int32_t otherLen, int8_t polarity) { 1764| 892k| if (isFrozen() || isBogus() || other==nullptr) { ------------------ | Branch (1764:9): [True: 0, False: 892k] | Branch (1764:23): [True: 0, False: 892k] | Branch (1764:36): [True: 0, False: 892k] ------------------ 1765| 0| return; 1766| 0| } 1767| 892k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1767:9): [True: 0, False: 892k] ------------------ 1768| 0| return; 1769| 0| } 1770| | 1771| 892k| int32_t i = 0, j = 0, k = 0; 1772| 892k| UChar32 a = list[i++]; 1773| 892k| UChar32 b = other[j++]; 1774| | // change from xor is that we have to check overlapping pairs 1775| | // polarity bit 1 means a is second, bit 2 means b is. 1776| 15.8M| for (;;) { 1777| 15.8M| switch (polarity) { ------------------ | Branch (1777:17): [True: 0, False: 15.8M] ------------------ 1778| 8.35M| case 0: // both first; take lower if unequal ------------------ | Branch (1778:11): [True: 8.35M, False: 7.47M] ------------------ 1779| 8.35M| if (a < b) { // take a ------------------ | Branch (1779:17): [True: 155k, False: 8.19M] ------------------ 1780| | // Back up over overlapping ranges in buffer[] 1781| 155k| if (k > 0 && a <= buffer[k-1]) { ------------------ | Branch (1781:21): [True: 151k, False: 4.04k] | Branch (1781:30): [True: 17.1k, False: 134k] ------------------ 1782| | // Pick latter end value in buffer[] vs. list[] 1783| 17.1k| a = max(list[i], buffer[--k]); 1784| 138k| } else { 1785| | // No overlap 1786| 138k| buffer[k++] = a; 1787| 138k| a = list[i]; 1788| 138k| } 1789| 155k| i++; // Common if/else code factored out 1790| 155k| polarity ^= 1; 1791| 8.19M| } else if (b < a) { // take b ------------------ | Branch (1791:24): [True: 7.09M, False: 1.09M] ------------------ 1792| 7.09M| if (k > 0 && b <= buffer[k-1]) { ------------------ | Branch (1792:21): [True: 6.21M, False: 883k] | Branch (1792:30): [True: 11.6k, False: 6.20M] ------------------ 1793| 11.6k| b = max(other[j], buffer[--k]); 1794| 7.08M| } else { 1795| 7.08M| buffer[k++] = b; 1796| 7.08M| b = other[j]; 1797| 7.08M| } 1798| 7.09M| j++; 1799| 7.09M| polarity ^= 2; 1800| 7.09M| } else { // a == b, take a, drop b 1801| 1.09M| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 1.09M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1801:21): [True: 887k, False: 212k] ------------------ 1802| | // This is symmetrical; it doesn't matter if 1803| | // we backtrack with a or b. - liu 1804| 212k| if (k > 0 && a <= buffer[k-1]) { ------------------ | Branch (1804:21): [True: 208k, False: 4.10k] | Branch (1804:30): [True: 0, False: 208k] ------------------ 1805| 0| a = max(list[i], buffer[--k]); 1806| 212k| } else { 1807| | // No overlap 1808| 212k| buffer[k++] = a; 1809| 212k| a = list[i]; 1810| 212k| } 1811| 212k| i++; 1812| 212k| polarity ^= 1; 1813| 212k| b = other[j++]; 1814| 212k| polarity ^= 2; 1815| 212k| } 1816| 7.46M| break; 1817| 7.46M| case 3: // both second; take higher if unequal, and drop other ------------------ | Branch (1817:11): [True: 216k, False: 15.6M] ------------------ 1818| 216k| if (b <= a) { // take a ------------------ | Branch (1818:17): [True: 214k, False: 2.69k] ------------------ 1819| 214k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 214k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1819:21): [True: 3.62k, False: 210k] ------------------ 1820| 210k| buffer[k++] = a; 1821| 210k| } else { // take b 1822| 2.69k| if (b == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 2.69k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1822:21): [True: 333, False: 2.36k] ------------------ 1823| 2.36k| buffer[k++] = b; 1824| 2.36k| } 1825| 212k| a = list[i++]; 1826| 212k| polarity ^= 1; // factored common code 1827| 212k| b = other[j++]; 1828| 212k| polarity ^= 2; 1829| 212k| break; 1830| 158k| case 1: // a second, b first; if b < a, overlap ------------------ | Branch (1830:11): [True: 158k, False: 15.6M] ------------------ 1831| 158k| if (a < b) { // no overlap, take a ------------------ | Branch (1831:17): [True: 153k, False: 5.09k] ------------------ 1832| 153k| buffer[k++] = a; a = list[i++]; polarity ^= 1; 1833| 153k| } else if (b < a) { // OVERLAP, drop b ------------------ | Branch (1833:24): [True: 2.50k, False: 2.58k] ------------------ 1834| 2.50k| b = other[j++]; 1835| 2.50k| polarity ^= 2; 1836| 2.58k| } else { // a == b, drop both! 1837| 2.58k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 2.58k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1837:21): [True: 312, False: 2.27k] ------------------ 1838| 2.27k| a = list[i++]; 1839| 2.27k| polarity ^= 1; 1840| 2.27k| b = other[j++]; 1841| 2.27k| polarity ^= 2; 1842| 2.27k| } 1843| 157k| break; 1844| 7.09M| case 2: // a first, b second; if a < b, overlap ------------------ | Branch (1844:11): [True: 7.09M, False: 8.72M] ------------------ 1845| 7.09M| if (b < a) { // no overlap, take b ------------------ | Branch (1845:17): [True: 7.09M, False: 4.93k] ------------------ 1846| 7.09M| buffer[k++] = b; 1847| 7.09M| b = other[j++]; 1848| 7.09M| polarity ^= 2; 1849| 7.09M| } else if (a < b) { // OVERLAP, drop a ------------------ | Branch (1849:25): [True: 2.18k, False: 2.74k] ------------------ 1850| 2.18k| a = list[i++]; 1851| 2.18k| polarity ^= 1; 1852| 2.74k| } else { // a == b, drop both! 1853| 2.74k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 2.74k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1853:21): [True: 564, False: 2.18k] ------------------ 1854| 2.18k| a = list[i++]; 1855| 2.18k| polarity ^= 1; 1856| 2.18k| b = other[j++]; 1857| 2.18k| polarity ^= 2; 1858| 2.18k| } 1859| 7.09M| break; 1860| 15.8M| } 1861| 15.8M| } 1862| 892k| loop_end: 1863| 892k| buffer[k++] = UNICODESET_HIGH; // terminate ------------------ | | 34| 892k|#define UNICODESET_HIGH 0x0110000 ------------------ 1864| 892k| len = k; 1865| 892k| swapBuffers(); 1866| 892k| releasePattern(); 1867| 892k|} _ZN6icu_7810UnicodeSet6retainEPKiia: 1874| 9.44k|void UnicodeSet::retain(const UChar32* other, int32_t otherLen, int8_t polarity) { 1875| 9.44k| if (isFrozen() || isBogus()) { ------------------ | Branch (1875:9): [True: 0, False: 9.44k] | Branch (1875:23): [True: 0, False: 9.44k] ------------------ 1876| 0| return; 1877| 0| } 1878| 9.44k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1878:9): [True: 0, False: 9.44k] ------------------ 1879| 0| return; 1880| 0| } 1881| | 1882| 9.44k| int32_t i = 0, j = 0, k = 0; 1883| 9.44k| UChar32 a = list[i++]; 1884| 9.44k| UChar32 b = other[j++]; 1885| | // change from xor is that we have to check overlapping pairs 1886| | // polarity bit 1 means a is second, bit 2 means b is. 1887| 2.05M| for (;;) { 1888| 2.05M| switch (polarity) { ------------------ | Branch (1888:17): [True: 0, False: 2.05M] ------------------ 1889| 27.6k| case 0: // both first; drop the smaller ------------------ | Branch (1889:11): [True: 27.6k, False: 2.02M] ------------------ 1890| 27.6k| if (a < b) { // drop a ------------------ | Branch (1890:17): [True: 4.82k, False: 22.8k] ------------------ 1891| 4.82k| a = list[i++]; 1892| 4.82k| polarity ^= 1; 1893| 22.8k| } else if (b < a) { // drop b ------------------ | Branch (1893:24): [True: 14.2k, False: 8.58k] ------------------ 1894| 14.2k| b = other[j++]; 1895| 14.2k| polarity ^= 2; 1896| 14.2k| } else { // a == b, take one, drop other 1897| 8.58k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 8.58k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1897:21): [True: 711, False: 7.87k] ------------------ 1898| 7.87k| buffer[k++] = a; 1899| 7.87k| a = list[i++]; 1900| 7.87k| polarity ^= 1; 1901| 7.87k| b = other[j++]; 1902| 7.87k| polarity ^= 2; 1903| 7.87k| } 1904| 26.9k| break; 1905| 991k| case 3: // both second; take lower if unequal ------------------ | Branch (1905:11): [True: 991k, False: 1.06M] ------------------ 1906| 991k| if (a < b) { // take a ------------------ | Branch (1906:17): [True: 974k, False: 17.0k] ------------------ 1907| 974k| buffer[k++] = a; 1908| 974k| a = list[i++]; 1909| 974k| polarity ^= 1; 1910| 974k| } else if (b < a) { // take b ------------------ | Branch (1910:24): [True: 8.91k, False: 8.17k] ------------------ 1911| 8.91k| buffer[k++] = b; 1912| 8.91k| b = other[j++]; 1913| 8.91k| polarity ^= 2; 1914| 8.91k| } else { // a == b, take one, drop other 1915| 8.17k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 8.17k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1915:21): [True: 149, False: 8.02k] ------------------ 1916| 8.02k| buffer[k++] = a; 1917| 8.02k| a = list[i++]; 1918| 8.02k| polarity ^= 1; 1919| 8.02k| b = other[j++]; 1920| 8.02k| polarity ^= 2; 1921| 8.02k| } 1922| 991k| break; 1923| 991k| case 1: // a second, b first; ------------------ | Branch (1923:11): [True: 26.0k, False: 2.02M] ------------------ 1924| 26.0k| if (a < b) { // NO OVERLAP, drop a ------------------ | Branch (1924:17): [True: 4.69k, False: 21.3k] ------------------ 1925| 4.69k| a = list[i++]; 1926| 4.69k| polarity ^= 1; 1927| 21.3k| } else if (b < a) { // OVERLAP, take b ------------------ | Branch (1927:24): [True: 8.57k, False: 12.7k] ------------------ 1928| 8.57k| buffer[k++] = b; 1929| 8.57k| b = other[j++]; 1930| 8.57k| polarity ^= 2; 1931| 12.7k| } else { // a == b, drop both! 1932| 12.7k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 12.7k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1932:21): [True: 167, False: 12.6k] ------------------ 1933| 12.6k| a = list[i++]; 1934| 12.6k| polarity ^= 1; 1935| 12.6k| b = other[j++]; 1936| 12.6k| polarity ^= 2; 1937| 12.6k| } 1938| 25.8k| break; 1939| 1.01M| case 2: // a first, b second; if a < b, overlap ------------------ | Branch (1939:11): [True: 1.01M, False: 1.04M] ------------------ 1940| 1.01M| if (b < a) { // no overlap, drop b ------------------ | Branch (1940:17): [True: 13.9k, False: 996k] ------------------ 1941| 13.9k| b = other[j++]; 1942| 13.9k| polarity ^= 2; 1943| 996k| } else if (a < b) { // OVERLAP, take a ------------------ | Branch (1943:25): [True: 975k, False: 20.7k] ------------------ 1944| 975k| buffer[k++] = a; 1945| 975k| a = list[i++]; 1946| 975k| polarity ^= 1; 1947| 975k| } else { // a == b, drop both! 1948| 20.7k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 20.7k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1948:21): [True: 8.41k, False: 12.3k] ------------------ 1949| 12.3k| a = list[i++]; 1950| 12.3k| polarity ^= 1; 1951| 12.3k| b = other[j++]; 1952| 12.3k| polarity ^= 2; 1953| 12.3k| } 1954| 1.00M| break; 1955| 2.05M| } 1956| 2.05M| } 1957| 9.44k| loop_end: 1958| 9.44k| buffer[k++] = UNICODESET_HIGH; // terminate ------------------ | | 34| 9.44k|#define UNICODESET_HIGH 0x0110000 ------------------ 1959| 9.44k| len = k; 1960| 9.44k| swapBuffers(); 1961| 9.44k| releasePattern(); 1962| 9.44k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringERKS1_a: 1968| 6.07k|void UnicodeSet::_appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable) { 1969| 6.07k| UChar32 cp; 1970| 46.2k| for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 40.1k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 39.9k, False: 222] | | ------------------ ------------------ | Branch (1970:25): [True: 40.1k, False: 6.07k] ------------------ 1971| 40.1k| _appendToPat(buf, cp = s.char32At(i), escapeUnprintable); 1972| 40.1k| } 1973| 6.07k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringEia: 1979| 233k|void UnicodeSet::_appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable) { 1980| 233k| if (escapeUnprintable ? ICU_Utility::isUnprintable(c) : ICU_Utility::shouldAlwaysBeEscaped(c)) { ------------------ | Branch (1980:9): [True: 0, False: 233k] | Branch (1980:9): [True: 30.0k, False: 203k] ------------------ 1981| | // Use hex escape notation (\uxxxx or \Uxxxxxxxx) for anything 1982| | // unprintable 1983| 30.0k| ICU_Utility::escape(buf, c); 1984| 30.0k| return; 1985| 30.0k| } 1986| | // Okay to let ':' pass through 1987| 203k| switch (c) { 1988| 524| case u'[': ------------------ | Branch (1988:5): [True: 524, False: 203k] ------------------ 1989| 1.32k| case u']': ------------------ | Branch (1989:5): [True: 805, False: 202k] ------------------ 1990| 1.76k| case u'-': ------------------ | Branch (1990:5): [True: 431, False: 203k] ------------------ 1991| 2.08k| case u'^': ------------------ | Branch (1991:5): [True: 321, False: 203k] ------------------ 1992| 2.75k| case u'&': ------------------ | Branch (1992:5): [True: 672, False: 203k] ------------------ 1993| 3.35k| case u'\\': ------------------ | Branch (1993:5): [True: 606, False: 203k] ------------------ 1994| 4.72k| case u'{': ------------------ | Branch (1994:5): [True: 1.36k, False: 202k] ------------------ 1995| 6.89k| case u'}': ------------------ | Branch (1995:5): [True: 2.17k, False: 201k] ------------------ 1996| 7.18k| case u':': ------------------ | Branch (1996:5): [True: 289, False: 203k] ------------------ 1997| 7.45k| case SymbolTable::SYMBOL_REF: ------------------ | Branch (1997:5): [True: 271, False: 203k] ------------------ 1998| 7.45k| buf.append(u'\\'); 1999| 7.45k| break; 2000| 196k| default: ------------------ | Branch (2000:5): [True: 196k, False: 7.45k] ------------------ 2001| | // Escape whitespace 2002| 196k| if (PatternProps::isWhiteSpace(c)) { ------------------ | Branch (2002:13): [True: 19, False: 196k] ------------------ 2003| 19| buf.append(u'\\'); 2004| 19| } 2005| 196k| break; 2006| 203k| } 2007| 203k| buf.append(c); 2008| 203k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringEiia: 2011| 50.1k| UBool escapeUnprintable) { 2012| 50.1k| _appendToPat(result, start, escapeUnprintable); 2013| 50.1k| if (start != end) { ------------------ | Branch (2013:9): [True: 13.2k, False: 36.8k] ------------------ 2014| 13.2k| if ((start+1) != end || ------------------ | Branch (2014:13): [True: 6.04k, False: 7.18k] ------------------ 2015| | // Avoid writing what looks like a lead+trail surrogate pair. 2016| 13.2k| start == 0xdbff) { ------------------ | Branch (2016:17): [True: 24, False: 7.16k] ------------------ 2017| 6.07k| result.append(u'-'); 2018| 6.07k| } 2019| 13.2k| _appendToPat(result, end, escapeUnprintable); 2020| 13.2k| } 2021| 50.1k|} _ZNK6icu_7810UnicodeSet16_generatePatternERNS_13UnicodeStringEa: 2082| 5.15k|{ 2083| 5.15k| result.append(u'['); 2084| | 2085| 5.15k| int32_t i = 0; 2086| 5.15k| int32_t limit = len & ~1; // = 2 * getRangeCount() 2087| | 2088| | // If the set contains at least 2 intervals and includes both 2089| | // MIN_VALUE and MAX_VALUE, then the inverse representation will 2090| | // be more economical. 2091| | // if (getRangeCount() >= 2 && 2092| | // getRangeStart(0) == MIN_VALUE && 2093| | // getRangeEnd(last) == MAX_VALUE) 2094| | // Invariant: list[len-1] == HIGH == MAX_VALUE + 1 2095| | // If limit == len then len is even and the last range ends with MAX_VALUE. 2096| | // 2097| | // *But* do not write the inverse (complement) if there are strings. 2098| | // Since ICU 70, the '^' performs a code point complement which removes all strings. 2099| 5.15k| if (len >= 4 && list[0] == 0 && limit == len && !hasStrings()) { ------------------ | Branch (2099:9): [True: 2.81k, False: 2.34k] | Branch (2099:21): [True: 1.17k, False: 1.63k] | Branch (2099:37): [True: 449, False: 728] | Branch (2099:53): [True: 439, False: 10] ------------------ 2100| | // Emit the inverse 2101| 439| result.append(u'^'); 2102| | // Offsetting the inversion list index by one lets us 2103| | // iterate over the ranges of the set complement. 2104| 439| i = 1; 2105| 439| --limit; 2106| 439| } 2107| | 2108| | // Emit the ranges as pairs. 2109| 54.7k| while (i < limit) { ------------------ | Branch (2109:12): [True: 49.6k, False: 5.15k] ------------------ 2110| 49.6k| UChar32 start = list[i]; // getRangeStart() 2111| 49.6k| UChar32 end = list[i + 1] - 1; // getRangeEnd() = range limit minus one 2112| 49.6k| if (!(0xd800 <= end && end <= 0xdbff)) { ------------------ | Branch (2112:15): [True: 4.25k, False: 45.3k] | Branch (2112:32): [True: 299, False: 3.96k] ------------------ 2113| 49.3k| _appendToPat(result, start, end, escapeUnprintable); 2114| 49.3k| i += 2; 2115| 49.3k| } else { 2116| | // The range ends with a lead surrogate. 2117| | // Avoid writing what looks like a lead+trail surrogate pair. 2118| | // 1. Postpone ranges that start with a lead surrogate code point. 2119| 299| int32_t firstLead = i; 2120| 499| while ((i += 2) < limit && list[i] <= 0xdbff) {} ------------------ | Branch (2120:20): [True: 427, False: 72] | Branch (2120:40): [True: 200, False: 227] ------------------ 2121| 299| int32_t firstAfterLead = i; 2122| | // 2. Write following ranges that start with a trail surrogate code point. 2123| 578| while (i < limit && (start = list[i]) <= 0xdfff) { ------------------ | Branch (2123:20): [True: 412, False: 166] | Branch (2123:33): [True: 279, False: 133] ------------------ 2124| 279| _appendToPat(result, start, list[i + 1] - 1, escapeUnprintable); 2125| 279| i += 2; 2126| 279| } 2127| | // 3. Now write the postponed ranges. 2128| 798| for (int j = firstLead; j < firstAfterLead; j += 2) { ------------------ | Branch (2128:37): [True: 499, False: 299] ------------------ 2129| 499| _appendToPat(result, list[j], list[j + 1] - 1, escapeUnprintable); 2130| 499| } 2131| 299| } 2132| 49.6k| } 2133| | 2134| 5.15k| if (strings_ != nullptr) { ------------------ | Branch (2134:9): [True: 1.05k, False: 4.09k] ------------------ 2135| 2.76k| for (int32_t i = 0; isize(); ++i) { ------------------ | Branch (2135:29): [True: 1.71k, False: 1.05k] ------------------ 2136| 1.71k| result.append(u'{'); 2137| 1.71k| _appendToPat(result, 2138| 1.71k| *static_cast(strings_->elementAt(i)), 2139| 1.71k| escapeUnprintable); 2140| 1.71k| result.append(u'}'); 2141| 1.71k| } 2142| 1.05k| } 2143| 5.15k| return result.append(u']'); 2144| 5.15k|} _ZN6icu_7810UnicodeSet14releasePatternEv: 2149| 41.6M|void UnicodeSet::releasePattern() { 2150| 41.6M| if (pat) { ------------------ | Branch (2150:9): [True: 9.16k, False: 41.6M] ------------------ 2151| 9.16k| uprv_free(pat); ------------------ | | 1503| 9.16k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 9.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2152| 9.16k| pat = nullptr; 2153| 9.16k| patLen = 0; 2154| 9.16k| } 2155| 41.6M|} _ZN6icu_7810UnicodeSet10setPatternEPKDsi: 2160| 9.16k|void UnicodeSet::setPattern(const char16_t *newPat, int32_t newPatLen) { 2161| 9.16k| releasePattern(); 2162| 9.16k| pat = static_cast(uprv_malloc((newPatLen + 1) * sizeof(char16_t))); ------------------ | | 1524| 9.16k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 9.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2163| 9.16k| if (pat) { ------------------ | Branch (2163:9): [True: 9.16k, False: 0] ------------------ 2164| 9.16k| patLen = newPatLen; 2165| 9.16k| u_memcpy(pat, newPat, patLen); ------------------ | | 334| 9.16k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 9.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2166| 9.16k| pat[patLen] = 0; 2167| 9.16k| } 2168| | // else we don't care if malloc failed. This was just a nice cache. 2169| | // We can regenerate an equivalent pattern later when requested. 2170| 9.16k|} _ZN6icu_7810UnicodeSet6freezeEv: 2172| 3.93k|UnicodeSet *UnicodeSet::freeze() { 2173| 3.93k| if(!isFrozen() && !isBogus()) { ------------------ | Branch (2173:8): [True: 3.93k, False: 0] | Branch (2173:23): [True: 3.93k, False: 0] ------------------ 2174| 3.93k| compact(); 2175| | 2176| | // Optimize contains() and span() and similar functions. 2177| 3.93k| if (hasStrings()) { ------------------ | Branch (2177:13): [True: 0, False: 3.93k] ------------------ 2178| 0| stringSpan = new UnicodeSetStringSpan(*this, *strings_, UnicodeSetStringSpan::ALL); 2179| 0| if (stringSpan == nullptr) { ------------------ | Branch (2179:17): [True: 0, False: 0] ------------------ 2180| 0| setToBogus(); 2181| 0| return this; 2182| 0| } else if (!stringSpan->needsStringSpanUTF16()) { ------------------ | Branch (2182:24): [True: 0, False: 0] ------------------ 2183| | // All strings are irrelevant for span() etc. because 2184| | // all of each string's code points are contained in this set. 2185| | // Do not check needsStringSpanUTF8() because UTF-8 has at most as 2186| | // many relevant strings as UTF-16. 2187| | // (Thus needsStringSpanUTF8() implies needsStringSpanUTF16().) 2188| 0| delete stringSpan; 2189| 0| stringSpan = nullptr; 2190| 0| } 2191| 0| } 2192| 3.93k| if (stringSpan == nullptr) { ------------------ | Branch (2192:13): [True: 3.93k, False: 0] ------------------ 2193| | // No span-relevant strings: Optimize for code point spans. 2194| 3.93k| bmpSet=new BMPSet(list, len); 2195| 3.93k| if (bmpSet == nullptr) { // Check for memory allocation error. ------------------ | Branch (2195:17): [True: 0, False: 3.93k] ------------------ 2196| 0| setToBogus(); 2197| 0| } 2198| 3.93k| } 2199| 3.93k| } 2200| 3.93k| return this; 2201| 3.93k|} uniset.cpp:_ZN6icu_78L12pinCodePointERi: 54| 43.3M|static inline UChar32 pinCodePoint(UChar32& c) { 55| 43.3M| if (c < UNICODESET_LOW) { ------------------ | | 37| 43.3M|#define UNICODESET_LOW 0x000000 ------------------ | Branch (55:9): [True: 0, False: 43.3M] ------------------ 56| 0| c = UNICODESET_LOW; ------------------ | | 37| 0|#define UNICODESET_LOW 0x000000 ------------------ 57| 43.3M| } else if (c > (UNICODESET_HIGH-1)) { ------------------ | | 34| 43.3M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (57:16): [True: 0, False: 43.3M] ------------------ 58| 0| c = (UNICODESET_HIGH-1); ------------------ | | 34| 0|#define UNICODESET_HIGH 0x0110000 ------------------ 59| 0| } 60| 43.3M| return c; 61| 43.3M|} uniset.cpp:_ZN6icu_78L20compareUnicodeStringE8UElementS0_: 114| 1.69M|static int32_t U_CALLCONV compareUnicodeString(UElement t1, UElement t2) { 115| 1.69M| const UnicodeString& a = *static_cast(t1.pointer); 116| 1.69M| const UnicodeString& b = *static_cast(t2.pointer); 117| 1.69M| return a.compare(b); 118| 1.69M|} uniset.cpp:_ZN6icu_78L3maxEii: 1708| 28.8k|static inline UChar32 max(UChar32 a, UChar32 b) { 1709| 28.8k| return (a > b) ? a : b; ------------------ | Branch (1709:12): [True: 1.66k, False: 27.1k] ------------------ 1710| 28.8k|} _ZN6icu_7810UnicodeSetC2ERKNS_13UnicodeStringER10UErrorCode: 156| 7.89k| UErrorCode& status) { 157| 7.89k| applyPattern(pattern, status); 158| 7.89k| _dbgct(this); 159| 7.89k|} _ZN6icu_7810UnicodeSet12applyPatternERKNS_13UnicodeStringER10UErrorCode: 166| 9.92k| UErrorCode& status) { 167| | // Equivalent to 168| | // return applyPattern(pattern, USET_IGNORE_SPACE, nullptr, status); 169| | // but without dependency on closeOver(). 170| 9.92k| ParsePosition pos(0); 171| 9.92k| applyPatternIgnoreSpace(pattern, pos, nullptr, status); 172| 9.92k| if (U_FAILURE(status)) return *this; ------------------ | Branch (172:9): [True: 767, False: 9.16k] ------------------ 173| | 174| 9.16k| int32_t i = pos.getIndex(); 175| | // Skip over trailing whitespace 176| 9.16k| ICU_Utility::skipWhitespace(pattern, i, true); 177| 9.16k| if (i != pattern.length()) { ------------------ | Branch (177:9): [True: 14, False: 9.14k] ------------------ 178| 14| status = U_ILLEGAL_ARGUMENT_ERROR; 179| 14| } 180| 9.16k| return *this; 181| 9.92k|} _ZN6icu_7810UnicodeSet23applyPatternIgnoreSpaceERKNS_13UnicodeStringERNS_13ParsePositionEPKNS_11SymbolTableER10UErrorCode: 187| 9.92k| UErrorCode& status) { 188| 9.92k| if (U_FAILURE(status)) { ------------------ | Branch (188:9): [True: 134, False: 9.79k] ------------------ 189| 134| return; 190| 134| } 191| 9.79k| if (isFrozen()) { ------------------ | Branch (191:9): [True: 0, False: 9.79k] ------------------ 192| 0| status = U_NO_WRITE_PERMISSION; 193| 0| return; 194| 0| } 195| | // Need to build the pattern in a temporary string because 196| | // _applyPattern calls add() etc., which set pat to empty. 197| 9.79k| UnicodeString rebuiltPat; 198| 9.79k| RuleCharacterIterator chars(pattern, symbols, pos); 199| 9.79k| applyPattern(chars, symbols, rebuiltPat, USET_IGNORE_SPACE, nullptr, 0, status); 200| 9.79k| if (U_FAILURE(status)) return; ------------------ | Branch (200:9): [True: 633, False: 9.16k] ------------------ 201| 9.16k| if (chars.inVariable()) { ------------------ | Branch (201:9): [True: 0, False: 9.16k] ------------------ 202| | // syntaxError(chars, "Extra chars in variable value"); 203| 0| status = U_MALFORMED_SET; 204| 0| return; 205| 0| } 206| 9.16k| setPattern(rebuiltPat); 207| 9.16k|} _ZN6icu_7810UnicodeSet12applyPatternERNS_21RuleCharacterIteratorEPKNS_11SymbolTableERNS_13UnicodeStringEjMS0_FRS0_iEiR10UErrorCode: 267| 16.5k| UErrorCode& ec) { 268| 16.5k| if (U_FAILURE(ec)) return; ------------------ | Branch (268:9): [True: 0, False: 16.5k] ------------------ 269| 16.5k| if (depth > MAX_DEPTH) { ------------------ | Branch (269:9): [True: 1, False: 16.5k] ------------------ 270| 1| ec = U_ILLEGAL_ARGUMENT_ERROR; 271| 1| return; 272| 1| } 273| | 274| | // Syntax characters: [ ] ^ - & { } 275| | 276| | // Recognized special forms for chars, sets: c-c s-s s&s 277| | 278| 16.5k| int32_t opts = RuleCharacterIterator::PARSE_VARIABLES | 279| 16.5k| RuleCharacterIterator::PARSE_ESCAPES; 280| 16.5k| if ((options & USET_IGNORE_SPACE) != 0) { ------------------ | Branch (280:9): [True: 16.5k, False: 0] ------------------ 281| 16.5k| opts |= RuleCharacterIterator::SKIP_WHITESPACE; 282| 16.5k| } 283| | 284| 16.5k| UnicodeString patLocal, buf; 285| 16.5k| UBool usePat = false; 286| 16.5k| UnicodeSetPointer scratch; 287| 16.5k| RuleCharacterIterator::Pos backup; 288| | 289| | // mode: 0=before [, 1=between [...], 2=after ] 290| | // lastItem: 0=none, 1=char, 2=set 291| 16.5k| int8_t lastItem = 0, mode = 0; 292| 16.5k| UChar32 lastChar = 0; 293| 16.5k| char16_t op = 0; 294| | 295| 16.5k| UBool invert = false; 296| | 297| 16.5k| clear(); 298| | 299| 189k| while (mode != 2 && !chars.atEnd()) { ------------------ | Branch (299:12): [True: 182k, False: 7.30k] | Branch (299:25): [True: 181k, False: 410] ------------------ 300| 181k| U_ASSERT((lastItem == 0 && op == 0) || ------------------ | | 35| 181k|# define U_ASSERT(exp) (void)0 ------------------ 301| 181k| (lastItem == 1 && (op == 0 || op == u'-')) || 302| 181k| (lastItem == 2 && (op == 0 || op == u'-' || op == u'&'))); 303| | 304| 181k| UChar32 c = 0; 305| 181k| UBool literal = false; 306| 181k| UnicodeSet* nested = nullptr; // alias - do not delete 307| | 308| | // -------- Check for property pattern 309| | 310| | // setMode: 0=none, 1=unicodeset, 2=propertypat, 3=preparsed 311| 181k| int8_t setMode = 0; 312| 181k| if (resemblesPropertyPattern(chars, opts)) { ------------------ | Branch (312:13): [True: 12.9k, False: 169k] ------------------ 313| 12.9k| setMode = 2; 314| 12.9k| } 315| | 316| | // -------- Parse '[' of opening delimiter OR nested set. 317| | // If there is a nested set, use `setMode' to define how 318| | // the set should be parsed. If the '[' is part of the 319| | // opening delimiter for this pattern, parse special 320| | // strings "[", "[^", "[-", and "[^-". Check for stand-in 321| | // characters representing a nested set in the symbol 322| | // table. 323| | 324| 169k| else { 325| | // Prepare to backup if necessary 326| 169k| chars.getPos(backup); 327| 169k| c = chars.next(opts, literal, ec); 328| 169k| if (U_FAILURE(ec)) return; ------------------ | Branch (328:17): [True: 270, False: 168k] ------------------ 329| | 330| 168k| if (c == u'[' && !literal) { ------------------ | Branch (330:17): [True: 15.3k, False: 153k] | Branch (330:30): [True: 15.3k, False: 11] ------------------ 331| 15.3k| if (mode == 1) { ------------------ | Branch (331:21): [True: 6.72k, False: 8.60k] ------------------ 332| 6.72k| chars.setPos(backup); // backup 333| 6.72k| setMode = 1; 334| 8.60k| } else { 335| | // Handle opening '[' delimiter 336| 8.60k| mode = 1; 337| 8.60k| patLocal.append(u'['); 338| 8.60k| chars.getPos(backup); // prepare to backup 339| 8.60k| c = chars.next(opts, literal, ec); 340| 8.60k| if (U_FAILURE(ec)) return; ------------------ | Branch (340:25): [True: 8, False: 8.59k] ------------------ 341| 8.59k| if (c == u'^' && !literal) { ------------------ | Branch (341:25): [True: 1.38k, False: 7.21k] | Branch (341:38): [True: 1.36k, False: 17] ------------------ 342| 1.36k| invert = true; 343| 1.36k| patLocal.append(u'^'); 344| 1.36k| chars.getPos(backup); // prepare to backup 345| 1.36k| c = chars.next(opts, literal, ec); 346| 1.36k| if (U_FAILURE(ec)) return; ------------------ | Branch (346:29): [True: 1, False: 1.36k] ------------------ 347| 1.36k| } 348| | // Fall through to handle special leading '-'; 349| | // otherwise restart loop for nested [], \p{}, etc. 350| 8.59k| if (c == u'-') { ------------------ | Branch (350:25): [True: 53, False: 8.54k] ------------------ 351| 53| literal = true; 352| | // Fall through to handle literal '-' below 353| 8.54k| } else { 354| 8.54k| chars.setPos(backup); // backup 355| 8.54k| continue; 356| 8.54k| } 357| 8.59k| } 358| 153k| } else if (symbols != nullptr) { ------------------ | Branch (358:24): [True: 0, False: 153k] ------------------ 359| 0| const UnicodeFunctor *m = symbols->lookupMatcher(c); 360| 0| if (m != nullptr) { ------------------ | Branch (360:21): [True: 0, False: 0] ------------------ 361| 0| const UnicodeSet *ms = dynamic_cast(m); 362| 0| if (ms == nullptr) { ------------------ | Branch (362:25): [True: 0, False: 0] ------------------ 363| 0| ec = U_MALFORMED_SET; 364| 0| return; 365| 0| } 366| | // casting away const, but `nested' won't be modified 367| | // (important not to modify stored set) 368| 0| nested = const_cast(ms); 369| 0| setMode = 3; 370| 0| } 371| 0| } 372| 168k| } 373| | 374| | // -------- Handle a nested set. This either is inline in 375| | // the pattern or represented by a stand-in that has 376| | // previously been parsed and was looked up in the symbol 377| | // table. 378| | 379| 173k| if (setMode != 0) { ------------------ | Branch (379:13): [True: 19.6k, False: 153k] ------------------ 380| 19.6k| if (lastItem == 1) { ------------------ | Branch (380:17): [True: 6.50k, False: 13.1k] ------------------ 381| 6.50k| if (op != 0) { ------------------ | Branch (381:21): [True: 2, False: 6.50k] ------------------ 382| | // syntaxError(chars, "Char expected after operator"); 383| 2| ec = U_MALFORMED_SET; 384| 2| return; 385| 2| } 386| 6.50k| add(lastChar, lastChar); 387| 6.50k| _appendToPat(patLocal, lastChar, false); 388| 6.50k| lastItem = 0; 389| 6.50k| op = 0; 390| 6.50k| } 391| | 392| 19.6k| if (op == u'-' || op == u'&') { ------------------ | Branch (392:17): [True: 487, False: 19.1k] | Branch (392:31): [True: 1.05k, False: 18.1k] ------------------ 393| 1.53k| patLocal.append(op); 394| 1.53k| } 395| | 396| 19.6k| if (nested == nullptr) { ------------------ | Branch (396:17): [True: 19.6k, False: 0] ------------------ 397| | // lazy allocation 398| 19.6k| if (!scratch.allocate()) { ------------------ | Branch (398:21): [True: 0, False: 19.6k] ------------------ 399| 0| ec = U_MEMORY_ALLOCATION_ERROR; 400| 0| return; 401| 0| } 402| 19.6k| nested = scratch.pointer(); 403| 19.6k| } 404| 19.6k| switch (setMode) { ------------------ | Branch (404:21): [True: 0, False: 19.6k] ------------------ 405| 6.72k| case 1: ------------------ | Branch (405:13): [True: 6.72k, False: 12.9k] ------------------ 406| 6.72k| nested->applyPattern(chars, symbols, patLocal, options, caseClosure, depth + 1, ec); 407| 6.72k| break; 408| 12.9k| case 2: ------------------ | Branch (408:13): [True: 12.9k, False: 6.72k] ------------------ 409| 12.9k| chars.skipIgnored(opts); 410| 12.9k| nested->applyPropertyPattern(chars, patLocal, ec); 411| 12.9k| if (U_FAILURE(ec)) return; ------------------ | Branch (411:21): [True: 451, False: 12.4k] ------------------ 412| 12.4k| break; 413| 12.4k| case 3: // `nested' already parsed ------------------ | Branch (413:13): [True: 0, False: 19.6k] ------------------ 414| 0| nested->_toPattern(patLocal, false); 415| 0| break; 416| 19.6k| } 417| | 418| 19.1k| usePat = true; 419| | 420| 19.1k| if (mode == 0) { ------------------ | Branch (420:17): [True: 7.86k, False: 11.3k] ------------------ 421| | // Entire pattern is a category; leave parse loop 422| 7.86k| *this = *nested; 423| 7.86k| mode = 2; 424| 7.86k| break; 425| 7.86k| } 426| | 427| 11.3k| switch (op) { ------------------ | Branch (427:21): [True: 0, False: 11.3k] ------------------ 428| 486| case u'-': ------------------ | Branch (428:13): [True: 486, False: 10.8k] ------------------ 429| 486| removeAll(*nested); 430| 486| break; 431| 1.05k| case u'&': ------------------ | Branch (431:13): [True: 1.05k, False: 10.2k] ------------------ 432| 1.05k| retainAll(*nested); 433| 1.05k| break; 434| 9.79k| case 0: ------------------ | Branch (434:13): [True: 9.79k, False: 1.53k] ------------------ 435| 9.79k| addAll(*nested); 436| 9.79k| break; 437| 11.3k| } 438| | 439| 11.3k| op = 0; 440| 11.3k| lastItem = 2; 441| | 442| 11.3k| continue; 443| 11.3k| } 444| | 445| 153k| if (mode == 0) { ------------------ | Branch (445:13): [True: 0, False: 153k] ------------------ 446| | // syntaxError(chars, "Missing '['"); 447| 0| ec = U_MALFORMED_SET; 448| 0| return; 449| 0| } 450| | 451| | // -------- Parse special (syntax) characters. If the 452| | // current character is not special, or if it is escaped, 453| | // then fall through and handle it below. 454| | 455| 153k| if (!literal) { ------------------ | Branch (455:13): [True: 149k, False: 3.99k] ------------------ 456| 149k| switch (c) { 457| 6.86k| case u']': ------------------ | Branch (457:13): [True: 6.86k, False: 142k] ------------------ 458| 6.86k| if (lastItem == 1) { ------------------ | Branch (458:21): [True: 4.17k, False: 2.69k] ------------------ 459| 4.17k| add(lastChar, lastChar); 460| 4.17k| _appendToPat(patLocal, lastChar, false); 461| 4.17k| } 462| | // Treat final trailing '-' as a literal 463| 6.86k| if (op == u'-') { ------------------ | Branch (463:21): [True: 77, False: 6.78k] ------------------ 464| 77| add(op, op); 465| 77| patLocal.append(op); 466| 6.78k| } else if (op == u'&') { ------------------ | Branch (466:28): [True: 16, False: 6.77k] ------------------ 467| | // syntaxError(chars, "Trailing '&'"); 468| 16| ec = U_MALFORMED_SET; 469| 16| return; 470| 16| } 471| 6.84k| patLocal.append(u']'); 472| 6.84k| mode = 2; 473| 6.84k| continue; 474| 10.1k| case u'-': ------------------ | Branch (474:13): [True: 10.1k, False: 139k] ------------------ 475| 10.1k| if (op == 0) { ------------------ | Branch (475:21): [True: 10.1k, False: 1] ------------------ 476| 10.1k| if (lastItem != 0) { ------------------ | Branch (476:25): [True: 10.0k, False: 16] ------------------ 477| 10.0k| op = static_cast(c); 478| 10.0k| continue; 479| 10.0k| } else { 480| | // Treat final trailing '-' as a literal 481| 16| add(c, c); 482| 16| c = chars.next(opts, literal, ec); 483| 16| if (U_FAILURE(ec)) return; ------------------ | Branch (483:29): [True: 1, False: 15] ------------------ 484| 15| if (c == u']' && !literal) { ------------------ | Branch (484:29): [True: 12, False: 3] | Branch (484:42): [True: 11, False: 1] ------------------ 485| 11| patLocal.append(u"-]", 2); 486| 11| mode = 2; 487| 11| continue; 488| 11| } 489| 15| } 490| 10.1k| } 491| | // syntaxError(chars, "'-' not after char or set"); 492| 5| ec = U_MALFORMED_SET; 493| 5| return; 494| 1.11k| case u'&': ------------------ | Branch (494:13): [True: 1.11k, False: 148k] ------------------ 495| 1.11k| if (lastItem == 2 && op == 0) { ------------------ | Branch (495:21): [True: 1.08k, False: 23] | Branch (495:38): [True: 1.08k, False: 2] ------------------ 496| 1.08k| op = static_cast(c); 497| 1.08k| continue; 498| 1.08k| } 499| | // syntaxError(chars, "'&' not after set"); 500| 25| ec = U_MALFORMED_SET; 501| 25| return; 502| 28| case u'^': ------------------ | Branch (502:13): [True: 28, False: 149k] ------------------ 503| | // syntaxError(chars, "'^' not after '['"); 504| 28| ec = U_MALFORMED_SET; 505| 28| return; 506| 4.45k| case u'{': ------------------ | Branch (506:13): [True: 4.45k, False: 145k] ------------------ 507| 4.45k| if (op != 0) { ------------------ | Branch (507:21): [True: 4, False: 4.45k] ------------------ 508| | // syntaxError(chars, "Missing operand after operator"); 509| 4| ec = U_MALFORMED_SET; 510| 4| return; 511| 4| } 512| 4.45k| if (lastItem == 1) { ------------------ | Branch (512:21): [True: 1.85k, False: 2.60k] ------------------ 513| 1.85k| add(lastChar, lastChar); 514| 1.85k| _appendToPat(patLocal, lastChar, false); 515| 1.85k| } 516| 4.45k| lastItem = 0; 517| 4.45k| buf.truncate(0); 518| 4.45k| { 519| 4.45k| UBool ok = false; 520| 31.1k| while (!chars.atEnd()) { ------------------ | Branch (520:28): [True: 31.0k, False: 90] ------------------ 521| 31.0k| c = chars.next(opts, literal, ec); 522| 31.0k| if (U_FAILURE(ec)) return; ------------------ | Branch (522:29): [True: 1, False: 31.0k] ------------------ 523| 31.0k| if (c == u'}' && !literal) { ------------------ | Branch (523:29): [True: 4.65k, False: 26.3k] | Branch (523:42): [True: 4.36k, False: 292] ------------------ 524| 4.36k| ok = true; 525| 4.36k| break; 526| 4.36k| } 527| 26.6k| buf.append(c); 528| 26.6k| } 529| 4.45k| if (!ok) { ------------------ | Branch (529:25): [True: 90, False: 4.36k] ------------------ 530| | // syntaxError(chars, "Invalid multicharacter string"); 531| 90| ec = U_MALFORMED_SET; 532| 90| return; 533| 90| } 534| 4.45k| } 535| | // We have new string. Add it to set and continue; 536| | // we don't need to drop through to the further 537| | // processing 538| 4.36k| add(buf); 539| 4.36k| patLocal.append(u'{'); 540| 4.36k| _appendToPat(patLocal, buf, false); 541| 4.36k| patLocal.append(u'}'); 542| 4.36k| continue; 543| 697| case SymbolTable::SYMBOL_REF: ------------------ | Branch (543:13): [True: 697, False: 148k] ------------------ 544| | // symbols nosymbols 545| | // [a-$] error error (ambiguous) 546| | // [a$] anchor anchor 547| | // [a-$x] var "x"* literal '$' 548| | // [a-$.] error literal '$' 549| | // *We won't get here in the case of var "x" 550| 697| { 551| 697| chars.getPos(backup); 552| 697| c = chars.next(opts, literal, ec); 553| 697| if (U_FAILURE(ec)) return; ------------------ | Branch (553:25): [True: 1, False: 696] ------------------ 554| 696| UBool anchor = (c == u']' && !literal); ------------------ | Branch (554:37): [True: 443, False: 253] | Branch (554:50): [True: 443, False: 0] ------------------ 555| 696| if (symbols == nullptr && !anchor) { ------------------ | Branch (555:25): [True: 696, False: 0] | Branch (555:47): [True: 253, False: 443] ------------------ 556| 253| c = SymbolTable::SYMBOL_REF; 557| 253| chars.setPos(backup); 558| 253| break; // literal '$' 559| 253| } 560| 443| if (anchor && op == 0) { ------------------ | Branch (560:25): [True: 443, False: 0] | Branch (560:35): [True: 442, False: 1] ------------------ 561| 442| if (lastItem == 1) { ------------------ | Branch (561:29): [True: 49, False: 393] ------------------ 562| 49| add(lastChar, lastChar); 563| 49| _appendToPat(patLocal, lastChar, false); 564| 49| } 565| 442| add(U_ETHER); ------------------ | | 37| 442|#define U_ETHER ((char16_t)0xFFFF) ------------------ 566| 442| usePat = true; 567| 442| patLocal.append(static_cast(SymbolTable::SYMBOL_REF)); 568| 442| patLocal.append(u']'); 569| 442| mode = 2; 570| 442| continue; 571| 442| } 572| | // syntaxError(chars, "Unquoted '$'"); 573| 1| ec = U_MALFORMED_SET; 574| 1| return; 575| 443| } 576| 126k| default: ------------------ | Branch (576:13): [True: 126k, False: 23.2k] ------------------ 577| 126k| break; 578| 149k| } 579| 149k| } 580| | 581| | // -------- Parse literal characters. This includes both 582| | // escaped chars ("\u4E01") and non-syntax characters 583| | // ("a"). 584| | 585| 130k| switch (lastItem) { ------------------ | Branch (585:17): [True: 0, False: 130k] ------------------ 586| 16.3k| case 0: ------------------ | Branch (586:9): [True: 16.3k, False: 114k] ------------------ 587| 16.3k| lastItem = 1; 588| 16.3k| lastChar = c; 589| 16.3k| break; 590| 108k| case 1: ------------------ | Branch (590:9): [True: 108k, False: 22.2k] ------------------ 591| 108k| if (op == u'-') { ------------------ | Branch (591:17): [True: 9.51k, False: 98.7k] ------------------ 592| 9.51k| if (lastChar >= c) { ------------------ | Branch (592:21): [True: 15, False: 9.49k] ------------------ 593| | // Don't allow redundant (a-a) or empty (b-a) ranges; 594| | // these are most likely typos. 595| | // syntaxError(chars, "Invalid range"); 596| 15| ec = U_MALFORMED_SET; 597| 15| return; 598| 15| } 599| 9.49k| add(lastChar, c); 600| 9.49k| _appendToPat(patLocal, lastChar, false); 601| 9.49k| patLocal.append(op); 602| 9.49k| _appendToPat(patLocal, c, false); 603| 9.49k| lastItem = 0; 604| 9.49k| op = 0; 605| 98.7k| } else { 606| 98.7k| add(lastChar, lastChar); 607| 98.7k| _appendToPat(patLocal, lastChar, false); 608| 98.7k| lastChar = c; 609| 98.7k| } 610| 108k| break; 611| 108k| case 2: ------------------ | Branch (611:9): [True: 5.90k, False: 124k] ------------------ 612| 5.90k| if (op != 0) { ------------------ | Branch (612:17): [True: 27, False: 5.87k] ------------------ 613| | // syntaxError(chars, "Set expected after operator"); 614| 27| ec = U_MALFORMED_SET; 615| 27| return; 616| 27| } 617| 5.87k| lastChar = c; 618| 5.87k| lastItem = 1; 619| 5.87k| break; 620| 130k| } 621| 130k| } 622| | 623| 15.5k| if (mode != 2) { ------------------ | Branch (623:9): [True: 410, False: 15.1k] ------------------ 624| | // syntaxError(chars, "Missing ']'"); 625| 410| ec = U_MALFORMED_SET; 626| 410| return; 627| 410| } 628| | 629| 15.1k| chars.skipIgnored(opts); 630| | 631| | /** 632| | * Handle global flags (invert, case insensitivity). If this 633| | * pattern should be compiled case-insensitive, then we need 634| | * to close over case BEFORE COMPLEMENTING. This makes 635| | * patterns like /[^abc]/i work. 636| | */ 637| 15.1k| if ((options & USET_CASE_MASK) != 0) { ------------------ | Branch (637:9): [True: 0, False: 15.1k] ------------------ 638| 0| (this->*caseClosure)(options); 639| 0| } 640| 15.1k| if (invert) { ------------------ | Branch (640:9): [True: 1.29k, False: 13.8k] ------------------ 641| 1.29k| complement().removeAllStrings(); // code point complement 642| 1.29k| } 643| | 644| | // Use the rebuilt pattern (patLocal) only if necessary. Prefer the 645| | // generated pattern. 646| 15.1k| if (usePat) { ------------------ | Branch (646:9): [True: 10.0k, False: 5.15k] ------------------ 647| 10.0k| rebuiltPat.append(patLocal); 648| 10.0k| } else { 649| 5.15k| _generatePattern(rebuiltPat, false); 650| 5.15k| } 651| 15.1k| if (isBogus() && U_SUCCESS(ec)) { ------------------ | Branch (651:9): [True: 0, False: 15.1k] | Branch (651:22): [True: 0, False: 0] ------------------ 652| | // We likely ran out of memory. AHHH! 653| 0| ec = U_MEMORY_ALLOCATION_ERROR; 654| 0| } 655| 15.1k|} _ZN6icu_7810UnicodeSet11applyFilterEPFaiPvES1_PKS0_R10UErrorCode: 706| 10.2k| UErrorCode &status) { 707| 10.2k| if (U_FAILURE(status)) return; ------------------ | Branch (707:9): [True: 0, False: 10.2k] ------------------ 708| | 709| | // Logically, walk through all Unicode characters, noting the start 710| | // and end of each range for which filter.contain(c) is 711| | // true. Add each range to a set. 712| | // 713| | // To improve performance, use an inclusions set which 714| | // encodes information about character ranges that are known 715| | // to have identical properties. 716| | // inclusions contains the first characters of 717| | // same-value ranges for the given property. 718| | 719| 10.2k| clear(); 720| | 721| 10.2k| UChar32 startHasProperty = -1; 722| 10.2k| int32_t limitRange = inclusions->getRangeCount(); 723| | 724| 13.2M| for (int j=0; jgetRangeStart(j); 727| 13.2M| UChar32 end = inclusions->getRangeEnd(j); 728| | 729| | // for all the code points in the range, process 730| 51.7M| for (UChar32 ch = start; ch <= end; ++ch) { ------------------ | Branch (730:34): [True: 38.5M, False: 13.2M] ------------------ 731| | // only add to this UnicodeSet on inflection points -- 732| | // where the hasProperty value changes to false 733| 38.5M| if ((*filter)(ch, context)) { ------------------ | Branch (733:17): [True: 5.04M, False: 33.4M] ------------------ 734| 5.04M| if (startHasProperty < 0) { ------------------ | Branch (734:21): [True: 1.80M, False: 3.23M] ------------------ 735| 1.80M| startHasProperty = ch; 736| 1.80M| } 737| 33.4M| } else if (startHasProperty >= 0) { ------------------ | Branch (737:24): [True: 1.80M, False: 31.6M] ------------------ 738| 1.80M| add(startHasProperty, ch-1); 739| 1.80M| startHasProperty = -1; 740| 1.80M| } 741| 38.5M| } 742| 13.2M| } 743| 10.2k| if (startHasProperty >= 0) { ------------------ | Branch (743:9): [True: 191, False: 10.0k] ------------------ 744| 191| add(startHasProperty, static_cast(0x10FFFF)); 745| 191| } 746| 10.2k| if (isBogus() && U_SUCCESS(status)) { ------------------ | Branch (746:9): [True: 0, False: 10.2k] | Branch (746:22): [True: 0, False: 0] ------------------ 747| | // We likely ran out of memory. AHHH! 748| 0| status = U_MEMORY_ALLOCATION_ERROR; 749| 0| } 750| 10.2k|} _ZN6icu_7810UnicodeSet21applyIntPropertyValueE9UPropertyiR10UErrorCode: 783| 11.0k|UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode& ec) { 784| 11.0k| if (U_FAILURE(ec) || isFrozen()) { return *this; } ------------------ | Branch (784:9): [True: 0, False: 11.0k] | Branch (784:26): [True: 0, False: 11.0k] ------------------ 785| 11.0k| if (prop == UCHAR_GENERAL_CATEGORY_MASK) { ------------------ | Branch (785:9): [True: 5.93k, False: 5.07k] ------------------ 786| 5.93k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 787| 5.93k| applyFilter(generalCategoryMaskFilter, &value, inclusions, ec); 788| 5.93k| } else if (prop == UCHAR_SCRIPT_EXTENSIONS) { ------------------ | Branch (788:16): [True: 0, False: 5.07k] ------------------ 789| 0| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 790| 0| UScriptCode script = static_cast(value); 791| 0| applyFilter(scriptExtensionsFilter, &script, inclusions, ec); 792| 5.07k| } else if (prop == UCHAR_IDENTIFIER_TYPE) { ------------------ | Branch (792:16): [True: 0, False: 5.07k] ------------------ 793| 0| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 794| 0| UIdentifierType idType = static_cast(value); 795| 0| applyFilter(idTypeFilter, &idType, inclusions, ec); 796| 5.07k| } else if (0 <= prop && prop < UCHAR_BINARY_LIMIT) { ------------------ | Branch (796:16): [True: 5.07k, False: 0] | Branch (796:29): [True: 839, False: 4.23k] ------------------ 797| 839| if (value == 0 || value == 1) { ------------------ | Branch (797:13): [True: 56, False: 783] | Branch (797:27): [True: 783, False: 0] ------------------ 798| 839| const USet *set = u_getBinaryPropertySet(prop, &ec); ------------------ | | 269| 839|#define u_getBinaryPropertySet U_ICU_ENTRY_POINT_RENAME(u_getBinaryPropertySet) | | ------------------ | | | | 123| 839|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 839|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 839|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 799| 839| if (U_FAILURE(ec)) { return *this; } ------------------ | Branch (799:17): [True: 0, False: 839] ------------------ 800| 839| copyFrom(*UnicodeSet::fromUSet(set), true); 801| 839| if (value == 0) { ------------------ | Branch (801:17): [True: 56, False: 783] ------------------ 802| 56| complement().removeAllStrings(); // code point complement 803| 56| } 804| 839| } else { 805| 0| clear(); 806| 0| } 807| 4.23k| } else if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { ------------------ | Branch (807:16): [True: 4.23k, False: 0] | Branch (807:43): [True: 4.23k, False: 0] ------------------ 808| 4.23k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 809| 4.23k| IntPropertyContext c = {prop, value}; 810| 4.23k| applyFilter(intPropertyFilter, &c, inclusions, ec); 811| 4.23k| } else { 812| 0| ec = U_ILLEGAL_ARGUMENT_ERROR; 813| 0| } 814| 11.0k| return *this; 815| 11.0k|} _ZN6icu_7810UnicodeSet18applyPropertyAliasERKNS_13UnicodeStringES3_R10UErrorCode: 820| 12.7k| UErrorCode& ec) { 821| 12.7k| if (U_FAILURE(ec) || isFrozen()) return *this; ------------------ | Branch (821:9): [True: 0, False: 12.7k] | Branch (821:26): [True: 0, False: 12.7k] ------------------ 822| | 823| | // prop and value used to be converted to char * using the default 824| | // converter instead of the invariant conversion. 825| | // This should not be necessary because all Unicode property and value 826| | // names use only invariant characters. 827| | // If there are any variant characters, then we won't find them anyway. 828| | // Checking first avoids assertion failures in the conversion. 829| 12.7k| if( !uprv_isInvariantUString(prop.getBuffer(), prop.length()) || ------------------ | | 1518| 12.7k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 12.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (829:9): [True: 28, False: 12.6k] ------------------ 830| 12.7k| !uprv_isInvariantUString(value.getBuffer(), value.length()) ------------------ | | 1518| 12.6k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 12.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (830:9): [True: 15, False: 12.6k] ------------------ 831| 12.7k| ) { 832| 43| FAIL(ec); ------------------ | | 777| 43|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 43|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 43| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 43| return *this; \ | | 780| 43|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 43|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 833| 43| } 834| 12.6k| CharString pname, vname; 835| 12.6k| pname.appendInvariantChars(prop, ec); 836| 12.6k| vname.appendInvariantChars(value, ec); 837| 12.6k| if (U_FAILURE(ec)) return *this; ------------------ | Branch (837:9): [True: 0, False: 12.6k] ------------------ 838| | 839| 12.6k| UProperty p; 840| 12.6k| int32_t v; 841| 12.6k| UBool invert = false; 842| | 843| 12.6k| if (value.length() > 0) { ------------------ | Branch (843:9): [True: 5.42k, False: 7.23k] ------------------ 844| 5.42k| p = u_getPropertyEnum(pname.data()); ------------------ | | 283| 5.42k|#define u_getPropertyEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyEnum) | | ------------------ | | | | 123| 5.42k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.42k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.42k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 845| 5.42k| if (p == UCHAR_INVALID_CODE) FAIL(ec); ------------------ | | 777| 1|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 1| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 1| return *this; \ | | 780| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ | Branch (845:13): [True: 1, False: 5.42k] ------------------ 846| | 847| | // Treat gc as gcm 848| 5.42k| if (p == UCHAR_GENERAL_CATEGORY) { ------------------ | Branch (848:13): [True: 0, False: 5.42k] ------------------ 849| 0| p = UCHAR_GENERAL_CATEGORY_MASK; 850| 0| } 851| | 852| 5.42k| if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) || ------------------ | Branch (852:14): [True: 5.42k, False: 0] | Branch (852:41): [True: 59, False: 5.36k] ------------------ 853| 5.42k| (p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) || ------------------ | Branch (853:14): [True: 5.36k, False: 0] | Branch (853:38): [True: 3.92k, False: 1.44k] ------------------ 854| 5.42k| (p >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) { ------------------ | Branch (854:14): [True: 1.44k, False: 0] | Branch (854:39): [True: 0, False: 1.44k] ------------------ 855| 3.98k| v = u_getPropertyValueEnum(p, vname.data()); ------------------ | | 285| 3.98k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 3.98k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.98k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.98k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 856| 3.98k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (856:17): [True: 3, False: 3.98k] ------------------ 857| | // Handle numeric CCC 858| 3| if (p == UCHAR_CANONICAL_COMBINING_CLASS || ------------------ | Branch (858:21): [True: 0, False: 3] ------------------ 859| 3| p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS || ------------------ | Branch (859:21): [True: 0, False: 3] ------------------ 860| 3| p == UCHAR_LEAD_CANONICAL_COMBINING_CLASS) { ------------------ | Branch (860:21): [True: 0, False: 3] ------------------ 861| 0| char* end; 862| 0| double val = uprv_strtod(vname.data(), &end); ------------------ | | 75| 0|#define uprv_strtod(source, end) U_STANDARD_CPP_NAMESPACE strtod(source, end) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 863| | // Anything between 0 and 255 is valid even if unused. 864| | // Cast double->int only after range check. 865| | // We catch NaN here because comparing it with both 0 and 255 will be false 866| | // (as are all comparisons with NaN). 867| 0| if (*end != 0 || !(0 <= val && val <= 255) || ------------------ | Branch (867:25): [True: 0, False: 0] | Branch (867:40): [True: 0, False: 0] | Branch (867:52): [True: 0, False: 0] ------------------ 868| 0| (v = static_cast(val)) != val) { ------------------ | Branch (868:29): [True: 0, False: 0] ------------------ 869| | // non-integral value or outside 0..255, or trailing junk 870| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 871| 0| } 872| 3| } else { 873| 3| FAIL(ec); ------------------ | | 777| 3|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 3| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 3| return *this; \ | | 780| 3|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 874| 3| } 875| 3| } 876| 3.98k| } 877| | 878| 1.44k| else { 879| | 880| 1.44k| switch (p) { 881| 0| case UCHAR_NUMERIC_VALUE: ------------------ | Branch (881:13): [True: 0, False: 1.44k] ------------------ 882| 0| { 883| 0| char* end; 884| 0| double val = uprv_strtod(vname.data(), &end); ------------------ | | 75| 0|#define uprv_strtod(source, end) U_STANDARD_CPP_NAMESPACE strtod(source, end) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 885| 0| if (*end != 0) { ------------------ | Branch (885:25): [True: 0, False: 0] ------------------ 886| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 887| 0| } 888| 0| applyFilter(numericValueFilter, &val, 889| 0| CharacterProperties::getInclusionsForProperty(p, ec), ec); 890| 0| return *this; 891| 0| } 892| 1.36k| case UCHAR_NAME: ------------------ | Branch (892:13): [True: 1.36k, False: 71] ------------------ 893| 1.36k| { 894| | // Must munge name, since u_charFromName() does not do 895| | // 'loose' matching. 896| 1.36k| char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength 897| 1.36k| if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec); ------------------ | | 777| 1|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 1| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 1| return *this; \ | | 780| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ | Branch (897:25): [True: 1, False: 1.36k] ------------------ 898| 1.36k| UChar32 ch = u_charFromName(U_EXTENDED_CHAR_NAME, buf, &ec); ------------------ | | 222| 1.36k|#define u_charFromName U_ICU_ENTRY_POINT_RENAME(u_charFromName) | | ------------------ | | | | 123| 1.36k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.36k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.36k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 899| 1.36k| if (U_SUCCESS(ec)) { ------------------ | Branch (899:25): [True: 1.29k, False: 78] ------------------ 900| 1.29k| clear(); 901| 1.29k| add(ch); 902| 1.29k| return *this; 903| 1.29k| } else { 904| 78| FAIL(ec); ------------------ | | 777| 78|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 78|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 78| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 78| return *this; \ | | 780| 78|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 78|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 905| 78| } 906| 1.36k| } 907| 0| case UCHAR_UNICODE_1_NAME: ------------------ | Branch (907:13): [True: 0, False: 1.44k] ------------------ 908| | // ICU 49 deprecates the Unicode_1_Name property APIs. 909| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 910| 70| case UCHAR_AGE: ------------------ | Branch (910:13): [True: 70, False: 1.37k] ------------------ 911| 70| { 912| | // Must munge name, since u_versionFromString() does not do 913| | // 'loose' matching. 914| 70| char buf[128]; 915| 70| if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ | Branch (915:25): [True: 0, False: 70] ------------------ 916| 70| UVersionInfo version; 917| 70| u_versionFromString(version, buf); ------------------ | | 417| 70|#define u_versionFromString U_ICU_ENTRY_POINT_RENAME(u_versionFromString) | | ------------------ | | | | 123| 70|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 70|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 70|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 918| 70| applyFilter(versionFilter, &version, 919| 70| CharacterProperties::getInclusionsForProperty(p, ec), ec); 920| 70| return *this; 921| 70| } 922| 0| case UCHAR_SCRIPT_EXTENSIONS: ------------------ | Branch (922:13): [True: 0, False: 1.44k] ------------------ 923| 0| v = u_getPropertyValueEnum(UCHAR_SCRIPT, vname.data()); ------------------ | | 285| 0|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 924| 0| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (924:21): [True: 0, False: 0] ------------------ 925| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 926| 0| } 927| | // fall through to calling applyIntPropertyValue() 928| 0| break; 929| 0| case UCHAR_IDENTIFIER_TYPE: ------------------ | Branch (929:13): [True: 0, False: 1.44k] ------------------ 930| 0| v = u_getPropertyValueEnum(p, vname.data()); ------------------ | | 285| 0|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 931| 0| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (931:21): [True: 0, False: 0] ------------------ 932| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 933| 0| } 934| | // fall through to calling applyIntPropertyValue() 935| 0| break; 936| 1| default: ------------------ | Branch (936:13): [True: 1, False: 1.43k] ------------------ 937| | // p is a non-binary, non-enumerated property that we 938| | // don't support (yet). 939| 1| FAIL(ec); ------------------ | | 777| 1|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 1| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 1| return *this; \ | | 780| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 940| 1.44k| } 941| 1.44k| } 942| 5.42k| } 943| | 944| 7.23k| else { 945| | // value is empty. Interpret as General Category, Script, or 946| | // Binary property. 947| 7.23k| p = UCHAR_GENERAL_CATEGORY_MASK; 948| 7.23k| v = u_getPropertyValueEnum(p, pname.data()); ------------------ | | 285| 7.23k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 7.23k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.23k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.23k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 949| 7.23k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (949:13): [True: 1.30k, False: 5.93k] ------------------ 950| 1.30k| p = UCHAR_SCRIPT; 951| 1.30k| v = u_getPropertyValueEnum(p, pname.data()); ------------------ | | 285| 1.30k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 1.30k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.30k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.30k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 952| 1.30k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (952:17): [True: 994, False: 309] ------------------ 953| 994| p = u_getPropertyEnum(pname.data()); ------------------ | | 283| 994|#define u_getPropertyEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyEnum) | | ------------------ | | | | 123| 994|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 994|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 994|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| 994| if (p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) { ------------------ | Branch (954:21): [True: 784, False: 210] | Branch (954:48): [True: 783, False: 1] ------------------ 955| 783| v = 1; 956| 783| } else if (0 == uprv_comparePropertyNames(ANY, pname.data())) { ------------------ | | 60| 211|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 211|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 211|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 211|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 211|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (956:28): [True: 102, False: 109] ------------------ 957| 102| set(MIN_VALUE, MAX_VALUE); 958| 102| return *this; 959| 109| } else if (0 == uprv_comparePropertyNames(ASCII, pname.data())) { ------------------ | | 60| 109|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 109|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 109|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 109|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 109|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (959:28): [True: 1, False: 108] ------------------ 960| 1| set(0, 0x7F); 961| 1| return *this; 962| 108| } else if (0 == uprv_comparePropertyNames(ASSIGNED, pname.data())) { ------------------ | | 60| 108|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 108|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 108|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 108|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 108|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (962:28): [True: 0, False: 108] ------------------ 963| | // [:Assigned:]=[:^Cn:] 964| 0| p = UCHAR_GENERAL_CATEGORY_MASK; 965| 0| v = U_GC_CN_MASK; ------------------ | | 925| 0|#define U_GC_CN_MASK U_MASK(U_GENERAL_OTHER_TYPES) | | ------------------ | | | | 174| 0|#define U_MASK(x) ((uint32_t)1<<(x)) | | ------------------ ------------------ 966| 0| invert = true; 967| 108| } else { 968| 108| FAIL(ec); ------------------ | | 777| 108|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 108|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 108| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 108| return *this; \ | | 780| 108|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 108|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 969| 108| } 970| 994| } 971| 1.30k| } 972| 7.23k| } 973| | 974| 11.0k| applyIntPropertyValue(p, v, ec); 975| 11.0k| if(invert) { ------------------ | Branch (975:8): [True: 0, False: 11.0k] ------------------ 976| 0| complement().removeAllStrings(); // code point complement 977| 0| } 978| | 979| 11.0k| if (isBogus() && U_SUCCESS(ec)) { ------------------ | Branch (979:9): [True: 0, False: 11.0k] | Branch (979:22): [True: 0, False: 0] ------------------ 980| | // We likely ran out of memory. AHHH! 981| 0| ec = U_MEMORY_ALLOCATION_ERROR; 982| 0| } 983| 11.0k| return *this; 984| 12.6k|} _ZN6icu_7810UnicodeSet24resemblesPropertyPatternERNS_21RuleCharacterIteratorEi: 1014| 181k| int32_t iterOpts) { 1015| | // NOTE: literal will always be false, because we don't parse escapes. 1016| 181k| UBool result = false, literal; 1017| 181k| UErrorCode ec = U_ZERO_ERROR; 1018| 181k| iterOpts &= ~RuleCharacterIterator::PARSE_ESCAPES; 1019| 181k| RuleCharacterIterator::Pos pos; 1020| 181k| chars.getPos(pos); 1021| 181k| UChar32 c = chars.next(iterOpts, literal, ec); 1022| 181k| if (c == u'[' || c == u'\\') { ------------------ | Branch (1022:9): [True: 23.5k, False: 158k] | Branch (1022:22): [True: 8.74k, False: 149k] ------------------ 1023| 32.3k| UChar32 d = chars.next(iterOpts & ~RuleCharacterIterator::SKIP_WHITESPACE, 1024| 32.3k| literal, ec); 1025| 32.3k| result = (c == u'[') ? (d == u':') : ------------------ | Branch (1025:18): [True: 23.5k, False: 8.74k] ------------------ 1026| 32.3k| (d == u'N' || d == u'p' || d == u'P'); ------------------ | Branch (1026:33): [True: 1.43k, False: 7.31k] | Branch (1026:46): [True: 364, False: 6.95k] | Branch (1026:59): [True: 2.99k, False: 3.96k] ------------------ 1027| 32.3k| } 1028| 181k| chars.setPos(pos); 1029| 181k| return result && U_SUCCESS(ec); ------------------ | Branch (1029:12): [True: 12.9k, False: 169k] | Branch (1029:22): [True: 12.9k, False: 0] ------------------ 1030| 181k|} _ZN6icu_7810UnicodeSet20applyPropertyPatternERKNS_13UnicodeStringERNS_13ParsePositionER10UErrorCode: 1037| 12.7k| UErrorCode &ec) { 1038| 12.7k| int32_t pos = ppos.getIndex(); 1039| | 1040| 12.7k| UBool posix = false; // true for [:pat:], false for \p{pat} \P{pat} \N{pat} 1041| 12.7k| UBool isName = false; // true for \N{pat}, o/w false 1042| 12.7k| UBool invert = false; 1043| | 1044| 12.7k| if (U_FAILURE(ec)) return *this; ------------------ | Branch (1044:9): [True: 0, False: 12.7k] ------------------ 1045| | 1046| | // Minimum length is 5 characters, e.g. \p{L} 1047| 12.7k| if ((pos+5) > pattern.length()) { ------------------ | Branch (1047:9): [True: 8, False: 12.7k] ------------------ 1048| 8| FAIL(ec); ------------------ | | 777| 8|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 8|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 8| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 8| return *this; \ | | 780| 8|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 8|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1049| 8| } 1050| | 1051| | // On entry, ppos should point to one of the following locations: 1052| | // Look for an opening [:, [:^, \p, or \P 1053| 12.7k| if (isPOSIXOpen(pattern, pos)) { ------------------ | Branch (1053:9): [True: 8.07k, False: 4.70k] ------------------ 1054| 8.07k| posix = true; 1055| 8.07k| pos += 2; 1056| 8.07k| pos = ICU_Utility::skipWhitespace(pattern, pos); 1057| 8.07k| if (pos < pattern.length() && pattern.charAt(pos) == u'^') { ------------------ | Branch (1057:13): [True: 8.07k, False: 0] | Branch (1057:39): [True: 1, False: 8.07k] ------------------ 1058| 1| ++pos; 1059| 1| invert = true; 1060| 1| } 1061| 8.07k| } else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) { ------------------ | Branch (1061:16): [True: 3.30k, False: 1.40k] | Branch (1061:44): [True: 1.40k, False: 0] ------------------ 1062| 4.70k| char16_t c = pattern.charAt(pos+1); 1063| 4.70k| invert = (c == u'P'); 1064| 4.70k| isName = (c == u'N'); 1065| 4.70k| pos += 2; 1066| 4.70k| pos = ICU_Utility::skipWhitespace(pattern, pos); 1067| 4.70k| if (pos == pattern.length() || pattern.charAt(pos++) != u'{') { ------------------ | Branch (1067:13): [True: 0, False: 4.70k] | Branch (1067:40): [True: 42, False: 4.66k] ------------------ 1068| | // Syntax error; "\p" or "\P" not followed by "{" 1069| 42| FAIL(ec); ------------------ | | 777| 42|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 42|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 42| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 42| return *this; \ | | 780| 42|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 42|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1070| 42| } 1071| 4.70k| } else { 1072| | // Open delimiter not seen 1073| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1074| 0| } 1075| | 1076| | // Look for the matching close delimiter, either :] or } 1077| 12.7k| int32_t close; 1078| 12.7k| if (posix) { ------------------ | Branch (1078:9): [True: 8.07k, False: 4.66k] ------------------ 1079| 8.07k| close = pattern.indexOf(u":]", 2, pos); 1080| 8.07k| } else { 1081| 4.66k| close = pattern.indexOf(u'}', pos); 1082| 4.66k| } 1083| 12.7k| if (close < 0) { ------------------ | Branch (1083:9): [True: 34, False: 12.7k] ------------------ 1084| | // Syntax error; close delimiter missing 1085| 34| FAIL(ec); ------------------ | | 777| 34|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 34|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 34| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 34| return *this; \ | | 780| 34|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 34|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1086| 34| } 1087| | 1088| | // Look for an '=' sign. If this is present, we will parse a 1089| | // medium \p{gc=Cf} or long \p{GeneralCategory=Format} 1090| | // pattern. 1091| 12.7k| int32_t equals = pattern.indexOf(u'=', pos); 1092| 12.7k| UnicodeString propName, valueName; 1093| 12.7k| if (equals >= 0 && equals < close && !isName) { ------------------ | Branch (1093:9): [True: 6.27k, False: 6.42k] | Branch (1093:24): [True: 4.11k, False: 2.16k] | Branch (1093:42): [True: 4.10k, False: 3] ------------------ 1094| | // Equals seen; parse medium/long pattern 1095| 4.10k| pattern.extractBetween(pos, equals, propName); 1096| 4.10k| pattern.extractBetween(equals+1, close, valueName); 1097| 4.10k| } 1098| | 1099| 8.59k| else { 1100| | // Handle case where no '=' is seen, and \N{} 1101| 8.59k| pattern.extractBetween(pos, close, propName); 1102| | 1103| | // Handle \N{name} 1104| 8.59k| if (isName) { ------------------ | Branch (1104:13): [True: 1.38k, False: 7.20k] ------------------ 1105| | // This is a little inefficient since it means we have to 1106| | // parse NAME_PROP back to UCHAR_NAME even though we already 1107| | // know it's UCHAR_NAME. If we refactor the API to 1108| | // support args of (UProperty, char*) then we can remove 1109| | // NAME_PROP and make this a little more efficient. 1110| 1.38k| valueName = propName; 1111| 1.38k| propName = NAME_PROP; 1112| 1.38k| } 1113| 8.59k| } 1114| | 1115| 12.7k| applyPropertyAlias(propName, valueName, ec); 1116| | 1117| 12.7k| if (U_SUCCESS(ec)) { ------------------ | Branch (1117:9): [True: 12.4k, False: 235] ------------------ 1118| 12.4k| if (invert) { ------------------ | Branch (1118:13): [True: 2.86k, False: 9.60k] ------------------ 1119| 2.86k| complement().removeAllStrings(); // code point complement 1120| 2.86k| } 1121| | 1122| | // Move to the limit position after the close delimiter if the 1123| | // parse succeeded. 1124| 12.4k| ppos.setIndex(close + (posix ? 2 : 1)); ------------------ | Branch (1124:32): [True: 8.01k, False: 4.45k] ------------------ 1125| 12.4k| } 1126| | 1127| 12.7k| return *this; 1128| 12.7k|} _ZN6icu_7810UnicodeSet20applyPropertyPatternERNS_21RuleCharacterIteratorERNS_13UnicodeStringER10UErrorCode: 1141| 12.9k| UErrorCode& ec) { 1142| 12.9k| if (U_FAILURE(ec)) return; ------------------ | Branch (1142:9): [True: 132, False: 12.7k] ------------------ 1143| 12.7k| UnicodeString pattern; 1144| 12.7k| chars.lookahead(pattern); 1145| 12.7k| ParsePosition pos(0); 1146| 12.7k| applyPropertyPattern(pattern, pos, ec); 1147| 12.7k| if (U_FAILURE(ec)) return; ------------------ | Branch (1147:9): [True: 319, False: 12.4k] ------------------ 1148| 12.4k| if (pos.getIndex() == 0) { ------------------ | Branch (1148:9): [True: 0, False: 12.4k] ------------------ 1149| | // syntaxError(chars, "Invalid property pattern"); 1150| 0| ec = U_MALFORMED_SET; 1151| 0| return; 1152| 0| } 1153| 12.4k| chars.jumpahead(pos.getIndex()); 1154| 12.4k| rebuiltPat.append(pattern, 0, pos.getIndex()); 1155| 12.4k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointerC2Ev: 232| 16.5k| inline UnicodeSetPointer() : p(nullptr) {} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointer8allocateEv: 235| 19.6k| inline UBool allocate() { 236| 19.6k| if (p == nullptr) { ------------------ | Branch (236:13): [True: 10.7k, False: 8.84k] ------------------ 237| 10.7k| p = new UnicodeSet(); 238| 10.7k| } 239| 19.6k| return p != nullptr; 240| 19.6k| } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointer7pointerEv: 234| 19.6k| inline UnicodeSet* pointer() { return p; } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointerD2Ev: 233| 16.5k| inline ~UnicodeSetPointer() { delete p; } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_125generalCategoryMaskFilterEiPv: 667| 35.6M|UBool generalCategoryMaskFilter(UChar32 ch, void* context) { 668| 35.6M| int32_t value = *static_cast(context); 669| 35.6M| return (U_GET_GC_MASK((UChar32) ch) & value) != 0; ------------------ | | 3644| 35.6M|#define U_GET_GC_MASK(c) U_MASK(u_charType(c)) | | ------------------ | | | | 174| 35.6M|#define U_MASK(x) ((uint32_t)1<<(x)) | | ------------------ ------------------ 670| 35.6M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117intPropertyFilterEiPv: 685| 2.43M|UBool intPropertyFilter(UChar32 ch, void* context) { 686| 2.43M| IntPropertyContext* c = static_cast(context); 687| 2.43M| return u_getIntPropertyValue(ch, c->prop) == c->value; ------------------ | | 280| 2.43M|#define u_getIntPropertyValue U_ICU_ENTRY_POINT_RENAME(u_getIntPropertyValue) | | ------------------ | | | | 123| 2.43M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.43M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.43M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 688| 2.43M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_113mungeCharNameEPcPKci: 754| 1.43k|UBool mungeCharName(char* dst, const char* src, int32_t dstCapacity) { 755| | /* Note: we use ' ' in compiler code page */ 756| 1.43k| int32_t j = 0; 757| 1.43k| char ch; 758| 1.43k| --dstCapacity; /* make room for term. zero */ 759| 7.09k| while ((ch = *src++) != 0) { ------------------ | Branch (759:12): [True: 5.65k, False: 1.43k] ------------------ 760| 5.65k| if (ch == ' ' && (j==0 || (j>0 && dst[j-1]==' '))) { ------------------ | Branch (760:13): [True: 1.09k, False: 4.55k] | Branch (760:27): [True: 24, False: 1.07k] | Branch (760:36): [True: 1.07k, False: 0] | Branch (760:43): [True: 158, False: 917] ------------------ 761| 182| continue; 762| 182| } 763| 5.47k| if (j >= dstCapacity) return false; ------------------ | Branch (763:13): [True: 1, False: 5.47k] ------------------ 764| 5.47k| dst[j++] = ch; 765| 5.47k| } 766| 1.43k| if (j > 0 && dst[j-1] == ' ') --j; ------------------ | Branch (766:9): [True: 1.43k, False: 7] | Branch (766:18): [True: 745, False: 686] ------------------ 767| 1.43k| dst[j] = 0; 768| 1.43k| return true; 769| 1.43k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_113versionFilterEiPv: 672| 499k|UBool versionFilter(UChar32 ch, void* context) { 673| 499k| static const UVersionInfo none = { 0, 0, 0, 0 }; 674| 499k| UVersionInfo v; 675| 499k| u_charAge(ch, v); ------------------ | | 219| 499k|#define u_charAge U_ICU_ENTRY_POINT_RENAME(u_charAge) | | ------------------ | | | | 123| 499k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 499k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 499k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 676| 499k| UVersionInfo* version = static_cast(context); 677| 499k| return uprv_memcmp(&v, &none, sizeof(v)) > 0 && uprv_memcmp(&v, version, sizeof(v)) <= 0; ------------------ | | 101| 499k|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 499k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ return uprv_memcmp(&v, &none, sizeof(v)) > 0 && uprv_memcmp(&v, version, sizeof(v)) <= 0; ------------------ | | 101| 447k|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 447k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (677:12): [True: 447k, False: 51.8k] | Branch (677:53): [True: 193k, False: 253k] ------------------ 678| 499k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_111isPOSIXOpenERKNS_13UnicodeStringEi: 129| 12.7k|isPOSIXOpen(const UnicodeString &pattern, int32_t pos) { 130| 12.7k| return pattern.charAt(pos)==u'[' && pattern.charAt(pos+1)==u':'; ------------------ | Branch (130:12): [True: 8.07k, False: 4.70k] | Branch (130:41): [True: 8.07k, False: 0] ------------------ 131| 12.7k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_110isPerlOpenERKNS_13UnicodeStringEi: 113| 4.70k|isPerlOpen(const UnicodeString &pattern, int32_t pos) { 114| 4.70k| char16_t c; 115| 4.70k| return pattern.charAt(pos)==u'\\' && ((c=pattern.charAt(pos+1))==u'p' || c==u'P'); ------------------ | Branch (115:12): [True: 4.70k, False: 0] | Branch (115:43): [True: 353, False: 4.35k] | Branch (115:78): [True: 2.95k, False: 1.40k] ------------------ 116| 4.70k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_110isNameOpenERKNS_13UnicodeStringEi: 124| 1.40k|isNameOpen(const UnicodeString &pattern, int32_t pos) { 125| 1.40k| return pattern.charAt(pos)==u'\\' && pattern.charAt(pos+1)==u'N'; ------------------ | Branch (125:12): [True: 1.40k, False: 0] | Branch (125:42): [True: 1.40k, False: 0] ------------------ 126| 1.40k|} _ZN6icu_7811ReplaceableD2Ev: 106| 1.14G|Replaceable::~Replaceable() {} _ZN6icu_78plERKNS_13UnicodeStringES2_: 111| 146k|operator+ (const UnicodeString &s1, const UnicodeString &s2) { 112| 146k| int32_t sumLengths; 113| 146k| if (uprv_add32_overflow(s1.length(), s2.length(), &sumLengths)) { ------------------ | | 1394| 146k|#define uprv_add32_overflow U_ICU_ENTRY_POINT_RENAME(uprv_add32_overflow) | | ------------------ | | | | 123| 146k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 146k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 146k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (113:7): [True: 0, False: 146k] ------------------ 114| 0| UnicodeString bogus; 115| 0| bogus.setToBogus(); 116| 0| return bogus; 117| 0| } 118| 146k| if (sumLengths != INT32_MAX) { ------------------ | Branch (118:7): [True: 146k, False: 0] ------------------ 119| 146k| ++sumLengths; // space for a terminating NUL if we need one 120| 146k| } 121| 146k| return UnicodeString(sumLengths, static_cast(0), 0).append(s1).append(s2); 122| 146k|} _ZN6icu_7813UnicodeString6addRefEv: 146| 1.53M|UnicodeString::addRef() { 147| 1.53M| umtx_atomic_inc(reinterpret_cast(fUnion.fFields.fArray) - 1); 148| 1.53M|} _ZN6icu_7813UnicodeString9removeRefEv: 151| 20.4M|UnicodeString::removeRef() { 152| 20.4M| return umtx_atomic_dec(reinterpret_cast(fUnion.fFields.fArray) - 1); 153| 20.4M|} _ZNK6icu_7813UnicodeString8refCountEv: 156| 253M|UnicodeString::refCount() const { 157| 253M| return umtx_loadAcquire(*(reinterpret_cast(fUnion.fFields.fArray) - 1)); 158| 253M|} _ZN6icu_7813UnicodeString12releaseArrayEv: 161| 1.36G|UnicodeString::releaseArray() { 162| 1.36G| if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) { ------------------ | Branch (162:6): [True: 20.4M, False: 1.34G] | Branch (162:56): [True: 18.9M, False: 1.51M] ------------------ 163| 18.9M| uprv_free(reinterpret_cast(fUnion.fFields.fArray) - 1); ------------------ | | 1503| 18.9M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 18.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 18.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 18.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 18.9M| } 165| 1.36G|} _ZN6icu_7813UnicodeStringC2Eiii: 175| 146k|UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) { 176| 146k| fUnion.fFields.fLengthAndFlags = 0; 177| 146k| if (count <= 0 || static_cast(c) > 0x10ffff) { ------------------ | Branch (177:7): [True: 146k, False: 0] | Branch (177:21): [True: 0, False: 0] ------------------ 178| | // just allocate and do not do anything else 179| 146k| allocate(capacity); 180| 146k| } else if(c <= 0xffff) { ------------------ | Branch (180:13): [True: 0, False: 0] ------------------ 181| 0| int32_t length = count; 182| 0| if(capacity < length) { ------------------ | Branch (182:8): [True: 0, False: 0] ------------------ 183| 0| capacity = length; 184| 0| } 185| 0| if(allocate(capacity)) { ------------------ | Branch (185:8): [True: 0, False: 0] ------------------ 186| 0| char16_t *array = getArrayStart(); 187| 0| char16_t unit = static_cast(c); 188| 0| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (188:26): [True: 0, False: 0] ------------------ 189| 0| array[i] = unit; 190| 0| } 191| 0| setLength(length); 192| 0| } 193| 0| } else { // supplementary code point, write surrogate pairs 194| 0| if(count > (INT32_MAX / 2)) { ------------------ | Branch (194:8): [True: 0, False: 0] ------------------ 195| | // We would get more than 2G UChars. 196| 0| allocate(capacity); 197| 0| return; 198| 0| } 199| 0| int32_t length = count * 2; 200| 0| if(capacity < length) { ------------------ | Branch (200:8): [True: 0, False: 0] ------------------ 201| 0| capacity = length; 202| 0| } 203| 0| if(allocate(capacity)) { ------------------ | Branch (203:8): [True: 0, False: 0] ------------------ 204| 0| char16_t *array = getArrayStart(); 205| 0| char16_t lead = U16_LEAD(c); ------------------ | | 123| 0|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 206| 0| char16_t trail = U16_TRAIL(c); ------------------ | | 132| 0|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 207| 0| for(int32_t i = 0; i < length; i += 2) { ------------------ | Branch (207:26): [True: 0, False: 0] ------------------ 208| 0| array[i] = lead; 209| 0| array[i + 1] = trail; 210| 0| } 211| 0| setLength(length); 212| 0| } 213| 0| } 214| 146k|} _ZN6icu_7813UnicodeStringC2EDs: 216| 438k|UnicodeString::UnicodeString(char16_t ch) { 217| 438k| fUnion.fFields.fLengthAndFlags = kLength1 | kShortString; 218| 438k| fUnion.fStackFields.fBuffer[0] = ch; 219| 438k|} _ZN6icu_7813UnicodeStringC2Ei: 221| 53.0M|UnicodeString::UnicodeString(UChar32 ch) { 222| 53.0M| fUnion.fFields.fLengthAndFlags = kShortString; 223| 53.0M| int32_t i = 0; 224| 53.0M| UBool isError = false; 225| 53.0M| U16_APPEND(fUnion.fStackFields.fBuffer, i, US_STACKBUF_SIZE, ch, isError); ------------------ | | 393| 53.0M|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 53.0M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 53.0M| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 52.6M, False: 390k] | | ------------------ | | 395| 52.6M| (s)[(i)++]=(uint16_t)(c); \ | | 396| 52.6M| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 390k, False: 0] | | | Branch (396:42): [True: 390k, False: 0] | | ------------------ | | 397| 390k| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 390k| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 390k| } else /* c>0x10ffff or not enough space */ { \ | | 400| 0| (isError)=true; \ | | 401| 0| } \ | | 402| 53.0M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 53.0M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 226| | // We test isError so that the compiler does not complain that we don't. 227| | // If isError then i==0 which is what we want anyway. 228| 53.0M| if(!isError) { ------------------ | Branch (228:6): [True: 53.0M, False: 0] ------------------ 229| 53.0M| setShortLength(i); 230| 53.0M| } 231| 53.0M|} _ZN6icu_7813UnicodeStringC2EPKDsi: 234| 9.48M| int32_t textLength) { 235| 9.48M| fUnion.fFields.fLengthAndFlags = kShortString; 236| 9.48M| doAppend(text, 0, textLength); 237| 9.48M|} _ZN6icu_7813UnicodeStringC2EaNS_14ConstChar16PtrEi: 241| 780M| int32_t textLength) { 242| 780M| fUnion.fFields.fLengthAndFlags = kReadonlyAlias; 243| 780M| const char16_t *text = textPtr; 244| 780M| if(text == nullptr) { ------------------ | Branch (244:6): [True: 0, False: 780M] ------------------ 245| | // treat as an empty string, do not alias 246| 0| setToEmpty(); 247| 780M| } else if(textLength < -1 || ------------------ | Branch (247:13): [True: 0, False: 780M] ------------------ 248| 780M| (textLength == -1 && !isTerminated) || ------------------ | Branch (248:14): [True: 83.9k, False: 780M] | Branch (248:34): [True: 0, False: 83.9k] ------------------ 249| 780M| (textLength >= 0 && isTerminated && text[textLength] != 0) ------------------ | Branch (249:14): [True: 780M, False: 83.9k] | Branch (249:33): [True: 0, False: 780M] | Branch (249:49): [True: 0, False: 0] ------------------ 250| 780M| ) { 251| 0| setToBogus(); 252| 780M| } else { 253| 780M| if(textLength == -1) { ------------------ | Branch (253:8): [True: 83.9k, False: 780M] ------------------ 254| | // text is terminated, or else it would have failed the above test 255| 83.9k| textLength = u_strlen(text); ------------------ | | 393| 83.9k|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 83.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 83.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 83.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 256| 83.9k| } 257| 780M| setArray(const_cast(text), textLength, 258| 780M| isTerminated ? textLength + 1 : textLength); ------------------ | Branch (258:14): [True: 83.9k, False: 780M] ------------------ 259| 780M| } 260| 780M|} _ZN6icu_7813UnicodeStringC2EPKciNS0_10EInvariantE: 284| 3.45k|UnicodeString::UnicodeString(const char *src, int32_t length, EInvariant) { 285| 3.45k| fUnion.fFields.fLengthAndFlags = kShortString; 286| 3.45k| if(src==nullptr) { ------------------ | Branch (286:6): [True: 0, False: 3.45k] ------------------ 287| | // treat as an empty string 288| 3.45k| } else { 289| 3.45k| if(length<0) { ------------------ | Branch (289:8): [True: 3.45k, False: 0] ------------------ 290| 3.45k| length = static_cast(uprv_strlen(src)); ------------------ | | 37| 3.45k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 3.45k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 291| 3.45k| } 292| 3.45k| if(cloneArrayIfNeeded(length, length, false)) { ------------------ | Branch (292:8): [True: 3.45k, False: 0] ------------------ 293| 3.45k| u_charsToUChars(src, getArrayStart(), length); ------------------ | | 226| 3.45k|#define u_charsToUChars U_ICU_ENTRY_POINT_RENAME(u_charsToUChars) | | ------------------ | | | | 123| 3.45k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.45k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.45k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 294| 3.45k| setLength(length); 295| 3.45k| } else { 296| 0| setToBogus(); 297| 0| } 298| 3.45k| } 299| 3.45k|} _ZN6icu_7813UnicodeStringC2ERKS0_: 345| 152M|UnicodeString::UnicodeString(const UnicodeString& that) { 346| 152M| fUnion.fFields.fLengthAndFlags = kShortString; 347| 152M| copyFrom(that); 348| 152M|} _ZN6icu_7813UnicodeStringC2ERKS0_i: 355| 43.7M| int32_t srcStart) { 356| 43.7M| fUnion.fFields.fLengthAndFlags = kShortString; 357| 43.7M| setTo(that, srcStart); 358| 43.7M|} _ZN6icu_7813UnicodeStringC2ERKS0_ii: 362| 3.15M| int32_t srcLength) { 363| 3.15M| fUnion.fFields.fLengthAndFlags = kShortString; 364| 3.15M| setTo(that, srcStart, srcLength); 365| 3.15M|} _ZN6icu_7813UnicodeString8allocateEi: 409| 20.5M|UnicodeString::allocate(int32_t capacity) { 410| 20.5M| if(capacity <= US_STACKBUF_SIZE) { ------------------ | Branch (410:6): [True: 109k, False: 20.4M] ------------------ 411| 109k| fUnion.fFields.fLengthAndFlags = kShortString; 412| 109k| return true; 413| 109k| } 414| 20.4M| if(capacity <= kMaxCapacity) { ------------------ | Branch (414:6): [True: 20.4M, False: 0] ------------------ 415| 20.4M| ++capacity; // for the NUL 416| | // Switch to size_t which is unsigned so that we can allocate up to 4GB. 417| | // Reference counter + UChars. 418| 20.4M| size_t numBytes = sizeof(int32_t) + static_cast(capacity) * U_SIZEOF_UCHAR; ------------------ | | 352| 20.4M|#define U_SIZEOF_UCHAR 2 ------------------ 419| | // Round up to a multiple of 16. 420| 20.4M| numBytes = (numBytes + 15) & ~15; 421| 20.4M| int32_t* array = static_cast(uprv_malloc(numBytes)); ------------------ | | 1524| 20.4M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 20.4M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 20.4M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 20.4M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| 20.4M| if(array != nullptr) { ------------------ | Branch (422:8): [True: 20.4M, False: 0] ------------------ 423| | // set initial refCount and point behind the refCount 424| 20.4M| *array++ = 1; 425| 20.4M| numBytes -= sizeof(int32_t); 426| | 427| | // have fArray point to the first char16_t 428| 20.4M| fUnion.fFields.fArray = reinterpret_cast(array); 429| 20.4M| fUnion.fFields.fCapacity = static_cast(numBytes / U_SIZEOF_UCHAR); ------------------ | | 352| 20.4M|#define U_SIZEOF_UCHAR 2 ------------------ 430| 20.4M| fUnion.fFields.fLengthAndFlags = kLongString; 431| 20.4M| return true; 432| 20.4M| } 433| 20.4M| } 434| 0| fUnion.fFields.fLengthAndFlags = kIsBogus; 435| 0| fUnion.fFields.fArray = nullptr; 436| 0| fUnion.fFields.fCapacity = 0; 437| 0| return false; 438| 20.4M|} _ZN6icu_7813UnicodeStringD2Ev: 462| 1.14G|{ 463| |#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS 464| | // Count lengths of strings at the end of their lifetime. 465| | // Useful for discussion of a desirable stack buffer size. 466| | // Count the contents length, not the optional NUL terminator nor further capacity. 467| | // Ignore open-buffer strings and strings which alias external storage. 468| | if((fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kReadonlyAlias|kWritableAlias)) == 0) { 469| | if(hasShortLength()) { 470| | umtx_atomic_inc(finalLengthCounts + getShortLength()); 471| | } else { 472| | umtx_atomic_inc(&beyondCount); 473| | } 474| | } 475| |#endif 476| | 477| 1.14G| releaseArray(); 478| 1.14G|} _ZN6icu_7813UnicodeStringaSERKS0_: 527| 8.84M|UnicodeString::operator=(const UnicodeString &src) { 528| 8.84M| return copyFrom(src); 529| 8.84M|} _ZN6icu_7813UnicodeString12fastCopyFromERKS0_: 532| 44.8M|UnicodeString::fastCopyFrom(const UnicodeString &src) { 533| 44.8M| return copyFrom(src, true); 534| 44.8M|} _ZN6icu_7813UnicodeString8copyFromERKS0_a: 537| 205M|UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) { 538| | // if assigning to ourselves, do nothing 539| 205M| if(this == &src) { ------------------ | Branch (539:6): [True: 0, False: 205M] ------------------ 540| 0| return *this; 541| 0| } 542| | 543| | // is the right side bogus? 544| 205M| if(src.isBogus()) { ------------------ | Branch (544:6): [True: 6.80M, False: 198M] ------------------ 545| 6.80M| setToBogus(); 546| 6.80M| return *this; 547| 6.80M| } 548| | 549| | // delete the current contents 550| 198M| releaseArray(); 551| | 552| 198M| if(src.isEmpty()) { ------------------ | Branch (552:6): [True: 2.66M, False: 196M] ------------------ 553| | // empty string - use the stack buffer 554| 2.66M| setToEmpty(); 555| 2.66M| return *this; 556| 2.66M| } 557| | 558| | // fLength>0 and not an "open" src.getBuffer(minCapacity) 559| 196M| fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags; 560| 196M| switch(src.fUnion.fFields.fLengthAndFlags & kAllStorageFlags) { 561| 149M| case kShortString: ------------------ | Branch (561:3): [True: 149M, False: 46.3M] ------------------ 562| | // short string using the stack buffer, do the same 563| 149M| uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer, ------------------ | | 42| 149M|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 149M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 149M| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 149M| _Pragma("clang diagnostic push") \ | | 45| 149M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 149M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 149M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 149M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 149M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 149M| _Pragma("clang diagnostic pop") \ | | 49| 149M| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 149M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 149M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 149M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 564| 149M| getShortLength() * U_SIZEOF_UCHAR); 565| 149M| break; 566| 1.53M| case kLongString: ------------------ | Branch (566:3): [True: 1.53M, False: 194M] ------------------ 567| | // src uses a refCounted string buffer, use that buffer with refCount 568| | // src is const, use a cast - we don't actually change it 569| 1.53M| const_cast(src).addRef(); 570| | // copy all fields, share the reference-counted buffer 571| 1.53M| fUnion.fFields.fArray = src.fUnion.fFields.fArray; 572| 1.53M| fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity; 573| 1.53M| if(!hasShortLength()) { ------------------ | Branch (573:8): [True: 91.0k, False: 1.44M] ------------------ 574| 91.0k| fUnion.fFields.fLength = src.fUnion.fFields.fLength; 575| 91.0k| } 576| 1.53M| break; 577| 44.8M| case kReadonlyAlias: ------------------ | Branch (577:3): [True: 44.8M, False: 151M] ------------------ 578| 44.8M| if(fastCopy) { ------------------ | Branch (578:8): [True: 44.8M, False: 4.09k] ------------------ 579| | // src is a readonly alias, do the same 580| | // -> maintain the readonly alias as such 581| 44.8M| fUnion.fFields.fArray = src.fUnion.fFields.fArray; 582| 44.8M| fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity; 583| 44.8M| if(!hasShortLength()) { ------------------ | Branch (583:10): [True: 66.6k, False: 44.7M] ------------------ 584| 66.6k| fUnion.fFields.fLength = src.fUnion.fFields.fLength; 585| 66.6k| } 586| 44.8M| break; 587| 44.8M| } 588| | // else if(!fastCopy) fall through to case kWritableAlias 589| | // -> allocate a new buffer and copy the contents 590| 4.09k| U_FALLTHROUGH; ------------------ | | 511| 4.09k|# define U_FALLTHROUGH [[clang::fallthrough]] ------------------ 591| 4.09k| case kWritableAlias: { ------------------ | Branch (591:3): [True: 0, False: 196M] ------------------ 592| | // src is a writable alias; we make a copy of that instead 593| 4.09k| int32_t srcLength = src.length(); 594| 4.09k| if(allocate(srcLength)) { ------------------ | Branch (594:8): [True: 4.09k, False: 0] ------------------ 595| 4.09k| u_memcpy(getArrayStart(), src.getArrayStart(), srcLength); ------------------ | | 334| 4.09k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 4.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 596| 4.09k| setLength(srcLength); 597| 4.09k| break; 598| 4.09k| } 599| | // if there is not enough memory, then fall through to setting to bogus 600| 0| U_FALLTHROUGH; ------------------ | | 511| 0|# define U_FALLTHROUGH [[clang::fallthrough]] ------------------ 601| 0| } 602| 0| default: ------------------ | Branch (602:3): [True: 0, False: 196M] ------------------ 603| | // if src is bogus, set ourselves to bogus 604| | // do not call setToBogus() here because fArray and flags are not consistent here 605| 0| fUnion.fFields.fLengthAndFlags = kIsBogus; 606| 0| fUnion.fFields.fArray = nullptr; 607| 0| fUnion.fFields.fCapacity = 0; 608| 0| break; 609| 196M| } 610| | 611| 196M| return *this; 612| 196M|} _ZNK6icu_7813UnicodeString10unescapeAtERi: 690| 4.67k|UChar32 UnicodeString::unescapeAt(int32_t &offset) const { 691| 4.67k| return u_unescapeAt(UnicodeString_charAt, &offset, length(), (void*)this); ------------------ | | 416| 4.67k|#define u_unescapeAt U_ICU_ENTRY_POINT_RENAME(u_unescapeAt) | | ------------------ | | | | 123| 4.67k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.67k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.67k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 692| 4.67k|} _ZNK6icu_7813UnicodeString8doEqualsEPKDsi: 698| 78.1M|UnicodeString::doEquals(const char16_t *text, int32_t len) const { 699| | // Requires: this not bogus and have same lengths. 700| | // Byte-wise comparison works for equality regardless of endianness. 701| 78.1M| return uprv_memcmp(getArrayStart(), text, len * U_SIZEOF_UCHAR) == 0; ------------------ | | 101| 78.1M|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 78.1M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 702| 78.1M|} _ZNK6icu_7813UnicodeString17doEqualsSubstringEiiPKDsii: 710| 85.1M|{ 711| | // compare illegal string values 712| 85.1M| if(isBogus()) { ------------------ | Branch (712:6): [True: 0, False: 85.1M] ------------------ 713| 0| return false; 714| 0| } 715| | 716| | // pin indices to legal values 717| 85.1M| pinIndices(start, length); 718| | 719| 85.1M| if(srcChars == nullptr) { ------------------ | Branch (719:6): [True: 0, False: 85.1M] ------------------ 720| | // treat const char16_t *srcChars==nullptr as an empty string 721| 0| return length == 0 ? true : false; ------------------ | Branch (721:12): [True: 0, False: 0] ------------------ 722| 0| } 723| | 724| | // get the correct pointer 725| 85.1M| const char16_t *chars = getArrayStart(); 726| | 727| 85.1M| chars += start; 728| 85.1M| srcChars += srcStart; 729| | 730| | // get the srcLength if necessary 731| 85.1M| if(srcLength < 0) { ------------------ | Branch (731:6): [True: 0, False: 85.1M] ------------------ 732| 0| srcLength = u_strlen(srcChars + srcStart); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 733| 0| } 734| | 735| 85.1M| if (length != srcLength) { ------------------ | Branch (735:7): [True: 89, False: 85.1M] ------------------ 736| 89| return false; 737| 89| } 738| | 739| 85.1M| if(length == 0 || chars == srcChars) { ------------------ | Branch (739:6): [True: 0, False: 85.1M] | Branch (739:21): [True: 0, False: 85.1M] ------------------ 740| 0| return true; 741| 0| } 742| | 743| 85.1M| return u_memcmp(chars, srcChars, srcLength) == 0; ------------------ | | 332| 85.1M|#define u_memcmp U_ICU_ENTRY_POINT_RENAME(u_memcmp) | | ------------------ | | | | 123| 85.1M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 85.1M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 85.1M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 744| 85.1M|} _ZNK6icu_7813UnicodeString9doCompareEiiPKDsii: 752| 366M|{ 753| | // compare illegal string values 754| 366M| if(isBogus()) { ------------------ | Branch (754:6): [True: 0, False: 366M] ------------------ 755| 0| return -1; 756| 0| } 757| | 758| | // pin indices to legal values 759| 366M| pinIndices(start, length); 760| | 761| 366M| if(srcChars == nullptr) { ------------------ | Branch (761:6): [True: 0, False: 366M] ------------------ 762| | // treat const char16_t *srcChars==nullptr as an empty string 763| 0| return length == 0 ? 0 : 1; ------------------ | Branch (763:12): [True: 0, False: 0] ------------------ 764| 0| } 765| | 766| | // get the correct pointer 767| 366M| const char16_t *chars = getArrayStart(); 768| | 769| 366M| chars += start; 770| 366M| srcChars += srcStart; 771| | 772| 366M| int32_t minLength; 773| 366M| int8_t lengthResult; 774| | 775| | // get the srcLength if necessary 776| 366M| if(srcLength < 0) { ------------------ | Branch (776:6): [True: 0, False: 366M] ------------------ 777| 0| srcLength = u_strlen(srcChars + srcStart); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 778| 0| } 779| | 780| | // are we comparing different lengths? 781| 366M| if(length != srcLength) { ------------------ | Branch (781:6): [True: 227M, False: 138M] ------------------ 782| 227M| if(length < srcLength) { ------------------ | Branch (782:8): [True: 107M, False: 120M] ------------------ 783| 107M| minLength = length; 784| 107M| lengthResult = -1; 785| 120M| } else { 786| 120M| minLength = srcLength; 787| 120M| lengthResult = 1; 788| 120M| } 789| 227M| } else { 790| 138M| minLength = length; 791| 138M| lengthResult = 0; 792| 138M| } 793| | 794| | /* 795| | * note that uprv_memcmp() returns an int but we return an int8_t; 796| | * we need to take care not to truncate the result - 797| | * one way to do this is to right-shift the value to 798| | * move the sign bit into the lower 8 bits and making sure that this 799| | * does not become 0 itself 800| | */ 801| | 802| 366M| if(minLength > 0 && chars != srcChars) { ------------------ | Branch (802:6): [True: 365M, False: 970k] | Branch (802:23): [True: 353M, False: 11.4M] ------------------ 803| 353M| int32_t result; 804| | 805| |# if U_IS_BIG_ENDIAN 806| | // big-endian: byte comparison works 807| | result = uprv_memcmp(chars, srcChars, minLength * sizeof(char16_t)); 808| | if(result != 0) { 809| | return (int8_t)(result >> 15 | 1); 810| | } 811| |# else 812| | // little-endian: compare char16_t units 813| 7.90G| do { 814| 7.90G| result = static_cast(*(chars++)) - static_cast(*(srcChars++)); 815| 7.90G| if(result != 0) { ------------------ | Branch (815:12): [True: 352M, False: 7.55G] ------------------ 816| 352M| return static_cast(result >> 15 | 1); 817| 352M| } 818| 7.90G| } while(--minLength > 0); ------------------ | Branch (818:15): [True: 7.55G, False: 1.59M] ------------------ 819| 353M|# endif 820| 353M| } 821| 13.9M| return lengthResult; 822| 366M|} _ZNK6icu_7813UnicodeString8char32AtEi: 871| 229M|{ 872| 229M| int32_t len = length(); 873| 229M| if (static_cast(offset) < static_cast(len)) { ------------------ | Branch (873:7): [True: 229M, False: 0] ------------------ 874| 229M| const char16_t *array = getArrayStart(); 875| 229M| UChar32 c; 876| 229M| U16_GET(array, 0, offset, len, c); ------------------ | | 201| 229M|#define U16_GET(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 229M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 202| 229M| (c)=(s)[i]; \ | | 203| 229M| if(U16_IS_SURROGATE(c)) { \ | | ------------------ | | | | 75| 229M|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | | | ------------------ | | | | | | 193| 229M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | | | ------------------ | | | | | | | Branch (193:27): [True: 9.46M, False: 220M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 204| 9.46M| uint16_t __c2; \ | | 205| 9.46M| if(U16_IS_SURROGATE_LEAD(c)) { \ | | ------------------ | | | | 84| 9.46M|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | | | ------------------ | | | | | Branch (84:34): [True: 7.45M, False: 2.00M] | | | | ------------------ | | ------------------ | | 206| 7.45M| if((i)+1!=(length) && U16_IS_TRAIL(__c2=(s)[(i)+1])) { \ | | ------------------ | | | | 67| 7.45M|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 7.45M, False: 2.22k] | | | | ------------------ | | ------------------ | | | Branch (206:16): [True: 7.45M, False: 107] | | ------------------ | | 207| 7.45M| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 7.45M| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 7.45M|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 208| 7.45M| } \ | | 209| 7.45M| } else { \ | | 210| 2.00M| if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \ | | ------------------ | | | | 59| 2.00M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 2.00M, False: 2.89k] | | | | ------------------ | | ------------------ | | | Branch (210:16): [True: 2.00M, False: 243] | | ------------------ | | 211| 2.00M| (c)=U16_GET_SUPPLEMENTARY(__c2, (c)); \ | | ------------------ | | | | 113| 2.00M| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 2.00M|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 212| 2.00M| } \ | | 213| 2.00M| } \ | | 214| 9.46M| } \ | | 215| 229M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 229M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 877| 229M| return c; 878| 229M| } else { 879| 0| return kInvalidUChar; 880| 0| } 881| 229M|} _ZNK6icu_7813UnicodeString11countChar32Eii: 907| 20.5M|UnicodeString::countChar32(int32_t start, int32_t length) const { 908| 20.5M| pinIndices(start, length); 909| | // if(isBogus()) then fArray==0 and start==0 - u_countChar32() checks for nullptr 910| 20.5M| return u_countChar32(getArrayStart()+start, length); ------------------ | | 228| 20.5M|#define u_countChar32 U_ICU_ENTRY_POINT_RENAME(u_countChar32) | | ------------------ | | | | 123| 20.5M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 20.5M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 20.5M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 911| 20.5M|} _ZNK6icu_7813UnicodeString11moveIndex32Eii: 921| 4.83M|UnicodeString::moveIndex32(int32_t index, int32_t delta) const { 922| | // pin index 923| 4.83M| int32_t len = length(); 924| 4.83M| if(index<0) { ------------------ | Branch (924:6): [True: 0, False: 4.83M] ------------------ 925| 0| index=0; 926| 4.83M| } else if(index>len) { ------------------ | Branch (926:13): [True: 0, False: 4.83M] ------------------ 927| 0| index=len; 928| 0| } 929| | 930| 4.83M| const char16_t *array = getArrayStart(); 931| 4.83M| if(delta>0) { ------------------ | Branch (931:6): [True: 2.63M, False: 2.19M] ------------------ 932| 2.63M| U16_FWD_N(array, index, len, delta); ------------------ | | 474| 2.63M|#define U16_FWD_N(s, i, length, n) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.63M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 475| 2.63M| int32_t __N=(n); \ | | 476| 7.85M| while(__N>0 && ((i)<(length) || ((length)<0 && (s)[i]!=0))) { \ | | ------------------ | | | Branch (476:11): [True: 5.22M, False: 2.63M] | | | Branch (476:21): [True: 5.22M, False: 0] | | | Branch (476:38): [True: 0, False: 0] | | | Branch (476:52): [True: 0, False: 0] | | ------------------ | | 477| 5.22M| U16_FWD_1(s, i, length); \ | | ------------------ | | | | 433| 5.22M|#define U16_FWD_1(s, i, length) UPRV_BLOCK_MACRO_BEGIN { \ | | | | ------------------ | | | | | | 169| 5.22M|#define UPRV_BLOCK_MACRO_BEGIN do | | | | ------------------ | | | | 434| 5.22M| if(U16_IS_LEAD((s)[(i)++]) && (i)!=(length) && U16_IS_TRAIL((s)[i])) { \ | | | | ------------------ | | | | | | 59| 10.4M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | | | ------------------ | | | | | | | Branch (59:24): [True: 16.7k, False: 5.20M] | | | | | | ------------------ | | | | ------------------ | | | | if(U16_IS_LEAD((s)[(i)++]) && (i)!=(length) && U16_IS_TRAIL((s)[i])) { \ | | | | ------------------ | | | | | | 67| 16.7k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | | | ------------------ | | | | | | | Branch (67:25): [True: 16.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (434:35): [True: 16.7k, False: 0] | | | | ------------------ | | | | 435| 16.7k| ++(i); \ | | | | 436| 16.7k| } \ | | | | 437| 5.22M|} UPRV_BLOCK_MACRO_END | | | | ------------------ | | | | | | 178| 5.22M|#define UPRV_BLOCK_MACRO_END while (false) | | | | | | ------------------ | | | | | | | Branch (178:37): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 478| 5.22M| --__N; \ | | 479| 5.22M| } \ | | 480| 2.63M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 933| 2.63M| } else { 934| 2.19M| U16_BACK_N(array, 0, index, -delta); ------------------ | | 684| 2.19M|#define U16_BACK_N(s, start, i, n) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.19M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 685| 2.19M| int32_t __N=(n); \ | | 686| 34.9M| while(__N>0 && (i)>(start)) { \ | | ------------------ | | | Branch (686:11): [True: 32.7M, False: 2.19M] | | | Branch (686:20): [True: 32.7M, False: 0] | | ------------------ | | 687| 32.7M| U16_BACK_1(s, start, i); \ | | ------------------ | | | | 643| 32.7M|#define U16_BACK_1(s, start, i) UPRV_BLOCK_MACRO_BEGIN { \ | | | | ------------------ | | | | | | 169| 32.7M|#define UPRV_BLOCK_MACRO_BEGIN do | | | | ------------------ | | | | 644| 32.7M| if(U16_IS_TRAIL((s)[--(i)]) && (i)>(start) && U16_IS_LEAD((s)[(i)-1])) { \ | | | | ------------------ | | | | | | 67| 65.4M|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | | | ------------------ | | | | | | | Branch (67:25): [True: 73.4k, False: 32.6M] | | | | | | ------------------ | | | | ------------------ | | | | if(U16_IS_TRAIL((s)[--(i)]) && (i)>(start) && U16_IS_LEAD((s)[(i)-1])) { \ | | | | ------------------ | | | | | | 59| 73.4k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | | | ------------------ | | | | | | | Branch (59:24): [True: 73.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (644:36): [True: 73.4k, False: 0] | | | | ------------------ | | | | 645| 73.4k| --(i); \ | | | | 646| 73.4k| } \ | | | | 647| 32.7M|} UPRV_BLOCK_MACRO_END | | | | ------------------ | | | | | | 178| 32.7M|#define UPRV_BLOCK_MACRO_END while (false) | | | | | | ------------------ | | | | | | | Branch (178:37): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 688| 32.7M| --__N; \ | | 689| 32.7M| } \ | | 690| 2.19M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.19M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 935| 2.19M| } 936| | 937| 4.83M| return index; 938| 4.83M|} _ZNK6icu_7813UnicodeString7extractENS_9Char16PtrEiR10UErrorCode: 958| 7.06M| UErrorCode &errorCode) const { 959| 7.06M| int32_t len = length(); 960| 7.06M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (960:6): [True: 7.06M, False: 0] ------------------ 961| 7.06M| if (isBogus() || destCapacity < 0 || (destCapacity > 0 && dest == nullptr)) { ------------------ | Branch (961:9): [True: 0, False: 7.06M] | Branch (961:22): [True: 0, False: 7.06M] | Branch (961:43): [True: 7.06M, False: 0] | Branch (961:63): [True: 0, False: 7.06M] ------------------ 962| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 963| 7.06M| } else { 964| 7.06M| const char16_t *array = getArrayStart(); 965| 7.06M| if(len>0 && len<=destCapacity && array!=dest) { ------------------ | Branch (965:10): [True: 7.06M, False: 0] | Branch (965:19): [True: 7.06M, False: 23] | Branch (965:40): [True: 7.06M, False: 0] ------------------ 966| 7.06M| u_memcpy(dest, array, len); ------------------ | | 334| 7.06M|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 7.06M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.06M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.06M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 967| 7.06M| } 968| 7.06M| return u_terminateUChars(dest, destCapacity, len, &errorCode); ------------------ | | 408| 7.06M|#define u_terminateUChars U_ICU_ENTRY_POINT_RENAME(u_terminateUChars) | | ------------------ | | | | 123| 7.06M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.06M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.06M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 969| 7.06M| } 970| 7.06M| } 971| | 972| 0| return len; 973| 7.06M|} _ZNK6icu_7813UnicodeString13tempSubStringEii: 998| 780M|UnicodeString::tempSubString(int32_t start, int32_t len) const { 999| 780M| pinIndices(start, len); 1000| 780M| const char16_t *array = getBuffer(); // not getArrayStart() to check kIsBogus & kOpenGetBuffer 1001| 780M| if(array==nullptr) { ------------------ | Branch (1001:6): [True: 0, False: 780M] ------------------ 1002| 0| array=fUnion.fStackFields.fBuffer; // anything not nullptr because that would make an empty string 1003| 0| len=-2; // bogus result string 1004| 0| } 1005| 780M| return UnicodeString(false, array + start, len); 1006| 780M|} _ZNK6icu_7813UnicodeString14extractBetweenEiiRS0_: 1040| 16.8k| UnicodeString& target) const { 1041| 16.8k| pinIndex(start); 1042| 16.8k| pinIndex(limit); 1043| 16.8k| doExtract(start, limit - start, target); 1044| 16.8k|} _ZNK6icu_7813UnicodeString7indexOfEPKDsiiii: 1112| 1.29M|{ 1113| 1.29M| if (isBogus() || srcChars == nullptr || srcStart < 0 || srcLength == 0) { ------------------ | Branch (1113:7): [True: 0, False: 1.29M] | Branch (1113:20): [True: 0, False: 1.29M] | Branch (1113:43): [True: 0, False: 1.29M] | Branch (1113:59): [True: 0, False: 1.29M] ------------------ 1114| 0| return -1; 1115| 0| } 1116| | 1117| | // UnicodeString does not find empty substrings 1118| 1.29M| if(srcLength < 0 && srcChars[srcStart] == 0) { ------------------ | Branch (1118:6): [True: 0, False: 1.29M] | Branch (1118:23): [True: 0, False: 0] ------------------ 1119| 0| return -1; 1120| 0| } 1121| | 1122| | // get the indices within bounds 1123| 1.29M| pinIndices(start, length); 1124| | 1125| | // find the first occurrence of the substring 1126| 1.29M| const char16_t *array = getArrayStart(); 1127| 1.29M| const char16_t *match = u_strFindFirst(array + start, length, srcChars + srcStart, srcLength); ------------------ | | 361| 1.29M|#define u_strFindFirst U_ICU_ENTRY_POINT_RENAME(u_strFindFirst) | | ------------------ | | | | 123| 1.29M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.29M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.29M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1128| 1.29M| if(match == nullptr) { ------------------ | Branch (1128:6): [True: 458k, False: 839k] ------------------ 1129| 458k| return -1; 1130| 839k| } else { 1131| 839k| return static_cast(match - array); 1132| 839k| } 1133| 1.29M|} _ZNK6icu_7813UnicodeString9doIndexOfEDsii: 1139| 26.0k|{ 1140| | // pin indices 1141| 26.0k| pinIndices(start, length); 1142| | 1143| | // find the first occurrence of c 1144| 26.0k| const char16_t *array = getArrayStart(); 1145| 26.0k| const char16_t *match = u_memchr(array + start, c, length); ------------------ | | 330| 26.0k|#define u_memchr U_ICU_ENTRY_POINT_RENAME(u_memchr) | | ------------------ | | | | 123| 26.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 26.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 26.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1146| 26.0k| if(match == nullptr) { ------------------ | Branch (1146:6): [True: 9.63k, False: 16.3k] ------------------ 1147| 9.63k| return -1; 1148| 16.3k| } else { 1149| 16.3k| return static_cast(match - array); 1150| 16.3k| } 1151| 26.0k|} _ZNK6icu_7813UnicodeString13doLastIndexOfEDsii: 1203| 7.17k|{ 1204| 7.17k| if(isBogus()) { ------------------ | Branch (1204:6): [True: 0, False: 7.17k] ------------------ 1205| 0| return -1; 1206| 0| } 1207| | 1208| | // pin indices 1209| 7.17k| pinIndices(start, length); 1210| | 1211| | // find the last occurrence of c 1212| 7.17k| const char16_t *array = getArrayStart(); 1213| 7.17k| const char16_t *match = u_memrchr(array + start, c, length); ------------------ | | 336| 7.17k|#define u_memrchr U_ICU_ENTRY_POINT_RENAME(u_memrchr) | | ------------------ | | | | 123| 7.17k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.17k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.17k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1214| 7.17k| if(match == nullptr) { ------------------ | Branch (1214:6): [True: 100, False: 7.07k] ------------------ 1215| 100| return -1; 1216| 7.07k| } else { 1217| 7.07k| return static_cast(match - array); 1218| 7.07k| } 1219| 7.17k|} _ZN6icu_7813UnicodeString10setToBogusEv: 1283| 13.6M|{ 1284| 13.6M| releaseArray(); 1285| | 1286| 13.6M| fUnion.fFields.fLengthAndFlags = kIsBogus; 1287| 13.6M| fUnion.fFields.fArray = nullptr; 1288| 13.6M| fUnion.fFields.fCapacity = 0; 1289| 13.6M|} _ZN6icu_7813UnicodeString7unBogusEv: 1293| 62.7M|UnicodeString::unBogus() { 1294| 62.7M| if(fUnion.fFields.fLengthAndFlags & kIsBogus) { ------------------ | Branch (1294:6): [True: 0, False: 62.7M] ------------------ 1295| 0| setToEmpty(); 1296| 0| } 1297| 62.7M|} _ZN6icu_7813UnicodeString19getTerminatedBufferEv: 1300| 11.8k|UnicodeString::getTerminatedBuffer() { 1301| 11.8k| if(!isWritable()) { ------------------ | Branch (1301:6): [True: 0, False: 11.8k] ------------------ 1302| 0| return nullptr; 1303| 0| } 1304| 11.8k| char16_t *array = getArrayStart(); 1305| 11.8k| int32_t len = length(); 1306| 11.8k| if(len < getCapacity()) { ------------------ | Branch (1306:6): [True: 11.7k, False: 23] ------------------ 1307| 11.7k| if(fUnion.fFields.fLengthAndFlags & kBufferIsReadonly) { ------------------ | Branch (1307:8): [True: 0, False: 11.7k] ------------------ 1308| | // If len= 0 && isTerminated && text[textLength] != 0) ------------------ | Branch (1358:8): [True: 10.7M, False: 0] | Branch (1358:27): [True: 1.08k, False: 10.7M] | Branch (1358:43): [True: 0, False: 1.08k] ------------------ 1359| 10.7M| ) { 1360| 0| setToBogus(); 1361| 0| return *this; 1362| 0| } 1363| | 1364| 10.7M| releaseArray(); 1365| | 1366| 10.7M| if(textLength == -1) { ------------------ | Branch (1366:6): [True: 0, False: 10.7M] ------------------ 1367| | // text is terminated, or else it would have failed the above test 1368| 0| textLength = u_strlen(text); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1369| 0| } 1370| 10.7M| fUnion.fFields.fLengthAndFlags = kReadonlyAlias; 1371| 10.7M| setArray(const_cast(text), textLength, isTerminated ? textLength + 1 : textLength); ------------------ | Branch (1371:53): [True: 1.08k, False: 10.7M] ------------------ 1372| 10.7M| return *this; 1373| 10.7M|} _ZN6icu_7813UnicodeString9setCharAtEiDs: 1439| 1.70M|{ 1440| 1.70M| int32_t len = length(); 1441| 1.70M| if(cloneArrayIfNeeded() && len > 0) { ------------------ | Branch (1441:6): [True: 1.70M, False: 0] | Branch (1441:30): [True: 1.70M, False: 0] ------------------ 1442| 1.70M| if(offset < 0) { ------------------ | Branch (1442:8): [True: 0, False: 1.70M] ------------------ 1443| 0| offset = 0; 1444| 1.70M| } else if(offset >= len) { ------------------ | Branch (1444:15): [True: 0, False: 1.70M] ------------------ 1445| 0| offset = len - 1; 1446| 0| } 1447| | 1448| 1.70M| getArrayStart()[offset] = c; 1449| 1.70M| } 1450| 1.70M| return *this; 1451| 1.70M|} _ZN6icu_7813UnicodeString7replaceEiii: 1456| 13.4M| UChar32 srcChar) { 1457| 13.4M| char16_t buffer[U16_MAX_LENGTH]; 1458| 13.4M| int32_t count = 0; 1459| 13.4M| UBool isError = false; 1460| 13.4M| U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError); ------------------ | | 393| 13.4M|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 13.4M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 13.4M| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 10.4M, False: 3.03M] | | ------------------ | | 395| 10.4M| (s)[(i)++]=(uint16_t)(c); \ | | 396| 10.4M| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 3.03M, False: 0] | | | Branch (396:42): [True: 3.03M, False: 0] | | ------------------ | | 397| 3.03M| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 3.03M| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 3.03M| } else /* c>0x10ffff or not enough space */ { \ | | 400| 0| (isError)=true; \ | | 401| 0| } \ | | 402| 13.4M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 13.4M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1461| | // We test isError so that the compiler does not complain that we don't. 1462| | // If isError (srcChar is not a valid code point) then count==0 which means 1463| | // we remove the source segment rather than replacing it with srcChar. 1464| 13.4M| return doReplace(start, _length, buffer, 0, isError ? 0 : count); ------------------ | Branch (1464:47): [True: 0, False: 13.4M] ------------------ 1465| 13.4M|} _ZN6icu_7813UnicodeString6appendEi: 1468| 124M|UnicodeString::append(UChar32 srcChar) { 1469| 124M| char16_t buffer[U16_MAX_LENGTH]; 1470| 124M| int32_t _length = 0; 1471| 124M| UBool isError = false; 1472| 124M| U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError); ------------------ | | 393| 124M|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 124M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 124M| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 124M, False: 117k] | | ------------------ | | 395| 124M| (s)[(i)++]=(uint16_t)(c); \ | | 396| 124M| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 117k, False: 0] | | | Branch (396:42): [True: 117k, False: 0] | | ------------------ | | 397| 117k| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 117k| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 117k| } else /* c>0x10ffff or not enough space */ { \ | | 400| 0| (isError)=true; \ | | 401| 0| } \ | | 402| 124M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 124M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1473| | // We test isError so that the compiler does not complain that we don't. 1474| | // If isError then _length==0 which turns the doAppend() into a no-op anyway. 1475| 124M| return isError ? *this : doAppend(buffer, 0, _length); ------------------ | Branch (1475:10): [True: 0, False: 124M] ------------------ 1476| 124M|} _ZN6icu_7813UnicodeString9doReplaceEiiRKS0_ii: 1484| 56.5M|{ 1485| | // pin the indices to legal values 1486| 56.5M| src.pinIndices(srcStart, srcLength); 1487| | 1488| | // get the characters from src 1489| | // and replace the range in ourselves with them 1490| 56.5M| return doReplace(start, length, src.getArrayStart(), srcStart, srcLength); 1491| 56.5M|} _ZN6icu_7813UnicodeString9doReplaceEiiPKDsii: 1499| 86.4M|{ 1500| 86.4M| if(!isWritable()) { ------------------ | Branch (1500:6): [True: 0, False: 86.4M] ------------------ 1501| 0| return *this; 1502| 0| } 1503| | 1504| 86.4M| int32_t oldLength = this->length(); 1505| | 1506| | // optimize (read-only alias).remove(0, start) and .remove(start, end) 1507| 86.4M| if((fUnion.fFields.fLengthAndFlags&kBufferIsReadonly) && srcLength == 0) { ------------------ | Branch (1507:6): [True: 3.92k, False: 86.3M] | Branch (1507:60): [True: 0, False: 3.92k] ------------------ 1508| 0| if(start == 0) { ------------------ | Branch (1508:8): [True: 0, False: 0] ------------------ 1509| | // remove prefix by adjusting the array pointer 1510| 0| pinIndex(length); 1511| 0| fUnion.fFields.fArray += length; 1512| 0| fUnion.fFields.fCapacity -= length; 1513| 0| setLength(oldLength - length); 1514| 0| return *this; 1515| 0| } else { 1516| 0| pinIndex(start); 1517| 0| if(length >= (oldLength - start)) { ------------------ | Branch (1517:10): [True: 0, False: 0] ------------------ 1518| | // remove suffix by reducing the length (like truncate()) 1519| 0| setLength(start); 1520| 0| fUnion.fFields.fCapacity = start; // not NUL-terminated any more 1521| 0| return *this; 1522| 0| } 1523| 0| } 1524| 0| } 1525| | 1526| 86.4M| if(start == oldLength) { ------------------ | Branch (1526:6): [True: 54.4M, False: 31.9M] ------------------ 1527| 54.4M| return doAppend(srcChars, srcStart, srcLength); 1528| 54.4M| } 1529| | 1530| 31.9M| if (srcChars == nullptr) { ------------------ | Branch (1530:7): [True: 16.3M, False: 15.6M] ------------------ 1531| 16.3M| srcLength = 0; 1532| 16.3M| } else { 1533| | // Perform all remaining operations relative to srcChars + srcStart. 1534| | // From this point forward, do not use srcStart. 1535| 15.6M| srcChars += srcStart; 1536| 15.6M| if (srcLength < 0) { ------------------ | Branch (1536:9): [True: 0, False: 15.6M] ------------------ 1537| | // get the srcLength if necessary 1538| 0| srcLength = u_strlen(srcChars); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1539| 0| } 1540| 15.6M| } 1541| | 1542| | // pin the indices to legal values 1543| 31.9M| pinIndices(start, length); 1544| | 1545| | // Calculate the size of the string after the replace. 1546| | // Avoid int32_t overflow. 1547| 31.9M| int32_t newLength = oldLength - length; 1548| 31.9M| if(srcLength > (INT32_MAX - newLength)) { ------------------ | Branch (1548:6): [True: 0, False: 31.9M] ------------------ 1549| 0| setToBogus(); 1550| 0| return *this; 1551| 0| } 1552| 31.9M| newLength += srcLength; 1553| | 1554| | // Check for insertion into ourself 1555| 31.9M| const char16_t *oldArray = getArrayStart(); 1556| 31.9M| if (isBufferWritable() && ------------------ | Branch (1556:7): [True: 31.9M, False: 4.14k] ------------------ 1557| 31.9M| oldArray < srcChars + srcLength && ------------------ | Branch (1557:7): [True: 10.4M, False: 21.5M] ------------------ 1558| 31.9M| srcChars < oldArray + oldLength) { ------------------ | Branch (1558:7): [True: 0, False: 10.4M] ------------------ 1559| | // Copy into a new UnicodeString and start over 1560| 0| UnicodeString copy(srcChars, srcLength); 1561| 0| if (copy.isBogus()) { ------------------ | Branch (1561:9): [True: 0, False: 0] ------------------ 1562| 0| setToBogus(); 1563| 0| return *this; 1564| 0| } 1565| 0| return doReplace(start, length, copy.getArrayStart(), 0, srcLength); 1566| 0| } 1567| | 1568| | // cloneArrayIfNeeded(doCopyArray=false) may change fArray but will not copy the current contents; 1569| | // therefore we need to keep the current fArray 1570| 31.9M| char16_t oldStackBuffer[US_STACKBUF_SIZE]; 1571| 31.9M| if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) { ------------------ | Branch (1571:6): [True: 31.3M, False: 637k] | Branch (1571:60): [True: 32, False: 31.3M] ------------------ 1572| | // copy the stack buffer contents because it will be overwritten with 1573| | // fUnion.fFields values 1574| 32| u_memcpy(oldStackBuffer, oldArray, oldLength); ------------------ | | 334| 32|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 32|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 32|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 32|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1575| 32| oldArray = oldStackBuffer; 1576| 32| } 1577| | 1578| | // clone our array and allocate a bigger array if needed 1579| 31.9M| int32_t *bufferToDelete = nullptr; 1580| 31.9M| if(!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength), ------------------ | Branch (1580:6): [True: 0, False: 31.9M] ------------------ 1581| 31.9M| false, &bufferToDelete) 1582| 31.9M| ) { 1583| 0| return *this; 1584| 0| } 1585| | 1586| | // now do the replace 1587| | 1588| 31.9M| char16_t *newArray = getArrayStart(); 1589| 31.9M| if(newArray != oldArray) { ------------------ | Branch (1589:6): [True: 4.23k, False: 31.9M] ------------------ 1590| | // if fArray changed, then we need to copy everything except what will change 1591| 4.23k| us_arrayCopy(oldArray, 0, newArray, 0, start); 1592| 4.23k| us_arrayCopy(oldArray, start + length, 1593| 4.23k| newArray, start + srcLength, 1594| 4.23k| oldLength - (start + length)); 1595| 31.9M| } else if(length != srcLength) { ------------------ | Branch (1595:13): [True: 18.5M, False: 13.4M] ------------------ 1596| | // fArray did not change; copy only the portion that isn't changing, leaving a hole 1597| 18.5M| us_arrayCopy(oldArray, start + length, 1598| 18.5M| newArray, start + srcLength, 1599| 18.5M| oldLength - (start + length)); 1600| 18.5M| } 1601| | 1602| | // now fill in the hole with the new string 1603| 31.9M| us_arrayCopy(srcChars, 0, newArray, start, srcLength); 1604| | 1605| 31.9M| setLength(newLength); 1606| | 1607| | // delayed delete in case srcChars == fArray when we started, and 1608| | // to keep oldArray alive for the above operations 1609| 31.9M| if (bufferToDelete) { ------------------ | Branch (1609:7): [True: 61, False: 31.9M] ------------------ 1610| 61| uprv_free(bufferToDelete); ------------------ | | 1503| 61|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 61|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 61|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 61|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 61| } 1612| | 1613| 31.9M| return *this; 1614| 31.9M|} _ZN6icu_7813UnicodeString9doReplaceEiiNSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 1617| 1.38k|UnicodeString::doReplace(int32_t start, int32_t length, std::u16string_view src) { 1618| 1.38k| if (!isWritable()) { ------------------ | Branch (1618:7): [True: 0, False: 1.38k] ------------------ 1619| 0| return *this; 1620| 0| } 1621| 1.38k| if (src.length() > INT32_MAX) { ------------------ | Branch (1621:7): [True: 0, False: 1.38k] ------------------ 1622| 0| setToBogus(); 1623| 0| return *this; 1624| 0| } 1625| 1.38k| return doReplace(start, length, src.data(), 0, static_cast(src.length())); 1626| 1.38k|} _ZN6icu_7813UnicodeString8doAppendERKS0_ii: 1632| 204M|UnicodeString::doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength) { 1633| 204M| if(srcLength == 0) { ------------------ | Branch (1633:6): [True: 1.58M, False: 203M] ------------------ 1634| 1.58M| return *this; 1635| 1.58M| } 1636| | 1637| | // pin the indices to legal values 1638| 203M| src.pinIndices(srcStart, srcLength); 1639| 203M| return doAppend(src.getArrayStart(), srcStart, srcLength); 1640| 204M|} _ZN6icu_7813UnicodeString8doAppendEPKDsii: 1643| 447M|UnicodeString::doAppend(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) { 1644| 447M| if(!isWritable() || srcLength == 0 || srcChars == nullptr) { ------------------ | Branch (1644:6): [True: 0, False: 447M] | Branch (1644:23): [True: 3.11M, False: 444M] | Branch (1644:41): [True: 0, False: 444M] ------------------ 1645| 3.11M| return *this; 1646| 3.11M| } 1647| | 1648| | // Perform all remaining operations relative to srcChars + srcStart. 1649| | // From this point forward, do not use srcStart. 1650| 444M| srcChars += srcStart; 1651| | 1652| 444M| if(srcLength < 0) { ------------------ | Branch (1652:6): [True: 0, False: 444M] ------------------ 1653| | // get the srcLength if necessary 1654| 0| if((srcLength = u_strlen(srcChars)) == 0) { ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1654:8): [True: 0, False: 0] ------------------ 1655| 0| return *this; 1656| 0| } 1657| 0| } 1658| | 1659| 444M| int32_t oldLength = length(); 1660| 444M| int32_t newLength; 1661| | 1662| 444M| if (srcLength <= getCapacity() - oldLength && isBufferWritable()) { ------------------ | Branch (1662:7): [True: 424M, False: 19.9M] | Branch (1662:49): [True: 424M, False: 13.4k] ------------------ 1663| 424M| newLength = oldLength + srcLength; 1664| | // Faster than a memmove 1665| 424M| if (srcLength <= 4) { ------------------ | Branch (1665:9): [True: 357M, False: 67.4M] ------------------ 1666| 357M| char16_t *arr = getArrayStart(); 1667| 357M| arr[oldLength] = srcChars[0]; 1668| 357M| if (srcLength > 1) arr[oldLength+1] = srcChars[1]; ------------------ | Branch (1668:11): [True: 111M, False: 245M] ------------------ 1669| 357M| if (srcLength > 2) arr[oldLength+2] = srcChars[2]; ------------------ | Branch (1669:11): [True: 34.0M, False: 323M] ------------------ 1670| 357M| if (srcLength > 3) arr[oldLength+3] = srcChars[3]; ------------------ | Branch (1670:11): [True: 5.37M, False: 351M] ------------------ 1671| 357M| setLength(newLength); 1672| 357M| return *this; 1673| 357M| } 1674| 424M| } else { 1675| 19.9M| if (uprv_add32_overflow(oldLength, srcLength, &newLength)) { ------------------ | | 1394| 19.9M|#define uprv_add32_overflow U_ICU_ENTRY_POINT_RENAME(uprv_add32_overflow) | | ------------------ | | | | 123| 19.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 19.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 19.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1675:9): [True: 0, False: 19.9M] ------------------ 1676| 0| setToBogus(); 1677| 0| return *this; 1678| 0| } 1679| | 1680| | // Check for append onto ourself 1681| 19.9M| const char16_t* oldArray = getArrayStart(); 1682| 19.9M| if (isBufferWritable() && ------------------ | Branch (1682:9): [True: 19.9M, False: 13.4k] ------------------ 1683| 19.9M| oldArray < srcChars + srcLength && ------------------ | Branch (1683:9): [True: 1.47M, False: 18.4M] ------------------ 1684| 19.9M| srcChars < oldArray + oldLength) { ------------------ | Branch (1684:9): [True: 0, False: 1.47M] ------------------ 1685| | // Copy into a new UnicodeString and start over 1686| 0| UnicodeString copy(srcChars, srcLength); 1687| 0| if (copy.isBogus()) { ------------------ | Branch (1687:11): [True: 0, False: 0] ------------------ 1688| 0| setToBogus(); 1689| 0| return *this; 1690| 0| } 1691| 0| return doAppend(copy.getArrayStart(), 0, srcLength); 1692| 0| } 1693| | 1694| | // optimize append() onto a large-enough, owned string 1695| 19.9M| if (!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength))) { ------------------ | Branch (1695:9): [True: 0, False: 19.9M] ------------------ 1696| 0| return *this; 1697| 0| } 1698| 19.9M| } 1699| | 1700| 87.4M| char16_t *newArray = getArrayStart(); 1701| | // Do not copy characters when 1702| | // char16_t *buffer=str.getAppendBuffer(...); 1703| | // is followed by 1704| | // str.append(buffer, length); 1705| | // or 1706| | // str.appendString(buffer, length) 1707| | // or similar. 1708| 87.4M| if(srcChars != newArray + oldLength) { ------------------ | Branch (1708:6): [True: 87.4M, False: 0] ------------------ 1709| 87.4M| us_arrayCopy(srcChars, 0, newArray, oldLength, srcLength); 1710| 87.4M| } 1711| 87.4M| setLength(newLength); 1712| | 1713| 87.4M| return *this; 1714| 444M|} _ZN6icu_7813UnicodeString9doReverseEii: 1773| 2.75M|UnicodeString::doReverse(int32_t start, int32_t length) { 1774| 2.75M| if(length <= 1 || !cloneArrayIfNeeded()) { ------------------ | Branch (1774:6): [True: 358k, False: 2.39M] | Branch (1774:21): [True: 0, False: 2.39M] ------------------ 1775| 358k| return *this; 1776| 358k| } 1777| | 1778| | // pin the indices to legal values 1779| 2.39M| pinIndices(start, length); 1780| 2.39M| if(length <= 1) { // pinIndices() might have shrunk the length ------------------ | Branch (1780:6): [True: 0, False: 2.39M] ------------------ 1781| 0| return *this; 1782| 0| } 1783| | 1784| 2.39M| char16_t *left = getArrayStart() + start; 1785| 2.39M| char16_t *right = left + length - 1; // -1 for inclusive boundary (length>=2) 1786| 2.39M| char16_t swap; 1787| 2.39M| UBool hasSupplementary = false; 1788| | 1789| | // Before the loop we know left=2. 1790| 87.3M| do { 1791| 87.3M| hasSupplementary |= static_cast(U16_IS_LEAD(swap = *left)); ------------------ | | 59| 87.3M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ 1792| 87.3M| hasSupplementary |= static_cast(U16_IS_LEAD(*left++ = *right)); ------------------ | | 59| 87.3M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ 1793| 87.3M| *right-- = swap; 1794| 87.3M| } while(left < right); ------------------ | Branch (1794:11): [True: 84.9M, False: 2.39M] ------------------ 1795| | // Make sure to test the middle code unit of an odd-length string. 1796| | // Redundant if the length is even. 1797| 2.39M| hasSupplementary |= static_cast(U16_IS_LEAD(*left)); ------------------ | | 59| 2.39M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ 1798| | 1799| | /* if there are supplementary code points in the reversed range, then re-swap their surrogates */ 1800| 2.39M| if(hasSupplementary) { ------------------ | Branch (1800:6): [True: 221k, False: 2.17M] ------------------ 1801| 221k| char16_t swap2; 1802| | 1803| 221k| left = getArrayStart() + start; 1804| 221k| right = left + length - 1; // -1 so that we can look at *(left+1) if left=-1 && cloneArrayIfNeeded(minCapacity)) { ------------------ | Branch (1880:6): [True: 55.8M, False: 0] | Branch (1880:25): [True: 55.8M, False: 0] ------------------ 1881| 55.8M| fUnion.fFields.fLengthAndFlags|=kOpenGetBuffer; 1882| 55.8M| setZeroLength(); 1883| 55.8M| return getArrayStart(); 1884| 55.8M| } else { 1885| 0| return nullptr; 1886| 0| } 1887| 55.8M|} _ZN6icu_7813UnicodeString13releaseBufferEi: 1890| 55.8M|UnicodeString::releaseBuffer(int32_t newLength) { 1891| 55.8M| if(fUnion.fFields.fLengthAndFlags&kOpenGetBuffer && newLength>=-1) { ------------------ | Branch (1891:6): [True: 55.8M, False: 0] | Branch (1891:55): [True: 55.8M, False: 0] ------------------ 1892| | // set the new fLength 1893| 55.8M| int32_t capacity=getCapacity(); 1894| 55.8M| if(newLength==-1) { ------------------ | Branch (1894:8): [True: 0, False: 55.8M] ------------------ 1895| | // the new length is the string length, capped by fCapacity 1896| 0| const char16_t *array=getArrayStart(), *p=array, *limit=array+capacity; 1897| 0| while(p(p - array); 1901| 55.8M| } else if(newLength>capacity) { ------------------ | Branch (1901:15): [True: 0, False: 55.8M] ------------------ 1902| 0| newLength=capacity; 1903| 0| } 1904| 55.8M| setLength(newLength); 1905| 55.8M| fUnion.fFields.fLengthAndFlags&=~kOpenGetBuffer; 1906| 55.8M| } 1907| 55.8M|} _ZN6icu_7813UnicodeString18cloneArrayIfNeededEiiaPPia: 1917| 111M| UBool forceClone) { 1918| | // default parameters need to be static, therefore 1919| | // the defaults are -1 to have convenience defaults 1920| 111M| if(newCapacity == -1) { ------------------ | Branch (1920:6): [True: 4.09M, False: 107M] ------------------ 1921| 4.09M| newCapacity = getCapacity(); 1922| 4.09M| } 1923| | 1924| | // while a getBuffer(minCapacity) is "open", 1925| | // prevent any modifications of the string by returning false here 1926| | // if the string is bogus, then only an assignment or similar can revive it 1927| 111M| if(!isWritable()) { ------------------ | Branch (1927:6): [True: 0, False: 111M] ------------------ 1928| 0| return false; 1929| 0| } 1930| | 1931| | /* 1932| | * We need to make a copy of the array if 1933| | * the buffer is read-only, or 1934| | * the buffer is refCounted (shared), and refCount>1, or 1935| | * the buffer is too small. 1936| | * Return false if memory could not be allocated. 1937| | */ 1938| 111M| if(forceClone || ------------------ | Branch (1938:6): [True: 0, False: 111M] ------------------ 1939| 111M| fUnion.fFields.fLengthAndFlags & kBufferIsReadonly || ------------------ | Branch (1939:6): [True: 3.92k, False: 111M] ------------------ 1940| 111M| (fUnion.fFields.fLengthAndFlags & kRefCounted && refCount() > 1) || ------------------ | Branch (1940:7): [True: 4.35M, False: 107M] | Branch (1940:55): [True: 18.9k, False: 4.33M] ------------------ 1941| 111M| newCapacity > getCapacity() ------------------ | Branch (1941:6): [True: 20.3M, False: 91.5M] ------------------ 1942| 111M| ) { 1943| | // check growCapacity for default value and use of the stack buffer 1944| 20.3M| if(growCapacity < 0) { ------------------ | Branch (1944:8): [True: 432k, False: 19.9M] ------------------ 1945| 432k| growCapacity = newCapacity; 1946| 19.9M| } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) { ------------------ | Branch (1946:15): [True: 5.95k, False: 19.9M] | Branch (1946:50): [True: 5.95k, False: 0] ------------------ 1947| 5.95k| growCapacity = US_STACKBUF_SIZE; 1948| 19.9M| } else if(newCapacity > growCapacity) { ------------------ | Branch (1948:15): [True: 0, False: 19.9M] ------------------ 1949| 0| setToBogus(); 1950| 0| return false; // bad inputs 1951| 0| } 1952| 20.3M| if(growCapacity > kMaxCapacity) { ------------------ | Branch (1952:8): [True: 0, False: 20.3M] ------------------ 1953| 0| setToBogus(); 1954| 0| return false; 1955| 0| } 1956| | 1957| | // save old values 1958| 20.3M| char16_t oldStackBuffer[US_STACKBUF_SIZE]; 1959| 20.3M| char16_t *oldArray; 1960| 20.3M| int32_t oldLength = length(); 1961| 20.3M| int16_t flags = fUnion.fFields.fLengthAndFlags; 1962| | 1963| 20.3M| if(flags&kUsingStackBuffer) { ------------------ | Branch (1963:8): [True: 18.8M, False: 1.52M] ------------------ 1964| 18.8M| U_ASSERT(!(flags&kRefCounted)); /* kRefCounted and kUsingStackBuffer are mutally exclusive */ ------------------ | | 35| 18.8M|# define U_ASSERT(exp) (void)0 ------------------ 1965| 18.8M| if(doCopyArray && growCapacity > US_STACKBUF_SIZE) { ------------------ | Branch (1965:10): [True: 18.8M, False: 32] | Branch (1965:25): [True: 18.8M, False: 0] ------------------ 1966| | // copy the stack buffer contents because it will be overwritten with 1967| | // fUnion.fFields values 1968| 18.8M| us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength); 1969| 18.8M| oldArray = oldStackBuffer; 1970| 18.8M| } else { 1971| 32| oldArray = nullptr; // no need to copy from the stack buffer to itself 1972| 32| } 1973| 18.8M| } else { 1974| 1.52M| oldArray = fUnion.fFields.fArray; 1975| 1.52M| U_ASSERT(oldArray!=nullptr); /* when stack buffer is not used, oldArray must have a non-nullptr reference */ ------------------ | | 35| 1.52M|# define U_ASSERT(exp) (void)0 ------------------ 1976| 1.52M| } 1977| | 1978| | // allocate a new array 1979| 20.3M| if(allocate(growCapacity) || ------------------ | Branch (1979:8): [True: 20.3M, False: 0] ------------------ 1980| 20.3M| (newCapacity < growCapacity && allocate(newCapacity)) ------------------ | Branch (1980:9): [True: 0, False: 0] | Branch (1980:39): [True: 0, False: 0] ------------------ 1981| 20.3M| ) { 1982| 20.3M| if(doCopyArray) { ------------------ | Branch (1982:10): [True: 20.3M, False: 4.23k] ------------------ 1983| | // copy the contents 1984| | // do not copy more than what fits - it may be smaller than before 1985| 20.3M| int32_t minLength = oldLength; 1986| 20.3M| newCapacity = getCapacity(); 1987| 20.3M| if(newCapacity < minLength) { ------------------ | Branch (1987:12): [True: 0, False: 20.3M] ------------------ 1988| 0| minLength = newCapacity; 1989| 0| } 1990| 20.3M| if(oldArray != nullptr) { ------------------ | Branch (1990:12): [True: 20.3M, False: 0] ------------------ 1991| 20.3M| us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength); 1992| 20.3M| } 1993| 20.3M| setLength(minLength); 1994| 20.3M| } else { 1995| 4.23k| setZeroLength(); 1996| 4.23k| } 1997| | 1998| | // release the old array 1999| 20.3M| if(flags & kRefCounted) { ------------------ | Branch (1999:10): [True: 1.52M, False: 18.8M] ------------------ 2000| | // the array is refCounted; decrement and release if 0 2001| 1.52M| u_atomic_int32_t* pRefCount = reinterpret_cast(oldArray) - 1; 2002| 1.52M| if(umtx_atomic_dec(pRefCount) == 0) { ------------------ | Branch (2002:12): [True: 1.50M, False: 18.9k] ------------------ 2003| 1.50M| if (pBufferToDelete == nullptr) { ------------------ | Branch (2003:15): [True: 1.50M, False: 61] ------------------ 2004| | // Note: cast to (void *) is needed with MSVC, where u_atomic_int32_t 2005| | // is defined as volatile. (Volatile has useful non-standard behavior 2006| | // with this compiler.) 2007| 1.50M| uprv_free((void *)pRefCount); ------------------ | | 1503| 1.50M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.50M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.50M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.50M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2008| 1.50M| } else { 2009| | // the caller requested to delete it himself 2010| 61| *pBufferToDelete = reinterpret_cast(pRefCount); 2011| 61| } 2012| 1.50M| } 2013| 1.52M| } 2014| 20.3M| } else { 2015| | // not enough memory for growCapacity and not even for the smaller newCapacity 2016| | // reset the old values for setToBogus() to release the array 2017| 0| if(!(flags&kUsingStackBuffer)) { ------------------ | Branch (2017:10): [True: 0, False: 0] ------------------ 2018| 0| fUnion.fFields.fArray = oldArray; 2019| 0| } 2020| 0| fUnion.fFields.fLengthAndFlags = flags; 2021| 0| setToBogus(); 2022| 0| return false; 2023| 0| } 2024| 20.3M| } 2025| 111M| return true; 2026| 111M|} uhash_hashUnicodeString_78: 2081| 60.2M|uhash_hashUnicodeString(const UElement key) { 2082| 60.2M| const UnicodeString *str = (const UnicodeString*) key.pointer; 2083| 60.2M| return (str == nullptr) ? 0 : str->hashCode(); ------------------ | Branch (2083:12): [True: 0, False: 60.2M] ------------------ 2084| 60.2M|} uhash_compareUnicodeString_78: 2089| 69.2M|uhash_compareUnicodeString(const UElement key1, const UElement key2) { 2090| 69.2M| const UnicodeString *str1 = (const UnicodeString*) key1.pointer; 2091| 69.2M| const UnicodeString *str2 = (const UnicodeString*) key2.pointer; 2092| 69.2M| if (str1 == str2) { ------------------ | Branch (2092:9): [True: 0, False: 69.2M] ------------------ 2093| 0| return true; 2094| 0| } 2095| 69.2M| if (str1 == nullptr || str2 == nullptr) { ------------------ | Branch (2095:9): [True: 0, False: 69.2M] | Branch (2095:28): [True: 0, False: 69.2M] ------------------ 2096| 0| return false; 2097| 0| } 2098| 69.2M| return *str1 == *str2; 2099| 69.2M|} unistr.cpp:_ZL20UnicodeString_charAtiPv: 96| 8.24k|UnicodeString_charAt(int32_t offset, void *context) { 97| 8.24k| return ((icu::UnicodeString*) context)->charAt(offset); 98| 8.24k|} unistr.cpp:_ZL12us_arrayCopyPKDsiPDsii: 87| 177M|{ 88| 177M| if(count>0) { ------------------ | Branch (88:6): [True: 119M, False: 58.0M] ------------------ 89| 119M| uprv_memmove(dst+dstStart, src+srcStart, (size_t)count*sizeof(*src)); ------------------ | | 51| 119M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 119M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 119M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 119M| _Pragma("clang diagnostic push") \ | | 54| 119M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 119M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 119M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 119M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 119M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 119M| _Pragma("clang diagnostic pop") \ | | 58| 119M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 119M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 119M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 119M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 90| 119M| } 91| 177M|} unistr.cpp:_ZN6icu_7812_GLOBAL__N_115getGrowCapacityEi: 397| 51.9M|int32_t getGrowCapacity(int32_t newLength) { 398| 51.9M| int32_t growSize = (newLength >> 2) + kGrowSize; 399| 51.9M| if(growSize <= (kMaxCapacity - newLength)) { ------------------ | Branch (399:6): [True: 51.9M, False: 0] ------------------ 400| 51.9M| return newLength + growSize; 401| 51.9M| } else { 402| 0| return kMaxCapacity; 403| 0| } 404| 51.9M|} _ZN6icu_787UMemorynwEm: 61| 224M|void * U_EXPORT2 UMemory::operator new(size_t size) noexcept { 62| 224M| return uprv_malloc(size); ------------------ | | 1524| 224M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 224M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 224M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 224M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 224M|} _ZN6icu_787UMemorydlEPv: 65| 224M|void U_EXPORT2 UMemory::operator delete(void *p) noexcept { 66| 224M| if(p!=nullptr) { ------------------ | Branch (66:8): [True: 224M, False: 0] ------------------ 67| 224M| uprv_free(p); ------------------ | | 1503| 224M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 224M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 224M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 224M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 68| 224M| } 69| 224M|} _ZN6icu_787UMemorynaEm: 71| 14.3M|void * U_EXPORT2 UMemory::operator new[](size_t size) noexcept { 72| 14.3M| return uprv_malloc(size); ------------------ | | 1524| 14.3M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 14.3M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 14.3M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 14.3M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 73| 14.3M|} _ZN6icu_787UMemorydaEPv: 75| 14.3M|void U_EXPORT2 UMemory::operator delete[](void *p) noexcept { 76| 14.3M| if(p!=nullptr) { ------------------ | Branch (76:8): [True: 14.3M, False: 0] ------------------ 77| 14.3M| uprv_free(p); ------------------ | | 1503| 14.3M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 14.3M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 14.3M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 14.3M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 78| 14.3M| } 79| 14.3M|} _ZN6icu_787UObjectD2Ev: 94| 1.29G|UObject::~UObject() {} uprv_deleteUObject_78: 103| 136M|uprv_deleteUObject(void *obj) { 104| 136M| delete static_cast(obj); 105| 136M|} u_hasBinaryProperty_78: 487| 40.9k|u_hasBinaryProperty(UChar32 c, UProperty which) { 488| | /* c is range-checked in the functions that are called from here */ 489| 40.9k| if(which(uscript_getScript(c, &errorCode)); ------------------ | | 1706| 534k|#define uscript_getScript U_ICU_ENTRY_POINT_RENAME(uscript_getScript) | | ------------------ | | | | 123| 534k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 534k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 534k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 534k|} uprops.cpp:_ZL17getNormQuickCheckRK11IntPropertyi9UProperty: 658| 1.90M|static int32_t getNormQuickCheck(const IntProperty &/*prop*/, UChar32 c, UProperty which) { 659| 1.90M| return static_cast(unorm_getQuickCheck(c, static_cast(which - UCHAR_NFD_QUICK_CHECK + UNORM_NFD))); ------------------ | | 1289| 1.90M|#define unorm_getQuickCheck U_ICU_ENTRY_POINT_RENAME(unorm_getQuickCheck) | | ------------------ | | | | 123| 1.90M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.90M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.90M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 660| 1.90M|} ures_close_78: 1147| 28.0k|{ 1148| 28.0k| ures_closeBundle(resB, true); 1149| 28.0k|} ures_getString_78: 1524| 79.7k|U_CAPI const char16_t* U_EXPORT2 ures_getString(const UResourceBundle* resB, int32_t* len, UErrorCode* status) { 1525| 79.7k| const char16_t *s; 1526| 79.7k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (1526:9): [True: 0, False: 79.7k] | Branch (1526:28): [True: 0, False: 79.7k] ------------------ 1527| 0| return nullptr; 1528| 0| } 1529| 79.7k| if(resB == nullptr) { ------------------ | Branch (1529:8): [True: 0, False: 79.7k] ------------------ 1530| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1531| 0| return nullptr; 1532| 0| } 1533| 79.7k| s = res_getString({resB}, &resB->getResData(), resB->fRes, len); 1534| 79.7k| if (s == nullptr) { ------------------ | Branch (1534:9): [True: 0, False: 79.7k] ------------------ 1535| 0| *status = U_RESOURCE_TYPE_MISMATCH; 1536| 0| } 1537| 79.7k| return s; 1538| 79.7k|} ures_getKey_78: 1685| 1.26k|U_CAPI const char * U_EXPORT2 ures_getKey(const UResourceBundle *resB) { 1686| | // 1687| | // TODO: Trace ures_getKey? I guess not usually. 1688| | // 1689| | // We usually get the key string to decide whether we want the value, or to 1690| | // make a key-value pair. Tracing the value should suffice. 1691| | // 1692| | // However, I believe we have some data (e.g., in res_index) where the key 1693| | // strings are the data. Tracing the enclosing table should suffice. 1694| | // 1695| 1.26k| if(resB == nullptr) { ------------------ | Branch (1695:6): [True: 0, False: 1.26k] ------------------ 1696| 0| return nullptr; 1697| 0| } 1698| 1.26k| return(resB->fKey); 1699| 1.26k|} ures_resetIterator_78: 1721| 917|U_CAPI void U_EXPORT2 ures_resetIterator(UResourceBundle *resB){ 1722| 917| if(resB == nullptr) { ------------------ | Branch (1722:6): [True: 0, False: 917] ------------------ 1723| 0| return; 1724| 0| } 1725| 917| resB->fIndex = -1; 1726| 917|} ures_hasNext_78: 1728| 80.7k|U_CAPI UBool U_EXPORT2 ures_hasNext(const UResourceBundle *resB) { 1729| 80.7k| if(resB == nullptr) { ------------------ | Branch (1729:6): [True: 0, False: 80.7k] ------------------ 1730| 0| return false; 1731| 0| } 1732| 80.7k| return resB->fIndex < resB->fSize-1; 1733| 80.7k|} ures_getNextResource_78: 1784| 79.7k|U_CAPI UResourceBundle* U_EXPORT2 ures_getNextResource(UResourceBundle *resB, UResourceBundle *fillIn, UErrorCode *status) { 1785| 79.7k| const char *key = nullptr; 1786| 79.7k| Resource r = RES_BOGUS; ------------------ | | 65| 79.7k|#define RES_BOGUS 0xffffffff ------------------ 1787| | 1788| 79.7k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (1788:9): [True: 0, False: 79.7k] | Branch (1788:28): [True: 0, False: 79.7k] ------------------ 1789| | /*return nullptr;*/ 1790| 0| return fillIn; 1791| 0| } 1792| 79.7k| if(resB == nullptr) { ------------------ | Branch (1792:8): [True: 0, False: 79.7k] ------------------ 1793| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1794| | /*return nullptr;*/ 1795| 0| return fillIn; 1796| 0| } 1797| | 1798| 79.7k| if(resB->fIndex == resB->fSize-1) { ------------------ | Branch (1798:8): [True: 0, False: 79.7k] ------------------ 1799| 0| *status = U_INDEX_OUTOFBOUNDS_ERROR; 1800| | /*return nullptr;*/ 1801| 79.7k| } else { 1802| 79.7k| resB->fIndex++; 1803| 79.7k| switch(RES_GET_TYPE(resB->fRes)) { ------------------ | | 68| 79.7k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 1804| 0| case URES_INT: ------------------ | Branch (1804:9): [True: 0, False: 79.7k] ------------------ 1805| 0| case URES_BINARY: ------------------ | Branch (1805:9): [True: 0, False: 79.7k] ------------------ 1806| 0| case URES_STRING: ------------------ | Branch (1806:9): [True: 0, False: 79.7k] ------------------ 1807| 0| case URES_STRING_V2: ------------------ | Branch (1807:9): [True: 0, False: 79.7k] ------------------ 1808| 0| case URES_INT_VECTOR: ------------------ | Branch (1808:9): [True: 0, False: 79.7k] ------------------ 1809| 0| return ures_copyResb(fillIn, resB, status); ------------------ | | 1653| 0|#define ures_copyResb U_ICU_ENTRY_POINT_RENAME(ures_copyResb) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1810| 0| case URES_TABLE: ------------------ | Branch (1810:9): [True: 0, False: 79.7k] ------------------ 1811| 79.7k| case URES_TABLE16: ------------------ | Branch (1811:9): [True: 79.7k, False: 0] ------------------ 1812| 79.7k| case URES_TABLE32: ------------------ | Branch (1812:9): [True: 0, False: 79.7k] ------------------ 1813| 79.7k| r = res_getTableItemByIndex(&resB->getResData(), resB->fRes, resB->fIndex, &key); ------------------ | | 206| 79.7k|#define res_getTableItemByIndex U_ICU_ENTRY_POINT_RENAME(res_getTableItemByIndex) | | ------------------ | | | | 123| 79.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 79.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 79.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1814| 79.7k| if(r == RES_BOGUS && resB->fHasFallback) { ------------------ | | 65| 159k|#define RES_BOGUS 0xffffffff ------------------ | Branch (1814:16): [True: 0, False: 79.7k] | Branch (1814:34): [True: 0, False: 0] ------------------ 1815| | /* TODO: do the fallback */ 1816| 0| } 1817| 79.7k| return init_resb_result(resB->fData, r, key, resB->fIndex, resB, fillIn, status); 1818| 0| case URES_ARRAY: ------------------ | Branch (1818:9): [True: 0, False: 79.7k] ------------------ 1819| 0| case URES_ARRAY16: ------------------ | Branch (1819:9): [True: 0, False: 79.7k] ------------------ 1820| 0| r = res_getArrayItem(&resB->getResData(), resB->fRes, resB->fIndex); ------------------ | | 200| 0|#define res_getArrayItem U_ICU_ENTRY_POINT_RENAME(res_getArrayItem) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1821| 0| if(r == RES_BOGUS && resB->fHasFallback) { ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ | Branch (1821:16): [True: 0, False: 0] | Branch (1821:34): [True: 0, False: 0] ------------------ 1822| | /* TODO: do the fallback */ 1823| 0| } 1824| 0| return init_resb_result(resB->fData, r, key, resB->fIndex, resB, fillIn, status); 1825| 0| default: ------------------ | Branch (1825:9): [True: 0, False: 79.7k] ------------------ 1826| | /*return nullptr;*/ 1827| 0| return fillIn; 1828| 79.7k| } 1829| 79.7k| } 1830| | /*return nullptr;*/ 1831| 0| return fillIn; 1832| 79.7k|} ures_getByKeyWithFallback_78: 2164| 4.85k| UErrorCode *status) { 2165| 4.85k| Resource res = RES_BOGUS, rootRes = RES_BOGUS; ------------------ | | 65| 4.85k|#define RES_BOGUS 0xffffffff ------------------ Resource res = RES_BOGUS, rootRes = RES_BOGUS; ------------------ | | 65| 4.85k|#define RES_BOGUS 0xffffffff ------------------ 2166| 4.85k| UResourceBundle *helper = nullptr; 2167| | 2168| 4.85k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (2168:9): [True: 0, False: 4.85k] | Branch (2168:28): [True: 0, False: 4.85k] ------------------ 2169| 0| return fillIn; 2170| 0| } 2171| 4.85k| if(resB == nullptr) { ------------------ | Branch (2171:8): [True: 0, False: 4.85k] ------------------ 2172| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2173| 0| return fillIn; 2174| 0| } 2175| | 2176| 4.85k| int32_t type = RES_GET_TYPE(resB->fRes); ------------------ | | 68| 4.85k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2177| 4.85k| if(URES_IS_TABLE(type)) { ------------------ | | 84| 4.85k|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 4.80k, False: 48] | | | Branch (84:61): [True: 48, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 2178| 4.85k| const char* origResPath = resB->fResPath; 2179| 4.85k| int32_t origResPathLen = resB->fResPathLen; 2180| 4.85k| res = getTableItemByKeyPath(&resB->getResData(), resB->fRes, inKey); 2181| 4.85k| const char* key = inKey; 2182| 4.85k| bool didRootOnce = false; 2183| 4.85k| if(res == RES_BOGUS) { ------------------ | | 65| 4.85k|#define RES_BOGUS 0xffffffff ------------------ | Branch (2183:12): [True: 96, False: 4.75k] ------------------ 2184| 96| UResourceDataEntry *dataEntry = resB->fData; 2185| 96| CharString path; 2186| 96| char *myPath = nullptr; 2187| 96| const char* resPath = resB->fResPath; 2188| 96| int32_t len = resB->fResPathLen; 2189| 349| while(res == RES_BOGUS && (dataEntry->fParent != nullptr || !didRootOnce)) { /* Otherwise, we'll look in parents */ ------------------ | | 65| 698|#define RES_BOGUS 0xffffffff ------------------ | Branch (2189:19): [True: 290, False: 59] | Branch (2189:40): [True: 216, False: 74] | Branch (2189:73): [True: 37, False: 37] ------------------ 2190| 253| if (dataEntry->fParent != nullptr) { ------------------ | Branch (2190:21): [True: 216, False: 37] ------------------ 2191| 216| dataEntry = dataEntry->fParent; 2192| 216| } else { 2193| | // We can't just stop when we get to a bundle whose fParent is nullptr. That'll work most of the time, 2194| | // but if the bundle that the caller passed to us was "root" (which happens in getAllItemsWithFallback(), 2195| | // this function will drop right out without doing anything if "root" doesn't contain the exact key path 2196| | // specified. In that case, we need one extra time through this loop to make sure we follow any 2197| | // applicable aliases at the root level. 2198| 37| didRootOnce = true; 2199| 37| } 2200| 253| rootRes = dataEntry->fData.rootRes; 2201| | 2202| 253| if(dataEntry->fBogus == U_ZERO_ERROR) { ------------------ | Branch (2202:20): [True: 253, False: 0] ------------------ 2203| 253| createPath(origResPath, origResPathLen, resPath, len, inKey, path, status); 2204| 253| if (U_FAILURE(*status)) { ------------------ | Branch (2204:25): [True: 0, False: 253] ------------------ 2205| 0| ures_close(helper); ------------------ | | 1652| 0|#define ures_close U_ICU_ENTRY_POINT_RENAME(ures_close) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2206| 0| return fillIn; 2207| 0| } 2208| 253| myPath = path.data(); 2209| 253| key = inKey; 2210| 253| do { 2211| 253| res = res_findResource(&(dataEntry->fData), rootRes, &myPath, &key); ------------------ | | 198| 253|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 253|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 253|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 253|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2212| 253| if (RES_GET_TYPE(res) == URES_ALIAS && *myPath) { ------------------ | | 68| 253|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (2212:29): [True: 0, False: 253] | Branch (2212:64): [True: 0, False: 0] ------------------ 2213| | /* We hit an alias, but we didn't finish following the path. */ 2214| 0| helper = init_resb_result(dataEntry, res, nullptr, -1, resB, helper, status); 2215| | /*helper = init_resb_result(dataEntry, res, inKey, -1, resB, helper, status);*/ 2216| 0| if(helper) { ------------------ | Branch (2216:32): [True: 0, False: 0] ------------------ 2217| 0| dataEntry = helper->fData; 2218| 0| rootRes = helper->fRes; 2219| 0| resPath = helper->fResPath; 2220| 0| len = helper->fResPathLen; 2221| | 2222| 0| } else { 2223| 0| break; 2224| 0| } 2225| 253| } else if (res == RES_BOGUS) { ------------------ | | 65| 253|#define RES_BOGUS 0xffffffff ------------------ | Branch (2225:36): [True: 194, False: 59] ------------------ 2226| 194| break; 2227| 194| } 2228| 253| } while(*myPath); /* Continue until the whole path is consumed */ ------------------ | Branch (2228:29): [True: 0, False: 59] ------------------ 2229| 253| } 2230| 253| } 2231| | /*dataEntry = getFallbackData(resB, &key, &res, status);*/ 2232| 96| if(res != RES_BOGUS) { ------------------ | | 65| 96|#define RES_BOGUS 0xffffffff ------------------ | Branch (2232:16): [True: 59, False: 37] ------------------ 2233| | /* check if resB->fResPath gives the right name here */ 2234| 59| if(uprv_strcmp(dataEntry->fName, uloc_getDefault())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName)==0) { ------------------ | | 38| 59|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 59|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ if(uprv_strcmp(dataEntry->fName, uloc_getDefault())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName)==0) { ------------------ | | 38| 59|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 59|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (2234:20): [True: 0, False: 59] | Branch (2234:75): [True: 59, False: 0] ------------------ 2235| 59| *status = U_USING_DEFAULT_WARNING; 2236| 59| } else { 2237| 0| *status = U_USING_FALLBACK_WARNING; 2238| 0| } 2239| | 2240| 59| fillIn = init_resb_result(dataEntry, res, key, -1, resB, fillIn, status); 2241| 59| if (resPath != nullptr) { ------------------ | Branch (2241:21): [True: 59, False: 0] ------------------ 2242| 59| createPath(origResPath, origResPathLen, resPath, len, inKey, path, status); 2243| 59| } else { 2244| 0| const char* separator = nullptr; 2245| 0| if (fillIn->fResPath != nullptr) { ------------------ | Branch (2245:25): [True: 0, False: 0] ------------------ 2246| 0| separator = uprv_strchr(fillIn->fResPath, RES_PATH_SEPARATOR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2247| 0| } 2248| 0| if (separator != nullptr && separator[1] != '\0') { ------------------ | Branch (2248:25): [True: 0, False: 0] | Branch (2248:49): [True: 0, False: 0] ------------------ 2249| 0| createPath(origResPath, origResPathLen, fillIn->fResPath, 2250| 0| static_cast(uprv_strlen(fillIn->fResPath)), inKey, path, status); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2251| 0| } else { 2252| 0| createPath(origResPath, origResPathLen, "", 0, inKey, path, status); 2253| 0| } 2254| 0| } 2255| 59| ures_freeResPath(fillIn); 2256| 59| ures_appendResPath(fillIn, path.data(), path.length(), status); 2257| 59| if(fillIn->fResPath[fillIn->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 59|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2257:20): [True: 59, False: 0] ------------------ 2258| 59| ures_appendResPath(fillIn, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 59|#define RES_PATH_SEPARATOR_S "/" ------------------ 2259| 59| } 2260| 59| } else { 2261| 37| *status = U_MISSING_RESOURCE_ERROR; 2262| 37| } 2263| 4.75k| } else { 2264| 4.75k| fillIn = init_resb_result(resB->fData, res, key, -1, resB, fillIn, status); 2265| 4.75k| } 2266| 4.85k| } 2267| 0| else { 2268| 0| *status = U_RESOURCE_TYPE_MISMATCH; 2269| 0| } 2270| 4.85k| ures_close(helper); ------------------ | | 1652| 4.85k|#define ures_close U_ICU_ENTRY_POINT_RENAME(ures_close) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2271| 4.85k| return fillIn; 2272| 4.85k|} ures_getByKey_78: 2493| 4.96k|U_CAPI UResourceBundle* U_EXPORT2 ures_getByKey(const UResourceBundle *resB, const char* inKey, UResourceBundle *fillIn, UErrorCode *status) { 2494| 4.96k| Resource res = RES_BOGUS; ------------------ | | 65| 4.96k|#define RES_BOGUS 0xffffffff ------------------ 2495| 4.96k| UResourceDataEntry *dataEntry = nullptr; 2496| 4.96k| const char *key = inKey; 2497| | 2498| 4.96k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (2498:9): [True: 0, False: 4.96k] | Branch (2498:28): [True: 0, False: 4.96k] ------------------ 2499| 0| return fillIn; 2500| 0| } 2501| 4.96k| if(resB == nullptr) { ------------------ | Branch (2501:8): [True: 0, False: 4.96k] ------------------ 2502| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2503| 0| return fillIn; 2504| 0| } 2505| | 2506| 4.96k| int32_t type = RES_GET_TYPE(resB->fRes); ------------------ | | 68| 4.96k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2507| 4.96k| if(URES_IS_TABLE(type)) { ------------------ | | 84| 4.96k|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 4.91k, False: 50] | | | Branch (84:61): [True: 50, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 2508| 4.96k| int32_t t; 2509| 4.96k| res = res_getTableItemByKey(&resB->getResData(), resB->fRes, &t, &key); ------------------ | | 207| 4.96k|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 4.96k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.96k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.96k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2510| 4.96k| if(res == RES_BOGUS) { ------------------ | | 65| 4.96k|#define RES_BOGUS 0xffffffff ------------------ | Branch (2510:12): [True: 134, False: 4.83k] ------------------ 2511| 134| key = inKey; 2512| 134| if(resB->fHasFallback) { ------------------ | Branch (2512:16): [True: 64, False: 70] ------------------ 2513| 64| dataEntry = getFallbackData(resB, &key, &res, status); 2514| 64| if(U_SUCCESS(*status)) { ------------------ | Branch (2514:20): [True: 64, False: 0] ------------------ 2515| | /* check if resB->fResPath gives the right name here */ 2516| 64| return init_resb_result(dataEntry, res, key, -1, resB, fillIn, status); 2517| 64| } else { 2518| 0| *status = U_MISSING_RESOURCE_ERROR; 2519| 0| } 2520| 70| } else { 2521| 70| *status = U_MISSING_RESOURCE_ERROR; 2522| 70| } 2523| 4.83k| } else { 2524| 4.83k| return init_resb_result(resB->fData, res, key, -1, resB, fillIn, status); 2525| 4.83k| } 2526| 4.96k| } 2527| |#if 0 2528| | /* this is a kind of TODO item. If we have an array with an index table, we could do this. */ 2529| | /* not currently */ 2530| | else if(RES_GET_TYPE(resB->fRes) == URES_ARRAY && resB->fHasFallback == true) { 2531| | /* here should go a first attempt to locate the key using index table */ 2532| | dataEntry = getFallbackData(resB, &key, &res, status); 2533| | if(U_SUCCESS(*status)) { 2534| | return init_resb_result(dataEntry, res, key, resB, fillIn, status); 2535| | } else { 2536| | *status = U_MISSING_RESOURCE_ERROR; 2537| | } 2538| | } 2539| |#endif 2540| 0| else { 2541| 0| *status = U_RESOURCE_TYPE_MISMATCH; 2542| 0| } 2543| 70| return fillIn; 2544| 4.96k|} ures_getStringByKey_78: 2546| 4.85k|U_CAPI const char16_t* U_EXPORT2 ures_getStringByKey(const UResourceBundle *resB, const char* inKey, int32_t* len, UErrorCode *status) { 2547| 4.85k| Resource res = RES_BOGUS; ------------------ | | 65| 4.85k|#define RES_BOGUS 0xffffffff ------------------ 2548| 4.85k| UResourceDataEntry *dataEntry = nullptr; 2549| 4.85k| const char* key = inKey; 2550| | 2551| 4.85k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (2551:9): [True: 0, False: 4.85k] | Branch (2551:28): [True: 37, False: 4.81k] ------------------ 2552| 37| return nullptr; 2553| 37| } 2554| 4.81k| if(resB == nullptr) { ------------------ | Branch (2554:8): [True: 0, False: 4.81k] ------------------ 2555| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2556| 0| return nullptr; 2557| 0| } 2558| | 2559| 4.81k| int32_t type = RES_GET_TYPE(resB->fRes); ------------------ | | 68| 4.81k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2560| 4.81k| if(URES_IS_TABLE(type)) { ------------------ | | 84| 4.81k|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 4.81k, False: 4] | | | Branch (84:61): [True: 4, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 2561| 4.81k| int32_t t=0; 2562| | 2563| 4.81k| res = res_getTableItemByKey(&resB->getResData(), resB->fRes, &t, &key); ------------------ | | 207| 4.81k|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 4.81k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.81k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.81k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2564| | 2565| 4.81k| if(res == RES_BOGUS) { ------------------ | | 65| 4.81k|#define RES_BOGUS 0xffffffff ------------------ | Branch (2565:12): [True: 0, False: 4.81k] ------------------ 2566| 0| key = inKey; 2567| 0| if(resB->fHasFallback) { ------------------ | Branch (2567:16): [True: 0, False: 0] ------------------ 2568| 0| dataEntry = getFallbackData(resB, &key, &res, status); 2569| 0| if(U_SUCCESS(*status)) { ------------------ | Branch (2569:20): [True: 0, False: 0] ------------------ 2570| 0| switch (RES_GET_TYPE(res)) { ------------------ | | 68| 0|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2571| 0| case URES_STRING: ------------------ | Branch (2571:21): [True: 0, False: 0] ------------------ 2572| 0| case URES_STRING_V2: ------------------ | Branch (2572:21): [True: 0, False: 0] ------------------ 2573| 0| return res_getString({resB, key}, &dataEntry->fData, res, len); 2574| 0| case URES_ALIAS: ------------------ | Branch (2574:21): [True: 0, False: 0] ------------------ 2575| 0| { 2576| 0| const char16_t* result = nullptr; 2577| 0| UResourceBundle *tempRes = ures_getByKey(resB, inKey, nullptr, status); ------------------ | | 1661| 0|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2578| 0| result = ures_getString(tempRes, len, status); ------------------ | | 1675| 0|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2579| 0| ures_close(tempRes); ------------------ | | 1652| 0|#define ures_close U_ICU_ENTRY_POINT_RENAME(ures_close) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2580| 0| return result; 2581| 0| } 2582| 0| default: ------------------ | Branch (2582:21): [True: 0, False: 0] ------------------ 2583| 0| *status = U_RESOURCE_TYPE_MISMATCH; 2584| 0| } 2585| 0| } else { 2586| 0| *status = U_MISSING_RESOURCE_ERROR; 2587| 0| } 2588| 0| } else { 2589| 0| *status = U_MISSING_RESOURCE_ERROR; 2590| 0| } 2591| 4.81k| } else { 2592| 4.81k| switch (RES_GET_TYPE(res)) { ------------------ | | 68| 4.81k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2593| 187| case URES_STRING: ------------------ | Branch (2593:13): [True: 187, False: 4.63k] ------------------ 2594| 4.81k| case URES_STRING_V2: ------------------ | Branch (2594:13): [True: 4.63k, False: 187] ------------------ 2595| 4.81k| return res_getString({resB, key}, &resB->getResData(), res, len); 2596| 0| case URES_ALIAS: ------------------ | Branch (2596:13): [True: 0, False: 4.81k] ------------------ 2597| 0| { 2598| 0| const char16_t* result = nullptr; 2599| 0| UResourceBundle *tempRes = ures_getByKey(resB, inKey, nullptr, status); ------------------ | | 1661| 0|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2600| 0| result = ures_getString(tempRes, len, status); ------------------ | | 1675| 0|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2601| 0| ures_close(tempRes); ------------------ | | 1652| 0|#define ures_close U_ICU_ENTRY_POINT_RENAME(ures_close) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2602| 0| return result; 2603| 187| } 2604| 0| default: ------------------ | Branch (2604:13): [True: 0, False: 4.81k] ------------------ 2605| 0| *status = U_RESOURCE_TYPE_MISMATCH; 2606| 4.81k| } 2607| 4.81k| } 2608| 4.81k| } 2609| |#if 0 2610| | /* this is a kind of TODO item. If we have an array with an index table, we could do this. */ 2611| | /* not currently */ 2612| | else if(RES_GET_TYPE(resB->fRes) == URES_ARRAY && resB->fHasFallback == true) { 2613| | /* here should go a first attempt to locate the key using index table */ 2614| | dataEntry = getFallbackData(resB, &key, &res, status); 2615| | if(U_SUCCESS(*status)) { 2616| | // TODO: Tracing 2617| | return res_getString(rd, res, len); 2618| | } else { 2619| | *status = U_MISSING_RESOURCE_ERROR; 2620| | } 2621| | } 2622| |#endif 2623| 0| else { 2624| 0| *status = U_RESOURCE_TYPE_MISMATCH; 2625| 0| } 2626| 0| return nullptr; 2627| 4.81k|} ures_open_78: 2769| 4.85k|ures_open(const char* path, const char* localeID, UErrorCode* status) { 2770| 4.85k| return ures_openWithType(nullptr, path, localeID, URES_OPEN_LOCALE_DEFAULT_ROOT, status); 2771| 4.85k|} ures_openDirect_78: 2783| 4|ures_openDirect(const char* path, const char* localeID, UErrorCode* status) { 2784| 4| return ures_openWithType(nullptr, path, localeID, URES_OPEN_DIRECT, status); 2785| 4|} uresbund.cpp:_ZL21ures_setIsStackObjectP15UResourceBundlea: 711| 15.5k|static void ures_setIsStackObject( UResourceBundle* resB, UBool state) { 712| 15.5k| if(state) { ------------------ | Branch (712:8): [True: 0, False: 15.5k] ------------------ 713| 0| resB->fMagic1 = 0; 714| 0| resB->fMagic2 = 0; 715| 15.5k| } else { 716| 15.5k| resB->fMagic1 = MAGIC1; ------------------ | | 30| 15.5k|#define MAGIC1 19700503 ------------------ 717| 15.5k| resB->fMagic2 = MAGIC2; ------------------ | | 31| 15.5k|#define MAGIC2 19641227 ------------------ 718| 15.5k| } 719| 15.5k|} uresbund.cpp:_ZL16ures_closeBundleP15UResourceBundlea: 1123| 28.0k|{ 1124| 28.0k| if(resB != nullptr) { ------------------ | Branch (1124:8): [True: 15.5k, False: 12.5k] ------------------ 1125| 15.5k| if(resB->fData != nullptr) { ------------------ | Branch (1125:12): [True: 15.5k, False: 0] ------------------ 1126| 15.5k| entryClose(resB->fData); 1127| 15.5k| } 1128| 15.5k| if(resB->fVersion != nullptr) { ------------------ | Branch (1128:12): [True: 0, False: 15.5k] ------------------ 1129| 0| uprv_free(resB->fVersion); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1130| 0| } 1131| 15.5k| ures_freeResPath(resB); 1132| | 1133| 15.5k| if(ures_isStackObject(resB) == false && freeBundleObj) { ------------------ | Branch (1133:12): [True: 15.5k, False: 0] | Branch (1133:49): [True: 15.5k, False: 0] ------------------ 1134| 15.5k| uprv_free(resB); ------------------ | | 1503| 15.5k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 15.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1135| 15.5k| } 1136| |#if 0 /*U_DEBUG*/ 1137| | else { 1138| | /* poison the data */ 1139| | uprv_memset(resB, -1, sizeof(UResourceBundle)); 1140| | } 1141| |#endif 1142| 15.5k| } 1143| 28.0k|} uresbund.cpp:_ZL10entryCloseP18UResourceDataEntry: 1061| 94.3k|static void entryClose(UResourceDataEntry *resB) { 1062| 94.3k| Mutex lock(&resbMutex); 1063| 94.3k| entryCloseInt(resB); 1064| 94.3k|} uresbund.cpp:_ZL13entryCloseIntP18UResourceDataEntry: 1028| 94.3k|static void entryCloseInt(UResourceDataEntry *resB) { 1029| 94.3k| UResourceDataEntry *p = resB; 1030| | 1031| 209k| while(resB != nullptr) { ------------------ | Branch (1031:11): [True: 114k, False: 94.3k] ------------------ 1032| 114k| p = resB->fParent; 1033| 114k| resB->fCountExisting--; 1034| | 1035| | /* Entries are left in the cache. TODO: add ures_flushCache() to force a flush 1036| | of the cache. */ 1037| |/* 1038| | if(resB->fCountExisting <= 0) { 1039| | uhash_remove(cache, resB); 1040| | if(resB->fBogus == U_ZERO_ERROR) { 1041| | res_unload(&(resB->fData)); 1042| | } 1043| | if(resB->fName != nullptr) { 1044| | uprv_free(resB->fName); 1045| | } 1046| | if(resB->fPath != nullptr) { 1047| | uprv_free(resB->fPath); 1048| | } 1049| | uprv_free(resB); 1050| | } 1051| |*/ 1052| | 1053| 114k| resB = p; 1054| 114k| } 1055| 94.3k|} uresbund.cpp:_ZL18ures_isStackObjectPK15UResourceBundle: 721| 15.5k|static UBool ures_isStackObject(const UResourceBundle* resB) { 722| 15.5k| return((resB->fMagic1 == MAGIC1 && resB->fMagic2 == MAGIC2)?false:true); ------------------ | | 30| 31.0k|#define MAGIC1 19700503 ------------------ return((resB->fMagic1 == MAGIC1 && resB->fMagic2 == MAGIC2)?false:true); ------------------ | | 31| 15.5k|#define MAGIC2 19641227 ------------------ | Branch (722:11): [True: 15.5k, False: 0] | Branch (722:38): [True: 15.5k, False: 0] ------------------ 723| 15.5k|} uresbund.cpp:_ZL18ures_appendResPathP15UResourceBundlePKciP10UErrorCode: 1083| 263k|static void ures_appendResPath(UResourceBundle *resB, const char* toAdd, int32_t lenToAdd, UErrorCode *status) { 1084| 263k| int32_t resPathLenOrig = resB->fResPathLen; 1085| 263k| if(resB->fResPath == nullptr) { ------------------ | Branch (1085:8): [True: 89.5k, False: 174k] ------------------ 1086| 89.5k| resB->fResPath = resB->fResBuf; 1087| 89.5k| *(resB->fResPath) = 0; 1088| 89.5k| resB->fResPathLen = 0; 1089| 89.5k| } 1090| 263k| resB->fResPathLen += lenToAdd; 1091| 263k| if(RES_BUFSIZE <= resB->fResPathLen+1) { ------------------ | | 59| 263k|#define RES_BUFSIZE 64 ------------------ | Branch (1091:8): [True: 0, False: 263k] ------------------ 1092| 0| if(resB->fResPath == resB->fResBuf) { ------------------ | Branch (1092:12): [True: 0, False: 0] ------------------ 1093| 0| resB->fResPath = static_cast(uprv_malloc((resB->fResPathLen + 1) * sizeof(char))); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1094| | /* Check that memory was allocated correctly. */ 1095| 0| if (resB->fResPath == nullptr) { ------------------ | Branch (1095:17): [True: 0, False: 0] ------------------ 1096| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1097| 0| return; 1098| 0| } 1099| 0| uprv_strcpy(resB->fResPath, resB->fResBuf); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1100| 0| } else { 1101| 0| char* temp = static_cast(uprv_realloc(resB->fResPath, (resB->fResPathLen + 1) * sizeof(char))); ------------------ | | 1536| 0|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1102| | /* Check that memory was reallocated correctly. */ 1103| 0| if (temp == nullptr) { ------------------ | Branch (1103:17): [True: 0, False: 0] ------------------ 1104| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1105| 0| return; 1106| 0| } 1107| 0| resB->fResPath = temp; 1108| 0| } 1109| 0| } 1110| 263k| uprv_strcpy(resB->fResPath + resPathLenOrig, toAdd); ------------------ | | 36| 263k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 263k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1111| 263k|} uresbund.cpp:_ZL13entryIncreaseP18UResourceDataEntry: 304| 89.5k|static void entryIncrease(UResourceDataEntry *entry) { 305| 89.5k| Mutex lock(&resbMutex); 306| 89.5k| entry->fCountExisting++; 307| 102k| while(entry->fParent != nullptr) { ------------------ | Branch (307:11): [True: 13.4k, False: 89.5k] ------------------ 308| 13.4k| entry = entry->fParent; 309| 13.4k| entry->fCountExisting++; 310| 13.4k| } 311| 89.5k|} uresbund.cpp:_ZN12_GLOBAL__N_116init_resb_resultEP18UResourceDataEntryjPKciPK15UResourceBundlePS4_P10UErrorCode: 1480| 89.5k| UResourceBundle *resB, UErrorCode *status) { 1481| 89.5k| return init_resb_result( 1482| 89.5k| dataEntry, r, key, idx, 1483| 89.5k| container->fValidLocaleDataEntry, container->fResPath, 0, resB, status); 1484| 89.5k|} uresbund.cpp:_ZN12_GLOBAL__N_116init_resb_resultEP18UResourceDataEntryjPKciS1_S3_iP15UResourceBundleP10UErrorCode: 1389| 89.5k| UResourceBundle *resB, UErrorCode *status) { 1390| | // TODO: When an error occurs: Should we return nullptr vs. resB? 1391| 89.5k| if(status == nullptr || U_FAILURE(*status)) { ------------------ | Branch (1391:8): [True: 0, False: 89.5k] | Branch (1391:29): [True: 0, False: 89.5k] ------------------ 1392| 0| return resB; 1393| 0| } 1394| 89.5k| if (validLocaleDataEntry == nullptr) { ------------------ | Branch (1394:9): [True: 0, False: 89.5k] ------------------ 1395| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1396| 0| return nullptr; 1397| 0| } 1398| 89.5k| if(RES_GET_TYPE(r) == URES_ALIAS) { ------------------ | | 68| 89.5k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (1398:8): [True: 3, False: 89.5k] ------------------ 1399| | // This is an alias, need to exchange with real data. 1400| 3| if(recursionDepth >= URES_MAX_ALIAS_LEVEL) { ------------------ | | 33| 3|#define URES_MAX_ALIAS_LEVEL 256 ------------------ | Branch (1400:12): [True: 0, False: 3] ------------------ 1401| 0| *status = U_TOO_MANY_ALIASES_ERROR; 1402| 0| return resB; 1403| 0| } 1404| 3| return getAliasTargetAsResourceBundle( 1405| 3| dataEntry->fData, r, key, idx, 1406| 3| validLocaleDataEntry, containerResPath, recursionDepth, resB, status); 1407| 3| } 1408| 89.5k| if(resB == nullptr) { ------------------ | Branch (1408:8): [True: 10.6k, False: 78.8k] ------------------ 1409| 10.6k| resB = static_cast(uprv_malloc(sizeof(UResourceBundle))); ------------------ | | 1524| 10.6k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 10.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 10.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 10.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1410| 10.6k| if (resB == nullptr) { ------------------ | Branch (1410:13): [True: 0, False: 10.6k] ------------------ 1411| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1412| 0| return nullptr; 1413| 0| } 1414| 10.6k| ures_setIsStackObject(resB, false); 1415| 10.6k| resB->fResPath = nullptr; 1416| 10.6k| resB->fResPathLen = 0; 1417| 78.8k| } else { 1418| 78.8k| if(resB->fData != nullptr) { ------------------ | Branch (1418:12): [True: 78.8k, False: 0] ------------------ 1419| 78.8k| entryClose(resB->fData); 1420| 78.8k| } 1421| 78.8k| if(resB->fVersion != nullptr) { ------------------ | Branch (1421:12): [True: 0, False: 78.8k] ------------------ 1422| 0| uprv_free(resB->fVersion); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1423| 0| } 1424| | /* 1425| | weiv: if stack object was passed in, it doesn't really need to be reinited, 1426| | since the purpose of initing is to remove stack junk. However, at this point 1427| | we would not do anything to an allocated object, so stack object should be 1428| | treated the same 1429| | */ 1430| | /* 1431| | if(ures_isStackObject(resB) != false) { 1432| | ures_initStackObject(resB); 1433| | } 1434| | */ 1435| 78.8k| if(containerResPath != resB->fResPath) { ------------------ | Branch (1435:12): [True: 78.8k, False: 0] ------------------ 1436| 78.8k| ures_freeResPath(resB); 1437| 78.8k| } 1438| 78.8k| } 1439| 89.5k| resB->fData = dataEntry; 1440| 89.5k| entryIncrease(resB->fData); 1441| 89.5k| resB->fHasFallback = false; 1442| 89.5k| resB->fIsTopLevel = false; 1443| 89.5k| resB->fIndex = -1; 1444| 89.5k| resB->fKey = key; 1445| 89.5k| resB->fValidLocaleDataEntry = validLocaleDataEntry; 1446| 89.5k| if(containerResPath != resB->fResPath) { ------------------ | Branch (1446:8): [True: 84.6k, False: 4.86k] ------------------ 1447| 84.6k| ures_appendResPath( 1448| 84.6k| resB, containerResPath, static_cast(uprv_strlen(containerResPath)), status); ------------------ | | 37| 84.6k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 84.6k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1449| 84.6k| } 1450| 89.5k| if(key != nullptr) { ------------------ | Branch (1450:8): [True: 89.5k, False: 0] ------------------ 1451| 89.5k| ures_appendResPath(resB, key, static_cast(uprv_strlen(key)), status); ------------------ | | 37| 89.5k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 89.5k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1452| 89.5k| if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 89.5k|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1452:12): [True: 89.5k, False: 0] ------------------ 1453| 89.5k| ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 89.5k|#define RES_PATH_SEPARATOR_S "/" ------------------ 1454| 89.5k| } 1455| 89.5k| } else if(idx >= 0) { ------------------ | Branch (1455:15): [True: 0, False: 0] ------------------ 1456| 0| char buf[256]; 1457| 0| int32_t len = T_CString_integerToString(buf, idx, 10); ------------------ | | 67| 0|#define T_CString_integerToString U_ICU_ENTRY_POINT_RENAME(T_CString_integerToString) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1458| 0| ures_appendResPath(resB, buf, len, status); 1459| 0| if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 0|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1459:12): [True: 0, False: 0] ------------------ 1460| 0| ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 0|#define RES_PATH_SEPARATOR_S "/" ------------------ 1461| 0| } 1462| 0| } 1463| | /* Make sure that Purify doesn't complain about uninitialized memory copies. */ 1464| 89.5k| { 1465| 89.5k| int32_t usedLen = ((resB->fResBuf == resB->fResPath) ? resB->fResPathLen : 0); ------------------ | Branch (1465:28): [True: 89.5k, False: 0] ------------------ 1466| 89.5k| uprv_memset(resB->fResBuf + usedLen, 0, sizeof(resB->fResBuf) - usedLen); ------------------ | | 100| 89.5k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 89.5k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1467| 89.5k| } 1468| | 1469| 89.5k| resB->fVersion = nullptr; 1470| 89.5k| resB->fRes = r; 1471| 89.5k| resB->fSize = res_countArrayItems(&resB->getResData(), resB->fRes); ------------------ | | 197| 89.5k|#define res_countArrayItems U_ICU_ENTRY_POINT_RENAME(res_countArrayItems) | | ------------------ | | | | 123| 89.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 89.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 89.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1472| 89.5k| ResourceTracer(resB).trace("get"); 1473| 89.5k| return resB; 1474| 89.5k|} uresbund.cpp:_ZN12_GLOBAL__N_130getAliasTargetAsResourceBundleERK12ResourceDatajPKciP18UResourceDataEntryS4_iP15UResourceBundleP10UErrorCode: 1166| 3| UResourceBundle *resB, UErrorCode *status) { 1167| | // TODO: When an error occurs: Should we return nullptr vs. resB? 1168| 3| if (U_FAILURE(*status)) { return resB; } ------------------ | Branch (1168:9): [True: 0, False: 3] ------------------ 1169| 3| U_ASSERT(RES_GET_TYPE(r) == URES_ALIAS); ------------------ | | 35| 3|# define U_ASSERT(exp) (void)0 ------------------ 1170| 3| int32_t len = 0; 1171| 3| const char16_t *alias = res_getAlias(&resData, r, &len); ------------------ | | 199| 3|#define res_getAlias U_ICU_ENTRY_POINT_RENAME(res_getAlias) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1172| 3| if(len <= 0) { ------------------ | Branch (1172:8): [True: 0, False: 3] ------------------ 1173| | // bad alias 1174| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1175| 0| return resB; 1176| 0| } 1177| | 1178| | // Copy the UTF-16 alias string into an invariant-character string. 1179| | // 1180| | // We do this so that res_findResource() can modify the path, 1181| | // which allows us to remove redundant _res_findResource() variants 1182| | // in uresdata.c. 1183| | // res_findResource() now NUL-terminates each segment so that table keys 1184| | // can always be compared with strcmp() instead of strncmp(). 1185| | // Saves code there and simplifies testing and code coverage. 1186| | // 1187| | // markus 2003oct17 1188| 3| CharString chAlias; 1189| 3| chAlias.appendInvariantChars(alias, len, *status); 1190| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1190:9): [True: 0, False: 3] ------------------ 1191| 0| return nullptr; 1192| 0| } 1193| | 1194| | // We have an alias, now let's cut it up. 1195| 3| const char *path = nullptr, *locale = nullptr, *keyPath = nullptr; 1196| 3| if(chAlias[0] == RES_PATH_SEPARATOR) { ------------------ | | 60| 3|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1196:8): [True: 3, False: 0] ------------------ 1197| | // There is a path included. 1198| 3| char *chAliasData = chAlias.data(); 1199| 3| char *sep = chAliasData + 1; 1200| 3| path = sep; 1201| 3| sep = uprv_strchr(sep, RES_PATH_SEPARATOR); ------------------ | | 40| 3|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1202| 3| if(sep != nullptr) { ------------------ | Branch (1202:12): [True: 3, False: 0] ------------------ 1203| 3| *sep++ = 0; 1204| 3| } 1205| 3| if(uprv_strcmp(path, "LOCALE") == 0) { ------------------ | | 38| 3|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1205:12): [True: 0, False: 3] ------------------ 1206| | // This is an XPath alias, starting with "/LOCALE/". 1207| | // It contains the path to a resource which should be looked up 1208| | // starting in the valid locale. 1209| | // TODO: Can/should we forbid a /LOCALE alias without key path? 1210| | // It seems weird to alias to the same path, just starting from the valid locale. 1211| | // That will often yield an infinite loop. 1212| 0| keyPath = sep; 1213| | // Read from the valid locale which we already have. 1214| 0| path = locale = nullptr; 1215| 3| } else { 1216| 3| if(uprv_strcmp(path, "ICUDATA") == 0) { /* want ICU data */ ------------------ | | 38| 3|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1216:16): [True: 3, False: 0] ------------------ 1217| 3| path = nullptr; 1218| 3| } 1219| 3| if (sep == nullptr) { ------------------ | Branch (1219:17): [True: 0, False: 3] ------------------ 1220| | // TODO: This ends up using the root bundle. Can/should we forbid this? 1221| 0| locale = ""; 1222| 3| } else { 1223| 3| locale = sep; 1224| 3| sep = uprv_strchr(sep, RES_PATH_SEPARATOR); ------------------ | | 40| 3|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1225| 3| if(sep != nullptr) { ------------------ | Branch (1225:20): [True: 3, False: 0] ------------------ 1226| 3| *sep++ = 0; 1227| 3| } 1228| 3| keyPath = sep; 1229| 3| } 1230| 3| } 1231| 3| } else { 1232| | // No path, start with a locale. 1233| 0| char *sep = chAlias.data(); 1234| 0| locale = sep; 1235| 0| sep = uprv_strchr(sep, RES_PATH_SEPARATOR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1236| 0| if(sep != nullptr) { ------------------ | Branch (1236:12): [True: 0, False: 0] ------------------ 1237| 0| *sep++ = 0; 1238| 0| } 1239| 0| keyPath = sep; 1240| 0| path = validLocaleDataEntry->fPath; 1241| 0| } 1242| | 1243| | // Got almost everything, let's try to open. 1244| | // First, open the bundle with real data. 1245| 3| LocalUResourceBundlePointer mainRes; 1246| 3| UResourceDataEntry *dataEntry; 1247| 3| if (locale == nullptr) { ------------------ | Branch (1247:9): [True: 0, False: 3] ------------------ 1248| | // alias = /LOCALE/keyPath 1249| | // Read from the valid locale which we already have. 1250| 0| dataEntry = validLocaleDataEntry; 1251| 3| } else { 1252| 3| UErrorCode intStatus = U_ZERO_ERROR; 1253| | // TODO: Shouldn't we use ures_open() for locale data bundles (!noFallback)? 1254| 3| mainRes.adoptInstead(ures_openDirect(path, locale, &intStatus)); ------------------ | | 1693| 3|#define ures_openDirect U_ICU_ENTRY_POINT_RENAME(ures_openDirect) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1255| 3| if(U_FAILURE(intStatus)) { ------------------ | Branch (1255:12): [True: 0, False: 3] ------------------ 1256| | // We failed to open the resource bundle we're aliasing to. 1257| 0| *status = intStatus; 1258| 0| return resB; 1259| 0| } 1260| 3| dataEntry = mainRes->fData; 1261| 3| } 1262| | 1263| 3| const char* temp = nullptr; 1264| 3| if(keyPath == nullptr) { ------------------ | Branch (1264:8): [True: 0, False: 3] ------------------ 1265| | // No key path. This means that we are going to to use the corresponding resource from 1266| | // another bundle. 1267| | // TODO: Why the special code path? 1268| | // Why not put together a key path from containerResPath + key or idx, 1269| | // as a comment below suggests, and go into the regular code branch? 1270| | // First, we are going to get a corresponding container 1271| | // resource to the one we are searching. 1272| 0| r = dataEntry->fData.rootRes; 1273| 0| if(containerResPath) { ------------------ | Branch (1273:12): [True: 0, False: 0] ------------------ 1274| 0| chAlias.clear().append(containerResPath, *status); 1275| 0| if (U_FAILURE(*status)) { ------------------ | Branch (1275:17): [True: 0, False: 0] ------------------ 1276| 0| return nullptr; 1277| 0| } 1278| 0| char *aKey = chAlias.data(); 1279| | // TODO: should res_findResource() return a new dataEntry, too? 1280| 0| r = res_findResource(&dataEntry->fData, r, &aKey, &temp); ------------------ | | 198| 0|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1281| 0| } 1282| 0| if(key) { ------------------ | Branch (1282:12): [True: 0, False: 0] ------------------ 1283| | // We need to make keyPath from the containerResPath and 1284| | // current key, if there is a key associated. 1285| 0| chAlias.clear().append(key, *status); 1286| 0| if (U_FAILURE(*status)) { ------------------ | Branch (1286:17): [True: 0, False: 0] ------------------ 1287| 0| return nullptr; 1288| 0| } 1289| 0| char *aKey = chAlias.data(); 1290| 0| r = res_findResource(&dataEntry->fData, r, &aKey, &temp); ------------------ | | 198| 0|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1291| 0| } else if(idx != -1) { ------------------ | Branch (1291:19): [True: 0, False: 0] ------------------ 1292| | // If there is no key, but there is an index, try to get by the index. 1293| | // Here we have either a table or an array, so get the element. 1294| 0| int32_t type = RES_GET_TYPE(r); ------------------ | | 68| 0|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 1295| 0| if(URES_IS_TABLE(type)) { ------------------ | | 84| 0|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 0, False: 0] | | | Branch (84:61): [True: 0, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 1296| 0| const char *aKey; 1297| 0| r = res_getTableItemByIndex(&dataEntry->fData, r, idx, &aKey); ------------------ | | 206| 0|#define res_getTableItemByIndex U_ICU_ENTRY_POINT_RENAME(res_getTableItemByIndex) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1298| 0| } else { /* array */ 1299| 0| r = res_getArrayItem(&dataEntry->fData, r, idx); ------------------ | | 200| 0|#define res_getArrayItem U_ICU_ENTRY_POINT_RENAME(res_getArrayItem) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1300| 0| } 1301| 0| } 1302| 0| if(r != RES_BOGUS) { ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ | Branch (1302:12): [True: 0, False: 0] ------------------ 1303| 0| resB = init_resb_result( 1304| 0| dataEntry, r, temp, -1, validLocaleDataEntry, nullptr, recursionDepth+1, 1305| 0| resB, status); 1306| 0| } else { 1307| 0| *status = U_MISSING_RESOURCE_ERROR; 1308| 0| } 1309| 3| } else { 1310| | // This one is a bit trickier. 1311| | // We start finding keys, but after we resolve one alias, the path might continue. 1312| | // Consider: 1313| | // aliastest:alias { "testtypes/anotheralias/Sequence" } 1314| | // anotheralias:alias { "/ICUDATA/sh/CollationElements" } 1315| | // aliastest resource should finally have the sequence, not collation elements. 1316| 3| CharString pathBuf(keyPath, *status); 1317| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1317:13): [True: 0, False: 3] ------------------ 1318| 0| return nullptr; 1319| 0| } 1320| 3| char *myPath = pathBuf.data(); 1321| 3| containerResPath = nullptr; 1322| | // Now we have fallback following here. 1323| 3| for(;;) { 1324| 3| r = dataEntry->fData.rootRes; 1325| | // TODO: Move containerResPath = nullptr to here, 1326| | // consistent with restarting from the rootRes of another bundle?! 1327| | 1328| | // This loop handles 'found' resources over several levels. 1329| 6| while(*myPath && U_SUCCESS(*status)) { ------------------ | Branch (1329:19): [True: 3, False: 3] | Branch (1329:30): [True: 3, False: 0] ------------------ 1330| 3| r = res_findResource(&(dataEntry->fData), r, &myPath, &temp); ------------------ | | 198| 3|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1331| 3| if(r == RES_BOGUS) { ------------------ | | 65| 3|#define RES_BOGUS 0xffffffff ------------------ | Branch (1331:20): [True: 0, False: 3] ------------------ 1332| | // No resource found, we don't really want to look anymore on this level. 1333| 0| break; 1334| 0| } 1335| | // Found a resource, but it might be an indirection. 1336| 3| resB = init_resb_result( 1337| 3| dataEntry, r, temp, -1, 1338| 3| validLocaleDataEntry, containerResPath, recursionDepth+1, 1339| 3| resB, status); 1340| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1340:21): [True: 0, False: 3] ------------------ 1341| 0| break; 1342| 0| } 1343| 3| if (temp == nullptr || uprv_strcmp(keyPath, temp) != 0) { ------------------ | | 38| 3|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1343:21): [True: 0, False: 3] | Branch (1343:40): [True: 3, False: 0] ------------------ 1344| | // The call to init_resb_result() above will set resB->fKeyPath to be 1345| | // the same as resB->fKey, 1346| | // throwing away any additional path elements if we had them -- 1347| | // if the key path wasn't just a single resource ID, clear out 1348| | // the bundle's key path and re-set it to be equal to keyPath. 1349| 3| ures_freeResPath(resB); 1350| 3| ures_appendResPath(resB, keyPath, static_cast(uprv_strlen(keyPath)), status); ------------------ | | 37| 3|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1351| 3| if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 3|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1351:24): [True: 3, False: 0] ------------------ 1352| 3| ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 3|#define RES_PATH_SEPARATOR_S "/" ------------------ 1353| 3| } 1354| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1354:25): [True: 0, False: 3] ------------------ 1355| 0| break; 1356| 0| } 1357| 3| } 1358| 3| r = resB->fRes; /* switch to a new resource, possibly a new tree */ 1359| 3| dataEntry = resB->fData; 1360| 3| containerResPath = resB->fResPath; 1361| 3| } 1362| 3| if (U_FAILURE(*status) || r != RES_BOGUS) { ------------------ | | 65| 3|#define RES_BOGUS 0xffffffff ------------------ | Branch (1362:17): [True: 0, False: 3] | Branch (1362:39): [True: 3, False: 0] ------------------ 1363| 3| break; 1364| 3| } 1365| | // Fall back to the parent bundle, if there is one. 1366| 0| dataEntry = dataEntry->fParent; 1367| 0| if (dataEntry == nullptr) { ------------------ | Branch (1367:17): [True: 0, False: 0] ------------------ 1368| 0| *status = U_MISSING_RESOURCE_ERROR; 1369| 0| break; 1370| 0| } 1371| | // Copy the same keyPath again. 1372| 0| myPath = pathBuf.data(); 1373| 0| uprv_strcpy(myPath, keyPath); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1374| 0| } 1375| 3| } 1376| 3| if(mainRes.getAlias() == resB) { ------------------ | Branch (1376:8): [True: 0, False: 3] ------------------ 1377| 0| mainRes.orphan(); 1378| 0| } 1379| 3| ResourceTracer(resB).maybeTrace("getalias"); 1380| 3| return resB; 1381| 3|} uresbund.cpp:_ZL21getTableItemByKeyPathPK12ResourceDatajPKc: 2059| 4.85k|static Resource getTableItemByKeyPath(const ResourceData *pResData, Resource table, const char *key) { 2060| 4.85k| Resource resource = table; /* The current resource */ 2061| 4.85k| icu::CharString path; 2062| 4.85k| UErrorCode errorCode = U_ZERO_ERROR; 2063| 4.85k| path.append(key, errorCode); 2064| 4.85k| if (U_FAILURE(errorCode)) { return RES_BOGUS; } ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ | Branch (2064:7): [True: 0, False: 4.85k] ------------------ 2065| 4.85k| char *pathPart = path.data(); /* Path from current resource to desired resource */ 2066| 4.85k| UResType type = static_cast(RES_GET_TYPE(resource)); /* the current resource type */ ------------------ | | 68| 4.85k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2067| 9.70k| while (*pathPart && resource != RES_BOGUS && URES_IS_CONTAINER(type)) { ------------------ | | 65| 14.5k|#define RES_BOGUS 0xffffffff ------------------ while (*pathPart && resource != RES_BOGUS && URES_IS_CONTAINER(type)) { ------------------ | | 85| 4.85k|#define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 84| 9.70k|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | | | ------------------ | | | | | Branch (84:30): [True: 4.80k, False: 48] | | | | | Branch (84:61): [True: 48, False: 0] | | | | | Branch (84:94): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | | | ------------------ | | | | | Branch (83:30): [True: 0, False: 0] | | | | | Branch (83:61): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (2067:10): [True: 4.85k, False: 4.85k] | Branch (2067:23): [True: 4.85k, False: 0] ------------------ 2068| 4.85k| char *nextPathPart = uprv_strchr(pathPart, RES_PATH_SEPARATOR); ------------------ | | 40| 4.85k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 4.85k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2069| 4.85k| if (nextPathPart != nullptr) { ------------------ | Branch (2069:9): [True: 0, False: 4.85k] ------------------ 2070| 0| *nextPathPart = 0; /* Terminating null for this part of path. */ 2071| 0| nextPathPart++; 2072| 4.85k| } else { 2073| 4.85k| nextPathPart = uprv_strchr(pathPart, 0); ------------------ | | 40| 4.85k|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 4.85k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2074| 4.85k| } 2075| 4.85k| int32_t t; 2076| 4.85k| const char *pathP = pathPart; 2077| 4.85k| resource = res_getTableItemByKey(pResData, resource, &t, &pathP); ------------------ | | 207| 4.85k|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2078| 4.85k| type = static_cast(RES_GET_TYPE(resource)); ------------------ | | 68| 4.85k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2079| 4.85k| pathPart = nextPathPart; 2080| 4.85k| } 2081| 4.85k| if (*pathPart) { ------------------ | Branch (2081:7): [True: 0, False: 4.85k] ------------------ 2082| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 2083| 0| } 2084| 4.85k| return resource; 2085| 4.85k|} uresbund.cpp:_ZL10createPathPKciS0_iS0_RN6icu_7810CharStringEP10UErrorCode: 2093| 312| UErrorCode* status) { 2094| | // This is a utility function used by ures_getByKeyWithFallback() below. This function builds a path from 2095| | // resPath and inKey, returning the result in `path`. Originally, this function just cleared `path` and 2096| | // appended resPath and inKey to it, but that caused problems for horizontal inheritance. 2097| | // 2098| | // In normal cases, resPath is the same as origResPath, but if ures_getByKeyWithFallback() has followed an 2099| | // alias, resPath may be different from origResPath. Not only may the existing path elements be different, 2100| | // but resPath may also have MORE path elements than origResPath did. If it does, those additional path 2101| | // elements SUPERSEDE the corresponding elements of inKey. So this code counts the number of elements in 2102| | // resPath and origResPath and, for each path element in resPath that doesn't have a counterpart in origResPath, 2103| | // deletes a path element from the beginning of inKey. The remainder of inKey is then appended to 2104| | // resPath to form the result. (We're not using uprv_strchr() here because resPath and origResPath may 2105| | // not be zero-terminated.) 2106| 312| path.clear(); 2107| 312| const char* key = inKey; 2108| 312| if (resPathLen > 0) { ------------------ | Branch (2108:9): [True: 312, False: 0] ------------------ 2109| 312| path.append(resPath, resPathLen, *status); 2110| 312| if (U_SUCCESS(*status)) { ------------------ | Branch (2110:13): [True: 312, False: 0] ------------------ 2111| 312| const char* resPathLimit = resPath + resPathLen; 2112| 312| const char* origResPathLimit = origResPath + origResPathLen; 2113| 312| const char* resPathPtr = resPath; 2114| 312| const char* origResPathPtr = origResPath; 2115| | 2116| | // Remove from the beginning of resPath the number of segments that are contained in origResPath. 2117| | // If origResPath has MORE segments than resPath, this will leave resPath as the empty string. 2118| 624| while (origResPathPtr < origResPathLimit && resPathPtr < resPathLimit) { ------------------ | Branch (2118:20): [True: 312, False: 312] | Branch (2118:57): [True: 312, False: 0] ------------------ 2119| 3.43k| while (origResPathPtr < origResPathLimit && *origResPathPtr != RES_PATH_SEPARATOR) { ------------------ | | 60| 3.43k|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2119:24): [True: 3.43k, False: 0] | Branch (2119:61): [True: 3.12k, False: 312] ------------------ 2120| 3.12k| ++origResPathPtr; 2121| 3.12k| } 2122| 312| if (origResPathPtr < origResPathLimit && *origResPathPtr == RES_PATH_SEPARATOR) { ------------------ | | 60| 312|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2122:21): [True: 312, False: 0] | Branch (2122:58): [True: 312, False: 0] ------------------ 2123| 312| ++origResPathPtr; 2124| 312| } 2125| 3.43k| while (resPathPtr < resPathLimit && *resPathPtr != RES_PATH_SEPARATOR) { ------------------ | | 60| 3.43k|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2125:24): [True: 3.43k, False: 0] | Branch (2125:53): [True: 3.12k, False: 312] ------------------ 2126| 3.12k| ++resPathPtr; 2127| 3.12k| } 2128| 312| if (resPathPtr < resPathLimit && *resPathPtr == RES_PATH_SEPARATOR) { ------------------ | | 60| 312|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2128:21): [True: 312, False: 0] | Branch (2128:50): [True: 312, False: 0] ------------------ 2129| 312| ++resPathPtr; 2130| 312| } 2131| 312| } 2132| | 2133| | // New remove from the beginning of `key` the number of segments remaining in resPath. 2134| | // If resPath has more segments than `key` does, `key` will end up empty. 2135| 312| while (resPathPtr < resPathLimit && *key != '\0') { ------------------ | Branch (2135:20): [True: 0, False: 312] | Branch (2135:49): [True: 0, False: 0] ------------------ 2136| 0| while (resPathPtr < resPathLimit && *resPathPtr != RES_PATH_SEPARATOR) { ------------------ | | 60| 0|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2136:24): [True: 0, False: 0] | Branch (2136:53): [True: 0, False: 0] ------------------ 2137| 0| ++resPathPtr; 2138| 0| } 2139| 0| if (resPathPtr < resPathLimit && *resPathPtr == RES_PATH_SEPARATOR) { ------------------ | | 60| 0|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2139:21): [True: 0, False: 0] | Branch (2139:50): [True: 0, False: 0] ------------------ 2140| 0| ++resPathPtr; 2141| 0| } 2142| 0| while (*key != '\0' && *key != RES_PATH_SEPARATOR) { ------------------ | | 60| 0|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2142:24): [True: 0, False: 0] | Branch (2142:40): [True: 0, False: 0] ------------------ 2143| 0| ++key; 2144| 0| } 2145| 0| if (*key == RES_PATH_SEPARATOR) { ------------------ | | 60| 0|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (2145:21): [True: 0, False: 0] ------------------ 2146| 0| ++key; 2147| 0| } 2148| 0| } 2149| 312| } 2150| | // Finally, append what's left of `key` to `path`. What you end up with here is `resPath`, plus 2151| | // any pieces of `key` that aren't superseded by `resPath`. 2152| | // Or, to put it another way, calculate <#-segments-in-key> - (<#-segments-in-resPath> - <#-segments-in-origResPath>), 2153| | // and append that many segments from the end of `key` to `resPath` to produce the result. 2154| 312| path.append(key, *status); 2155| 312| } else { 2156| 0| path.append(inKey, *status); 2157| 0| } 2158| 312|} uresbund.cpp:_ZL16ures_freeResPathP15UResourceBundle: 1113| 94.4k|static void ures_freeResPath(UResourceBundle *resB) { 1114| 94.4k| if (resB->fResPath && resB->fResPath != resB->fResBuf) { ------------------ | Branch (1114:9): [True: 89.5k, False: 4.85k] | Branch (1114:27): [True: 0, False: 89.5k] ------------------ 1115| 0| uprv_free(resB->fResPath); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1116| 0| } 1117| 94.4k| resB->fResPath = nullptr; 1118| 94.4k| resB->fResPathLen = 0; 1119| 94.4k|} uresbund.cpp:_ZL15getFallbackDataPK15UResourceBundlePPKcPjP10UErrorCode: 319| 64| const char **resTag, Resource *res, UErrorCode *status) { 320| 64| UResourceDataEntry *dataEntry = resBundle->fData; 321| 64| int32_t indexR = -1; 322| 64| int32_t i = 0; 323| 64| *res = RES_BOGUS; ------------------ | | 65| 64|#define RES_BOGUS 0xffffffff ------------------ 324| 64| if(dataEntry == nullptr) { ------------------ | Branch (324:8): [True: 0, False: 64] ------------------ 325| 0| *status = U_MISSING_RESOURCE_ERROR; 326| 0| return nullptr; 327| 0| } 328| 64| if(dataEntry->fBogus == U_ZERO_ERROR) { /* if this resource is real, */ ------------------ | Branch (328:8): [True: 64, False: 0] ------------------ 329| 64| *res = res_getTableItemByKey(&(dataEntry->fData), dataEntry->fData.rootRes, &indexR, resTag); /* try to get data from there */ ------------------ | | 207| 64|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 64|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 64|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 64|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 330| 64| i++; 331| 64| } 332| 64| if(resBundle->fHasFallback) { ------------------ | Branch (332:8): [True: 64, False: 0] ------------------ 333| | // Otherwise, we'll look in parents. 334| 128| while(*res == RES_BOGUS && dataEntry->fParent != nullptr) { ------------------ | | 65| 256|#define RES_BOGUS 0xffffffff ------------------ | Branch (334:15): [True: 64, False: 64] | Branch (334:36): [True: 64, False: 0] ------------------ 335| 64| dataEntry = dataEntry->fParent; 336| 64| if(dataEntry->fBogus == U_ZERO_ERROR) { ------------------ | Branch (336:16): [True: 64, False: 0] ------------------ 337| 64| i++; 338| 64| *res = res_getTableItemByKey(&(dataEntry->fData), dataEntry->fData.rootRes, &indexR, resTag); ------------------ | | 207| 64|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 64|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 64|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 64|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 339| 64| } 340| 64| } 341| 64| } 342| | 343| 64| if(*res == RES_BOGUS) { ------------------ | | 65| 64|#define RES_BOGUS 0xffffffff ------------------ | Branch (343:8): [True: 0, False: 64] ------------------ 344| | // If the resource is not found, we need to give an error. 345| 0| *status = U_MISSING_RESOURCE_ERROR; 346| 0| return nullptr; 347| 0| } 348| | // If the resource is found in parents, we need to adjust the error. 349| 64| if(i>1) { ------------------ | Branch (349:8): [True: 64, False: 0] ------------------ 350| 64| if(uprv_strcmp(dataEntry->fName, uloc_getDefault())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName)==0) { ------------------ | | 38| 64|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 64|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ if(uprv_strcmp(dataEntry->fName, uloc_getDefault())==0 || uprv_strcmp(dataEntry->fName, kRootLocaleName)==0) { ------------------ | | 38| 64|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 64|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (350:12): [True: 0, False: 64] | Branch (350:67): [True: 9, False: 55] ------------------ 351| 9| *status = U_USING_DEFAULT_WARNING; 352| 55| } else { 353| 55| *status = U_USING_FALLBACK_WARNING; 354| 55| } 355| 64| } 356| 64| return dataEntry; 357| 64|} uresbund.cpp:_ZL17ures_openWithTypeP15UResourceBundlePKcS2_12UResOpenTypeP10UErrorCode: 2712| 4.85k| UResOpenType openType, UErrorCode* status) { 2713| 4.85k| if(U_FAILURE(*status)) { ------------------ | Branch (2713:8): [True: 0, False: 4.85k] ------------------ 2714| 0| return nullptr; 2715| 0| } 2716| | 2717| 4.85k| UResourceDataEntry *entry; 2718| 4.85k| if(openType != URES_OPEN_DIRECT) { ------------------ | Branch (2718:8): [True: 4.85k, False: 4] ------------------ 2719| 4.85k| if (localeID == nullptr) { ------------------ | Branch (2719:13): [True: 0, False: 4.85k] ------------------ 2720| 0| localeID = uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2721| 0| } 2722| | /* first "canonicalize" the locale ID */ 2723| 4.85k| CharString canonLocaleID = ulocimp_getBaseName(localeID, *status); ------------------ | | 1199| 4.85k|#define ulocimp_getBaseName U_ICU_ENTRY_POINT_RENAME(ulocimp_getBaseName) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2724| 4.85k| if(U_FAILURE(*status)) { ------------------ | Branch (2724:12): [True: 0, False: 4.85k] ------------------ 2725| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2726| 0| return nullptr; 2727| 0| } 2728| 4.85k| entry = entryOpen(path, canonLocaleID.data(), openType, status); 2729| 4.85k| } else { 2730| 4| entry = entryOpenDirect(path, localeID, status); 2731| 4| } 2732| 4.85k| if(U_FAILURE(*status)) { ------------------ | Branch (2732:8): [True: 0, False: 4.85k] ------------------ 2733| 0| return nullptr; 2734| 0| } 2735| 4.85k| if(entry == nullptr) { ------------------ | Branch (2735:8): [True: 0, False: 4.85k] ------------------ 2736| 0| *status = U_MISSING_RESOURCE_ERROR; 2737| 0| return nullptr; 2738| 0| } 2739| | 2740| 4.85k| UBool isStackObject; 2741| 4.85k| if(r == nullptr) { ------------------ | Branch (2741:8): [True: 4.85k, False: 0] ------------------ 2742| 4.85k| r = static_cast(uprv_malloc(sizeof(UResourceBundle))); ------------------ | | 1524| 4.85k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2743| 4.85k| if(r == nullptr) { ------------------ | Branch (2743:12): [True: 0, False: 4.85k] ------------------ 2744| 0| entryClose(entry); 2745| 0| *status = U_MEMORY_ALLOCATION_ERROR; 2746| 0| return nullptr; 2747| 0| } 2748| 4.85k| isStackObject = false; 2749| 4.85k| } else { // fill-in 2750| 0| isStackObject = ures_isStackObject(r); 2751| 0| ures_closeBundle(r, false); 2752| 0| } 2753| 4.85k| uprv_memset(r, 0, sizeof(UResourceBundle)); ------------------ | | 100| 4.85k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 4.85k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2754| 4.85k| ures_setIsStackObject(r, isStackObject); 2755| | 2756| 4.85k| r->fValidLocaleDataEntry = r->fData = entry; 2757| 4.85k| r->fHasFallback = openType != URES_OPEN_DIRECT && !r->getResData().noFallback; ------------------ | Branch (2757:23): [True: 4.85k, False: 4] | Branch (2757:55): [True: 4.85k, False: 0] ------------------ 2758| 4.85k| r->fIsTopLevel = true; 2759| 4.85k| r->fRes = r->getResData().rootRes; 2760| 4.85k| r->fSize = res_countArrayItems(&r->getResData(), r->fRes); ------------------ | | 197| 4.85k|#define res_countArrayItems U_ICU_ENTRY_POINT_RENAME(res_countArrayItems) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2761| 4.85k| r->fIndex = -1; 2762| | 2763| 4.85k| ResourceTracer(r).traceOpen(); 2764| | 2765| 4.85k| return r; 2766| 4.85k|} uresbund.cpp:_ZL9entryOpenPKcS0_12UResOpenTypeP10UErrorCode: 812| 4.85k| UResOpenType openType, UErrorCode* status) { 813| 4.85k| U_ASSERT(openType != URES_OPEN_DIRECT); ------------------ | | 35| 4.85k|# define U_ASSERT(exp) (void)0 ------------------ 814| 4.85k| UErrorCode intStatus = U_ZERO_ERROR; 815| 4.85k| UResourceDataEntry *r = nullptr; 816| 4.85k| UResourceDataEntry *t1 = nullptr; 817| 4.85k| UBool isDefault = false; 818| 4.85k| UBool isRoot = false; 819| 4.85k| UBool hasRealData = false; 820| 4.85k| UBool hasChopped = true; 821| 4.85k| UBool usingUSRData = U_USE_USRDATA && ( path == nullptr || uprv_strncmp(path,U_ICUDATA_NAME,8) == 0); ------------------ | | 157| 9.70k|#define U_USE_USRDATA 0 /**< @internal */ | | ------------------ | | | Branch (157:27): [Folded - Ignored] | | ------------------ ------------------ UBool usingUSRData = U_USE_USRDATA && ( path == nullptr || uprv_strncmp(path,U_ICUDATA_NAME,8) == 0); ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (821:45): [True: 0, False: 0] | Branch (821:64): [True: 0, False: 0] ------------------ 822| | 823| 4.85k| char name[ULOC_FULLNAME_CAPACITY]; 824| 4.85k| char usrDataPath[96]; 825| | 826| 4.85k| initCache(status); 827| | 828| 4.85k| if(U_FAILURE(*status)) { ------------------ | Branch (828:8): [True: 0, False: 4.85k] ------------------ 829| 0| return nullptr; 830| 0| } 831| | 832| 4.85k| uprv_strncpy(name, localeID, sizeof(name) - 1); ------------------ | | 43| 4.85k|#define uprv_strncpy(dst, src, size) U_STANDARD_CPP_NAMESPACE strncpy(dst, src, size) | | ------------------ | | | | 393| 4.85k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 833| 4.85k| name[sizeof(name) - 1] = 0; 834| | 835| 4.85k| if ( usingUSRData ) { ------------------ | Branch (835:10): [True: 0, False: 4.85k] ------------------ 836| 0| if ( path == nullptr ) { ------------------ | Branch (836:14): [True: 0, False: 0] ------------------ 837| 0| uprv_strcpy(usrDataPath, U_USRDATA_NAME); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 838| 0| } else { 839| 0| uprv_strncpy(usrDataPath, path, sizeof(usrDataPath) - 1); ------------------ | | 43| 0|#define uprv_strncpy(dst, src, size) U_STANDARD_CPP_NAMESPACE strncpy(dst, src, size) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 840| 0| usrDataPath[0] = 'u'; 841| 0| usrDataPath[1] = 's'; 842| 0| usrDataPath[2] = 'r'; 843| 0| usrDataPath[sizeof(usrDataPath) - 1] = 0; 844| 0| } 845| 0| } 846| | 847| | // Note: We need to query the default locale *before* locking resbMutex. 848| 4.85k| const char *defaultLocale = uloc_getDefault(); ------------------ | | 1118| 4.85k|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 849| | 850| 4.85k| Mutex lock(&resbMutex); // Lock resbMutex until the end of this function. 851| | 852| | /* We're going to skip all the locales that do not have any data */ 853| 4.85k| r = findFirstExisting(path, name, defaultLocale, openType, &isRoot, &hasChopped, &isDefault, &intStatus); 854| | 855| | // If we failed due to out-of-memory, report the failure and exit early. 856| 4.85k| if (intStatus == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (856:9): [True: 0, False: 4.85k] ------------------ 857| 0| *status = intStatus; 858| 0| goto finish; 859| 0| } 860| | 861| 4.85k| if(r != nullptr) { /* if there is one real locale, we can look for parents. */ ------------------ | Branch (861:8): [True: 3.82k, False: 1.02k] ------------------ 862| 3.82k| t1 = r; 863| 3.82k| hasRealData = true; 864| 3.82k| if ( usingUSRData ) { /* This code inserts user override data into the inheritance chain */ ------------------ | Branch (864:14): [True: 0, False: 3.82k] ------------------ 865| 0| UErrorCode usrStatus = U_ZERO_ERROR; 866| 0| UResourceDataEntry *u1 = init_entry(t1->fName, usrDataPath, &usrStatus); 867| | // If we failed due to out-of-memory, report the failure and exit early. 868| 0| if (intStatus == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (868:17): [True: 0, False: 0] ------------------ 869| 0| *status = intStatus; 870| 0| goto finish; 871| 0| } 872| 0| if ( u1 != nullptr ) { ------------------ | Branch (872:18): [True: 0, False: 0] ------------------ 873| 0| if(u1->fBogus == U_ZERO_ERROR) { ------------------ | Branch (873:20): [True: 0, False: 0] ------------------ 874| 0| u1->fParent = t1; 875| 0| r = u1; 876| 0| } else { 877| | /* the USR override data wasn't found, set it to be deleted */ 878| 0| u1->fCountExisting = 0; 879| 0| } 880| 0| } 881| 0| } 882| 3.82k| if ((hasChopped || mayHaveParent(name)) && !isRoot) { ------------------ | Branch (882:14): [True: 65, False: 3.76k] | Branch (882:28): [True: 49, False: 3.71k] | Branch (882:52): [True: 114, False: 0] ------------------ 883| 114| if (!loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name), usingUSRData, usrDataPath, status)) { ------------------ | | 99| 114|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (883:17): [True: 0, False: 114] ------------------ 884| 0| goto finish; 885| 0| } 886| 114| } 887| 3.82k| } 888| | 889| | /* we could have reached this point without having any real data */ 890| | /* if that is the case, we need to chain in the default locale */ 891| 4.85k| if(r==nullptr && openType == URES_OPEN_LOCALE_DEFAULT_ROOT && !isDefault && !isRoot) { ------------------ | Branch (891:8): [True: 1.02k, False: 3.82k] | Branch (891:22): [True: 1.02k, False: 0] | Branch (891:67): [True: 1.02k, False: 0] | Branch (891:81): [True: 1.02k, False: 0] ------------------ 892| | /* insert default locale */ 893| 1.02k| uprv_strcpy(name, defaultLocale); ------------------ | | 36| 1.02k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 1.02k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 894| 1.02k| r = findFirstExisting(path, name, defaultLocale, openType, &isRoot, &hasChopped, &isDefault, &intStatus); 895| | // If we failed due to out-of-memory, report the failure and exit early. 896| 1.02k| if (intStatus == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (896:13): [True: 0, False: 1.02k] ------------------ 897| 0| *status = intStatus; 898| 0| goto finish; 899| 0| } 900| 1.02k| intStatus = U_USING_DEFAULT_WARNING; 901| 1.02k| if(r != nullptr) { /* the default locale exists */ ------------------ | Branch (901:12): [True: 1.02k, False: 0] ------------------ 902| 1.02k| t1 = r; 903| 1.02k| hasRealData = true; 904| 1.02k| isDefault = true; 905| | // TODO: Why not if (usingUSRData) { ... } like in the non-default-locale code path? 906| 1.02k| if ((hasChopped || mayHaveParent(name)) && !isRoot) { ------------------ | Branch (906:18): [True: 1.02k, False: 0] | Branch (906:32): [True: 0, False: 0] | Branch (906:56): [True: 1.02k, False: 0] ------------------ 907| 1.02k| if (!loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name), usingUSRData, usrDataPath, status)) { ------------------ | | 99| 1.02k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (907:21): [True: 0, False: 1.02k] ------------------ 908| 0| goto finish; 909| 0| } 910| 1.02k| } 911| 1.02k| } 912| 1.02k| } 913| | 914| | /* we could still have r == nullptr at this point - maybe even default locale is not */ 915| | /* present */ 916| 4.85k| if(r == nullptr) { ------------------ | Branch (916:8): [True: 0, False: 4.85k] ------------------ 917| 0| uprv_strcpy(name, kRootLocaleName); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 918| 0| r = findFirstExisting(path, name, defaultLocale, openType, &isRoot, &hasChopped, &isDefault, &intStatus); 919| | // If we failed due to out-of-memory, report the failure and exit early. 920| 0| if (intStatus == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (920:13): [True: 0, False: 0] ------------------ 921| 0| *status = intStatus; 922| 0| goto finish; 923| 0| } 924| 0| if(r != nullptr) { ------------------ | Branch (924:12): [True: 0, False: 0] ------------------ 925| 0| t1 = r; 926| 0| intStatus = U_USING_DEFAULT_WARNING; 927| 0| hasRealData = true; 928| 0| } else { /* we don't even have the root locale */ 929| 0| *status = U_MISSING_RESOURCE_ERROR; 930| 0| goto finish; 931| 0| } 932| 4.85k| } else if(!isRoot && uprv_strcmp(t1->fName, kRootLocaleName) != 0 && ------------------ | | 38| 4.73k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 4.73k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (932:15): [True: 4.73k, False: 119] | Branch (932:26): [True: 4.73k, False: 0] ------------------ 933| 4.85k| t1->fParent == nullptr && !r->fData.noFallback) { ------------------ | Branch (933:13): [True: 59, False: 4.67k] | Branch (933:39): [True: 59, False: 0] ------------------ 934| 59| if (!insertRootBundle(t1, status)) { ------------------ | Branch (934:13): [True: 0, False: 59] ------------------ 935| 0| goto finish; 936| 0| } 937| 59| if(!hasRealData) { ------------------ | Branch (937:12): [True: 0, False: 59] ------------------ 938| 0| r->fBogus = U_USING_DEFAULT_WARNING; 939| 0| } 940| 59| } 941| | 942| | // TODO: Does this ever loop? 943| 11.6k| while(r != nullptr && !isRoot && t1->fParent != nullptr) { ------------------ | Branch (943:11): [True: 11.6k, False: 0] | Branch (943:27): [True: 11.5k, False: 119] | Branch (943:38): [True: 6.83k, False: 4.73k] ------------------ 944| 6.83k| t1->fParent->fCountExisting++; 945| 6.83k| t1 = t1->fParent; 946| 6.83k| } 947| | 948| 4.85k|finish: 949| 4.85k| if(U_SUCCESS(*status)) { ------------------ | Branch (949:8): [True: 4.85k, False: 0] ------------------ 950| 4.85k| if(intStatus != U_ZERO_ERROR) { ------------------ | Branch (950:12): [True: 1.32k, False: 3.52k] ------------------ 951| 1.32k| *status = intStatus; 952| 1.32k| } 953| 4.85k| return r; 954| 4.85k| } else { 955| 0| return nullptr; 956| 0| } 957| 4.85k|} uresbund.cpp:_ZL9initCacheP10UErrorCode: 483| 4.85k|static void initCache(UErrorCode *status) { 484| 4.85k| umtx_initOnce(gCacheInitOnce, &createCache, *status); 485| 4.85k|} uresbund.cpp:_ZL11createCacheR10UErrorCode: 477| 1|static void U_CALLCONV createCache(UErrorCode &status) { 478| 1| U_ASSERT(cache == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 479| 1| cache = uhash_open(hashEntry, compareEntries, nullptr, &status); ------------------ | | 1030| 1|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 480| 1| ucln_common_registerCleanup(UCLN_COMMON_URES, ures_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 481| 1|} uresbund.cpp:_ZL9hashEntry8UElement: 58| 9.55k|static int32_t U_CALLCONV hashEntry(const UHashTok parm) { 59| 9.55k| UResourceDataEntry* b = static_cast(parm.pointer); 60| 9.55k| UHashTok namekey, pathkey; 61| 9.55k| namekey.pointer = b->fName; 62| 9.55k| pathkey.pointer = b->fPath; 63| 9.55k| return uhash_hashChars(namekey)+37u*uhash_hashChars(pathkey); ------------------ | | 1011| 9.55k|#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars) | | ------------------ | | | | 123| 9.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return uhash_hashChars(namekey)+37u*uhash_hashChars(pathkey); ------------------ | | 1011| 9.55k|#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars) | | ------------------ | | | | 123| 9.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 9.55k|} uresbund.cpp:_ZL14compareEntries8UElementS_: 67| 7.43k|static UBool U_CALLCONV compareEntries(const UHashTok p1, const UHashTok p2) { 68| 7.43k| UResourceDataEntry* b1 = static_cast(p1.pointer); 69| 7.43k| UResourceDataEntry* b2 = static_cast(p2.pointer); 70| 7.43k| UHashTok name1, name2, path1, path2; 71| 7.43k| name1.pointer = b1->fName; 72| 7.43k| name2.pointer = b2->fName; 73| 7.43k| path1.pointer = b1->fPath; 74| 7.43k| path2.pointer = b2->fPath; 75| 7.43k| return uhash_compareChars(name1, name2) && uhash_compareChars(path1, path2); ------------------ | | 993| 7.43k|#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars) | | ------------------ | | | | 123| 7.43k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.43k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.43k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return uhash_compareChars(name1, name2) && uhash_compareChars(path1, path2); ------------------ | | 993| 7.43k|#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars) | | ------------------ | | | | 123| 7.43k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.43k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.43k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (75:12): [True: 7.43k, False: 7] | Branch (75:48): [True: 7.43k, False: 0] ------------------ 76| 7.43k|} uresbund.cpp:_ZL17findFirstExistingPKcPcS0_12UResOpenTypePaS3_S3_P10UErrorCode: 665| 5.87k| UBool *isRoot, UBool *foundParent, UBool *isDefault, UErrorCode* status) { 666| 5.87k| UResourceDataEntry *r = nullptr; 667| 5.87k| UBool hasRealData = false; 668| 5.87k| *foundParent = true; /* we're starting with a fresh name */ 669| 5.87k| char origName[ULOC_FULLNAME_CAPACITY]; 670| | 671| 5.87k| uprv_strcpy(origName, name); ------------------ | | 36| 5.87k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 5.87k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 672| 13.9k| while(*foundParent && !hasRealData) { ------------------ | Branch (672:11): [True: 9.15k, False: 4.78k] | Branch (672:27): [True: 8.06k, False: 1.09k] ------------------ 673| 8.06k| r = init_entry(name, path, status); 674| | /* Null pointer test */ 675| 8.06k| if (U_FAILURE(*status)) { ------------------ | Branch (675:13): [True: 0, False: 8.06k] ------------------ 676| 0| return nullptr; 677| 0| } 678| 8.06k| *isDefault = static_cast(uprv_strncmp(name, defaultLocale, uprv_strlen(name)) == 0); ------------------ | | 44| 8.06k|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 8.06k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 679| 8.06k| hasRealData = static_cast(r->fBogus == U_ZERO_ERROR); 680| 8.06k| if(!hasRealData) { ------------------ | Branch (680:12): [True: 3.21k, False: 4.85k] ------------------ 681| | /* this entry is not real. We will discard it. */ 682| | /* However, the parent line for this entry is */ 683| | /* not to be used - as there might be parent */ 684| | /* lines in cache from previous openings that */ 685| | /* are not updated yet. */ 686| 3.21k| r->fCountExisting--; 687| | /*entryCloseInt(r);*/ 688| 3.21k| r = nullptr; 689| 3.21k| *status = U_USING_FALLBACK_WARNING; 690| 4.85k| } else { 691| 4.85k| uprv_strcpy(name, r->fName); /* this is needed for supporting aliases */ ------------------ | | 36| 4.85k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 4.85k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 692| 4.85k| } 693| | 694| 8.06k| *isRoot = static_cast(uprv_strcmp(name, kRootLocaleName) == 0); ------------------ | | 38| 8.06k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 8.06k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 695| | 696| | /*Fallback data stuff*/ 697| 8.06k| if (!hasRealData) { ------------------ | Branch (697:13): [True: 3.21k, False: 4.85k] ------------------ 698| 3.21k| *foundParent = getParentLocaleID(name, origName, openType); 699| 4.85k| } else { 700| | // we've already found a real resource file; what we return to the caller is the parent 701| | // locale ID for inheritance, which should come from chopLocale(), not getParentLocaleID() 702| 4.85k| *foundParent = chopLocale(name); 703| 4.85k| } 704| 8.06k| if (*foundParent && *name == '\0') { ------------------ | Branch (704:13): [True: 3.27k, False: 4.78k] | Branch (704:29): [True: 2, False: 3.27k] ------------------ 705| 2| uprv_strcpy(name, "und"); ------------------ | | 36| 2|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 706| 2| } 707| 8.06k| } 708| 5.87k| return r; 709| 5.87k|} uresbund.cpp:_ZL17getParentLocaleIDPcPKc12UResOpenType: 211| 3.21k|static bool getParentLocaleID(char *name, const char *origName, UResOpenType openType) { 212| | // early out if the locale ID has a variant code or ends with _ 213| 3.21k| size_t nameLen = uprv_strlen(name); ------------------ | | 37| 3.21k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 3.21k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 214| 3.21k| if (!nameLen || name[nameLen - 1] == '_' || hasVariant(name)) { ------------------ | Branch (214:9): [True: 0, False: 3.21k] | Branch (214:21): [True: 175, False: 3.03k] | Branch (214:49): [True: 962, False: 2.07k] ------------------ 215| 1.13k| return chopLocale(name); 216| 1.13k| } 217| | 218| 2.07k| UErrorCode err = U_ZERO_ERROR; 219| 2.07k| CharString language; 220| 2.07k| CharString script; 221| 2.07k| CharString region; 222| 2.07k| ulocimp_getSubtags(name, &language, &script, ®ion, nullptr, nullptr, err); ------------------ | | 1209| 2.07k|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 2.07k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.07k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.07k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 223| | 224| 2.07k| if (U_FAILURE(err)) { ------------------ | Branch (224:9): [True: 0, False: 2.07k] ------------------ 225| | // hopefully this never happens... 226| 0| return chopLocale(name); 227| 0| } 228| | 229| | // if the open type is URES_OPEN_LOCALE_DEFAULT_ROOT, first look the locale ID up in the parent locale table; 230| | // if that table specifies a parent for it, return that (we don't do this for the other open types-- if we're not 231| | // falling back through the system default locale, we also want to do straight truncation fallback instead 232| | // of looking things up in the parent locale table-- see https://www.unicode.org/reports/tr35/tr35.html#Parent_Locales: 233| | // "Collation data, however, is an exception...") 234| 2.07k| if (openType == URES_OPEN_LOCALE_DEFAULT_ROOT) { ------------------ | Branch (234:9): [True: 2.07k, False: 0] ------------------ 235| 2.07k| const char* parentID = performFallbackLookup(name, parentLocaleChars, parentLocaleChars, parentLocaleTable, UPRV_LENGTHOF(parentLocaleTable)); ------------------ | | 99| 2.07k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 236| 2.07k| if (parentID != nullptr) { ------------------ | Branch (236:13): [True: 3, False: 2.07k] ------------------ 237| 3| uprv_strcpy(name, parentID); ------------------ | | 36| 3|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 238| 3| return true; 239| 3| } 240| 2.07k| } 241| | 242| 2.07k| CharString workingLocale; 243| | 244| | // if it's not in the parent locale table, figure out the fallback script algorithmically 245| | // (see CLDR-15265 for an explanation of the algorithm) 246| 2.07k| if (!script.isEmpty() && !region.isEmpty()) { ------------------ | Branch (246:9): [True: 754, False: 1.31k] | Branch (246:30): [True: 69, False: 685] ------------------ 247| | // if "name" has both script and region, is the script the default script? 248| | // - if so, remove it and keep the region 249| | // - if not, remove the region and keep the script 250| 69| if (getDefaultScript(language, region) == script) { ------------------ | Branch (250:13): [True: 0, False: 69] ------------------ 251| 0| workingLocale.append(language, err).append("_", err).append(region, err); 252| 69| } else { 253| 69| workingLocale.append(language, err).append("_", err).append(script, err); 254| 69| } 255| 2.00k| } else if (!region.isEmpty()) { ------------------ | Branch (255:16): [True: 492, False: 1.50k] ------------------ 256| | // if "name" has region but not script, did the original locale ID specify a script? 257| | // - if yes, replace the region with the script from the original locale ID 258| | // - if no, replace the region with the default script for that language and region 259| 492| UErrorCode err = U_ZERO_ERROR; 260| 492| CharString origNameLanguage; 261| 492| CharString origNameScript; 262| 492| ulocimp_getSubtags(origName, &origNameLanguage, &origNameScript, nullptr, nullptr, nullptr, err); ------------------ | | 1209| 492|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 492|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 492|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 492|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 263| 492| if (!origNameScript.isEmpty()) { ------------------ | Branch (263:13): [True: 0, False: 492] ------------------ 264| 0| workingLocale.append(language, err).append("_", err).append(origNameScript, err); 265| 492| } else { 266| 492| workingLocale.append(language, err).append("_", err).append(getDefaultScript(language, region), err); 267| 492| } 268| 1.50k| } else if (!script.isEmpty()) { ------------------ | Branch (268:16): [True: 685, False: 824] ------------------ 269| | // if "name" has script but not region (and our open type if URES_OPEN_LOCALE_DEFAULT_ROOT), is the script 270| | // the default script for the language? 271| | // - if so, remove it from the locale ID 272| | // - if not, return false to continue up the chain 273| | // (we don't do this for other open types for the same reason we don't look things up in the parent 274| | // locale table for other open types-- see the reference to UTS #35 above) 275| 685| if (openType != URES_OPEN_LOCALE_DEFAULT_ROOT || getDefaultScript(language, CharString()) == script) { ------------------ | Branch (275:13): [True: 0, False: 685] | Branch (275:13): [True: 487, False: 198] | Branch (275:58): [True: 487, False: 198] ------------------ 276| 487| workingLocale.append(language, err); 277| 487| } else { 278| 198| return false; 279| 198| } 280| 824| } else { 281| | // if "name" just contains a language code, return false so the calling code falls back to "root" 282| 824| return false; 283| 824| } 284| 1.04k| if (U_SUCCESS(err) && !workingLocale.isEmpty()) { ------------------ | Branch (284:9): [True: 1.04k, False: 0] | Branch (284:27): [True: 1.04k, False: 3] ------------------ 285| 1.04k| uprv_strcpy(name, workingLocale.data()); ------------------ | | 36| 1.04k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 1.04k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 286| 1.04k| return true; 287| 1.04k| } else { 288| 3| return false; 289| 3| } 290| 1.04k|} uresbund.cpp:_ZL10hasVariantPKc: 94| 3.03k|static UBool hasVariant(const char* localeID) { 95| 3.03k| UErrorCode err = U_ZERO_ERROR; 96| 3.03k| CheckedArrayByteSink sink(nullptr, 0); 97| 3.03k| ulocimp_getSubtags( ------------------ | | 1209| 3.03k|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 3.03k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.03k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.03k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 98| 3.03k| localeID, 99| 3.03k| nullptr, 100| 3.03k| nullptr, 101| 3.03k| nullptr, 102| 3.03k| &sink, 103| 3.03k| nullptr, 104| 3.03k| err); 105| 3.03k| return sink.NumberOfBytesAppended() != 0; 106| 3.03k|} uresbund.cpp:_ZL21performFallbackLookupPKcS0_S0_PKii: 118| 3.88k| int32_t lookupTableLength) { 119| 3.88k| const int32_t* bottom = lookupTable; 120| 3.88k| const int32_t* top = lookupTable + lookupTableLength; 121| | 122| 37.2k| while (bottom < top) { ------------------ | Branch (122:12): [True: 33.9k, False: 3.30k] ------------------ 123| | // Effectively, divide by 2 and round down to an even index 124| 33.9k| const int32_t* middle = bottom + (((top - bottom) / 4) * 2); 125| 33.9k| const char* entryKey = &(keyStrs[*middle]); 126| 33.9k| int32_t strcmpResult = uprv_strcmp(key, entryKey); ------------------ | | 38| 33.9k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 33.9k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 127| 33.9k| if (strcmpResult == 0) { ------------------ | Branch (127:13): [True: 572, False: 33.3k] ------------------ 128| 572| return &(valueStrs[middle[1]]); 129| 33.3k| } else if (strcmpResult < 0) { ------------------ | Branch (129:20): [True: 11.5k, False: 21.7k] ------------------ 130| 11.5k| top = middle; 131| 21.7k| } else { 132| 21.7k| bottom = middle + 2; 133| 21.7k| } 134| 33.9k| } 135| 3.30k| return nullptr; 136| 3.88k|} uresbund.cpp:_ZL16getDefaultScriptRKN6icu_7810CharStringES2_: 138| 1.24k|static CharString getDefaultScript(const CharString& language, const CharString& region) { 139| 1.24k| const char* defaultScript = nullptr; 140| 1.24k| UErrorCode err = U_ZERO_ERROR; 141| | 142| | // the default script will be "Latn" if we don't find the locale ID in the tables 143| 1.24k| CharString result("Latn", err); 144| | 145| | // if we were passed both language and region, make them into a locale ID and look that up in the default 146| | // script table 147| 1.24k| if (!region.isEmpty()) { ------------------ | Branch (147:9): [True: 561, False: 685] ------------------ 148| 561| CharString localeID; 149| 561| localeID.append(language, err).append("_", err).append(region, err); 150| 561| if (U_FAILURE(err)) { ------------------ | Branch (150:13): [True: 0, False: 561] ------------------ 151| 0| return result; 152| 0| } 153| 561| defaultScript = performFallbackLookup(localeID.data(), dsLocaleIDChars, scriptCodeChars, defaultScriptTable, UPRV_LENGTHOF(defaultScriptTable)); ------------------ | | 99| 561|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 154| 561| } 155| | 156| | // if we didn't find anything, look up just the language in the default script table 157| 1.24k| if (defaultScript == nullptr) { ------------------ | Branch (157:9): [True: 1.24k, False: 0] ------------------ 158| 1.24k| defaultScript = performFallbackLookup(language.data(), dsLocaleIDChars, scriptCodeChars, defaultScriptTable, UPRV_LENGTHOF(defaultScriptTable)); ------------------ | | 99| 1.24k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 159| 1.24k| } 160| | 161| | // if either lookup above succeeded, copy the result from "defaultScript" into "result"; otherwise, return "Latn" 162| 1.24k| if (defaultScript != nullptr) { ------------------ | Branch (162:9): [True: 569, False: 677] ------------------ 163| 569| result.clear(); 164| 569| result.append(defaultScript, err); 165| 569| } 166| 1.24k| return result; 167| 1.24k|} uresbund.cpp:_ZL10chopLocalePc: 83| 5.99k|static UBool chopLocale(char *name) { 84| 5.99k| char *i = uprv_strrchr(name, '_'); ------------------ | | 42| 5.99k|#define uprv_strrchr(s, c) U_STANDARD_CPP_NAMESPACE strrchr(s, c) | | ------------------ | | | | 393| 5.99k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 85| | 86| 5.99k| if(i != nullptr) { ------------------ | Branch (86:8): [True: 2.22k, False: 3.77k] ------------------ 87| 2.22k| *i = '\0'; 88| 2.22k| return true; 89| 2.22k| } 90| | 91| 3.77k| return false; 92| 5.99k|} uresbund.cpp:_ZL10init_entryPKcS0_P10UErrorCode: 514| 8.13k|static UResourceDataEntry *init_entry(const char *localeID, const char *path, UErrorCode *status) { 515| 8.13k| UResourceDataEntry *r = nullptr; 516| 8.13k| UResourceDataEntry find; 517| | /*int32_t hashValue;*/ 518| 8.13k| const char *name; 519| 8.13k| char aliasName[100] = { 0 }; 520| 8.13k| int32_t aliasLen = 0; 521| | /*UBool isAlias = false;*/ 522| | /*UHashTok hashkey; */ 523| | 524| 8.13k| if(U_FAILURE(*status)) { ------------------ | Branch (524:8): [True: 0, False: 8.13k] ------------------ 525| 0| return nullptr; 526| 0| } 527| | 528| | /* here we try to deduce the right locale name */ 529| 8.13k| if(localeID == nullptr) { /* if localeID is nullptr, we're trying to open default locale */ ------------------ | Branch (529:8): [True: 0, False: 8.13k] ------------------ 530| 0| name = uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 531| 8.13k| } else if(*localeID == 0) { /* if localeID is "" then we try to open root locale */ ------------------ | Branch (531:15): [True: 119, False: 8.02k] ------------------ 532| 119| name = kRootLocaleName; ------------------ | | 18| 119|#define kRootLocaleName "root" ------------------ 533| 8.02k| } else { /* otherwise, we'll open what we're given */ 534| 8.02k| name = localeID; 535| 8.02k| } 536| | 537| 8.13k| find.fName = const_cast(name); 538| 8.13k| find.fPath = const_cast(path); 539| | 540| | /* calculate the hash value of the entry */ 541| | /*hashkey.pointer = (void *)&find;*/ 542| | /*hashValue = hashEntry(hashkey);*/ 543| | 544| | /* check to see if we already have this entry */ 545| 8.13k| r = static_cast(uhash_get(cache, &find)); ------------------ | | 1007| 8.13k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 8.13k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.13k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.13k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 546| 8.13k| if(r == nullptr) { ------------------ | Branch (546:8): [True: 708, False: 7.43k] ------------------ 547| | /* if the entry is not yet in the hash table, we'll try to construct a new one */ 548| 708| r = static_cast(uprv_malloc(sizeof(UResourceDataEntry))); ------------------ | | 1524| 708|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 708|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 708|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 708|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 549| 708| if(r == nullptr) { ------------------ | Branch (549:12): [True: 0, False: 708] ------------------ 550| 0| *status = U_MEMORY_ALLOCATION_ERROR; 551| 0| return nullptr; 552| 0| } 553| | 554| 708| uprv_memset(r, 0, sizeof(UResourceDataEntry)); ------------------ | | 100| 708|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 708|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 555| | /*r->fHashKey = hashValue;*/ 556| | 557| 708| setEntryName(r, name, status); 558| 708| if (U_FAILURE(*status)) { ------------------ | Branch (558:13): [True: 0, False: 708] ------------------ 559| 0| uprv_free(r); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 560| 0| return nullptr; 561| 0| } 562| | 563| 708| if(path != nullptr) { ------------------ | Branch (563:12): [True: 706, False: 2] ------------------ 564| 706| r->fPath = uprv_strdup(path); ------------------ | | 1541| 706|#define uprv_strdup U_ICU_ENTRY_POINT_RENAME(uprv_strdup) | | ------------------ | | | | 123| 706|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 706|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 706|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 565| 706| if(r->fPath == nullptr) { ------------------ | Branch (565:16): [True: 0, False: 706] ------------------ 566| 0| *status = U_MEMORY_ALLOCATION_ERROR; 567| 0| uprv_free(r); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 0| return nullptr; 569| 0| } 570| 706| } 571| | 572| | /* this is the actual loading */ 573| 708| res_load(&(r->fData), r->fPath, r->fName, status); ------------------ | | 208| 708|#define res_load U_ICU_ENTRY_POINT_RENAME(res_load) | | ------------------ | | | | 123| 708|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 708|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 708|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 574| | 575| 708| if (U_FAILURE(*status)) { ------------------ | Branch (575:13): [True: 634, False: 74] ------------------ 576| | /* if we failed to load due to an out-of-memory error, exit early. */ 577| 634| if (*status == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (577:17): [True: 0, False: 634] ------------------ 578| 0| uprv_free(r); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 579| 0| return nullptr; 580| 0| } 581| | /* we have no such entry in dll, so it will always use fallback */ 582| 634| *status = U_USING_FALLBACK_WARNING; 583| 634| r->fBogus = U_USING_FALLBACK_WARNING; 584| 634| } else { /* if we have a regular entry */ 585| 74| Resource aliasres; 586| 74| if (r->fData.usesPoolBundle) { ------------------ | Branch (586:17): [True: 0, False: 74] ------------------ 587| 0| r->fPool = getPoolEntry(r->fPath, status); 588| 0| if (U_SUCCESS(*status)) { ------------------ | Branch (588:21): [True: 0, False: 0] ------------------ 589| 0| const int32_t *poolIndexes = r->fPool->fData.pRoot + 1; 590| 0| if(r->fData.pRoot[1 + URES_INDEX_POOL_CHECKSUM] == poolIndexes[URES_INDEX_POOL_CHECKSUM]) { ------------------ | Branch (590:24): [True: 0, False: 0] ------------------ 591| 0| r->fData.poolBundleKeys = reinterpret_cast(poolIndexes + (poolIndexes[URES_INDEX_LENGTH] & 0xff)); 592| 0| r->fData.poolBundleStrings = r->fPool->fData.p16BitUnits; 593| 0| } else { 594| 0| r->fBogus = *status = U_INVALID_FORMAT_ERROR; 595| 0| } 596| 0| } else { 597| 0| r->fBogus = *status; 598| 0| } 599| 0| } 600| 74| if (U_SUCCESS(*status)) { ------------------ | Branch (600:17): [True: 74, False: 0] ------------------ 601| | /* handle the alias by trying to get out the %%Alias tag.*/ 602| | /* We'll try to get alias string from the bundle */ 603| 74| aliasres = res_getResource(&(r->fData), "%%ALIAS"); ------------------ | | 204| 74|#define res_getResource U_ICU_ENTRY_POINT_RENAME(res_getResource) | | ------------------ | | | | 123| 74|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 74|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 74|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 604| 74| if (aliasres != RES_BOGUS) { ------------------ | | 65| 74|#define RES_BOGUS 0xffffffff ------------------ | Branch (604:21): [True: 5, False: 69] ------------------ 605| | // No tracing: called during initial data loading 606| 5| const char16_t *alias = res_getStringNoTrace(&(r->fData), aliasres, &aliasLen); ------------------ | | 205| 5|#define res_getStringNoTrace U_ICU_ENTRY_POINT_RENAME(res_getStringNoTrace) | | ------------------ | | | | 123| 5|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 5| if(alias != nullptr && aliasLen > 0) { /* if there is actual alias - unload and load new data */ ------------------ | Branch (607:24): [True: 5, False: 0] | Branch (607:44): [True: 5, False: 0] ------------------ 608| 5| u_UCharsToChars(alias, aliasName, aliasLen+1); ------------------ | | 211| 5|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 123| 5|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 609| 5| r->fAlias = init_entry(aliasName, path, status); 610| 5| } 611| 5| } 612| 74| } 613| 74| } 614| | 615| 708| { 616| 708| UResourceDataEntry *oldR = nullptr; 617| 708| if ((oldR = static_cast(uhash_get(cache, r))) == nullptr) { /* if the data is not cached */ ------------------ | | 1007| 708|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 708|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 708|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 708|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (617:17): [True: 708, False: 0] ------------------ 618| | /* just insert it in the cache */ 619| 708| UErrorCode cacheStatus = U_ZERO_ERROR; 620| 708| uhash_put(cache, (void *)r, r, &cacheStatus); ------------------ | | 1032| 708|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 708|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 708|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 708|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 621| 708| if (U_FAILURE(cacheStatus)) { ------------------ | Branch (621:21): [True: 0, False: 708] ------------------ 622| 0| *status = cacheStatus; 623| 0| free_entry(r); 624| 0| r = nullptr; 625| 0| } 626| 708| } else { 627| | /* somebody have already inserted it while we were working, discard newly opened data */ 628| | /* Also, we could get here IF we opened an alias */ 629| 0| free_entry(r); 630| 0| r = oldR; 631| 0| } 632| 708| } 633| | 634| 708| } 635| 8.13k| if(r != nullptr) { ------------------ | Branch (635:8): [True: 8.13k, False: 0] ------------------ 636| | /* return the real bundle */ 637| 8.21k| while(r->fAlias != nullptr) { ------------------ | Branch (637:15): [True: 77, False: 8.13k] ------------------ 638| 77| r = r->fAlias; 639| 77| } 640| 8.13k| r->fCountExisting++; /* we increase its reference count */ 641| | /* if the resource has a warning */ 642| | /* we don't want to overwrite a status with no error */ 643| 8.13k| if(r->fBogus != U_ZERO_ERROR && U_SUCCESS(*status)) { ------------------ | Branch (643:12): [True: 3.21k, False: 4.92k] | Branch (643:41): [True: 3.21k, False: 0] ------------------ 644| 3.21k| *status = r->fBogus; /* set the returning status */ 645| 3.21k| } 646| 8.13k| } 647| 8.13k| return r; 648| 8.13k|} uresbund.cpp:_ZL12setEntryNameP18UResourceDataEntryPKcP10UErrorCode: 489| 708|static void setEntryName(UResourceDataEntry *res, const char *name, UErrorCode *status) { 490| 708| int32_t len = static_cast(uprv_strlen(name)); ------------------ | | 37| 708|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 708|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 491| 708| if(res->fName != nullptr && res->fName != res->fNameBuffer) { ------------------ | Branch (491:8): [True: 0, False: 708] | Branch (491:33): [True: 0, False: 0] ------------------ 492| 0| uprv_free(res->fName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 493| 0| } 494| 708| if (len < static_cast(sizeof(res->fNameBuffer))) { ------------------ | Branch (494:9): [True: 115, False: 593] ------------------ 495| 115| res->fName = res->fNameBuffer; 496| 115| } 497| 593| else { 498| 593| res->fName = static_cast(uprv_malloc(len + 1)); ------------------ | | 1524| 593|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 593|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 593|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 593|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 499| 593| } 500| 708| if(res->fName == nullptr) { ------------------ | Branch (500:8): [True: 0, False: 708] ------------------ 501| 0| *status = U_MEMORY_ALLOCATION_ERROR; 502| 708| } else { 503| 708| uprv_strcpy(res->fName, name); ------------------ | | 36| 708|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 708|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 504| 708| } 505| 708|} uresbund.cpp:_ZL13mayHaveParentPc: 297| 3.77k|static UBool mayHaveParent(char *name) { 298| 3.77k| return (name[0] != 0 && uprv_strstr("nb nn",name) != nullptr); ------------------ | | 41| 3.77k|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 3.77k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (298:13): [True: 3.77k, False: 0] | Branch (298:29): [True: 49, False: 3.72k] ------------------ 299| 3.77k|} uresbund.cpp:_ZL21loadParentsExceptRootRP18UResourceDataEntryPciaS2_P10UErrorCode: 746| 1.13k| UBool usingUSRData, char usrDataPath[], UErrorCode *status) { 747| 1.13k| if (U_FAILURE(*status)) { return false; } ------------------ | Branch (747:9): [True: 0, False: 1.13k] ------------------ 748| 1.13k| UBool checkParent = true; 749| 1.14k| while (checkParent && t1->fParent == nullptr && !t1->fData.noFallback && ------------------ | Branch (749:12): [True: 1.14k, False: 6] | Branch (749:27): [True: 7, False: 1.13k] | Branch (749:53): [True: 7, False: 0] ------------------ 750| 1.14k| res_getResource(&t1->fData,"%%ParentIsRoot") == RES_BOGUS) { ------------------ | | 204| 7|#define res_getResource U_ICU_ENTRY_POINT_RENAME(res_getResource) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ res_getResource(&t1->fData,"%%ParentIsRoot") == RES_BOGUS) { ------------------ | | 65| 7|#define RES_BOGUS 0xffffffff ------------------ | Branch (750:13): [True: 7, False: 0] ------------------ 751| 7| Resource parentRes = res_getResource(&t1->fData, "%%Parent"); ------------------ | | 204| 7|#define res_getResource U_ICU_ENTRY_POINT_RENAME(res_getResource) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 7| if (parentRes != RES_BOGUS) { // An explicit parent was found. ------------------ | | 65| 7|#define RES_BOGUS 0xffffffff ------------------ | Branch (752:13): [True: 1, False: 6] ------------------ 753| 1| int32_t parentLocaleLen = 0; 754| | // No tracing: called during initial data loading 755| 1| const char16_t *parentLocaleName = res_getStringNoTrace(&(t1->fData), parentRes, &parentLocaleLen); ------------------ | | 205| 1|#define res_getStringNoTrace U_ICU_ENTRY_POINT_RENAME(res_getStringNoTrace) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 756| 1| if(parentLocaleName != nullptr && 0 < parentLocaleLen && parentLocaleLen < nameCapacity) { ------------------ | Branch (756:16): [True: 1, False: 0] | Branch (756:47): [True: 1, False: 0] | Branch (756:70): [True: 1, False: 0] ------------------ 757| 1| u_UCharsToChars(parentLocaleName, name, parentLocaleLen + 1); ------------------ | | 211| 1|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 758| 1| if (uprv_strcmp(name, kRootLocaleName) == 0) { ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (758:21): [True: 0, False: 1] ------------------ 759| 0| return true; 760| 0| } 761| 1| } 762| 1| } 763| | // Insert regular parents. 764| 7| UErrorCode parentStatus = U_ZERO_ERROR; 765| 7| UResourceDataEntry *t2 = init_entry(name, t1->fPath, &parentStatus); 766| 7| if (U_FAILURE(parentStatus)) { ------------------ | Branch (766:13): [True: 0, False: 7] ------------------ 767| 0| *status = parentStatus; 768| 0| return false; 769| 0| } 770| 7| UResourceDataEntry *u2 = nullptr; 771| 7| UErrorCode usrStatus = U_ZERO_ERROR; 772| 7| if (usingUSRData) { // This code inserts user override data into the inheritance chain. ------------------ | Branch (772:13): [True: 0, False: 7] ------------------ 773| 0| u2 = init_entry(name, usrDataPath, &usrStatus); 774| | // If we failed due to out-of-memory, report that to the caller and exit early. 775| 0| if (usrStatus == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (775:17): [True: 0, False: 0] ------------------ 776| 0| *status = usrStatus; 777| 0| return false; 778| 0| } 779| 0| } 780| | 781| 7| if (usingUSRData && U_SUCCESS(usrStatus) && u2->fBogus == U_ZERO_ERROR) { ------------------ | Branch (781:13): [True: 0, False: 7] | Branch (781:29): [True: 0, False: 0] | Branch (781:53): [True: 0, False: 0] ------------------ 782| 0| t1->fParent = u2; 783| 0| u2->fParent = t2; 784| 7| } else { 785| 7| t1->fParent = t2; 786| 7| if (usingUSRData) { ------------------ | Branch (786:17): [True: 0, False: 7] ------------------ 787| | // The USR override data wasn't found, set it to be deleted. 788| 0| u2->fCountExisting = 0; 789| 0| } 790| 7| } 791| 7| t1 = t2; 792| 7| checkParent = chopLocale(name) || mayHaveParent(name); ------------------ | Branch (792:23): [True: 1, False: 6] | Branch (792:43): [True: 0, False: 6] ------------------ 793| 7| } 794| 1.13k| return true; 795| 1.13k|} uresbund.cpp:_ZL16insertRootBundleRP18UResourceDataEntryP10UErrorCode: 798| 59|insertRootBundle(UResourceDataEntry *&t1, UErrorCode *status) { 799| 59| if (U_FAILURE(*status)) { return false; } ------------------ | Branch (799:9): [True: 0, False: 59] ------------------ 800| 59| UErrorCode parentStatus = U_ZERO_ERROR; 801| 59| UResourceDataEntry *t2 = init_entry(kRootLocaleName, t1->fPath, &parentStatus); ------------------ | | 18| 59|#define kRootLocaleName "root" ------------------ 802| 59| if (U_FAILURE(parentStatus)) { ------------------ | Branch (802:9): [True: 0, False: 59] ------------------ 803| 0| *status = parentStatus; 804| 0| return false; 805| 0| } 806| 59| t1->fParent = t2; 807| 59| t1 = t2; 808| 59| return true; 809| 59|} uresbund.cpp:_ZL15entryOpenDirectPKcS0_P10UErrorCode: 966| 4|entryOpenDirect(const char* path, const char* localeID, UErrorCode* status) { 967| 4| initCache(status); 968| 4| if(U_FAILURE(*status)) { ------------------ | Branch (968:8): [True: 0, False: 4] ------------------ 969| 0| return nullptr; 970| 0| } 971| | 972| | // Note: We need to query the default locale *before* locking resbMutex. 973| | // If the localeID is nullptr, then we want to use the default locale. 974| 4| if (localeID == nullptr) { ------------------ | Branch (974:9): [True: 0, False: 4] ------------------ 975| 0| localeID = uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 976| 4| } else if (*localeID == 0) { ------------------ | Branch (976:16): [True: 0, False: 4] ------------------ 977| | // If the localeID is "", then we want to use the root locale. 978| 0| localeID = kRootLocaleName; ------------------ | | 18| 0|#define kRootLocaleName "root" ------------------ 979| 0| } 980| | 981| 4| Mutex lock(&resbMutex); 982| | 983| | // findFirstExisting() without fallbacks. 984| 4| UResourceDataEntry *r = init_entry(localeID, path, status); 985| 4| if(U_SUCCESS(*status)) { ------------------ | Branch (985:8): [True: 4, False: 0] ------------------ 986| 4| if(r->fBogus != U_ZERO_ERROR) { ------------------ | Branch (986:12): [True: 0, False: 4] ------------------ 987| 0| r->fCountExisting--; 988| 0| r = nullptr; 989| 0| } 990| 4| } else { 991| 0| r = nullptr; 992| 0| } 993| | 994| | // Some code depends on the ures_openDirect() bundle to have a parent bundle chain, 995| | // unless it is marked with "nofallback". 996| 4| UResourceDataEntry *t1 = r; 997| 4| if(r != nullptr && uprv_strcmp(localeID, kRootLocaleName) != 0 && // not root ------------------ | | 38| 4|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (997:8): [True: 4, False: 0] | Branch (997:24): [True: 4, False: 0] ------------------ 998| 4| r->fParent == nullptr && !r->fData.noFallback && ------------------ | Branch (998:13): [True: 4, False: 0] | Branch (998:38): [True: 0, False: 4] ------------------ 999| 4| uprv_strlen(localeID) < ULOC_FULLNAME_CAPACITY) { ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ uprv_strlen(localeID) < ULOC_FULLNAME_CAPACITY) { ------------------ | | 264| 0|#define ULOC_FULLNAME_CAPACITY 157 ------------------ | Branch (999:13): [True: 0, False: 0] ------------------ 1000| 0| char name[ULOC_FULLNAME_CAPACITY]; 1001| 0| uprv_strcpy(name, localeID); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1002| 0| if(!chopLocale(name) || uprv_strcmp(name, kRootLocaleName) == 0 || ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1002:12): [True: 0, False: 0] | Branch (1002:33): [True: 0, False: 0] ------------------ 1003| 0| loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name), false, nullptr, status)) { ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1003:17): [True: 0, False: 0] ------------------ 1004| 0| if(uprv_strcmp(t1->fName, kRootLocaleName) != 0 && t1->fParent == nullptr) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1004:16): [True: 0, False: 0] | Branch (1004:64): [True: 0, False: 0] ------------------ 1005| 0| insertRootBundle(t1, status); 1006| 0| } 1007| 0| } 1008| 0| if(U_FAILURE(*status)) { ------------------ | Branch (1008:12): [True: 0, False: 0] ------------------ 1009| 0| r = nullptr; 1010| 0| } 1011| 0| } 1012| | 1013| 4| if(r != nullptr) { ------------------ | Branch (1013:8): [True: 4, False: 0] ------------------ 1014| | // TODO: Does this ever loop? 1015| 4| while(t1->fParent != nullptr) { ------------------ | Branch (1015:15): [True: 0, False: 4] ------------------ 1016| 0| t1->fParent->fCountExisting++; 1017| 0| t1 = t1->fParent; 1018| 0| } 1019| 4| } 1020| 4| return r; 1021| 4|} res_load_78: 260| 708| const char *path, const char *name, UErrorCode *errorCode) { 261| 708| UVersionInfo formatVersion; 262| | 263| 708| uprv_memset(pResData, 0, sizeof(ResourceData)); ------------------ | | 100| 708|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 708|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 264| | 265| | /* load the ResourceBundle file */ 266| 708| pResData->data=udata_openChoice(path, "res", name, isAcceptable, formatVersion, errorCode); ------------------ | | 894| 708|#define udata_openChoice U_ICU_ENTRY_POINT_RENAME(udata_openChoice) | | ------------------ | | | | 123| 708|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 708|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 708|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 267| 708| if(U_FAILURE(*errorCode)) { ------------------ | Branch (267:8): [True: 634, False: 74] ------------------ 268| 634| return; 269| 634| } 270| | 271| | /* get its memory and initialize *pResData */ 272| 74| res_init(pResData, formatVersion, udata_getMemory(pResData->data), -1, errorCode); ------------------ | | 891| 74|#define udata_getMemory U_ICU_ENTRY_POINT_RENAME(udata_getMemory) | | ------------------ | | | | 123| 74|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 74|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 74|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 273| 74|} res_getStringNoTrace_78: 311| 84.6k|res_getStringNoTrace(const ResourceData *pResData, Resource res, int32_t *pLength) { 312| 84.6k| const char16_t *p; 313| 84.6k| uint32_t offset=RES_GET_OFFSET(res); ------------------ | | 69| 84.6k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 314| 84.6k| int32_t length; 315| 84.6k| if(RES_GET_TYPE(res)==URES_STRING_V2) { ------------------ | | 68| 84.6k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (315:8): [True: 84.4k, False: 187] ------------------ 316| 84.4k| int32_t first; 317| 84.4k| if((int32_t)offsetpoolStringIndexLimit) { ------------------ | Branch (317:12): [True: 0, False: 84.4k] ------------------ 318| 0| p=(const char16_t *)pResData->poolBundleStrings+offset; 319| 84.4k| } else { 320| 84.4k| p=(const char16_t *)pResData->p16BitUnits+(offset-pResData->poolStringIndexLimit); 321| 84.4k| } 322| 84.4k| first=*p; 323| 84.4k| if(!U16_IS_TRAIL(first)) { ------------------ | | 67| 84.4k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) ------------------ | Branch (323:12): [True: 80.1k, False: 4.31k] ------------------ 324| 80.1k| length=u_strlen(p); ------------------ | | 393| 80.1k|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 80.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 80.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 80.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 325| 80.1k| } else if(first<0xdfef) { ------------------ | Branch (325:19): [True: 3.54k, False: 769] ------------------ 326| 3.54k| length=first&0x3ff; 327| 3.54k| ++p; 328| 3.54k| } else if(first<0xdfff) { ------------------ | Branch (328:19): [True: 769, False: 0] ------------------ 329| 769| length=((first-0xdfef)<<16)|p[1]; 330| 769| p+=2; 331| 769| } else { 332| 0| length=((int32_t)p[1]<<16)|p[2]; 333| 0| p+=3; 334| 0| } 335| 84.4k| } else if(res==offset) /* RES_GET_TYPE(res)==URES_STRING */ { ------------------ | Branch (335:15): [True: 187, False: 0] ------------------ 336| 187| const int32_t *p32= res==0 ? &gEmptyString.length : pResData->pRoot+res; ------------------ | Branch (336:29): [True: 187, False: 0] ------------------ 337| 187| length=*p32++; 338| 187| p=(const char16_t *)p32; 339| 187| } else { 340| 0| p=nullptr; 341| 0| length=0; 342| 0| } 343| 84.6k| if(pLength) { ------------------ | Branch (343:8): [True: 84.6k, False: 0] ------------------ 344| 84.6k| *pLength=length; 345| 84.6k| } 346| 84.6k| return p; 347| 84.6k|} res_getAlias_78: 420| 3|res_getAlias(const ResourceData *pResData, Resource res, int32_t *pLength) { 421| 3| const char16_t *p; 422| 3| uint32_t offset=RES_GET_OFFSET(res); ------------------ | | 69| 3|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 423| 3| int32_t length; 424| 3| if(RES_GET_TYPE(res)==URES_ALIAS) { ------------------ | | 68| 3|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (424:8): [True: 3, False: 0] ------------------ 425| 3| const int32_t *p32= offset==0 ? &gEmptyString.length : pResData->pRoot+offset; ------------------ | Branch (425:29): [True: 0, False: 3] ------------------ 426| 3| length=*p32++; 427| 3| p=(const char16_t *)p32; 428| 3| } else { 429| 0| p=nullptr; 430| 0| length=0; 431| 0| } 432| 3| if(pLength) { ------------------ | Branch (432:8): [True: 3, False: 0] ------------------ 433| 3| *pLength=length; 434| 3| } 435| 3| return p; 436| 3|} res_countArrayItems_78: 477| 94.3k|res_countArrayItems(const ResourceData *pResData, Resource res) { 478| 94.3k| uint32_t offset=RES_GET_OFFSET(res); ------------------ | | 69| 94.3k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 479| 94.3k| switch(RES_GET_TYPE(res)) { ------------------ | | 68| 94.3k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 480| 0| case URES_STRING: ------------------ | Branch (480:5): [True: 0, False: 94.3k] ------------------ 481| 79.7k| case URES_STRING_V2: ------------------ | Branch (481:5): [True: 79.7k, False: 14.5k] ------------------ 482| 79.7k| case URES_BINARY: ------------------ | Branch (482:5): [True: 0, False: 94.3k] ------------------ 483| 79.7k| case URES_ALIAS: ------------------ | Branch (483:5): [True: 0, False: 94.3k] ------------------ 484| 79.7k| case URES_INT: ------------------ | Branch (484:5): [True: 0, False: 94.3k] ------------------ 485| 79.7k| case URES_INT_VECTOR: ------------------ | Branch (485:5): [True: 0, False: 94.3k] ------------------ 486| 79.7k| return 1; 487| 0| case URES_ARRAY: ------------------ | Branch (487:5): [True: 0, False: 94.3k] ------------------ 488| 0| case URES_TABLE32: ------------------ | Branch (488:5): [True: 0, False: 94.3k] ------------------ 489| 0| return offset==0 ? 0 : *(pResData->pRoot+offset); ------------------ | Branch (489:16): [True: 0, False: 0] ------------------ 490| 14.4k| case URES_TABLE: ------------------ | Branch (490:5): [True: 14.4k, False: 79.9k] ------------------ 491| 14.4k| return offset==0 ? 0 : *((const uint16_t *)(pResData->pRoot+offset)); ------------------ | Branch (491:16): [True: 14, False: 14.4k] ------------------ 492| 0| case URES_ARRAY16: ------------------ | Branch (492:5): [True: 0, False: 94.3k] ------------------ 493| 144| case URES_TABLE16: ------------------ | Branch (493:5): [True: 144, False: 94.2k] ------------------ 494| 144| return pResData->p16BitUnits[offset]; 495| 0| default: ------------------ | Branch (495:5): [True: 0, False: 94.3k] ------------------ 496| 0| return 0; 497| 94.3k| } 498| 94.3k|} res_getTableItemByKey_78: 713| 15.2k| int32_t *indexR, const char **key) { 714| 15.2k| uint32_t offset=RES_GET_OFFSET(table); ------------------ | | 69| 15.2k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 715| 15.2k| int32_t length; 716| 15.2k| int32_t idx; 717| 15.2k| if(key == nullptr || *key == nullptr) { ------------------ | Branch (717:8): [True: 0, False: 15.2k] | Branch (717:26): [True: 0, False: 15.2k] ------------------ 718| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 719| 0| } 720| 15.2k| switch(RES_GET_TYPE(table)) { ------------------ | | 68| 15.2k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 721| 15.1k| case URES_TABLE: { ------------------ | Branch (721:5): [True: 15.1k, False: 163] ------------------ 722| 15.1k| if (offset!=0) { /* empty if offset==0 */ ------------------ | Branch (722:13): [True: 15.0k, False: 111] ------------------ 723| 15.0k| const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset); 724| 15.0k| length=*p++; 725| 15.0k| *indexR=idx=_res_findTableItem(pResData, p, length, *key, key); 726| 15.0k| if(idx>=0) { ------------------ | Branch (726:16): [True: 14.7k, False: 306] ------------------ 727| 14.7k| const Resource *p32=(const Resource *)(p+length+(~length&1)); 728| 14.7k| return p32[idx]; 729| 14.7k| } 730| 15.0k| } 731| 417| break; 732| 15.1k| } 733| 417| case URES_TABLE16: { ------------------ | Branch (733:5): [True: 163, False: 15.1k] ------------------ 734| 163| const uint16_t *p=pResData->p16BitUnits+offset; 735| 163| length=*p++; 736| 163| *indexR=idx=_res_findTableItem(pResData, p, length, *key, key); 737| 163| if(idx>=0) { ------------------ | Branch (737:12): [True: 10, False: 153] ------------------ 738| 10| return makeResourceFrom16(pResData, p[length+idx]); 739| 10| } 740| 153| break; 741| 163| } 742| 153| case URES_TABLE32: { ------------------ | Branch (742:5): [True: 0, False: 15.2k] ------------------ 743| 0| if (offset!=0) { /* empty if offset==0 */ ------------------ | Branch (743:13): [True: 0, False: 0] ------------------ 744| 0| const int32_t *p= pResData->pRoot+offset; 745| 0| length=*p++; 746| 0| *indexR=idx=_res_findTable32Item(pResData, p, length, *key, key); 747| 0| if(idx>=0) { ------------------ | Branch (747:16): [True: 0, False: 0] ------------------ 748| 0| return (Resource)p[length+idx]; 749| 0| } 750| 0| } 751| 0| break; 752| 0| } 753| 0| default: ------------------ | Branch (753:5): [True: 0, False: 15.2k] ------------------ 754| 0| break; 755| 15.2k| } 756| 570| return RES_BOGUS; ------------------ | | 65| 570|#define RES_BOGUS 0xffffffff ------------------ 757| 15.2k|} res_getTableItemByIndex_78: 761| 79.7k| int32_t indexR, const char **key) { 762| 79.7k| uint32_t offset=RES_GET_OFFSET(table); ------------------ | | 69| 79.7k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 763| 79.7k| int32_t length; 764| 79.7k| if (indexR < 0) { ------------------ | Branch (764:9): [True: 0, False: 79.7k] ------------------ 765| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 766| 0| } 767| 79.7k| switch(RES_GET_TYPE(table)) { ------------------ | | 68| 79.7k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 768| 0| case URES_TABLE: { ------------------ | Branch (768:5): [True: 0, False: 79.7k] ------------------ 769| 0| if (offset != 0) { /* empty if offset==0 */ ------------------ | Branch (769:13): [True: 0, False: 0] ------------------ 770| 0| const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset); 771| 0| length=*p++; 772| 0| if(indexRlocalKeyLimit ? \ | | ------------------ | | | Branch (44:6): [True: 0, False: 0] | | ------------------ | | 45| 0| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 46| 0| (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit) ------------------ 776| 0| } 777| 0| return p32[indexR]; 778| 0| } 779| 0| } 780| 0| break; 781| 0| } 782| 79.7k| case URES_TABLE16: { ------------------ | Branch (782:5): [True: 79.7k, False: 0] ------------------ 783| 79.7k| const uint16_t *p=pResData->p16BitUnits+offset; 784| 79.7k| length=*p++; 785| 79.7k| if(indexRlocalKeyLimit ? \ | | ------------------ | | | Branch (44:6): [True: 79.7k, False: 0] | | ------------------ | | 45| 79.7k| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 46| 79.7k| (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit) ------------------ 788| 79.7k| } 789| 79.7k| return makeResourceFrom16(pResData, p[length+indexR]); 790| 79.7k| } 791| 0| break; 792| 79.7k| } 793| 0| case URES_TABLE32: { ------------------ | Branch (793:5): [True: 0, False: 79.7k] ------------------ 794| 0| if (offset != 0) { /* empty if offset==0 */ ------------------ | Branch (794:13): [True: 0, False: 0] ------------------ 795| 0| const int32_t *p= pResData->pRoot+offset; 796| 0| length=*p++; 797| 0| if(indexR=0 ? \ | | ------------------ | | | Branch (49:6): [True: 0, False: 0] | | ------------------ | | 50| 0| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 51| 0| (pResData)->poolBundleKeys+((keyOffset)&0x7fffffff)) ------------------ 800| 0| } 801| 0| return (Resource)p[length+indexR]; 802| 0| } 803| 0| } 804| 0| break; 805| 0| } 806| 0| default: ------------------ | Branch (806:5): [True: 0, False: 79.7k] ------------------ 807| 0| break; 808| 79.7k| } 809| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 810| 79.7k|} res_getResource_78: 813| 88|res_getResource(const ResourceData *pResData, const char *key) { 814| 88| const char *realKey=key; 815| 88| int32_t idx; 816| 88| return res_getTableItemByKey(pResData, pResData->rootRes, &idx, &realKey); ------------------ | | 207| 88|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 88|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 88|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 88|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 817| 88|} res_findResource_78: 921| 256|res_findResource(const ResourceData *pResData, Resource r, char** path, const char** key) { 922| 256| char *pathP = *path, *nextSepP = *path; 923| 256| char *closeIndex = nullptr; 924| 256| Resource t1 = r; 925| 256| Resource t2; 926| 256| int32_t indexR = 0; 927| 256| UResType type = (UResType)RES_GET_TYPE(t1); ------------------ | | 68| 256|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 928| | 929| | /* if you come in with an empty path, you'll be getting back the same resource */ 930| 256| if(!uprv_strlen(pathP)) { ------------------ | | 37| 256|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 256|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (930:6): [True: 0, False: 256] ------------------ 931| 0| return r; 932| 0| } 933| | 934| | /* one needs to have an aggregate resource in order to search in it */ 935| 256| if(!URES_IS_CONTAINER(type)) { ------------------ | | 85| 256|#define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 84| 512|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | | | ------------------ | | | | | Branch (84:30): [True: 256, False: 0] | | | | | Branch (84:61): [True: 0, False: 0] | | | | | Branch (84:94): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | | | ------------------ | | | | | Branch (83:30): [True: 0, False: 0] | | | | | Branch (83:61): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 936| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 937| 0| } 938| | 939| 696| while(nextSepP && *pathP && t1 != RES_BOGUS && URES_IS_CONTAINER(type)) { ------------------ | | 65| 1.20k|#define RES_BOGUS 0xffffffff ------------------ while(nextSepP && *pathP && t1 != RES_BOGUS && URES_IS_CONTAINER(type)) { ------------------ | | 85| 440|#define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 84| 880|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | | | ------------------ | | | | | Branch (84:30): [True: 440, False: 0] | | | | | Branch (84:61): [True: 0, False: 0] | | | | | Branch (84:94): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | | | ------------------ | | | | | Branch (83:30): [True: 0, False: 0] | | | | | Branch (83:61): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (939:9): [True: 512, False: 184] | Branch (939:21): [True: 512, False: 0] | Branch (939:31): [True: 440, False: 72] ------------------ 940| | /* Iteration stops if: the path has been consumed, we found a non-existing 941| | * resource (t1 == RES_BOGUS) or we found a scalar resource (including alias) 942| | */ 943| 440| nextSepP = uprv_strchr(pathP, RES_PATH_SEPARATOR); ------------------ | | 40| 440|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 440|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 944| | /* if there are more separators, terminate string 945| | * and set path to the remaining part of the string 946| | */ 947| 440| if(nextSepP != nullptr) { ------------------ | Branch (947:8): [True: 256, False: 184] ------------------ 948| 256| if(nextSepP == pathP) { ------------------ | Branch (948:10): [True: 0, False: 256] ------------------ 949| | // Empty key string. 950| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 951| 0| } 952| 256| *nextSepP = 0; /* overwrite the separator with a NUL to terminate the key */ 953| 256| *path = nextSepP+1; 954| 256| } else { 955| 184| *path = uprv_strchr(pathP, 0); ------------------ | | 40| 184|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 184|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 956| 184| } 957| | 958| | /* if the resource is a table */ 959| | /* try the key based access */ 960| 440| if(URES_IS_TABLE(type)) { ------------------ | | 84| 440|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 440, False: 0] | | | Branch (84:61): [True: 0, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 961| 440| *key = pathP; 962| 440| t2 = res_getTableItemByKey(pResData, t1, &indexR, key); ------------------ | | 207| 440|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 440|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 440|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 440|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 963| 440| } else if(URES_IS_ARRAY(type)) { ------------------ | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | ------------------ | | | Branch (83:30): [True: 0, False: 0] | | | Branch (83:61): [True: 0, False: 0] | | ------------------ ------------------ 964| 0| indexR = uprv_strtol(pathP, &closeIndex, 10); ------------------ | | 77| 0|#define uprv_strtol(str, end, base) U_STANDARD_CPP_NAMESPACE strtol(str, end, base) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 965| 0| if(indexR >= 0 && *closeIndex == 0) { ------------------ | Branch (965:10): [True: 0, False: 0] | Branch (965:25): [True: 0, False: 0] ------------------ 966| 0| t2 = res_getArrayItem(pResData, t1, indexR); ------------------ | | 200| 0|#define res_getArrayItem U_ICU_ENTRY_POINT_RENAME(res_getArrayItem) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 967| 0| } else { 968| 0| t2 = RES_BOGUS; /* have an array, but don't have a valid index */ ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 969| 0| } 970| 0| *key = nullptr; 971| 0| } else { /* can't do much here, except setting t2 to bogus */ 972| 0| t2 = RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 973| 0| } 974| 440| t1 = t2; 975| 440| type = (UResType)RES_GET_TYPE(t1); ------------------ | | 68| 440|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 976| | /* position pathP to next resource key/index */ 977| 440| pathP = *path; 978| 440| } 979| | 980| 256| return t1; 981| 256|} uresdata.cpp:_ZL12isAcceptablePvPKcS1_PK9UDataInfo: 141| 74| const UDataInfo *pInfo) { 142| 74| uprv_memcpy(context, pInfo->formatVersion, 4); ------------------ | | 42| 74|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 74|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 74| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 74| _Pragma("clang diagnostic push") \ | | 45| 74| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 74| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 74|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 74| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 74|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 74| _Pragma("clang diagnostic pop") \ | | 49| 74| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 74|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 74|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 74|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 143| 74| return 144| 74| pInfo->size>=20 && ------------------ | Branch (144:9): [True: 74, False: 0] ------------------ 145| 74| pInfo->isBigEndian==U_IS_BIG_ENDIAN && ------------------ | | 353| 148|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (145:9): [True: 74, False: 0] ------------------ 146| 74| pInfo->charsetFamily==U_CHARSET_FAMILY && ------------------ | | 588| 74|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 148|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (146:9): [True: 74, False: 0] ------------------ 147| 74| pInfo->sizeofUChar==U_SIZEOF_UCHAR && ------------------ | | 352| 148|#define U_SIZEOF_UCHAR 2 ------------------ | Branch (147:9): [True: 74, False: 0] ------------------ 148| 74| pInfo->dataFormat[0]==0x52 && /* dataFormat="ResB" */ ------------------ | Branch (148:9): [True: 74, False: 0] ------------------ 149| 74| pInfo->dataFormat[1]==0x65 && ------------------ | Branch (149:9): [True: 74, False: 0] ------------------ 150| 74| pInfo->dataFormat[2]==0x73 && ------------------ | Branch (150:9): [True: 74, False: 0] ------------------ 151| 74| pInfo->dataFormat[3]==0x42 && ------------------ | Branch (151:9): [True: 74, False: 0] ------------------ 152| 74| (1<=pInfo->formatVersion[0] && pInfo->formatVersion[0]<=3); ------------------ | Branch (152:10): [True: 74, False: 0] | Branch (152:40): [True: 74, False: 0] ------------------ 153| 74|} uresdata.cpp:_ZL8res_initP12ResourceDataPhPKviP10UErrorCode: 160| 74| UErrorCode *errorCode) { 161| 74| UResType rootType; 162| | 163| | /* get the root resource */ 164| 74| pResData->pRoot = static_cast(inBytes); 165| 74| pResData->rootRes = static_cast(*pResData->pRoot); 166| 74| pResData->p16BitUnits=&gEmpty16; 167| | 168| | /* formatVersion 1.1 must have a root item and at least 5 indexes */ 169| 74| if(length>=0 && (length/4)<((formatVersion[0]==1 && formatVersion[1]==0) ? 1 : 1+5)) { ------------------ | Branch (169:8): [True: 0, False: 74] | Branch (169:21): [True: 0, False: 0] | Branch (169:34): [True: 0, False: 0] | Branch (169:57): [True: 0, False: 0] ------------------ 170| 0| *errorCode=U_INVALID_FORMAT_ERROR; 171| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 172| 0| return; 173| 0| } 174| | 175| | /* currently, we accept only resources that have a Table as their roots */ 176| 74| rootType = static_cast(RES_GET_TYPE(pResData->rootRes)); ------------------ | | 68| 74|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 177| 74| if(!URES_IS_TABLE(rootType)) { ------------------ | | 84| 74|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 67, False: 7] | | | Branch (84:61): [True: 7, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 178| 0| *errorCode=U_INVALID_FORMAT_ERROR; 179| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 180| 0| return; 181| 0| } 182| | 183| 74| if(formatVersion[0]==1 && formatVersion[1]==0) { ------------------ | Branch (183:8): [True: 0, False: 74] | Branch (183:31): [True: 0, False: 0] ------------------ 184| 0| pResData->localKeyLimit=0x10000; /* greater than any 16-bit key string offset */ 185| 74| } else { 186| | /* bundles with formatVersion 1.1 and later contain an indexes[] array */ 187| 74| const int32_t *indexes=pResData->pRoot+1; 188| 74| int32_t indexLength=indexes[URES_INDEX_LENGTH]&0xff; 189| 74| if(indexLength<=URES_INDEX_MAX_TABLE_LENGTH) { ------------------ | Branch (189:12): [True: 0, False: 74] ------------------ 190| 0| *errorCode=U_INVALID_FORMAT_ERROR; 191| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 192| 0| return; 193| 0| } 194| 74| if( length>=0 && ------------------ | Branch (194:13): [True: 0, False: 74] ------------------ 195| 74| (length<((1+indexLength)<<2) || ------------------ | Branch (195:14): [True: 0, False: 0] ------------------ 196| 0| length<(indexes[URES_INDEX_BUNDLE_TOP]<<2)) ------------------ | Branch (196:14): [True: 0, False: 0] ------------------ 197| 74| ) { 198| 0| *errorCode=U_INVALID_FORMAT_ERROR; 199| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 0| return; 201| 0| } 202| 74| if(indexes[URES_INDEX_KEYS_TOP]>(1+indexLength)) { ------------------ | Branch (202:12): [True: 67, False: 7] ------------------ 203| 67| pResData->localKeyLimit=indexes[URES_INDEX_KEYS_TOP]<<2; 204| 67| } 205| 74| if(formatVersion[0]>=3) { ------------------ | Branch (205:12): [True: 0, False: 74] ------------------ 206| | // In formatVersion 1, the indexLength took up this whole int. 207| | // In version 2, bits 31..8 were reserved and always 0. 208| | // In version 3, they contain bits 23..0 of the poolStringIndexLimit. 209| | // Bits 27..24 are in indexes[URES_INDEX_ATTRIBUTES] bits 15..12. 210| 0| pResData->poolStringIndexLimit = static_cast(static_cast(indexes[URES_INDEX_LENGTH]) >> 8); 211| 0| } 212| 74| if(indexLength>URES_INDEX_ATTRIBUTES) { ------------------ | Branch (212:12): [True: 74, False: 0] ------------------ 213| 74| int32_t att=indexes[URES_INDEX_ATTRIBUTES]; 214| 74| pResData->noFallback = static_cast(att & URES_ATT_NO_FALLBACK); ------------------ | | 148| 74|#define URES_ATT_NO_FALLBACK 1 ------------------ 215| 74| pResData->isPoolBundle = static_cast((att & URES_ATT_IS_POOL_BUNDLE) != 0); ------------------ | | 156| 74|#define URES_ATT_IS_POOL_BUNDLE 2 ------------------ 216| 74| pResData->usesPoolBundle = static_cast((att & URES_ATT_USES_POOL_BUNDLE) != 0); ------------------ | | 157| 74|#define URES_ATT_USES_POOL_BUNDLE 4 ------------------ 217| 74| pResData->poolStringIndexLimit|=(att&0xf000)<<12; // bits 15..12 -> 27..24 218| 74| pResData->poolStringIndex16Limit = static_cast(static_cast(att) >> 16); 219| 74| } 220| 74| if((pResData->isPoolBundle || pResData->usesPoolBundle) && indexLength<=URES_INDEX_POOL_CHECKSUM) { ------------------ | Branch (220:13): [True: 0, False: 74] | Branch (220:39): [True: 0, False: 74] | Branch (220:68): [True: 0, False: 0] ------------------ 221| 0| *errorCode=U_INVALID_FORMAT_ERROR; 222| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 223| 0| return; 224| 0| } 225| 74| if( indexLength>URES_INDEX_16BIT_TOP && ------------------ | Branch (225:13): [True: 74, False: 0] ------------------ 226| 74| indexes[URES_INDEX_16BIT_TOP]>indexes[URES_INDEX_KEYS_TOP] ------------------ | Branch (226:13): [True: 74, False: 0] ------------------ 227| 74| ) { 228| 74| pResData->p16BitUnits = reinterpret_cast(pResData->pRoot + indexes[URES_INDEX_KEYS_TOP]); 229| 74| } 230| 74| } 231| | 232| 74| if(formatVersion[0]==1 || U_CHARSET_FAMILY==U_ASCII_FAMILY) { ------------------ | | 588| 74|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 74|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ if(formatVersion[0]==1 || U_CHARSET_FAMILY==U_ASCII_FAMILY) { ------------------ | | 531| 74|#define U_ASCII_FAMILY 0 ------------------ | Branch (232:8): [True: 0, False: 74] | Branch (232:31): [Folded - Ignored] ------------------ 233| | /* 234| | * formatVersion 1: compare key strings in native-charset order 235| | * formatVersion 2 and up: compare key strings in ASCII order 236| | */ 237| 74| pResData->useNativeStrcmp=true; 238| 74| } 239| 74|} uresdata.cpp:_ZL18_res_findTableItemPK12ResourceDataPKtiPKcPS5_: 76| 15.1k| const char *key, const char **realKey) { 77| 15.1k| const char *tableKey; 78| 15.1k| int32_t mid, start, limit; 79| 15.1k| int result; 80| | 81| | /* do a binary search for the key */ 82| 15.1k| start=0; 83| 15.1k| limit=length; 84| 16.7k| while(startlocalKeyLimit ? \ | | ------------------ | | | Branch (44:6): [True: 16.2k, False: 0] | | ------------------ | | 45| 16.2k| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 46| 16.2k| (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit) ------------------ 87| 16.2k| if (pResData->useNativeStrcmp) { ------------------ | Branch (87:13): [True: 16.2k, False: 0] ------------------ 88| 16.2k| result = uprv_strcmp(key, tableKey); ------------------ | | 38| 16.2k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 16.2k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 89| 16.2k| } else { 90| 0| result = uprv_compareInvCharsAsAscii(key, tableKey); ------------------ | | 153| 0|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 91| 0| } 92| 16.2k| if (result < 0) { ------------------ | Branch (92:13): [True: 562, False: 15.7k] ------------------ 93| 562| limit = mid; 94| 15.7k| } else if (result > 0) { ------------------ | Branch (94:20): [True: 1.01k, False: 14.7k] ------------------ 95| 1.01k| start = mid + 1; 96| 14.7k| } else { 97| | /* We found it! */ 98| 14.7k| *realKey=tableKey; 99| 14.7k| return mid; 100| 14.7k| } 101| 16.2k| } 102| 459| return URESDATA_ITEM_NOT_FOUND; /* not found or table is empty. */ ------------------ | | 53| 459|#define URESDATA_ITEM_NOT_FOUND -1 ------------------ 103| 15.1k|} uresdata.cpp:_ZL18makeResourceFrom16PK12ResourceDatai: 700| 79.7k|makeResourceFrom16(const ResourceData *pResData, int32_t res16) { 701| 79.7k| if(res16poolStringIndex16Limit) { ------------------ | Branch (701:8): [True: 0, False: 79.7k] ------------------ 702| | // Pool string, nothing to do. 703| 79.7k| } else { 704| | // Local string, adjust the 16-bit offset to a regular one, 705| | // with a larger pool string index limit. 706| 79.7k| res16=res16-pResData->poolStringIndex16Limit+pResData->poolStringIndexLimit; 707| 79.7k| } 708| 79.7k| return URES_MAKE_RESOURCE(URES_STRING_V2, res16); ------------------ | | 87| 79.7k|#define URES_MAKE_RESOURCE(type, offset) (((Resource)(type)<<28)|(Resource)(offset)) ------------------ 709| 79.7k|} _ZN6icu_7813res_getStringERKNS_14ResourceTracerEPK12ResourceDatajPi: 486| 84.6k| const ResourceData *pResData, Resource res, int32_t *pLength) { 487| 84.6k| traceInfo.trace("string"); 488| 84.6k| return res_getStringNoTrace(pResData, res, pLength); ------------------ | | 205| 84.6k|#define res_getStringNoTrace U_ICU_ENTRY_POINT_RENAME(res_getStringNoTrace) | | ------------------ | | | | 123| 84.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 84.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 84.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 489| 84.6k|} _ZNK15UResourceBundle10getResDataEv: 94| 283k| inline const ResourceData &getResData() const { return fData->fData; } uset_getSerializedSet_78: 404| 1|uset_getSerializedSet(USerializedSet* fillSet, const uint16_t* src, int32_t srcLength) { 405| 1| int32_t length; 406| | 407| 1| if(fillSet==nullptr) { ------------------ | Branch (407:8): [True: 0, False: 1] ------------------ 408| 0| return false; 409| 0| } 410| 1| if(src==nullptr || srcLength<=0) { ------------------ | Branch (410:8): [True: 0, False: 1] | Branch (410:24): [True: 0, False: 1] ------------------ 411| 0| fillSet->length=fillSet->bmpLength=0; 412| 0| return false; 413| 0| } 414| | 415| 1| length=*src++; 416| 1| if(length&0x8000) { ------------------ | Branch (416:8): [True: 1, False: 0] ------------------ 417| | /* there are supplementary values */ 418| 1| length&=0x7fff; 419| 1| if(srcLength<(2+length)) { ------------------ | Branch (419:12): [True: 0, False: 1] ------------------ 420| 0| fillSet->length=fillSet->bmpLength=0; 421| 0| return false; 422| 0| } 423| 1| fillSet->bmpLength=*src++; 424| 1| } else { 425| | /* only BMP values */ 426| 0| if(srcLength<(1+length)) { ------------------ | Branch (426:12): [True: 0, False: 0] ------------------ 427| 0| fillSet->length=fillSet->bmpLength=0; 428| 0| return false; 429| 0| } 430| 0| fillSet->bmpLength=length; 431| 0| } 432| 1| fillSet->array=src; 433| 1| fillSet->length=length; 434| 1| return true; 435| 1|} uset_getSerializedRangeCount_78: 529| 1|uset_getSerializedRangeCount(const USerializedSet* set) { 530| 1| if(set==nullptr) { ------------------ | Branch (530:8): [True: 0, False: 1] ------------------ 531| 0| return 0; 532| 0| } 533| | 534| 1| return (set->bmpLength+(set->length-set->bmpLength)/2+1)/2; 535| 1|} uset_getSerializedRange_78: 539| 226| UChar32* pStart, UChar32* pEnd) { 540| 226| const uint16_t* array; 541| 226| int32_t bmpLength, length; 542| | 543| 226| if(set==nullptr || rangeIndex<0 || pStart==nullptr || pEnd==nullptr) { ------------------ | Branch (543:8): [True: 0, False: 226] | Branch (543:24): [True: 0, False: 226] | Branch (543:40): [True: 0, False: 226] | Branch (543:59): [True: 0, False: 226] ------------------ 544| 0| return false; 545| 0| } 546| | 547| 226| array=set->array; 548| 226| length=set->length; 549| 226| bmpLength=set->bmpLength; 550| | 551| 226| rangeIndex*=2; /* address start/limit pairs */ 552| 226| if(rangeIndex= stringCount) return false; ------------------ | Branch (62:9): [True: 2.59M, False: 5] ------------------ 63| 5| codepoint = static_cast(IS_STRING); // signal that value is actually a string 64| 5| string = static_cast(set->strings_->elementAt(nextString++)); 65| 5| return true; 66| 2.59M|} _ZN6icu_7818UnicodeSetIterator5resetERKNS_10UnicodeSetE: 104| 2.60M|void UnicodeSetIterator::reset(const UnicodeSet& uSet) { 105| 2.60M| this->set = &uSet; 106| 2.60M| reset(); 107| 2.60M|} _ZN6icu_7818UnicodeSetIterator5resetEv: 112| 2.60M|void UnicodeSetIterator::reset() { 113| 2.60M| if (set == nullptr) { ------------------ | Branch (113:9): [True: 0, False: 2.60M] ------------------ 114| | // Set up indices to empty iteration 115| 0| endRange = -1; 116| 0| stringCount = 0; 117| 2.60M| } else { 118| 2.60M| endRange = set->getRangeCount() - 1; 119| 2.60M| stringCount = set->stringsSize(); 120| 2.60M| } 121| 2.60M| range = 0; 122| 2.60M| endElement = -1; 123| 2.60M| nextElement = 0; 124| 2.60M| if (endRange >= 0) { ------------------ | Branch (124:9): [True: 2.60M, False: 833] ------------------ 125| 2.60M| loadRange(range); 126| 2.60M| } 127| 2.60M| nextString = 0; 128| 2.60M| string = nullptr; 129| 2.60M|} _ZN6icu_7818UnicodeSetIterator9loadRangeEi: 131| 20.1M|void UnicodeSetIterator::loadRange(int32_t iRange) { 132| 20.1M| nextElement = set->getRangeStart(iRange); 133| 20.1M| endElement = set->getRangeEnd(iRange); 134| 20.1M|} _ZN6icu_7818UnicodeSetIterator9getStringEv: 137| 8.16M|const UnicodeString& UnicodeSetIterator::getString() { 138| 8.16M| if (string == nullptr && codepoint != static_cast(IS_STRING)) { ------------------ | Branch (138:9): [True: 8.16M, False: 0] | Branch (138:30): [True: 8.16M, False: 0] ------------------ 139| 8.16M| if (cpString == nullptr) { ------------------ | Branch (139:12): [True: 3.92k, False: 8.16M] ------------------ 140| 3.92k| cpString = new UnicodeString(); 141| 3.92k| } 142| 8.16M| if (cpString != nullptr) { ------------------ | Branch (142:12): [True: 8.16M, False: 0] ------------------ 143| 8.16M| cpString->setTo(codepoint); 144| 8.16M| } 145| 8.16M| string = cpString; 146| 8.16M| } 147| 8.16M| return *string; 148| 8.16M|} u_strFindFirst_78: 57| 1.29M| const char16_t *sub, int32_t subLength) { 58| 1.29M| const char16_t *start, *p, *q, *subLimit; 59| 1.29M| char16_t c, cs, cq; 60| | 61| 1.29M| if(sub==nullptr || subLength<-1) { ------------------ | Branch (61:8): [True: 0, False: 1.29M] | Branch (61:24): [True: 0, False: 1.29M] ------------------ 62| 0| return (char16_t *)s; 63| 0| } 64| 1.29M| if(s==nullptr || length<-1) { ------------------ | Branch (64:8): [True: 0, False: 1.29M] | Branch (64:22): [True: 0, False: 1.29M] ------------------ 65| 0| return nullptr; 66| 0| } 67| | 68| 1.29M| start=s; 69| | 70| 1.29M| if(length<0 && subLength<0) { ------------------ | Branch (70:8): [True: 0, False: 1.29M] | Branch (70:20): [True: 0, False: 0] ------------------ 71| | /* both strings are NUL-terminated */ 72| 0| if((cs=*sub++)==0) { ------------------ | Branch (72:12): [True: 0, False: 0] ------------------ 73| 0| return (char16_t *)s; 74| 0| } 75| 0| if(*sub==0 && !U16_IS_SURROGATE(cs)) { ------------------ | | 75| 0|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 0|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ ------------------ | Branch (75:12): [True: 0, False: 0] | Branch (75:23): [True: 0, False: 0] ------------------ 76| | /* the substring consists of a single, non-surrogate BMP code point */ 77| 0| return u_strchr(s, cs); ------------------ | | 385| 0|#define u_strchr U_ICU_ENTRY_POINT_RENAME(u_strchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 78| 0| } 79| | 80| 0| while((c=*s++)!=0) { ------------------ | Branch (80:15): [True: 0, False: 0] ------------------ 81| 0| if(c==cs) { ------------------ | Branch (81:16): [True: 0, False: 0] ------------------ 82| | /* found first substring char16_t, compare rest */ 83| 0| p=s; 84| 0| q=sub; 85| 0| for(;;) { 86| 0| if((cq=*q)==0) { ------------------ | Branch (86:24): [True: 0, False: 0] ------------------ 87| 0| if(isMatchAtCPBoundary(start, s-1, p, nullptr)) { ------------------ | Branch (87:28): [True: 0, False: 0] ------------------ 88| 0| return (char16_t *)(s-1); /* well-formed match */ 89| 0| } else { 90| 0| break; /* no match because surrogate pair is split */ 91| 0| } 92| 0| } 93| 0| if((c=*p)==0) { ------------------ | Branch (93:24): [True: 0, False: 0] ------------------ 94| 0| return nullptr; /* no match, and none possible after s */ 95| 0| } 96| 0| if(c!=cq) { ------------------ | Branch (96:24): [True: 0, False: 0] ------------------ 97| 0| break; /* no match */ 98| 0| } 99| 0| ++p; 100| 0| ++q; 101| 0| } 102| 0| } 103| 0| } 104| | 105| | /* not found */ 106| 0| return nullptr; 107| 0| } 108| | 109| 1.29M| if(subLength<0) { ------------------ | Branch (109:8): [True: 0, False: 1.29M] ------------------ 110| 0| subLength=u_strlen(sub); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 111| 0| } 112| 1.29M| if(subLength==0) { ------------------ | Branch (112:8): [True: 0, False: 1.29M] ------------------ 113| 0| return (char16_t *)s; 114| 0| } 115| | 116| | /* get sub[0] to search for it fast */ 117| 1.29M| cs=*sub++; 118| 1.29M| --subLength; 119| 1.29M| subLimit=sub+subLength; 120| | 121| 1.29M| if(subLength==0 && !U16_IS_SURROGATE(cs)) { ------------------ | | 75| 0|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 0|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ ------------------ | Branch (121:8): [True: 0, False: 1.29M] | Branch (121:24): [True: 0, False: 0] ------------------ 122| | /* the substring consists of a single, non-surrogate BMP code point */ 123| 0| return length<0 ? u_strchr(s, cs) : u_memchr(s, cs, length); ------------------ | | 385| 0|#define u_strchr U_ICU_ENTRY_POINT_RENAME(u_strchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return length<0 ? u_strchr(s, cs) : u_memchr(s, cs, length); ------------------ | | 330| 0|#define u_memchr U_ICU_ENTRY_POINT_RENAME(u_memchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (123:16): [True: 0, False: 0] ------------------ 124| 0| } 125| | 126| 1.29M| if(length<0) { ------------------ | Branch (126:8): [True: 0, False: 1.29M] ------------------ 127| | /* s is NUL-terminated */ 128| 0| while((c=*s++)!=0) { ------------------ | Branch (128:15): [True: 0, False: 0] ------------------ 129| 0| if(c==cs) { ------------------ | Branch (129:16): [True: 0, False: 0] ------------------ 130| | /* found first substring char16_t, compare rest */ 131| 0| p=s; 132| 0| q=sub; 133| 0| for(;;) { 134| 0| if(q==subLimit) { ------------------ | Branch (134:24): [True: 0, False: 0] ------------------ 135| 0| if(isMatchAtCPBoundary(start, s-1, p, nullptr)) { ------------------ | Branch (135:28): [True: 0, False: 0] ------------------ 136| 0| return (char16_t *)(s-1); /* well-formed match */ 137| 0| } else { 138| 0| break; /* no match because surrogate pair is split */ 139| 0| } 140| 0| } 141| 0| if((c=*p)==0) { ------------------ | Branch (141:24): [True: 0, False: 0] ------------------ 142| 0| return nullptr; /* no match, and none possible after s */ 143| 0| } 144| 0| if(c!=*q) { ------------------ | Branch (144:24): [True: 0, False: 0] ------------------ 145| 0| break; /* no match */ 146| 0| } 147| 0| ++p; 148| 0| ++q; 149| 0| } 150| 0| } 151| 0| } 152| 1.29M| } else { 153| 1.29M| const char16_t *limit, *preLimit; 154| | 155| | /* subLength was decremented above */ 156| 1.29M| if(length<=subLength) { ------------------ | Branch (156:12): [True: 10.9k, False: 1.28M] ------------------ 157| 10.9k| return nullptr; /* s is shorter than sub */ 158| 10.9k| } 159| | 160| 1.28M| limit=s+length; 161| | 162| | /* the substring must start before preLimit */ 163| 1.28M| preLimit=limit-subLength; 164| | 165| 31.1G| while(s!=preLimit) { ------------------ | Branch (165:15): [True: 31.1G, False: 447k] ------------------ 166| 31.1G| c=*s++; 167| 31.1G| if(c==cs) { ------------------ | Branch (167:16): [True: 514M, False: 30.6G] ------------------ 168| | /* found first substring char16_t, compare rest */ 169| 514M| p=s; 170| 514M| q=sub; 171| 1.34G| for(;;) { 172| 1.34G| if(q==subLimit) { ------------------ | Branch (172:24): [True: 840k, False: 1.34G] ------------------ 173| 840k| if(isMatchAtCPBoundary(start, s-1, p, limit)) { ------------------ | Branch (173:28): [True: 839k, False: 1.60k] ------------------ 174| 839k| return (char16_t *)(s-1); /* well-formed match */ 175| 839k| } else { 176| 1.60k| break; /* no match because surrogate pair is split */ 177| 1.60k| } 178| 840k| } 179| 1.34G| if(*p!=*q) { ------------------ | Branch (179:24): [True: 513M, False: 830M] ------------------ 180| 513M| break; /* no match */ 181| 513M| } 182| 830M| ++p; 183| 830M| ++q; 184| 830M| } 185| 514M| } 186| 31.1G| } 187| 1.28M| } 188| | 189| | /* not found */ 190| 447k| return nullptr; 191| 1.29M|} u_memchr_78: 241| 26.0k|u_memchr(const char16_t *s, char16_t c, int32_t count) { 242| 26.0k| if(count<=0) { ------------------ | Branch (242:8): [True: 0, False: 26.0k] ------------------ 243| 0| return nullptr; /* no string */ 244| 26.0k| } else if(U16_IS_SURROGATE(c)) { ------------------ | | 75| 26.0k|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 26.0k|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | ------------------ | | | | | Branch (193:27): [True: 0, False: 26.0k] | | | | ------------------ | | ------------------ ------------------ 245| | /* make sure to not find half of a surrogate pair */ 246| 0| return u_strFindFirst(s, count, &c, 1); ------------------ | | 361| 0|#define u_strFindFirst U_ICU_ENTRY_POINT_RENAME(u_strFindFirst) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 26.0k| } else { 248| | /* trivial search for a BMP code point */ 249| 26.0k| const char16_t *limit=s+count; 250| 667k| do { 251| 667k| if(*s==c) { ------------------ | Branch (251:16): [True: 16.3k, False: 651k] ------------------ 252| 16.3k| return (char16_t *)s; 253| 16.3k| } 254| 667k| } while(++s!=limit); ------------------ | Branch (254:17): [True: 641k, False: 9.63k] ------------------ 255| 9.63k| return nullptr; 256| 26.0k| } 257| 26.0k|} u_memrchr_78: 416| 7.17k|u_memrchr(const char16_t *s, char16_t c, int32_t count) { 417| 7.17k| if(count<=0) { ------------------ | Branch (417:8): [True: 1, False: 7.17k] ------------------ 418| 1| return nullptr; /* no string */ 419| 7.17k| } else if(U16_IS_SURROGATE(c)) { ------------------ | | 75| 7.17k|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 7.17k|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | ------------------ | | | | | Branch (193:27): [True: 0, False: 7.17k] | | | | ------------------ | | ------------------ ------------------ 420| | /* make sure to not find half of a surrogate pair */ 421| 0| return u_strFindLast(s, count, &c, 1); ------------------ | | 362| 0|#define u_strFindLast U_ICU_ENTRY_POINT_RENAME(u_strFindLast) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| 7.17k| } else { 423| | /* trivial search for a BMP code point */ 424| 7.17k| const char16_t *limit=s+count; 425| 65.8k| do { 426| 65.8k| if(*(--limit)==c) { ------------------ | Branch (426:16): [True: 7.07k, False: 58.7k] ------------------ 427| 7.07k| return (char16_t *)limit; 428| 7.07k| } 429| 65.8k| } while(s!=limit); ------------------ | Branch (429:17): [True: 58.6k, False: 99] ------------------ 430| 99| return nullptr; 431| 7.17k| } 432| 7.17k|} u_strlen_78: 995| 164k|{ 996| |#if U_SIZEOF_WCHAR_T == U_SIZEOF_UCHAR 997| | return (int32_t)uprv_wcslen((const wchar_t *)s); 998| |#else 999| 164k| const char16_t *t = s; 1000| 1.98M| while(*t != 0) { ------------------ | Branch (1000:11): [True: 1.82M, False: 164k] ------------------ 1001| 1.82M| ++t; 1002| 1.82M| } 1003| 164k| return t - s; 1004| 164k|#endif 1005| 164k|} u_countChar32_78: 1008| 20.5M|u_countChar32(const char16_t *s, int32_t length) { 1009| 20.5M| int32_t count; 1010| | 1011| 20.5M| if(s==nullptr || length<-1) { ------------------ | Branch (1011:8): [True: 0, False: 20.5M] | Branch (1011:22): [True: 0, False: 20.5M] ------------------ 1012| 0| return 0; 1013| 0| } 1014| | 1015| 20.5M| count=0; 1016| 20.5M| if(length>=0) { ------------------ | Branch (1016:8): [True: 20.5M, False: 0] ------------------ 1017| 45.6M| while(length>0) { ------------------ | Branch (1017:15): [True: 25.1M, False: 20.5M] ------------------ 1018| 25.1M| ++count; 1019| 25.1M| if(U16_IS_LEAD(*s) && length>=2 && U16_IS_TRAIL(*(s+1))) { ------------------ | | 59| 50.2M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 868k, False: 24.2M] | | ------------------ ------------------ if(U16_IS_LEAD(*s) && length>=2 && U16_IS_TRAIL(*(s+1))) { ------------------ | | 67| 868k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 868k, False: 0] | | ------------------ ------------------ | Branch (1019:35): [True: 868k, False: 0] ------------------ 1020| 868k| s+=2; 1021| 868k| length-=2; 1022| 24.2M| } else { 1023| 24.2M| ++s; 1024| 24.2M| --length; 1025| 24.2M| } 1026| 25.1M| } 1027| 20.5M| } else /* length==-1 */ { 1028| 0| char16_t c; 1029| | 1030| 0| for(;;) { 1031| 0| if((c=*s++)==0) { ------------------ | Branch (1031:16): [True: 0, False: 0] ------------------ 1032| 0| break; 1033| 0| } 1034| 0| ++count; 1035| | 1036| | /* 1037| | * sufficient to look ahead one because of UTF-16; 1038| | * safe to look ahead one because at worst that would be the terminating NUL 1039| | */ 1040| 0| if(U16_IS_LEAD(c) && U16_IS_TRAIL(*s)) { ------------------ | | 59| 0|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 0, False: 0] | | ------------------ ------------------ if(U16_IS_LEAD(c) && U16_IS_TRAIL(*s)) { ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ 1041| 0| ++s; 1042| 0| } 1043| 0| } 1044| 0| } 1045| 20.5M| return count; 1046| 20.5M|} u_memcpy_78: 1117| 60.1M|u_memcpy(char16_t *dest, const char16_t *src, int32_t count) { 1118| 60.1M| if(count > 0) { ------------------ | Branch (1118:8): [True: 60.1M, False: 0] ------------------ 1119| 60.1M| uprv_memcpy(dest, src, (size_t)count*U_SIZEOF_UCHAR); ------------------ | | 42| 60.1M|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 60.1M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 60.1M| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 60.1M| _Pragma("clang diagnostic push") \ | | 45| 60.1M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 60.1M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 60.1M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 60.1M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 60.1M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 60.1M| _Pragma("clang diagnostic pop") \ | | 49| 60.1M| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 60.1M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 60.1M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 60.1M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1120| 60.1M| } 1121| 60.1M| return dest; 1122| 60.1M|} u_memcmp_78: 1146| 130M|u_memcmp(const char16_t *buf1, const char16_t *buf2, int32_t count) { 1147| 130M| if(count > 0) { ------------------ | Branch (1147:8): [True: 130M, False: 0] ------------------ 1148| 130M| const char16_t *limit = buf1 + count; 1149| 130M| int32_t result; 1150| | 1151| 841M| while (buf1 < limit) { ------------------ | Branch (1151:16): [True: 753M, False: 87.9M] ------------------ 1152| 753M| result = (int32_t)(uint16_t)*buf1 - (int32_t)(uint16_t)*buf2; 1153| 753M| if (result != 0) { ------------------ | Branch (1153:17): [True: 42.4M, False: 710M] ------------------ 1154| 42.4M| return result; 1155| 42.4M| } 1156| 710M| buf1++; 1157| 710M| buf2++; 1158| 710M| } 1159| 130M| } 1160| 87.9M| return 0; 1161| 130M|} u_unescapeAt_78: 1216| 4.67k| void *context) { 1217| | 1218| 4.67k| int32_t start = *offset; 1219| 4.67k| UChar32 c; 1220| 4.67k| UChar32 result = 0; 1221| 4.67k| int8_t n = 0; 1222| 4.67k| int8_t minDig = 0; 1223| 4.67k| int8_t maxDig = 0; 1224| 4.67k| int8_t bitsPerDigit = 4; 1225| 4.67k| int32_t dig; 1226| 4.67k| UBool braces = false; 1227| | 1228| | /* Check that offset is in range */ 1229| 4.67k| if (*offset < 0 || *offset >= length) { ------------------ | Branch (1229:9): [True: 0, False: 4.67k] | Branch (1229:24): [True: 0, False: 4.67k] ------------------ 1230| 0| goto err; 1231| 0| } 1232| | 1233| | /* Fetch first char16_t after '\\' */ 1234| 4.67k| c = charAt((*offset)++, context); 1235| | 1236| | /* Convert hexadecimal and octal escapes */ 1237| 4.67k| switch (c) { 1238| 21| case u'u': ------------------ | Branch (1238:5): [True: 21, False: 4.65k] ------------------ 1239| 21| minDig = maxDig = 4; 1240| 21| break; 1241| 11| case u'U': ------------------ | Branch (1241:5): [True: 11, False: 4.66k] ------------------ 1242| 11| minDig = maxDig = 8; 1243| 11| break; 1244| 674| case u'x': ------------------ | Branch (1244:5): [True: 674, False: 3.99k] ------------------ 1245| 674| minDig = 1; 1246| 674| if (*offset < length && charAt(*offset, context) == u'{') { ------------------ | Branch (1246:13): [True: 674, False: 0] | Branch (1246:33): [True: 113, False: 561] ------------------ 1247| 113| ++(*offset); 1248| 113| braces = true; 1249| 113| maxDig = 8; 1250| 561| } else { 1251| 561| maxDig = 2; 1252| 561| } 1253| 674| break; 1254| 3.96k| default: ------------------ | Branch (1254:5): [True: 3.96k, False: 706] ------------------ 1255| 3.96k| dig = _digit8(c); 1256| 3.96k| if (dig >= 0) { ------------------ | Branch (1256:13): [True: 526, False: 3.44k] ------------------ 1257| 526| minDig = 1; 1258| 526| maxDig = 3; 1259| 526| n = 1; /* Already have first octal digit */ 1260| 526| bitsPerDigit = 3; 1261| 526| result = dig; 1262| 526| } 1263| 3.96k| break; 1264| 4.67k| } 1265| 4.67k| if (minDig != 0) { ------------------ | Branch (1265:9): [True: 1.23k, False: 3.44k] ------------------ 1266| 2.43k| while (*offset < length && n < maxDig) { ------------------ | Branch (1266:16): [True: 2.43k, False: 0] | Branch (1266:36): [True: 2.25k, False: 175] ------------------ 1267| 2.25k| c = charAt(*offset, context); 1268| 2.25k| dig = (bitsPerDigit == 3) ? _digit8(c) : _digit16(c); ------------------ | Branch (1268:19): [True: 726, False: 1.53k] ------------------ 1269| 2.25k| if (dig < 0) { ------------------ | Branch (1269:17): [True: 1.05k, False: 1.20k] ------------------ 1270| 1.05k| break; 1271| 1.05k| } 1272| 1.20k| result = (result << bitsPerDigit) | dig; 1273| 1.20k| ++(*offset); 1274| 1.20k| ++n; 1275| 1.20k| } 1276| 1.23k| if (n < minDig) { ------------------ | Branch (1276:13): [True: 25, False: 1.20k] ------------------ 1277| 25| goto err; 1278| 25| } 1279| 1.20k| if (braces) { ------------------ | Branch (1279:13): [True: 111, False: 1.09k] ------------------ 1280| 111| if (c != u'}') { ------------------ | Branch (1280:17): [True: 7, False: 104] ------------------ 1281| 7| goto err; 1282| 7| } 1283| 104| ++(*offset); 1284| 104| } 1285| 1.20k| if (result < 0 || result >= 0x110000) { ------------------ | Branch (1285:13): [True: 1, False: 1.19k] | Branch (1285:27): [True: 1, False: 1.19k] ------------------ 1286| 2| goto err; 1287| 2| } 1288| | /* If an escape sequence specifies a lead surrogate, see if 1289| | * there is a trail surrogate after it, either as an escape or 1290| | * as a literal. If so, join them up into a supplementary. 1291| | */ 1292| 1.19k| if (*offset < length && U16_IS_LEAD(result)) { ------------------ | | 59| 1.19k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 7, False: 1.19k] | | ------------------ ------------------ | Branch (1292:13): [True: 1.19k, False: 0] ------------------ 1293| 7| int32_t ahead = *offset + 1; 1294| 7| c = charAt(*offset, context); 1295| 7| if (c == u'\\' && ahead < length) { ------------------ | Branch (1295:17): [True: 1, False: 6] | Branch (1295:31): [True: 1, False: 0] ------------------ 1296| | // Calling ourselves recursively may cause a stack overflow if 1297| | // we have repeated escaped lead surrogates. 1298| | // Limit the length to 11 ("x{0000DFFF}") after ahead. 1299| 1| int32_t tailLimit = ahead + 11; 1300| 1| if (tailLimit > length) { ------------------ | Branch (1300:21): [True: 1, False: 0] ------------------ 1301| 1| tailLimit = length; 1302| 1| } 1303| 1| c = u_unescapeAt(charAt, &ahead, tailLimit, context); ------------------ | | 416| 1|#define u_unescapeAt U_ICU_ENTRY_POINT_RENAME(u_unescapeAt) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1304| 1| } 1305| 7| if (U16_IS_TRAIL(c)) { ------------------ | | 67| 7|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 7] | | ------------------ ------------------ 1306| 0| *offset = ahead; 1307| 0| result = U16_GET_SUPPLEMENTARY(result, c); ------------------ | | 113| 0| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 0|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 1308| 0| } 1309| 7| } 1310| 1.19k| return result; 1311| 1.20k| } 1312| | 1313| | /* Convert C-style escapes in table */ 1314| 18.7k| for (int32_t i=0; idestCapacity */ { \ | | 1454| 23| /* even the string itself did not fit - set an error code */ \ | | 1455| 23| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; \ | | 1456| 23| } \ | | 1457| 7.06M| } \ | | 1458| 7.06M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7.06M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1471| 7.06M| return length; 1472| 7.06M|} u_terminateChars_78: 1475| 15.4k|u_terminateChars(char *dest, int32_t destCapacity, int32_t length, UErrorCode *pErrorCode) { 1476| 15.4k| __TERMINATE_STRING(dest, destCapacity, length, pErrorCode); ------------------ | | 1437| 15.4k|#define __TERMINATE_STRING(dest, destCapacity, length, pErrorCode) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 15.4k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1438| 15.4k| if(pErrorCode!=nullptr && U_SUCCESS(*pErrorCode)) { \ | | ------------------ | | | Branch (1438:8): [True: 15.4k, False: 0] | | | Branch (1438:31): [True: 15.4k, False: 0] | | ------------------ | | 1439| 15.4k| /* not a public function, so no complete argument checking */ \ | | 1440| 15.4k| \ | | 1441| 15.4k| if(length<0) { \ | | ------------------ | | | Branch (1441:12): [True: 0, False: 15.4k] | | ------------------ | | 1442| 0| /* assume that the caller handles this */ \ | | 1443| 15.4k| } else if(lengthdestCapacity */ { \ | | 1454| 0| /* even the string itself did not fit - set an error code */ \ | | 1455| 0| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; \ | | 1456| 0| } \ | | 1457| 15.4k| } \ | | 1458| 15.4k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 15.4k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1477| 15.4k| return length; 1478| 15.4k|} ustr_hashUCharsN_78: 1523| 111M|ustr_hashUCharsN(const char16_t *str, int32_t length) { 1524| 111M| STRING_HASH(char16_t, str, length, *p); ------------------ | | 1506| 111M|#define STRING_HASH(TYPE, STR, STRLEN, DEREF) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 111M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1507| 111M| uint32_t hash = 0; \ | | 1508| 111M| const TYPE *p = (const TYPE*) STR; \ | | 1509| 111M| if (p != nullptr) { \ | | ------------------ | | | Branch (1509:9): [True: 111M, False: 0] | | ------------------ | | 1510| 111M| int32_t len = (int32_t)(STRLEN); \ | | 1511| 111M| int32_t inc = ((len - 32) / 32) + 1; \ | | 1512| 111M| const TYPE *limit = p + len; \ | | 1513| 657M| while (p(hash); \ | | 1519| 111M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 111M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1525| 111M|} ustr_hashCharsN_78: 1528| 19.7k|ustr_hashCharsN(const char *str, int32_t length) { 1529| 19.7k| STRING_HASH(uint8_t, str, length, *p); ------------------ | | 1506| 19.7k|#define STRING_HASH(TYPE, STR, STRLEN, DEREF) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 19.7k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1507| 19.7k| uint32_t hash = 0; \ | | 1508| 19.7k| const TYPE *p = (const TYPE*) STR; \ | | 1509| 19.7k| if (p != nullptr) { \ | | ------------------ | | | Branch (1509:9): [True: 19.7k, False: 0] | | ------------------ | | 1510| 19.7k| int32_t len = (int32_t)(STRLEN); \ | | 1511| 19.7k| int32_t inc = ((len - 32) / 32) + 1; \ | | 1512| 19.7k| const TYPE *limit = p + len; \ | | 1513| 231k| while (p(hash); \ | | 1519| 19.7k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 19.7k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1530| 19.7k|} ustr_hashICharsN_78: 1533| 5.23k|ustr_hashICharsN(const char *str, int32_t length) { 1534| 5.23k| STRING_HASH(char, str, length, (uint8_t)uprv_tolower(*p)); ------------------ | | 1506| 5.23k|#define STRING_HASH(TYPE, STR, STRLEN, DEREF) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5.23k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1507| 5.23k| uint32_t hash = 0; \ | | 1508| 5.23k| const TYPE *p = (const TYPE*) STR; \ | | 1509| 5.23k| if (p != nullptr) { \ | | ------------------ | | | Branch (1509:9): [True: 5.23k, False: 0] | | ------------------ | | 1510| 5.23k| int32_t len = (int32_t)(STRLEN); \ | | 1511| 5.23k| int32_t inc = ((len - 32) / 32) + 1; \ | | 1512| 5.23k| const TYPE *limit = p + len; \ | | 1513| 30.5k| while (p(hash); \ | | 1519| 5.23k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5.23k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1535| 5.23k|} ustring.cpp:_ZL19isMatchAtCPBoundaryPKDsS0_S0_S0_: 43| 840k|isMatchAtCPBoundary(const char16_t *start, const char16_t *match, const char16_t *matchLimit, const char16_t *limit) { 44| 840k| if(U16_IS_TRAIL(*match) && start!=match && U16_IS_LEAD(*(match-1))) { ------------------ | | 67| 1.68M|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 1.93k, False: 838k] | | ------------------ ------------------ if(U16_IS_TRAIL(*match) && start!=match && U16_IS_LEAD(*(match-1))) { ------------------ | | 59| 1.93k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 810, False: 1.12k] | | ------------------ ------------------ | Branch (44:32): [True: 1.93k, False: 0] ------------------ 45| | /* the leading edge of the match is in the middle of a surrogate pair */ 46| 810| return false; 47| 810| } 48| 840k| if(U16_IS_LEAD(*(matchLimit-1)) && matchLimit!=limit && U16_IS_TRAIL(*matchLimit)) { ------------------ | | 59| 1.68M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 1.34k, False: 838k] | | ------------------ ------------------ if(U16_IS_LEAD(*(matchLimit-1)) && matchLimit!=limit && U16_IS_TRAIL(*matchLimit)) { ------------------ | | 67| 1.08k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 798, False: 282] | | ------------------ ------------------ | Branch (48:40): [True: 1.08k, False: 266] ------------------ 49| | /* the trailing edge of the match is in the middle of a surrogate pair */ 50| 798| return false; 51| 798| } 52| 839k| return true; 53| 840k|} ustring.cpp:_ZL7_digit8Ds: 1188| 4.69k|static int32_t _digit8(char16_t c) { 1189| 4.69k| if (c >= u'0' && c <= u'7') { ------------------ | Branch (1189:9): [True: 4.37k, False: 314] | Branch (1189:22): [True: 728, False: 3.65k] ------------------ 1190| 728| return c - u'0'; 1191| 728| } 1192| 3.96k| return -1; 1193| 4.69k|} ustring.cpp:_ZL8_digit16Ds: 1196| 1.53k|static int32_t _digit16(char16_t c) { 1197| 1.53k| if (c >= u'0' && c <= u'9') { ------------------ | Branch (1197:9): [True: 1.48k, False: 45] | Branch (1197:22): [True: 303, False: 1.18k] ------------------ 1198| 303| return c - u'0'; 1199| 303| } 1200| 1.22k| if (c >= u'A' && c <= u'F') { ------------------ | Branch (1200:9): [True: 1.18k, False: 47] | Branch (1200:22): [True: 341, False: 841] ------------------ 1201| 341| return c - (u'A' - 10); 1202| 341| } 1203| 888| if (c >= u'a' && c <= u'f') { ------------------ | Branch (1203:9): [True: 818, False: 70] | Branch (1203:22): [True: 355, False: 463] ------------------ 1204| 355| return c - (u'a' - 10); 1205| 355| } 1206| 533| return -1; 1207| 888|} _ZN6icu_7811ICU_Utility21shouldAlwaysBeEscapedEi: 72| 233k|UBool ICU_Utility::shouldAlwaysBeEscaped(UChar32 c) { 73| 233k| if (c < 0x20) { ------------------ | Branch (73:9): [True: 18.3k, False: 215k] ------------------ 74| 18.3k| return true; // C0 control codes 75| 215k| } else if (c <= 0x7e) { ------------------ | Branch (75:16): [True: 19.2k, False: 196k] ------------------ 76| 19.2k| return false; // printable ASCII 77| 196k| } else if (c <= 0x9f) { ------------------ | Branch (77:16): [True: 1.98k, False: 194k] ------------------ 78| 1.98k| return true; // C1 control codes 79| 194k| } else if (c < 0xd800) { ------------------ | Branch (79:16): [True: 164k, False: 30.1k] ------------------ 80| 164k| return false; // most of the BMP 81| 164k| } else if (c <= 0xdfff || (0xfdd0 <= c && c <= 0xfdef) || (c & 0xfffe) == 0xfffe) { ------------------ | Branch (81:16): [True: 3.69k, False: 26.4k] | Branch (81:32): [True: 11.3k, False: 15.0k] | Branch (81:47): [True: 49, False: 11.3k] | Branch (81:63): [True: 6.02k, False: 20.3k] ------------------ 82| 9.76k| return true; // surrogate or noncharacter code points 83| 20.3k| } else if (c <= 0x10ffff) { ------------------ | Branch (83:16): [True: 20.3k, False: 0] ------------------ 84| 20.3k| return false; // all else 85| 20.3k| } else { 86| 0| return true; // not a code point 87| 0| } 88| 233k|} _ZN6icu_7811ICU_Utility6escapeERNS_13UnicodeStringEi: 98| 30.0k|UnicodeString &ICU_Utility::escape(UnicodeString& result, UChar32 c) { 99| 30.0k| result.append(BACKSLASH); 100| 30.0k| if (c & ~0xFFFF) { ------------------ | Branch (100:9): [True: 1.40k, False: 28.6k] ------------------ 101| 1.40k| result.append(UPPER_U); 102| 1.40k| result.append(DIGITS[0xF&(c>>28)]); 103| 1.40k| result.append(DIGITS[0xF&(c>>24)]); 104| 1.40k| result.append(DIGITS[0xF&(c>>20)]); 105| 1.40k| result.append(DIGITS[0xF&(c>>16)]); 106| 28.6k| } else { 107| 28.6k| result.append(LOWER_U); 108| 28.6k| } 109| 30.0k| result.append(DIGITS[0xF&(c>>12)]); 110| 30.0k| result.append(DIGITS[0xF&(c>>8)]); 111| 30.0k| result.append(DIGITS[0xF&(c>>4)]); 112| 30.0k| result.append(DIGITS[0xF&c]); 113| 30.0k| return result; 114| 30.0k|} _ZN6icu_7811ICU_Utility14skipWhitespaceERKNS_13UnicodeStringERia: 150| 21.9k| UBool advance) { 151| 21.9k| int32_t p = pos; 152| 21.9k| const char16_t* s = str.getBuffer(); 153| 21.9k| p = static_cast(PatternProps::skipWhiteSpace(s + p, str.length() - p) - s); 154| 21.9k| if (advance) { ------------------ | Branch (154:9): [True: 9.16k, False: 12.7k] ------------------ 155| 9.16k| pos = p; 156| 9.16k| } 157| 21.9k| return p; 158| 21.9k|} utrie2_get32_78: 61| 58.2M|utrie2_get32(const UTrie2 *trie, UChar32 c) { 62| 58.2M| if(trie->data16!=nullptr) { ------------------ | Branch (62:8): [True: 0, False: 58.2M] ------------------ 63| 0| return UTRIE2_GET16(trie, c); ------------------ | | 360| 0|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 0| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 0| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 846| 0| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 0| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 0| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 816| 0| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 0| (trie)->index, c) : \ | | | | | | 851| 0| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 852| 0| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 0| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 854| 0| (trie)->highValueIndex : \ | | | | | | 855| 0| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 0| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 0| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 0| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 0| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 0| <data32!=nullptr) { ------------------ | Branch (64:15): [True: 0, False: 58.2M] ------------------ 65| 0| return UTRIE2_GET32(trie, c); ------------------ | | 370| 0|#define UTRIE2_GET32(trie, c) _UTRIE2_GET((trie), data32, 0, (c)) | | ------------------ | | | | 871| 0| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 0| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 846| 0| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 0| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 0| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 816| 0| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 0| (trie)->index, c) : \ | | | | | | 851| 0| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 852| 0| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 0| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 854| 0| (trie)->highValueIndex : \ | | | | | | 855| 0| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 0| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 0| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 0| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 0| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 0| <0x10ffff) { ------------------ | Branch (66:15): [True: 0, False: 58.2M] ------------------ 67| 0| return trie->errorValue; 68| 58.2M| } else { 69| 58.2M| return get32(trie->newTrie, c, true); 70| 58.2M| } 71| 58.2M|} utrie2_openFromSerialized_78: 131| 1| UErrorCode *pErrorCode) { 132| 1| const UTrie2Header *header; 133| 1| const uint16_t *p16; 134| 1| int32_t actualLength; 135| | 136| 1| UTrie2 tempTrie; 137| 1| UTrie2 *trie; 138| | 139| 1| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (139:8): [True: 0, False: 1] ------------------ 140| 0| return nullptr; 141| 0| } 142| | 143| 1| if( length<=0 || (U_POINTER_MASK_LSB(data, 3)!=0) || ------------------ | | 123| 1|#define U_POINTER_MASK_LSB(ptr, mask) ((uintptr_t)(ptr) & (mask)) ------------------ | Branch (143:9): [True: 0, False: 1] | Branch (143:22): [True: 0, False: 1] ------------------ 144| 1| valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits ------------------ | Branch (144:9): [True: 0, False: 1] | Branch (144:24): [True: 0, False: 1] ------------------ 145| 1| ) { 146| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 147| 0| return nullptr; 148| 0| } 149| | 150| | /* enough data for a trie header? */ 151| 1| if(length<(int32_t)sizeof(UTrie2Header)) { ------------------ | Branch (151:8): [True: 0, False: 1] ------------------ 152| 0| *pErrorCode=U_INVALID_FORMAT_ERROR; 153| 0| return nullptr; 154| 0| } 155| | 156| | /* check the signature */ 157| 1| header=(const UTrie2Header *)data; 158| 1| if(header->signature!=UTRIE2_SIG) { ------------------ | | 39| 1|#define UTRIE2_SIG 0x54726932 ------------------ | Branch (158:8): [True: 0, False: 1] ------------------ 159| 0| *pErrorCode=U_INVALID_FORMAT_ERROR; 160| 0| return nullptr; 161| 0| } 162| | 163| | /* get the options */ 164| 1| if(valueBits!=(UTrie2ValueBits)(header->options&UTRIE2_OPTIONS_VALUE_BITS_MASK)) { ------------------ | Branch (164:8): [True: 0, False: 1] ------------------ 165| 0| *pErrorCode=U_INVALID_FORMAT_ERROR; 166| 0| return nullptr; 167| 0| } 168| | 169| | /* get the length values and offsets */ 170| 1| uprv_memset(&tempTrie, 0, sizeof(tempTrie)); ------------------ | | 100| 1|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 171| 1| tempTrie.indexLength=header->indexLength; 172| 1| tempTrie.dataLength=header->shiftedDataLength<index2NullOffset; 174| 1| tempTrie.dataNullOffset=header->dataNullOffset; 175| | 176| 1| tempTrie.highStart=header->shiftedHighStart<memory=(uint32_t *)data; 202| 1| trie->length=actualLength; 203| 1| trie->isMemoryOwned=false; 204| |#ifdef UTRIE2_DEBUG 205| | trie->name="fromSerialized"; 206| |#endif 207| | 208| | /* set the pointers to its index and data arrays */ 209| 1| p16=(const uint16_t *)(header+1); 210| 1| trie->index=p16; 211| 1| p16+=trie->indexLength; 212| | 213| | /* get the data */ 214| 1| switch(valueBits) { 215| 0| case UTRIE2_16_VALUE_BITS: ------------------ | Branch (215:5): [True: 0, False: 1] ------------------ 216| 0| trie->data16=p16; 217| 0| trie->data32=nullptr; 218| 0| trie->initialValue=trie->index[trie->dataNullOffset]; 219| 0| trie->errorValue=trie->data16[UTRIE2_BAD_UTF8_DATA_OFFSET]; 220| 0| break; 221| 1| case UTRIE2_32_VALUE_BITS: ------------------ | Branch (221:5): [True: 1, False: 0] ------------------ 222| 1| trie->data16=nullptr; 223| 1| trie->data32=(const uint32_t *)p16; 224| 1| trie->initialValue=trie->data32[trie->dataNullOffset]; 225| 1| trie->errorValue=trie->data32[UTRIE2_BAD_UTF8_DATA_OFFSET]; 226| 1| break; 227| 0| default: ------------------ | Branch (227:5): [True: 0, False: 1] ------------------ 228| 0| *pErrorCode=U_INVALID_FORMAT_ERROR; 229| 0| return nullptr; 230| 1| } 231| | 232| 1| if(pActualLength!=nullptr) { ------------------ | Branch (232:8): [True: 0, False: 1] ------------------ 233| 0| *pActualLength=actualLength; 234| 0| } 235| 1| return trie; 236| 1|} utrie2_close_78: 374| 19.3k|utrie2_close(UTrie2 *trie) { 375| 19.3k| if(trie!=nullptr) { ------------------ | Branch (375:8): [True: 11.6k, False: 7.71k] ------------------ 376| 11.6k| if(trie->isMemoryOwned) { ------------------ | Branch (376:12): [True: 3.92k, False: 7.71k] ------------------ 377| 3.92k| uprv_free(trie->memory); ------------------ | | 1503| 3.92k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 378| 3.92k| } 379| 11.6k| if(trie->newTrie!=nullptr) { ------------------ | Branch (379:12): [True: 7.71k, False: 3.92k] ------------------ 380| 7.71k| uprv_free(trie->newTrie->data); ------------------ | | 1503| 7.71k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 7.71k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.71k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.71k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 381| |#ifdef UCPTRIE_DEBUG 382| | umutablecptrie_close(trie->newTrie->t3); 383| |#endif 384| 7.71k| uprv_free(trie->newTrie); ------------------ | | 1503| 7.71k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 7.71k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.71k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.71k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 385| 7.71k| } 386| 11.6k| uprv_free(trie); ------------------ | | 1503| 11.6k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 11.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 387| 11.6k| } 388| 19.3k|} utrie2_isFrozen_78: 391| 13.7M|utrie2_isFrozen(const UTrie2 *trie) { 392| 13.7M| return trie->newTrie==nullptr; 393| 13.7M|} utrie2_enum_78: 622| 7.85k| UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 623| 7.85k| enumEitherTrie(trie, 0, 0x110000, enumValue, enumRange, context); 624| 7.85k|} utrie2_enumForLeadSurrogate_78: 629| 4.02M| const void *context) { 630| 4.02M| if(!U16_IS_LEAD(lead)) { ------------------ | | 59| 4.02M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ | Branch (630:8): [True: 0, False: 4.02M] ------------------ 631| 0| return; 632| 0| } 633| 4.02M| lead=(lead-0xd7c0)<<10; /* start code point */ 634| 4.02M| enumEitherTrie(trie, lead, lead+0x400, enumValue, enumRange, context); 635| 4.02M|} utrie2.cpp:_ZL5get32PK9UNewTrie2ia: 42| 58.2M|get32(const UNewTrie2 *trie, UChar32 c, UBool fromLSCP) { 43| 58.2M| int32_t i2, block; 44| | 45| 58.2M| if(c>=trie->highStart && (!U_IS_LEAD(c) || fromLSCP)) { ------------------ | | 177| 0|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ | Branch (45:8): [True: 0, False: 58.2M] | Branch (45:31): [True: 0, False: 0] | Branch (45:48): [True: 0, False: 0] ------------------ 46| 0| return trie->data[trie->dataLength-UTRIE2_DATA_GRANULARITY]; 47| 0| } 48| | 49| 58.2M| if(U_IS_LEAD(c) && fromLSCP) { ------------------ | | 177| 116M|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 8.58k, False: 58.2M] | | ------------------ ------------------ | Branch (49:24): [True: 8.58k, False: 0] ------------------ 50| 8.58k| i2=(UTRIE2_LSCP_INDEX_2_OFFSET-(0xd800>>UTRIE2_SHIFT_2))+ 51| 8.58k| (c>>UTRIE2_SHIFT_2); 52| 58.2M| } else { 53| 58.2M| i2=trie->index1[c>>UTRIE2_SHIFT_1]+ 54| 58.2M| ((c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK); 55| 58.2M| } 56| 58.2M| block=trie->index2[i2]; 57| 58.2M| return trie->data[block+(c&UTRIE2_DATA_MASK)]; 58| 58.2M|} utrie2.cpp:_ZL14enumEitherTriePK6UTrie2iiPFjPKvjEPFaS3_iijES3_: 445| 4.02M| UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 446| 4.02M| const uint32_t *data32; 447| 4.02M| const uint16_t *idx; 448| | 449| 4.02M| uint32_t value, prevValue, initialValue; 450| 4.02M| UChar32 c, prev, highStart; 451| 4.02M| int32_t j, i2Block, prevI2Block, index2NullOffset, block, prevBlock, nullBlock; 452| | 453| 4.02M| if(enumRange==nullptr) { ------------------ | Branch (453:8): [True: 0, False: 4.02M] ------------------ 454| 0| return; 455| 0| } 456| 4.02M| if(enumValue==nullptr) { ------------------ | Branch (456:8): [True: 4.02M, False: 0] ------------------ 457| 4.02M| enumValue=enumSameValue; 458| 4.02M| } 459| | 460| 4.02M| if(trie->newTrie==nullptr) { ------------------ | Branch (460:8): [True: 3.93k, False: 4.02M] ------------------ 461| | /* frozen trie */ 462| 3.93k| idx=trie->index; 463| 3.93k| U_ASSERT(idx!=nullptr); /* the following code assumes trie->newTrie is not nullptr when idx is nullptr */ ------------------ | | 35| 3.93k|# define U_ASSERT(exp) (void)0 ------------------ 464| 3.93k| data32=trie->data32; 465| | 466| 3.93k| index2NullOffset=trie->index2NullOffset; 467| 3.93k| nullBlock=trie->dataNullOffset; 468| 4.02M| } else { 469| | /* unfrozen, mutable trie */ 470| 4.02M| idx=nullptr; 471| 4.02M| data32=trie->newTrie->data; 472| 4.02M| U_ASSERT(data32!=nullptr); /* the following code assumes idx is not nullptr when data32 is nullptr */ ------------------ | | 35| 4.02M|# define U_ASSERT(exp) (void)0 ------------------ 473| | 474| 4.02M| index2NullOffset=trie->newTrie->index2NullOffset; 475| 4.02M| nullBlock=trie->newTrie->dataNullOffset; 476| 4.02M| } 477| | 478| 4.02M| highStart=trie->highStart; 479| | 480| | /* get the enumeration value that corresponds to an initial-value trie data entry */ 481| 4.02M| initialValue=enumValue(context, trie->initialValue); 482| | 483| | /* set variables for previous range */ 484| 4.02M| prevI2Block=-1; 485| 4.02M| prevBlock=-1; 486| 4.02M| prev=start; 487| 4.02M| prevValue=0; 488| | 489| | /* enumerate index-2 blocks */ 490| 10.4M| for(c=start; c>UTRIE2_SHIFT_2; 499| 233k| } else if(U_IS_SURROGATE_LEAD(c)) { ------------------ | | 202| 15.7k|#define U_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | ------------------ | | | Branch (202:32): [True: 7.85k, False: 7.85k] | | ------------------ ------------------ 500| | /* 501| | * Enumerate values for lead surrogate code points, not code units: 502| | * This special block has half the normal length. 503| | */ 504| 7.85k| i2Block=UTRIE2_LSCP_INDEX_2_OFFSET; 505| 7.85k| tempLimit=MIN_VALUE(0xdc00, limit); ------------------ | | 421| 7.85k|#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) | | ------------------ | | | Branch (421:26): [True: 7.85k, False: 0] | | ------------------ ------------------ 506| 7.85k| } else { 507| | /* 508| | * Switch back to the normal part of the index-2 table. 509| | * Enumerate the second half of the surrogates block. 510| | */ 511| 7.85k| i2Block=0xd800>>UTRIE2_SHIFT_2; 512| 7.85k| tempLimit=MIN_VALUE(0xe000, limit); ------------------ | | 421| 7.85k|#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) | | ------------------ | | | Branch (421:26): [True: 7.85k, False: 0] | | ------------------ ------------------ 513| 7.85k| } 514| 6.18M| } else { 515| | /* supplementary code points */ 516| 6.18M| if(idx!=nullptr) { ------------------ | Branch (516:16): [True: 156k, False: 6.03M] ------------------ 517| 156k| i2Block=idx[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ 518| 156k| (c>>UTRIE2_SHIFT_1)]; 519| 6.03M| } else { 520| 6.03M| i2Block=trie->newTrie->index1[c>>UTRIE2_SHIFT_1]; 521| 6.03M| } 522| 6.18M| if(i2Block==prevI2Block && (c-prev)>=UTRIE2_CP_PER_INDEX_1_ENTRY) { ------------------ | Branch (522:16): [True: 2.15M, False: 4.03M] | Branch (522:40): [True: 2.15M, False: 1] ------------------ 523| | /* 524| | * The index-2 block is the same as the previous one, and filled with prevValue. 525| | * Only possible for supplementary code points because the linear-BMP index-2 526| | * table creates unique i2Block values. 527| | */ 528| 2.15M| c+=UTRIE2_CP_PER_INDEX_1_ENTRY; 529| 2.15M| continue; 530| 2.15M| } 531| 6.18M| } 532| 4.27M| prevI2Block=i2Block; 533| 4.27M| if(i2Block==index2NullOffset) { ------------------ | Branch (533:12): [True: 4.02M, False: 254k] ------------------ 534| | /* this is the null index-2 block */ 535| 4.02M| if(prevValue!=initialValue) { ------------------ | Branch (535:16): [True: 4.01M, False: 6.36k] ------------------ 536| 4.01M| if(prev>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 548| 254k| if((c>>UTRIE2_SHIFT_1)==(tempLimit>>UTRIE2_SHIFT_1)) { ------------------ | Branch (548:16): [True: 9.47k, False: 245k] ------------------ 549| 9.47k| i2Limit=(tempLimit>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 550| 245k| } else { 551| 245k| i2Limit=UTRIE2_INDEX_2_BLOCK_LENGTH; 552| 245k| } 553| 15.9M| for(; i2(idx[i2Block + i2]) << UTRIE2_INDEX_SHIFT; 556| 8.18M| } else { 557| 8.18M| block=trie->newTrie->index2[i2Block+i2]; 558| 8.18M| } 559| 15.6M| if(block==prevBlock && (c-prev)>=UTRIE2_DATA_BLOCK_LENGTH) { ------------------ | Branch (559:20): [True: 14.8M, False: 805k] | Branch (559:40): [True: 14.8M, False: 25] ------------------ 560| | /* the block is the same as the previous one, and filled with prevValue */ 561| 14.8M| c+=UTRIE2_DATA_BLOCK_LENGTH; 562| 14.8M| continue; 563| 14.8M| } 564| 805k| prevBlock=block; 565| 805k| if(block==nullBlock) { ------------------ | Branch (565:20): [True: 159k, False: 646k] ------------------ 566| | /* this is the null data block */ 567| 159k| if(prevValue!=initialValue) { ------------------ | Branch (567:24): [True: 10.3k, False: 149k] ------------------ 568| 10.3k| if(prevlimit) { ------------------ | Branch (592:8): [True: 4.01M, False: 9.36k] ------------------ 593| 4.01M| c=limit; /* could be higher if in the index2NullOffset */ 594| 4.01M| } else if(chighValueIndex] : 601| 3.84k| idx[trie->highValueIndex]; 602| 3.84k| } else { 603| 0| highValue=trie->newTrie->data[trie->newTrie->dataLength-UTRIE2_DATA_GRANULARITY]; 604| 0| } 605| 3.84k| value=enumValue(context, highValue); 606| 3.84k| if(value!=prevValue) { ------------------ | Branch (606:12): [True: 47, False: 3.79k] ------------------ 607| 47| if(previnitialValue=initialValue; 139| 11.6k| trie->errorValue=errorValue; 140| 11.6k| trie->highStart=0x110000; 141| 11.6k| trie->newTrie=newTrie; 142| |#ifdef UTRIE2_DEBUG 143| | trie->name="open"; 144| |#endif 145| | 146| 11.6k| newTrie->data=data; 147| |#ifdef UCPTRIE_DEBUG 148| | newTrie->t3=umutablecptrie_open(initialValue, errorValue, pErrorCode); 149| |#endif 150| 11.6k| newTrie->dataCapacity=UNEWTRIE2_INITIAL_DATA_LENGTH; ------------------ | | 107| 11.6k|#define UNEWTRIE2_INITIAL_DATA_LENGTH ((int32_t)1<<14) ------------------ 151| 11.6k| newTrie->initialValue=initialValue; 152| 11.6k| newTrie->errorValue=errorValue; 153| 11.6k| newTrie->highStart=0x110000; 154| 11.6k| newTrie->firstFreeBlock=0; /* no free block in the list */ 155| 11.6k| newTrie->isCompacted=false; 156| | 157| | /* 158| | * preallocate and reset 159| | * - ASCII 160| | * - the bad-UTF-8-data block 161| | * - the null data block 162| | */ 163| 1.50M| for(i=0; i<0x80; ++i) { ------------------ | Branch (163:14): [True: 1.49M, False: 11.6k] ------------------ 164| 1.49M| newTrie->data[i]=initialValue; 165| 1.49M| } 166| 756k| for(; i<0xc0; ++i) { ------------------ | Branch (166:11): [True: 745k, False: 11.6k] ------------------ 167| 745k| newTrie->data[i]=errorValue; 168| 745k| } 169| 756k| for(i=UNEWTRIE2_DATA_NULL_OFFSET; idata[i]=initialValue; 171| 745k| } 172| 11.6k| newTrie->dataNullOffset=UNEWTRIE2_DATA_NULL_OFFSET; 173| 11.6k| newTrie->dataLength=UNEWTRIE2_DATA_START_OFFSET; 174| | 175| | /* set the index-2 indexes for the 2=0x80>>UTRIE2_SHIFT_2 ASCII data blocks */ 176| 58.2k| for(i=0, j=0; j<0x80; ++i, j+=UTRIE2_DATA_BLOCK_LENGTH) { ------------------ | Branch (176:19): [True: 46.5k, False: 11.6k] ------------------ 177| 46.5k| newTrie->index2[i]=j; 178| 46.5k| newTrie->map[i]=1; 179| 46.5k| } 180| | /* reference counts for the bad-UTF-8-data block */ 181| 34.9k| for(; j<0xc0; ++i, j+=UTRIE2_DATA_BLOCK_LENGTH) { ------------------ | Branch (181:11): [True: 23.2k, False: 11.6k] ------------------ 182| 23.2k| newTrie->map[i]=0; 183| 23.2k| } 184| | /* 185| | * Reference counts for the null data block: all blocks except for the ASCII blocks. 186| | * Plus 1 so that we don't drop this block during compaction. 187| | * Plus as many as needed for lead surrogate code points. 188| | */ 189| | /* i==newTrie->dataNullOffset */ 190| 11.6k| newTrie->map[i++]= 191| 11.6k| (0x110000>>UTRIE2_SHIFT_2)- 192| 11.6k| (0x80>>UTRIE2_SHIFT_2)+ 193| 11.6k| 1+ 194| 11.6k| UTRIE2_LSCP_INDEX_2_LENGTH; 195| 11.6k| j+=UTRIE2_DATA_BLOCK_LENGTH; 196| 23.2k| for(; jmap[i]=0; 198| 11.6k| } 199| | 200| | /* 201| | * set the remaining indexes in the BMP index-2 block 202| | * to the null data block 203| | */ 204| 24.1M| for(i=0x80>>UTRIE2_SHIFT_2; iindex2[i]=UNEWTRIE2_DATA_NULL_OFFSET; 206| 24.1M| } 207| | 208| | /* 209| | * Fill the index gap with impossible values so that compaction 210| | * does not overlap other index-2 blocks with the gap. 211| | */ 212| 6.71M| for(i=0; iindex2[UNEWTRIE2_INDEX_GAP_OFFSET+i]=-1; 214| 6.70M| } 215| | 216| | /* set the indexes in the null index-2 block */ 217| 756k| for(i=0; iindex2[UNEWTRIE2_INDEX_2_NULL_OFFSET+i]=UNEWTRIE2_DATA_NULL_OFFSET; 219| 745k| } 220| 11.6k| newTrie->index2NullOffset=UNEWTRIE2_INDEX_2_NULL_OFFSET; 221| 11.6k| newTrie->index2Length=UNEWTRIE2_INDEX_2_START_OFFSET; 222| | 223| | /* set the index-1 indexes for the linear index-2 block */ 224| 11.6k| for(i=0, j=0; 225| 384k| iindex1[i]=j; 229| 372k| } 230| | 231| | /* set the remaining index-1 indexes to the null index-2 block */ 232| 5.97M| for(; iindex1[i]=UNEWTRIE2_INDEX_2_NULL_OFFSET; 234| 5.96M| } 235| | 236| | /* 237| | * Preallocate and reset data for U+0080..U+07ff, 238| | * for 2-byte UTF-8 which will be compacted in 64-blocks 239| | * even if UTRIE2_DATA_BLOCK_LENGTH is smaller. 240| | */ 241| 710k| for(i=0x80; i<0x800; i+=UTRIE2_DATA_BLOCK_LENGTH) { ------------------ | Branch (241:17): [True: 698k, False: 11.6k] ------------------ 242| 698k| utrie2_set32(trie, i, initialValue, pErrorCode); ------------------ | | 1975| 698k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 698k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 698k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 698k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 243| 698k| } 244| | 245| 11.6k| return trie; 246| 11.6k|} utrie2_set32_78: 678| 10.3M|utrie2_set32(UTrie2 *trie, UChar32 c, uint32_t value, UErrorCode *pErrorCode) { 679| 10.3M| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (679:8): [True: 0, False: 10.3M] ------------------ 680| 0| return; 681| 0| } 682| 10.3M| if((uint32_t)c>0x10ffff) { ------------------ | Branch (682:8): [True: 0, False: 10.3M] ------------------ 683| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 684| 0| return; 685| 0| } 686| 10.3M| set32(trie->newTrie, c, true, value, pErrorCode); 687| 10.3M|} utrie2_set32ForLeadSurrogateCodeUnit_78: 692| 4.02M| UErrorCode *pErrorCode) { 693| 4.02M| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (693:8): [True: 0, False: 4.02M] ------------------ 694| 0| return; 695| 0| } 696| 4.02M| if(!U_IS_LEAD(c)) { ------------------ | | 177| 4.02M|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) ------------------ | Branch (696:8): [True: 0, False: 4.02M] ------------------ 697| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 698| 0| return; 699| 0| } 700| 4.02M| set32(trie->newTrie, c, false, value, pErrorCode); 701| 4.02M|} utrie2_setRange32_78: 740| 1.70M| UErrorCode *pErrorCode) { 741| | /* 742| | * repeat value in [start..end] 743| | * mark index values for repeat-data blocks by setting bit 31 of the index values 744| | * fill around existing values if any, if(overwrite) 745| | */ 746| 1.70M| UNewTrie2 *newTrie; 747| 1.70M| int32_t block, rest, repeatBlock; 748| 1.70M| UChar32 limit; 749| | 750| 1.70M| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (750:8): [True: 0, False: 1.70M] ------------------ 751| 0| return; 752| 0| } 753| 1.70M| if((uint32_t)start>0x10ffff || (uint32_t)end>0x10ffff || start>end) { ------------------ | Branch (753:8): [True: 0, False: 1.70M] | Branch (753:36): [True: 0, False: 1.70M] | Branch (753:62): [True: 0, False: 1.70M] ------------------ 754| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 755| 0| return; 756| 0| } 757| 1.70M| newTrie=trie->newTrie; 758| 1.70M| if(newTrie==nullptr || newTrie->isCompacted) { ------------------ | Branch (758:8): [True: 0, False: 1.70M] | Branch (758:28): [True: 0, False: 1.70M] ------------------ 759| 0| *pErrorCode=U_NO_WRITE_PERMISSION; 760| 0| return; 761| 0| } 762| |#ifdef UCPTRIE_DEBUG 763| | umutablecptrie_setRange(newTrie->t3, start, end, value, pErrorCode); 764| |#endif 765| 1.70M| if(!overwrite && value==newTrie->initialValue) { ------------------ | Branch (765:8): [True: 0, False: 1.70M] | Branch (765:22): [True: 0, False: 0] ------------------ 766| 0| return; /* nothing to do */ 767| 0| } 768| | 769| 1.70M| limit=end+1; 770| 1.70M| if(start&UTRIE2_DATA_MASK) { ------------------ | Branch (770:8): [True: 1.62M, False: 85.4k] ------------------ 771| 1.62M| UChar32 nextStart; 772| | 773| | /* set partial block at [start..following block boundary[ */ 774| 1.62M| block=getDataBlock(newTrie, start, true); 775| 1.62M| if(block<0) { ------------------ | Branch (775:12): [True: 0, False: 1.62M] ------------------ 776| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 777| 0| return; 778| 0| } 779| | 780| 1.62M| nextStart=(start+UTRIE2_DATA_MASK)&~UTRIE2_DATA_MASK; 781| 1.62M| if(nextStart<=limit) { ------------------ | Branch (781:12): [True: 111k, False: 1.51M] ------------------ 782| 111k| fillBlock(newTrie->data+block, start&UTRIE2_DATA_MASK, UTRIE2_DATA_BLOCK_LENGTH, 783| 111k| value, newTrie->initialValue, overwrite); 784| 111k| start=nextStart; 785| 1.51M| } else { 786| 1.51M| fillBlock(newTrie->data+block, start&UTRIE2_DATA_MASK, limit&UTRIE2_DATA_MASK, 787| 1.51M| value, newTrie->initialValue, overwrite); 788| 1.51M| return; 789| 1.51M| } 790| 1.62M| } 791| | 792| | /* number of positions in the last, partial block */ 793| 196k| rest=limit&UTRIE2_DATA_MASK; 794| | 795| | /* round down limit to a block boundary */ 796| 196k| limit&=~UTRIE2_DATA_MASK; 797| | 798| | /* iterate over all-value blocks */ 799| 196k| if(value==newTrie->initialValue) { ------------------ | Branch (799:8): [True: 3.83k, False: 193k] ------------------ 800| 3.83k| repeatBlock=newTrie->dataNullOffset; 801| 193k| } else { 802| 193k| repeatBlock=-1; 803| 193k| } 804| | 805| 125M| while(startinitialValue && isInNullBlock(newTrie, start, true)) { ------------------ | Branch (809:12): [True: 118M, False: 6.76M] | Branch (809:44): [True: 118M, False: 0] ------------------ 810| 118M| start+=UTRIE2_DATA_BLOCK_LENGTH; /* nothing to do */ 811| 118M| continue; 812| 118M| } 813| | 814| | /* get index value */ 815| 6.76M| i2=getIndex2Block(newTrie, start, true); 816| 6.76M| if(i2<0) { ------------------ | Branch (816:12): [True: 0, False: 6.76M] ------------------ 817| 0| *pErrorCode=U_INTERNAL_PROGRAM_ERROR; 818| 0| return; 819| 0| } 820| 6.76M| i2+=(start>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 821| 6.76M| block=newTrie->index2[i2]; 822| 6.76M| if(isWritableBlock(newTrie, block)) { ------------------ | Branch (822:12): [True: 3.97k, False: 6.76M] ------------------ 823| | /* already allocated */ 824| 3.97k| if(overwrite && block>=UNEWTRIE2_DATA_0800_OFFSET) { ------------------ | Branch (824:16): [True: 3.97k, False: 0] | Branch (824:29): [True: 3.71k, False: 261] ------------------ 825| | /* 826| | * We overwrite all values, and it's not a 827| | * protected (ASCII-linear or 2-byte UTF-8) block: 828| | * replace with the repeatBlock. 829| | */ 830| 3.71k| setRepeatBlock=true; 831| 3.71k| } else { 832| | /* !overwrite, or protected block: just write the values into this block */ 833| 261| fillBlock(newTrie->data+block, 834| 261| 0, UTRIE2_DATA_BLOCK_LENGTH, 835| 261| value, newTrie->initialValue, overwrite); 836| 261| } 837| 6.76M| } else if(newTrie->data[block]!=value && (overwrite || block==newTrie->dataNullOffset)) { ------------------ | Branch (837:19): [True: 5.36M, False: 1.40M] | Branch (837:51): [True: 5.36M, False: 0] | Branch (837:64): [True: 0, False: 0] ------------------ 838| | /* 839| | * Set the repeatBlock instead of the null block or previous repeat block: 840| | * 841| | * If !isWritableBlock() then all entries in the block have the same value 842| | * because it's the null block or a range block (the repeatBlock from a previous 843| | * call to utrie2_setRange32()). 844| | * No other blocks are used multiple times before compacting. 845| | * 846| | * The null block is the only non-writable block with the initialValue because 847| | * of the repeatBlock initialization above. (If value==initialValue, then 848| | * the repeatBlock will be the null data block.) 849| | * 850| | * We set our repeatBlock if the desired value differs from the block's value, 851| | * and if we overwrite any data or if the data is all initial values 852| | * (which is the same as the block being the null block, see above). 853| | */ 854| 5.36M| setRepeatBlock=true; 855| 5.36M| } 856| 6.76M| if(setRepeatBlock) { ------------------ | Branch (856:12): [True: 5.36M, False: 1.40M] ------------------ 857| 5.36M| if(repeatBlock>=0) { ------------------ | Branch (857:16): [True: 5.28M, False: 84.7k] ------------------ 858| 5.28M| setIndex2Entry(newTrie, i2, repeatBlock); 859| 5.28M| } else { 860| | /* create and set and fill the repeatBlock */ 861| 84.7k| repeatBlock=getDataBlock(newTrie, start, true); 862| 84.7k| if(repeatBlock<0) { ------------------ | Branch (862:20): [True: 0, False: 84.7k] ------------------ 863| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 864| 0| return; 865| 0| } 866| 84.7k| writeBlock(newTrie->data+repeatBlock, value); 867| 84.7k| } 868| 5.36M| } 869| | 870| 6.76M| start+=UTRIE2_DATA_BLOCK_LENGTH; 871| 6.76M| } 872| | 873| 196k| if(rest>0) { ------------------ | Branch (873:8): [True: 137k, False: 59.2k] ------------------ 874| | /* set partial block at [last block boundary..limit[ */ 875| 137k| block=getDataBlock(newTrie, start, true); 876| 137k| if(block<0) { ------------------ | Branch (876:12): [True: 0, False: 137k] ------------------ 877| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 878| 0| return; 879| 0| } 880| | 881| 137k| fillBlock(newTrie->data+block, 0, rest, value, newTrie->initialValue, overwrite); 882| 137k| } 883| 196k|} utrie2_freeze_78: 1304| 3.92k|utrie2_freeze(UTrie2 *trie, UTrie2ValueBits valueBits, UErrorCode *pErrorCode) { 1305| 3.92k| UNewTrie2 *newTrie; 1306| 3.92k| UTrie2Header *header; 1307| 3.92k| uint32_t *p; 1308| 3.92k| uint16_t *dest16; 1309| 3.92k| int32_t i, length; 1310| 3.92k| int32_t allIndexesLength; 1311| 3.92k| int32_t dataMove; /* >0 if the data is moved to the end of the index array */ 1312| 3.92k| UChar32 highStart; 1313| | 1314| | /* argument check */ 1315| 3.92k| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (1315:8): [True: 0, False: 3.92k] ------------------ 1316| 0| return; 1317| 0| } 1318| 3.92k| if( trie==nullptr || ------------------ | Branch (1318:9): [True: 0, False: 3.92k] ------------------ 1319| 3.92k| valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits ------------------ | Branch (1319:9): [True: 0, False: 3.92k] | Branch (1319:24): [True: 0, False: 3.92k] ------------------ 1320| 3.92k| ) { 1321| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1322| 0| return; 1323| 0| } 1324| 3.92k| newTrie=trie->newTrie; 1325| 3.92k| if(newTrie==nullptr) { ------------------ | Branch (1325:8): [True: 0, False: 3.92k] ------------------ 1326| | /* already frozen */ 1327| 0| UTrie2ValueBits frozenValueBits= 1328| 0| trie->data16!=nullptr ? UTRIE2_16_VALUE_BITS : UTRIE2_32_VALUE_BITS; ------------------ | Branch (1328:13): [True: 0, False: 0] ------------------ 1329| 0| if(valueBits!=frozenValueBits) { ------------------ | Branch (1329:12): [True: 0, False: 0] ------------------ 1330| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1331| 0| } 1332| 0| return; 1333| 0| } 1334| | 1335| | /* compact if necessary */ 1336| 3.92k| if(!newTrie->isCompacted) { ------------------ | Branch (1336:8): [True: 3.92k, False: 0] ------------------ 1337| 3.92k| compactTrie(trie, pErrorCode); 1338| 3.92k| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (1338:12): [True: 0, False: 3.92k] ------------------ 1339| 0| return; 1340| 0| } 1341| 3.92k| } 1342| 3.92k| highStart=trie->highStart; 1343| | 1344| 3.92k| if(highStart<=0x10000) { ------------------ | Branch (1344:8): [True: 3.12k, False: 803] ------------------ 1345| 3.12k| allIndexesLength=UTRIE2_INDEX_1_OFFSET; 1346| 3.12k| } else { 1347| 803| allIndexesLength=newTrie->index2Length; 1348| 803| } 1349| 3.92k| if(valueBits==UTRIE2_16_VALUE_BITS) { ------------------ | Branch (1349:8): [True: 0, False: 3.92k] ------------------ 1350| 0| dataMove=allIndexesLength; 1351| 3.92k| } else { 1352| 3.92k| dataMove=0; 1353| 3.92k| } 1354| | 1355| | /* are indexLength and dataLength within limits? */ 1356| 3.92k| if( /* for unshifted indexLength */ 1357| 3.92k| allIndexesLength>UTRIE2_MAX_INDEX_LENGTH || ------------------ | | 1293| 7.85k|#define UTRIE2_MAX_INDEX_LENGTH 0xffff ------------------ | Branch (1357:9): [True: 0, False: 3.92k] ------------------ 1358| | /* for unshifted dataNullOffset */ 1359| 3.92k| (dataMove+newTrie->dataNullOffset)>0xffff || ------------------ | Branch (1359:9): [True: 0, False: 3.92k] ------------------ 1360| | /* for unshifted 2-byte UTF-8 index-2 values */ 1361| 3.92k| (dataMove+UNEWTRIE2_DATA_0800_OFFSET)>0xffff || ------------------ | Branch (1361:9): [True: 0, False: 3.92k] ------------------ 1362| | /* for shiftedDataLength */ 1363| 3.92k| (dataMove+newTrie->dataLength)>UTRIE2_MAX_DATA_LENGTH ------------------ | | 1300| 3.92k|#define UTRIE2_MAX_DATA_LENGTH (0xffff<dataLength*2; 1373| 3.92k| } else { 1374| 3.92k| length+=newTrie->dataLength*4; 1375| 3.92k| } 1376| | 1377| 3.92k| trie->memory=uprv_malloc(length); ------------------ | | 1524| 3.92k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1378| 3.92k| if(trie->memory==nullptr) { ------------------ | Branch (1378:8): [True: 0, False: 3.92k] ------------------ 1379| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 1380| 0| return; 1381| 0| } 1382| 3.92k| trie->length=length; 1383| 3.92k| trie->isMemoryOwned=true; 1384| | 1385| 3.92k| trie->indexLength=allIndexesLength; 1386| 3.92k| trie->dataLength=newTrie->dataLength; 1387| 3.92k| if(highStart<=0x10000) { ------------------ | Branch (1387:8): [True: 3.12k, False: 803] ------------------ 1388| 3.12k| trie->index2NullOffset=0xffff; 1389| 3.12k| } else { 1390| 803| trie->index2NullOffset=static_cast(UTRIE2_INDEX_2_OFFSET+newTrie->index2NullOffset); 1391| 803| } 1392| 3.92k| trie->dataNullOffset=(uint16_t)(dataMove+newTrie->dataNullOffset); 1393| 3.92k| trie->highValueIndex=dataMove+trie->dataLength-UTRIE2_DATA_GRANULARITY; 1394| | 1395| | /* set the header fields */ 1396| 3.92k| header=(UTrie2Header *)trie->memory; 1397| | 1398| 3.92k| header->signature=UTRIE2_SIG; /* "Tri2" */ ------------------ | | 39| 3.92k|#define UTRIE2_SIG 0x54726932 ------------------ 1399| 3.92k| header->options=(uint16_t)valueBits; 1400| | 1401| 3.92k| header->indexLength=(uint16_t)trie->indexLength; 1402| 3.92k| header->shiftedDataLength=(uint16_t)(trie->dataLength>>UTRIE2_INDEX_SHIFT); 1403| 3.92k| header->index2NullOffset=trie->index2NullOffset; 1404| 3.92k| header->dataNullOffset=trie->dataNullOffset; 1405| 3.92k| header->shiftedHighStart=(uint16_t)(highStart>>UTRIE2_SHIFT_1); 1406| | 1407| | /* fill the index and data arrays */ 1408| 3.92k| dest16=(uint16_t *)(header+1); 1409| 3.92k| trie->index=dest16; 1410| | 1411| | /* write the index-2 array values shifted right by UTRIE2_INDEX_SHIFT, after adding dataMove */ 1412| 3.92k| p=(uint32_t *)newTrie->index2; 1413| 8.17M| for(i=UTRIE2_INDEX_2_BMP_LENGTH; i>0; --i) { ------------------ | Branch (1413:38): [True: 8.16M, False: 3.92k] ------------------ 1414| 8.16M| *dest16++=(uint16_t)((dataMove + *p++)>>UTRIE2_INDEX_SHIFT); 1415| 8.16M| } 1416| | 1417| | /* write UTF-8 2-byte index-2 values, not right-shifted */ 1418| 11.7k| for(i=0; i<(0xc2-0xc0); ++i) { /* C0..C1 */ ------------------ | Branch (1418:14): [True: 7.85k, False: 3.92k] ------------------ 1419| 7.85k| *dest16++=(uint16_t)(dataMove+UTRIE2_BAD_UTF8_DATA_OFFSET); 1420| 7.85k| } 1421| 121k| for(; i<(0xe0-0xc0); ++i) { /* C2..DF */ ------------------ | Branch (1421:11): [True: 117k, False: 3.92k] ------------------ 1422| 117k| *dest16++=(uint16_t)(dataMove+newTrie->index2[i<<(6-UTRIE2_SHIFT_2)]); 1423| 117k| } 1424| | 1425| 3.92k| if(highStart>0x10000) { ------------------ | Branch (1425:8): [True: 803, False: 3.12k] ------------------ 1426| 803| int32_t index1Length=(highStart-0x10000)>>UTRIE2_SHIFT_1; 1427| 803| int32_t index2Offset=UTRIE2_INDEX_2_BMP_LENGTH+UTRIE2_UTF8_2B_INDEX_2_LENGTH+index1Length; 1428| | 1429| | /* write 16-bit index-1 values for supplementary code points */ 1430| 803| p=(uint32_t *)newTrie->index1+UTRIE2_OMITTED_BMP_INDEX_1_LENGTH; 1431| 156k| for(i=index1Length; i>0; --i) { ------------------ | Branch (1431:29): [True: 155k, False: 803] ------------------ 1432| 155k| *dest16++=(uint16_t)(UTRIE2_INDEX_2_OFFSET + *p++); 1433| 155k| } 1434| | 1435| | /* 1436| | * write the index-2 array values for supplementary code points, 1437| | * shifted right by UTRIE2_INDEX_SHIFT, after adding dataMove 1438| | */ 1439| 803| p=(uint32_t *)newTrie->index2+index2Offset; 1440| 89.2k| for(i=newTrie->index2Length-index2Offset; i>0; --i) { ------------------ | Branch (1440:51): [True: 88.4k, False: 803] ------------------ 1441| 88.4k| *dest16++=(uint16_t)((dataMove + *p++)>>UTRIE2_INDEX_SHIFT); 1442| 88.4k| } 1443| 803| } 1444| | 1445| | /* write the 16/32-bit data array */ 1446| 3.92k| switch(valueBits) { 1447| 0| case UTRIE2_16_VALUE_BITS: ------------------ | Branch (1447:5): [True: 0, False: 3.92k] ------------------ 1448| | /* write 16-bit data values */ 1449| 0| trie->data16=dest16; 1450| 0| trie->data32=nullptr; 1451| 0| p=newTrie->data; 1452| 0| for(i=newTrie->dataLength; i>0; --i) { ------------------ | Branch (1452:36): [True: 0, False: 0] ------------------ 1453| 0| *dest16++=(uint16_t)*p++; 1454| 0| } 1455| 0| break; 1456| 3.92k| case UTRIE2_32_VALUE_BITS: ------------------ | Branch (1456:5): [True: 3.92k, False: 0] ------------------ 1457| | /* write 32-bit data values */ 1458| 3.92k| trie->data16=nullptr; 1459| 3.92k| trie->data32=(uint32_t *)dest16; 1460| 3.92k| uprv_memcpy(dest16, newTrie->data, (size_t)newTrie->dataLength*4); ------------------ | | 42| 3.92k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.92k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.92k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.92k| _Pragma("clang diagnostic push") \ | | 45| 3.92k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.92k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.92k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.92k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.92k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.92k| _Pragma("clang diagnostic pop") \ | | 49| 3.92k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.92k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.92k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.92k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1461| 3.92k| break; 1462| 0| default: ------------------ | Branch (1462:5): [True: 0, False: 3.92k] ------------------ 1463| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1464| 0| return; 1465| 3.92k| } 1466| | 1467| |#ifdef UTRIE2_DEBUG 1468| | utrie2_printLengths(trie, ""); 1469| |#endif 1470| | 1471| |#ifdef UCPTRIE_DEBUG 1472| | umutablecptrie_setName(newTrie->t3, trie->name); 1473| | ucptrie_close( 1474| | umutablecptrie_buildImmutable( 1475| | newTrie->t3, UCPTRIE_TYPE_FAST, (UCPTrieValueWidth)valueBits, pErrorCode)); 1476| |#endif 1477| | /* Delete the UNewTrie2. */ 1478| 3.92k| uprv_free(newTrie->data); ------------------ | | 1503| 3.92k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1479| 3.92k| uprv_free(newTrie); ------------------ | | 1503| 3.92k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1480| 3.92k| trie->newTrie=nullptr; 1481| 3.92k|} utrie2_builder.cpp:_ZL5set32P9UNewTrie2iajP10UErrorCode: 657| 14.4M| UErrorCode *pErrorCode) { 658| 14.4M| int32_t block; 659| | 660| 14.4M| if(trie==nullptr || trie->isCompacted) { ------------------ | Branch (660:8): [True: 0, False: 14.4M] | Branch (660:25): [True: 0, False: 14.4M] ------------------ 661| 0| *pErrorCode=U_NO_WRITE_PERMISSION; 662| 0| return; 663| 0| } 664| |#ifdef UCPTRIE_DEBUG 665| | umutablecptrie_set(trie->t3, c, value, pErrorCode); 666| |#endif 667| | 668| 14.4M| block=getDataBlock(trie, c, forLSCP); 669| 14.4M| if(block<0) { ------------------ | Branch (669:8): [True: 0, False: 14.4M] ------------------ 670| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 671| 0| return; 672| 0| } 673| | 674| 14.4M| trie->data[block+(c&UTRIE2_DATA_MASK)]=value; 675| 14.4M|} utrie2_builder.cpp:_ZL12getDataBlockP9UNewTrie2ia: 627| 16.2M|getDataBlock(UNewTrie2 *trie, UChar32 c, UBool forLSCP) { 628| 16.2M| int32_t i2, oldBlock, newBlock; 629| | 630| 16.2M| i2=getIndex2Block(trie, c, forLSCP); 631| 16.2M| if(i2<0) { ------------------ | Branch (631:8): [True: 0, False: 16.2M] ------------------ 632| 0| return -1; /* program error */ 633| 0| } 634| | 635| 16.2M| i2+=(c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 636| 16.2M| oldBlock=trie->index2[i2]; 637| 16.2M| if(isWritableBlock(trie, oldBlock)) { ------------------ | Branch (637:8): [True: 14.9M, False: 1.25M] ------------------ 638| 14.9M| return oldBlock; 639| 14.9M| } 640| | 641| | /* allocate a new data block */ 642| 1.25M| newBlock=allocDataBlock(trie, oldBlock); 643| 1.25M| if(newBlock<0) { ------------------ | Branch (643:8): [True: 0, False: 1.25M] ------------------ 644| | /* out of memory in the data array */ 645| 0| return -1; 646| 0| } 647| 1.25M| setIndex2Entry(trie, i2, newBlock); 648| 1.25M| return newBlock; 649| 1.25M|} utrie2_builder.cpp:_ZL14allocDataBlockP9UNewTrie2i: 552| 1.25M|allocDataBlock(UNewTrie2 *trie, int32_t copyBlock) { 553| 1.25M| int32_t newBlock, newTop; 554| | 555| 1.25M| if(trie->firstFreeBlock!=0) { ------------------ | Branch (555:8): [True: 3.71k, False: 1.25M] ------------------ 556| | /* get the first free block */ 557| 3.71k| newBlock=trie->firstFreeBlock; 558| 3.71k| trie->firstFreeBlock=-trie->map[newBlock>>UTRIE2_SHIFT_2]; 559| 1.25M| } else { 560| | /* get a new block from the high end */ 561| 1.25M| newBlock=trie->dataLength; 562| 1.25M| newTop=newBlock+UTRIE2_DATA_BLOCK_LENGTH; 563| 1.25M| if(newTop>trie->dataCapacity) { ------------------ | Branch (563:12): [True: 185, False: 1.25M] ------------------ 564| | /* out of memory in the data array */ 565| 185| int32_t capacity; 566| 185| uint32_t *data; 567| | 568| 185| if(trie->dataCapacitydataCapacity(uprv_malloc(capacity * 4)); ------------------ | | 1524| 185|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 185|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 185|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 185|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 581| 185| if(data==nullptr) { ------------------ | Branch (581:16): [True: 0, False: 185] ------------------ 582| 0| return -1; 583| 0| } 584| 185| uprv_memcpy(data, trie->data, (size_t)trie->dataLength*4); ------------------ | | 42| 185|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 185|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 185| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 185| _Pragma("clang diagnostic push") \ | | 45| 185| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 185| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 185|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 185| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 185|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 185| _Pragma("clang diagnostic pop") \ | | 49| 185| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 185|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 185|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 185|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 585| 185| uprv_free(trie->data); ------------------ | | 1503| 185|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 185|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 185|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 185|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 586| 185| trie->data=data; 587| 185| trie->dataCapacity=capacity; 588| 185| } 589| 1.25M| trie->dataLength=newTop; 590| 1.25M| } 591| 1.25M| uprv_memcpy(trie->data+newBlock, trie->data+copyBlock, UTRIE2_DATA_BLOCK_LENGTH*4); ------------------ | | 42| 1.25M|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.25M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.25M| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.25M| _Pragma("clang diagnostic push") \ | | 45| 1.25M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.25M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.25M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.25M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.25M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.25M| _Pragma("clang diagnostic pop") \ | | 49| 1.25M| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.25M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.25M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.25M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 592| 1.25M| trie->map[newBlock>>UTRIE2_SHIFT_2]=0; 593| 1.25M| return newBlock; 594| 1.25M|} utrie2_builder.cpp:_ZL9fillBlockPjiijja: 717| 1.75M| uint32_t value, uint32_t initialValue, UBool overwrite) { 718| 1.75M| uint32_t *pLimit; 719| | 720| 1.75M| pLimit=block+limit; 721| 1.75M| block+=start; 722| 1.75M| if(overwrite) { ------------------ | Branch (722:8): [True: 1.75M, False: 0] ------------------ 723| 5.51M| while(block>UTRIE2_SHIFT_2))+ 503| 0| (c>>UTRIE2_SHIFT_2); 504| 118M| } else { 505| 118M| i2=trie->index1[c>>UTRIE2_SHIFT_1]+ 506| 118M| ((c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK); 507| 118M| } 508| 118M| block=trie->index2[i2]; 509| 118M| return block == trie->dataNullOffset; 510| 118M|} utrie2_builder.cpp:_ZL14getIndex2BlockP9UNewTrie2ia: 532| 23.0M|getIndex2Block(UNewTrie2 *trie, UChar32 c, UBool forLSCP) { 533| 23.0M| int32_t i1, i2; 534| | 535| 23.0M| if(U_IS_LEAD(c) && forLSCP) { ------------------ | | 177| 46.0M|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 4.02M, False: 18.9M] | | ------------------ ------------------ | Branch (535:24): [True: 8.58k, False: 4.02M] ------------------ 536| 8.58k| return UTRIE2_LSCP_INDEX_2_OFFSET; 537| 8.58k| } 538| | 539| 23.0M| i1=c>>UTRIE2_SHIFT_1; 540| 23.0M| i2=trie->index1[i1]; 541| 23.0M| if(i2==trie->index2NullOffset) { ------------------ | Branch (541:8): [True: 3.46k, False: 23.0M] ------------------ 542| 3.46k| i2=allocIndex2Block(trie); 543| 3.46k| if(i2<0) { ------------------ | Branch (543:12): [True: 0, False: 3.46k] ------------------ 544| 0| return -1; /* program error */ 545| 0| } 546| 3.46k| trie->index1[i1]=i2; 547| 3.46k| } 548| 23.0M| return i2; 549| 23.0M|} utrie2_builder.cpp:_ZL16allocIndex2BlockP9UNewTrie2: 513| 3.46k|allocIndex2Block(UNewTrie2 *trie) { 514| 3.46k| int32_t newBlock, newTop; 515| | 516| 3.46k| newBlock=trie->index2Length; 517| 3.46k| newTop=newBlock+UTRIE2_INDEX_2_BLOCK_LENGTH; 518| 3.46k| if(newTop>UPRV_LENGTHOF(trie->index2)) { ------------------ | | 99| 3.46k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (518:8): [True: 0, False: 3.46k] ------------------ 519| | /* 520| | * Should never occur. 521| | * Either UTRIE2_MAX_BUILD_TIME_INDEX_LENGTH is incorrect, 522| | * or the code writes more values than should be possible. 523| | */ 524| 0| return -1; 525| 0| } 526| 3.46k| trie->index2Length=newTop; 527| 3.46k| uprv_memcpy(trie->index2+newBlock, trie->index2+trie->index2NullOffset, UTRIE2_INDEX_2_BLOCK_LENGTH*4); ------------------ | | 42| 3.46k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.46k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.46k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.46k| _Pragma("clang diagnostic push") \ | | 45| 3.46k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.46k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.46k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.46k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.46k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.46k| _Pragma("clang diagnostic pop") \ | | 49| 3.46k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.46k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.46k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.46k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 528| 3.46k| return newBlock; 529| 3.46k|} utrie2_builder.cpp:_ZL15isWritableBlockP9UNewTrie2i: 605| 23.0M|isWritableBlock(UNewTrie2 *trie, int32_t block) { 606| 23.0M| return block != trie->dataNullOffset && 1 == trie->map[block >> UTRIE2_SHIFT_2]; ------------------ | Branch (606:12): [True: 17.8M, False: 5.21M] | Branch (606:45): [True: 14.9M, False: 2.81M] ------------------ 607| 23.0M|} utrie2_builder.cpp:_ZL14setIndex2EntryP9UNewTrie2ii: 610| 6.54M|setIndex2Entry(UNewTrie2 *trie, int32_t i2, int32_t block) { 611| 6.54M| int32_t oldBlock; 612| 6.54M| ++trie->map[block>>UTRIE2_SHIFT_2]; /* increment first, in case block==oldBlock! */ 613| 6.54M| oldBlock=trie->index2[i2]; 614| 6.54M| if(0 == --trie->map[oldBlock>>UTRIE2_SHIFT_2]) { ------------------ | Branch (614:8): [True: 3.71k, False: 6.53M] ------------------ 615| 3.71k| releaseDataBlock(trie, oldBlock); 616| 3.71k| } 617| 6.54M| trie->index2[i2]=block; 618| 6.54M|} utrie2_builder.cpp:_ZL16releaseDataBlockP9UNewTrie2i: 598| 3.71k|releaseDataBlock(UNewTrie2 *trie, int32_t block) { 599| | /* put this block at the front of the free-block chain */ 600| 3.71k| trie->map[block>>UTRIE2_SHIFT_2]=-trie->firstFreeBlock; 601| 3.71k| trie->firstFreeBlock=block; 602| 3.71k|} utrie2_builder.cpp:_ZL10writeBlockPjj: 704| 84.7k|writeBlock(uint32_t *block, uint32_t value) { 705| 84.7k| uint32_t *limit=block+UTRIE2_DATA_BLOCK_LENGTH; 706| 2.79M| while(blocknewTrie; 1233| | 1234| | /* find highStart and round it up */ 1235| 3.92k| highValue=utrie2_get32(trie, 0x10ffff); ------------------ | | 1966| 3.92k|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1236| 3.92k| highStart=findHighStart(newTrie, highValue); 1237| 3.92k| highStart=(highStart+(UTRIE2_CP_PER_INDEX_1_ENTRY-1))&~(UTRIE2_CP_PER_INDEX_1_ENTRY-1); 1238| 3.92k| if(highStart==0x110000) { ------------------ | Branch (1238:8): [True: 88, False: 3.83k] ------------------ 1239| 88| highValue=trie->errorValue; 1240| 88| } 1241| | 1242| | /* 1243| | * Set trie->highStart only after utrie2_get32(trie, highStart). 1244| | * Otherwise utrie2_get32(trie, highStart) would try to read the highValue. 1245| | */ 1246| 3.92k| trie->highStart=newTrie->highStart=highStart; 1247| | 1248| |#ifdef UTRIE2_DEBUG 1249| | printf("UTrie2: highStart U+%06lx highValue 0x%lx initialValue 0x%lx\n", 1250| | (long)highStart, (long)highValue, (long)trie->initialValue); 1251| |#endif 1252| | 1253| 3.92k| if(highStart<0x110000) { ------------------ | Branch (1253:8): [True: 3.83k, False: 88] ------------------ 1254| | /* Blank out [highStart..10ffff] to release associated data blocks. */ 1255| 3.83k| suppHighStart= highStart<=0x10000 ? 0x10000 : highStart; ------------------ | Branch (1255:24): [True: 3.12k, False: 715] ------------------ 1256| 3.83k| utrie2_setRange32(trie, suppHighStart, 0x10ffff, trie->initialValue, true, pErrorCode); ------------------ | | 1977| 3.83k|#define utrie2_setRange32 U_ICU_ENTRY_POINT_RENAME(utrie2_setRange32) | | ------------------ | | | | 123| 3.83k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.83k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.83k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1257| 3.83k| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (1257:12): [True: 0, False: 3.83k] ------------------ 1258| 0| return; 1259| 0| } 1260| 3.83k| } 1261| | 1262| 3.92k| compactData(newTrie); 1263| 3.92k| if(highStart>0x10000) { ------------------ | Branch (1263:8): [True: 803, False: 3.12k] ------------------ 1264| 803| compactIndex2(newTrie); 1265| |#ifdef UTRIE2_DEBUG 1266| | } else { 1267| | printf("UTrie2: highStart U+%04lx count of 16-bit index words %lu->%lu\n", 1268| | (long)highStart, (long)trie->newTrie->index2Length, (long)UTRIE2_INDEX_1_OFFSET); 1269| |#endif 1270| 803| } 1271| | 1272| | /* 1273| | * Store the highValue in the data array and round up the dataLength. 1274| | * Must be done after compactData() because that assumes that dataLength 1275| | * is a multiple of UTRIE2_DATA_BLOCK_LENGTH. 1276| | */ 1277| 3.92k| newTrie->data[newTrie->dataLength++]=highValue; 1278| 15.7k| while((newTrie->dataLength&(UTRIE2_DATA_GRANULARITY-1))!=0) { ------------------ | Branch (1278:11): [True: 11.7k, False: 3.92k] ------------------ 1279| 11.7k| newTrie->data[newTrie->dataLength++]=trie->initialValue; 1280| 11.7k| } 1281| | 1282| 3.92k| newTrie->isCompacted=true; 1283| 3.92k|} utrie2_builder.cpp:_ZL13findHighStartP9UNewTrie2j: 942| 3.92k|findHighStart(UNewTrie2 *trie, uint32_t highValue) { 943| 3.92k| const uint32_t *data32; 944| | 945| 3.92k| uint32_t value, initialValue; 946| 3.92k| UChar32 c, prev; 947| 3.92k| int32_t i1, i2, j, i2Block, prevI2Block, index2NullOffset, block, prevBlock, nullBlock; 948| | 949| 3.92k| data32=trie->data; 950| 3.92k| initialValue=trie->initialValue; 951| | 952| 3.92k| index2NullOffset=trie->index2NullOffset; 953| 3.92k| nullBlock=trie->dataNullOffset; 954| | 955| | /* set variables for previous range */ 956| 3.92k| if(highValue==initialValue) { ------------------ | Branch (956:8): [True: 3.90k, False: 26] ------------------ 957| 3.90k| prevI2Block=index2NullOffset; 958| 3.90k| prevBlock=nullBlock; 959| 3.90k| } else { 960| 26| prevI2Block=-1; 961| 26| prevBlock=-1; 962| 26| } 963| 3.92k| prev=0x110000; 964| | 965| | /* enumerate index-2 blocks */ 966| 3.92k| i1=UNEWTRIE2_INDEX_1_LENGTH; 967| 3.92k| c=prev; 968| 1.86M| while(c>0) { ------------------ | Branch (968:11): [True: 1.86M, False: 0] ------------------ 969| 1.86M| i2Block=trie->index1[--i1]; 970| 1.86M| if(i2Block==prevI2Block) { ------------------ | Branch (970:12): [True: 1.85M, False: 13.9k] ------------------ 971| | /* the index-2 block is the same as the previous one, and filled with highValue */ 972| 1.85M| c-=UTRIE2_CP_PER_INDEX_1_ENTRY; 973| 1.85M| continue; 974| 1.85M| } 975| 13.9k| prevI2Block=i2Block; 976| 13.9k| if(i2Block==index2NullOffset) { ------------------ | Branch (976:12): [True: 0, False: 13.9k] ------------------ 977| | /* this is the null index-2 block */ 978| 0| if(highValue!=initialValue) { ------------------ | Branch (978:16): [True: 0, False: 0] ------------------ 979| 0| return c; 980| 0| } 981| 0| c-=UTRIE2_CP_PER_INDEX_1_ENTRY; 982| 13.9k| } else { 983| | /* enumerate data blocks for one index-2 block */ 984| 774k| for(i2=UTRIE2_INDEX_2_BLOCK_LENGTH; i2>0;) { ------------------ | Branch (984:49): [True: 764k, False: 10.0k] ------------------ 985| 764k| block=trie->index2[i2Block+ --i2]; 986| 764k| if(block==prevBlock) { ------------------ | Branch (986:20): [True: 760k, False: 3.92k] ------------------ 987| | /* the block is the same as the previous one, and filled with highValue */ 988| 760k| c-=UTRIE2_DATA_BLOCK_LENGTH; 989| 760k| continue; 990| 760k| } 991| 3.92k| prevBlock=block; 992| 3.92k| if(block==nullBlock) { ------------------ | Branch (992:20): [True: 0, False: 3.92k] ------------------ 993| | /* this is the null data block */ 994| 0| if(highValue!=initialValue) { ------------------ | Branch (994:24): [True: 0, False: 0] ------------------ 995| 0| return c; 996| 0| } 997| 0| c-=UTRIE2_DATA_BLOCK_LENGTH; 998| 3.92k| } else { 999| 24.8k| for(j=UTRIE2_DATA_BLOCK_LENGTH; j>0;) { ------------------ | Branch (999:53): [True: 24.8k, False: 0] ------------------ 1000| 24.8k| value=data32[block+ --j]; 1001| 24.8k| if(value!=highValue) { ------------------ | Branch (1001:28): [True: 3.92k, False: 20.9k] ------------------ 1002| 3.92k| return c; 1003| 3.92k| } 1004| 20.9k| --c; 1005| 20.9k| } 1006| 3.92k| } 1007| 3.92k| } 1008| 13.9k| } 1009| 13.9k| } 1010| | 1011| | /* deliver last range */ 1012| 0| return 0; 1013| 3.92k|} utrie2_builder.cpp:_ZL11compactDataP9UNewTrie2: 1028| 3.92k|compactData(UNewTrie2 *trie) { 1029| |#ifdef UTRIE2_DEBUG 1030| | int32_t countSame=0, sumOverlaps=0; 1031| |#endif 1032| | 1033| 3.92k| int32_t start, newStart, movedStart; 1034| 3.92k| int32_t blockLength, overlap; 1035| 3.92k| int32_t i, mapIndex, blockCount; 1036| | 1037| | /* do not compact linear-ASCII data */ 1038| 3.92k| newStart=UTRIE2_DATA_START_OFFSET; 1039| 27.4k| for(start=0, i=0; startmap[i]=start; 1041| 23.5k| } 1042| | 1043| | /* 1044| | * Start with a block length of 64 for 2-byte UTF-8, 1045| | * then switch to UTRIE2_DATA_BLOCK_LENGTH. 1046| | */ 1047| 3.92k| blockLength=64; 1048| 3.92k| blockCount=blockLength>>UTRIE2_SHIFT_2; 1049| 516k| for(start=newStart; startdataLength;) { ------------------ | Branch (1049:25): [True: 513k, False: 3.92k] ------------------ 1050| | /* 1051| | * start: index of first entry of current block 1052| | * newStart: index where the current block is to be moved 1053| | * (right after current end of already-compacted data) 1054| | */ 1055| 513k| if(start==UNEWTRIE2_DATA_0800_OFFSET) { ------------------ | Branch (1055:12): [True: 3.92k, False: 509k] ------------------ 1056| 3.92k| blockLength=UTRIE2_DATA_BLOCK_LENGTH; 1057| 3.92k| blockCount=1; 1058| 3.92k| } 1059| | 1060| | /* skip blocks that are not used */ 1061| 513k| if(trie->map[start>>UTRIE2_SHIFT_2]<=0) { ------------------ | Branch (1061:12): [True: 0, False: 513k] ------------------ 1062| | /* advance start to the next block */ 1063| 0| start+=blockLength; 1064| | 1065| | /* leave newStart with the previous block! */ 1066| 0| continue; 1067| 0| } 1068| | 1069| | /* search for an identical block */ 1070| 513k| if( (movedStart=findSameDataBlock(trie->data, newStart, start, blockLength)) ------------------ | Branch (1070:13): [True: 356k, False: 156k] ------------------ 1071| 513k| >=0 1072| 513k| ) { 1073| |#ifdef UTRIE2_DEBUG 1074| | ++countSame; 1075| |#endif 1076| | /* found an identical block, set the other block's index value for the current block */ 1077| 817k| for(i=blockCount, mapIndex=start>>UTRIE2_SHIFT_2; i>0; --i) { ------------------ | Branch (1077:63): [True: 460k, False: 356k] ------------------ 1078| 460k| trie->map[mapIndex++]=movedStart; 1079| 460k| movedStart+=UTRIE2_DATA_BLOCK_LENGTH; 1080| 460k| } 1081| | 1082| | /* advance start to the next block */ 1083| 356k| start+=blockLength; 1084| | 1085| | /* leave newStart with the previous block! */ 1086| 356k| continue; 1087| 356k| } 1088| | 1089| | /* see if the beginning of this block can be overlapped with the end of the previous block */ 1090| | /* look for maximum overlap (modulo granularity) with the previous, adjacent block */ 1091| 156k| for(overlap=blockLength-UTRIE2_DATA_GRANULARITY; 1092| 1.33M| overlap>0 && !equal_uint32(trie->data+(newStart-overlap), trie->data+start, overlap); ------------------ | Branch (1092:13): [True: 1.19M, False: 136k] | Branch (1092:26): [True: 1.17M, False: 19.3k] ------------------ 1093| 1.17M| overlap-=UTRIE2_DATA_GRANULARITY) {} 1094| | 1095| |#ifdef UTRIE2_DEBUG 1096| | sumOverlaps+=overlap; 1097| |#endif 1098| 156k| if(overlap>0 || newStart>UTRIE2_SHIFT_2; i>0; --i) { ------------------ | Branch (1101:63): [True: 162k, False: 149k] ------------------ 1102| 162k| trie->map[mapIndex++]=movedStart; 1103| 162k| movedStart+=UTRIE2_DATA_BLOCK_LENGTH; 1104| 162k| } 1105| | 1106| | /* move the non-overlapping indexes to their new positions */ 1107| 149k| start+=overlap; 1108| 5.11M| for(i=blockLength-overlap; i>0; --i) { ------------------ | Branch (1108:40): [True: 4.96M, False: 149k] ------------------ 1109| 4.96M| trie->data[newStart++]=trie->data[start++]; 1110| 4.96M| } 1111| 149k| } else /* no overlap && newStart==start */ { 1112| 18.0k| for(i=blockCount, mapIndex=start>>UTRIE2_SHIFT_2; i>0; --i) { ------------------ | Branch (1112:63): [True: 11.7k, False: 6.28k] ------------------ 1113| 11.7k| trie->map[mapIndex++]=start; 1114| 11.7k| start+=UTRIE2_DATA_BLOCK_LENGTH; 1115| 11.7k| } 1116| 6.28k| newStart=start; 1117| 6.28k| } 1118| 156k| } 1119| | 1120| | /* now adjust the index-2 table */ 1121| 8.52M| for(i=0; iindex2Length; ++i) { ------------------ | Branch (1121:14): [True: 8.52M, False: 3.92k] ------------------ 1122| 8.52M| if(i==UNEWTRIE2_INDEX_GAP_OFFSET) { ------------------ | Branch (1122:12): [True: 3.92k, False: 8.51M] ------------------ 1123| | /* Gap indexes are invalid (-1). Skip over the gap. */ 1124| 3.92k| i+=UNEWTRIE2_INDEX_GAP_LENGTH; 1125| 3.92k| } 1126| 8.52M| trie->index2[i]=trie->map[trie->index2[i]>>UTRIE2_SHIFT_2]; 1127| 8.52M| } 1128| 3.92k| trie->dataNullOffset=trie->map[trie->dataNullOffset>>UTRIE2_SHIFT_2]; 1129| | 1130| | /* ensure dataLength alignment */ 1131| 3.92k| while((newStart&(UTRIE2_DATA_GRANULARITY-1))!=0) { ------------------ | Branch (1131:11): [True: 0, False: 3.92k] ------------------ 1132| 0| trie->data[newStart++]=trie->initialValue; 1133| 0| } 1134| | 1135| |#ifdef UTRIE2_DEBUG 1136| | /* we saved some space */ 1137| | printf("compacting UTrie2: count of 32-bit data words %lu->%lu countSame=%ld sumOverlaps=%ld\n", 1138| | (long)trie->dataLength, (long)newStart, (long)countSame, (long)sumOverlaps); 1139| |#endif 1140| | 1141| 3.92k| trie->dataLength=newStart; 1142| 3.92k|} utrie2_builder.cpp:_ZL17findSameDataBlockPKjiii: 923| 513k|findSameDataBlock(const uint32_t *data, int32_t dataLength, int32_t otherBlock, int32_t blockLength) { 924| 513k| int32_t block; 925| | 926| | /* ensure that we do not even partially get past dataLength */ 927| 513k| dataLength-=blockLength; 928| | 929| 753M| for(block=0; block<=dataLength; block+=UTRIE2_DATA_GRANULARITY) { ------------------ | Branch (929:18): [True: 753M, False: 156k] ------------------ 930| 753M| if(equal_uint32(data+block, data+otherBlock, blockLength)) { ------------------ | Branch (930:12): [True: 356k, False: 753M] ------------------ 931| 356k| return block; 932| 356k| } 933| 753M| } 934| 156k| return -1; 935| 513k|} utrie2_builder.cpp:_ZL12equal_uint32PKjS0_i: 898| 754M|equal_uint32(const uint32_t *s, const uint32_t *t, int32_t length) { 899| 813M| while(length>0 && *s==*t) { ------------------ | Branch (899:11): [True: 813M, False: 376k] | Branch (899:23): [True: 58.9M, False: 754M] ------------------ 900| 58.9M| ++s; 901| 58.9M| ++t; 902| 58.9M| --length; 903| 58.9M| } 904| 754M| return length == 0; 905| 754M|} utrie2_builder.cpp:_ZL13compactIndex2P9UNewTrie2: 1145| 803|compactIndex2(UNewTrie2 *trie) { 1146| 803| int32_t i, start, newStart, movedStart, overlap; 1147| | 1148| | /* do not compact linear-BMP index-2 blocks */ 1149| 803| newStart=UTRIE2_INDEX_2_BMP_LENGTH; 1150| 27.3k| for(start=0, i=0; startmap[i]=start; 1152| 26.4k| } 1153| | 1154| | /* Reduce the index table gap to what will be needed at runtime. */ 1155| 803| newStart+=UTRIE2_UTF8_2B_INDEX_2_LENGTH+((trie->highStart-0x10000)>>UTRIE2_SHIFT_1); 1156| | 1157| 3.22k| for(start=UNEWTRIE2_INDEX_2_NULL_OFFSET; startindex2Length;) { ------------------ | Branch (1157:46): [True: 2.42k, False: 803] ------------------ 1158| | /* 1159| | * start: index of first entry of current block 1160| | * newStart: index where the current block is to be moved 1161| | * (right after current end of already-compacted data) 1162| | */ 1163| | 1164| | /* search for an identical block */ 1165| 2.42k| if( (movedStart=findSameIndex2Block(trie->index2, newStart, start)) ------------------ | Branch (1165:13): [True: 924, False: 1.49k] ------------------ 1166| 2.42k| >=0 1167| 2.42k| ) { 1168| | /* found an identical block, set the other block's index value for the current block */ 1169| 924| trie->map[start>>UTRIE2_SHIFT_1_2]=movedStart; 1170| | 1171| | /* advance start to the next block */ 1172| 924| start+=UTRIE2_INDEX_2_BLOCK_LENGTH; 1173| | 1174| | /* leave newStart with the previous block! */ 1175| 924| continue; 1176| 924| } 1177| | 1178| | /* see if the beginning of this block can be overlapped with the end of the previous block */ 1179| | /* look for maximum overlap with the previous, adjacent block */ 1180| 1.49k| for(overlap=UTRIE2_INDEX_2_BLOCK_LENGTH-1; 1181| 87.8k| overlap>0 && !equal_int32(trie->index2+(newStart-overlap), trie->index2+start, overlap); ------------------ | Branch (1181:13): [True: 86.6k, False: 1.20k] | Branch (1181:26): [True: 86.4k, False: 290] ------------------ 1182| 86.4k| --overlap) {} 1183| | 1184| 1.49k| if(overlap>0 || newStartmap[start>>UTRIE2_SHIFT_1_2]=newStart-overlap; 1187| | 1188| | /* move the non-overlapping indexes to their new positions */ 1189| 1.49k| start+=overlap; 1190| 89.3k| for(i=UTRIE2_INDEX_2_BLOCK_LENGTH-overlap; i>0; --i) { ------------------ | Branch (1190:56): [True: 87.8k, False: 1.49k] ------------------ 1191| 87.8k| trie->index2[newStart++]=trie->index2[start++]; 1192| 87.8k| } 1193| 1.49k| } else /* no overlap && newStart==start */ { 1194| 0| trie->map[start>>UTRIE2_SHIFT_1_2]=start; 1195| 0| start+=UTRIE2_INDEX_2_BLOCK_LENGTH; 1196| 0| newStart=start; 1197| 0| } 1198| 1.49k| } 1199| | 1200| | /* now adjust the index-1 table */ 1201| 437k| for(i=0; iindex1[i]=trie->map[trie->index1[i]>>UTRIE2_SHIFT_1_2]; 1203| 436k| } 1204| 803| trie->index2NullOffset=trie->map[trie->index2NullOffset>>UTRIE2_SHIFT_1_2]; 1205| | 1206| | /* 1207| | * Ensure data table alignment: 1208| | * Needs to be granularity-aligned for 16-bit trie 1209| | * (so that dataMove will be down-shiftable), 1210| | * and 2-aligned for uint32_t data. 1211| | */ 1212| 1.39k| while((newStart&((UTRIE2_DATA_GRANULARITY-1)|1))!=0) { ------------------ | Branch (1212:11): [True: 594, False: 803] ------------------ 1213| | /* Arbitrary value: 0x3fffc not possible for real data. */ 1214| 594| trie->index2[newStart++] = static_cast(0xffff) << UTRIE2_INDEX_SHIFT; 1215| 594| } 1216| | 1217| |#ifdef UTRIE2_DEBUG 1218| | /* we saved some space */ 1219| | printf("compacting UTrie2: count of 16-bit index words %lu->%lu\n", 1220| | (long)trie->index2Length, (long)newStart); 1221| |#endif 1222| | 1223| 803| trie->index2Length=newStart; 1224| 803|} utrie2_builder.cpp:_ZL19findSameIndex2BlockPKiii: 908| 2.42k|findSameIndex2Block(const int32_t *idx, int32_t index2Length, int32_t otherBlock) { 909| 2.42k| int32_t block; 910| | 911| | /* ensure that we do not even partially get past index2Length */ 912| 2.42k| index2Length-=UTRIE2_INDEX_2_BLOCK_LENGTH; 913| | 914| 4.59M| for(block=0; block<=index2Length; ++block) { ------------------ | Branch (914:18): [True: 4.59M, False: 1.49k] ------------------ 915| 4.59M| if(equal_int32(idx+block, idx+otherBlock, UTRIE2_INDEX_2_BLOCK_LENGTH)) { ------------------ | Branch (915:12): [True: 924, False: 4.59M] ------------------ 916| 924| return block; 917| 924| } 918| 4.59M| } 919| 1.49k| return -1; 920| 2.42k|} utrie2_builder.cpp:_ZL11equal_int32PKiS0_i: 888| 4.67M|equal_int32(const int32_t *s, const int32_t *t, int32_t length) { 889| 46.6M| while(length>0 && *s==*t) { ------------------ | Branch (889:11): [True: 46.6M, False: 1.21k] | Branch (889:23): [True: 42.0M, False: 4.67M] ------------------ 890| 42.0M| ++s; 891| 42.0M| ++t; 892| 42.0M| --length; 893| 42.0M| } 894| 4.67M| return length == 0; 895| 4.67M|} _ZN6icu_787UVectorC2ER10UErrorCode: 33| 11.6k| UVector(nullptr, nullptr, DEFAULT_CAPACITY, status) { 34| 11.6k|} _ZN6icu_787UVectorC2EPFvPvEPFa8UElementS4_ER10UErrorCode: 41| 1| UVector(d, c, DEFAULT_CAPACITY, status) { 42| 1|} _ZN6icu_787UVectorC2EPFvPvEPFa8UElementS4_EiR10UErrorCode: 45| 15.7k| deleter(d), 46| 15.7k| comparer(c) 47| 15.7k|{ 48| 15.7k| if (U_FAILURE(status)) { ------------------ | Branch (48:9): [True: 0, False: 15.7k] ------------------ 49| 0| return; 50| 0| } 51| | // Fix bogus initialCapacity values; avoid malloc(0) and integer overflow 52| 15.7k| if ((initialCapacity < 1) || (initialCapacity > static_cast(INT32_MAX / sizeof(UElement)))) { ------------------ | Branch (52:9): [True: 0, False: 15.7k] | Branch (52:34): [True: 0, False: 15.7k] ------------------ 53| 0| initialCapacity = DEFAULT_CAPACITY; 54| 0| } 55| 15.7k| elements = static_cast(uprv_malloc(sizeof(UElement) * initialCapacity)); ------------------ | | 1524| 15.7k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 15.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 56| 15.7k| if (elements == nullptr) { ------------------ | Branch (56:9): [True: 0, False: 15.7k] ------------------ 57| 0| status = U_MEMORY_ALLOCATION_ERROR; 58| 15.7k| } else { 59| 15.7k| capacity = initialCapacity; 60| 15.7k| } 61| 15.7k|} _ZN6icu_787UVectorD2Ev: 63| 15.7k|UVector::~UVector() { 64| 15.7k| removeAllElements(); 65| 15.7k| uprv_free(elements); ------------------ | | 1503| 15.7k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 15.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 66| 15.7k| elements = nullptr; 67| 15.7k|} _ZN6icu_787UVector12adoptElementEPvR10UErrorCode: 109| 713k|void UVector::adoptElement(void* obj, UErrorCode &status) { 110| 713k| U_ASSERT(deleter != nullptr); ------------------ | | 35| 713k|# define U_ASSERT(exp) (void)0 ------------------ 111| 713k| if (ensureCapacity(count + 1, status)) { ------------------ | Branch (111:9): [True: 713k, False: 0] ------------------ 112| 713k| elements[count++].pointer = obj; 113| 713k| } else { 114| 0| (*deleter)(obj); 115| 0| } 116| 713k|} _ZNK6icu_787UVector9elementAtEi: 185| 200M|void* UVector::elementAt(int32_t index) const { 186| 200M| return (0 <= index && index < count) ? elements[index].pointer : nullptr; ------------------ | Branch (186:13): [True: 200M, False: 0] | Branch (186:27): [True: 200M, False: 0] ------------------ 187| 200M|} _ZN6icu_787UVector9removeAllERKS0_: 211| 192|UBool UVector::removeAll(const UVector& other) { 212| 192| UBool changed = false; 213| 686| for (int32_t i=0; i= 0) { ------------------ | Branch (215:13): [True: 161, False: 333] ------------------ 216| 161| removeElementAt(j); 217| 161| changed = true; 218| 161| } 219| 494| } 220| 192| return changed; 221| 192|} _ZN6icu_787UVector9retainAllERKS0_: 223| 114|UBool UVector::retainAll(const UVector& other) { 224| 114| UBool changed = false; 225| 529| for (int32_t j=size()-1; j>=0; --j) { ------------------ | Branch (225:30): [True: 415, False: 114] ------------------ 226| 415| int32_t i = other.indexOf(elements[j]); 227| 415| if (i < 0) { ------------------ | Branch (227:13): [True: 259, False: 156] ------------------ 228| 259| removeElementAt(j); 229| 259| changed = true; 230| 259| } 231| 415| } 232| 114| return changed; 233| 114|} _ZN6icu_787UVector15removeElementAtEi: 235| 420|void UVector::removeElementAt(int32_t index) { 236| 420| void* e = orphanElementAt(index); 237| 420| if (e != nullptr && deleter != nullptr) { ------------------ | Branch (237:9): [True: 420, False: 0] | Branch (237:25): [True: 420, False: 0] ------------------ 238| 420| (*deleter)(e); 239| 420| } 240| 420|} _ZN6icu_787UVector17removeAllElementsEv: 251| 16.8k|void UVector::removeAllElements() { 252| 16.8k| if (deleter != nullptr) { ------------------ | Branch (252:9): [True: 16.8k, False: 0] ------------------ 253| 997k| for (int32_t i=0; i (INT32_MAX - 1) / 2) { // integer overflow check ------------------ | Branch (335:13): [True: 0, False: 31.0k] ------------------ 336| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 337| 0| return false; 338| 0| } 339| 31.0k| int32_t newCap = capacity * 2; 340| 31.0k| if (newCap < minimumCapacity) { ------------------ | Branch (340:13): [True: 0, False: 31.0k] ------------------ 341| 0| newCap = minimumCapacity; 342| 0| } 343| 31.0k| if (newCap > static_cast(INT32_MAX / sizeof(UElement))) { // integer overflow check ------------------ | Branch (343:13): [True: 0, False: 31.0k] ------------------ 344| | // We keep the original memory contents on bad minimumCapacity. 345| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 346| 0| return false; 347| 0| } 348| 31.0k| UElement* newElems = static_cast(uprv_realloc(elements, sizeof(UElement) * newCap)); ------------------ | | 1536| 31.0k|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 31.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 31.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 31.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 349| 31.0k| if (newElems == nullptr) { ------------------ | Branch (349:13): [True: 0, False: 31.0k] ------------------ 350| | // We keep the original contents on the memory failure on realloc or bad minimumCapacity. 351| 0| status = U_MEMORY_ALLOCATION_ERROR; 352| 0| return false; 353| 0| } 354| 31.0k| elements = newElems; 355| 31.0k| capacity = newCap; 356| 31.0k| } 357| 981k| return true; 358| 981k|} _ZN6icu_787UVector10setDeleterEPFvPvE: 397| 11.6k|UObjectDeleter *UVector::setDeleter(UObjectDeleter *d) { 398| 11.6k| UObjectDeleter *old = deleter; 399| 11.6k| deleter = d; 400| 11.6k| return old; 401| 11.6k|} _ZN6icu_787UVector15orphanElementAtEi: 418| 420|void* UVector::orphanElementAt(int32_t index) { 419| 420| void* e = nullptr; 420| 420| if (0 <= index && index < count) { ------------------ | Branch (420:9): [True: 420, False: 0] | Branch (420:23): [True: 420, False: 0] ------------------ 421| 420| e = elements[index].pointer; 422| 1.05k| for (int32_t i=index; i 0) { ------------------ | Branch (471:13): [True: 176k, False: 1.51M] ------------------ 472| 176k| max = probe; 473| 1.51M| } else { 474| | // assert(c <= 0); 475| 1.51M| min = probe + 1; 476| 1.51M| } 477| 1.69M| } 478| 5.38M| for (int32_t i=count; i>min; --i) { ------------------ | Branch (478:27): [True: 5.11M, False: 268k] ------------------ 479| 5.11M| elements[i] = elements[i-1]; 480| 5.11M| } 481| 268k| elements[min] = e; 482| 268k| ++count; 483| 268k|} _ZNK6icu_787UVector8containsEPv: 174| 265k| inline UBool contains(void* obj) const {return indexOf(obj) >= 0;} _ZNK6icu_787UVector4sizeEv: 190| 720k| inline int32_t size() const {return count;} _ZNK6icu_787UVector7isEmptyEv: 192| 1.67k| inline UBool isEmpty() const {return count == 0;} _ZNK6icu_787UVectorixEi: 218| 200M| inline void* operator[](int32_t index) const {return elementAt(index);} _ZN6icu_789UVector32C2ER10UErrorCode: 30| 70.5k| count(0), 31| 70.5k| capacity(0), 32| 70.5k| maxCapacity(0), 33| 70.5k| elements(nullptr) 34| 70.5k|{ 35| 70.5k| _init(DEFAULT_CAPACITY, status); ------------------ | | 19| 70.5k|#define DEFAULT_CAPACITY 8 ------------------ 36| 70.5k|} _ZN6icu_789UVector325_initEiR10UErrorCode: 49| 70.5k|void UVector32::_init(int32_t initialCapacity, UErrorCode &status) { 50| | // Fix bogus initialCapacity values; avoid malloc(0) 51| 70.5k| if (initialCapacity < 1) { ------------------ | Branch (51:9): [True: 0, False: 70.5k] ------------------ 52| 0| initialCapacity = DEFAULT_CAPACITY; ------------------ | | 19| 0|#define DEFAULT_CAPACITY 8 ------------------ 53| 0| } 54| 70.5k| if (maxCapacity>0 && maxCapacity static_cast(INT32_MAX / sizeof(int32_t))) { ------------------ | Branch (57:9): [True: 0, False: 70.5k] ------------------ 58| 0| initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); ------------------ | | 1529| 0|#define uprv_min U_ICU_ENTRY_POINT_RENAME(uprv_min) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); ------------------ | | 19| 0|#define DEFAULT_CAPACITY 8 ------------------ 59| 0| } 60| 70.5k| elements = static_cast(uprv_malloc(sizeof(int32_t) * initialCapacity)); ------------------ | | 1524| 70.5k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 70.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 70.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 70.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 61| 70.5k| if (elements == nullptr) { ------------------ | Branch (61:9): [True: 0, False: 70.5k] ------------------ 62| 0| status = U_MEMORY_ALLOCATION_ERROR; 63| 70.5k| } else { 64| 70.5k| capacity = initialCapacity; 65| 70.5k| } 66| 70.5k|} _ZN6icu_789UVector32D2Ev: 68| 70.5k|UVector32::~UVector32() { 69| 70.5k| uprv_free(elements); ------------------ | | 1503| 70.5k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 70.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 70.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 70.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 70| 70.5k| elements = nullptr; 71| 70.5k|} _ZN6icu_789UVector3212setElementAtEii: 98| 3.92k|void UVector32::setElementAt(int32_t elem, int32_t index) { 99| 3.92k| if (0 <= index && index < count) { ------------------ | Branch (99:9): [True: 3.92k, False: 0] | Branch (99:23): [True: 3.92k, False: 0] ------------------ 100| 3.92k| elements[index] = elem; 101| 3.92k| } 102| | /* else index out of range */ 103| 3.92k|} _ZN6icu_789UVector3215insertElementAtEiiR10UErrorCode: 105| 21.6k|void UVector32::insertElementAt(int32_t elem, int32_t index, UErrorCode &status) { 106| | // must have 0 <= index <= count 107| 21.6k| if (0 <= index && index <= count && ensureCapacity(count + 1, status)) { ------------------ | Branch (107:9): [True: 21.6k, False: 0] | Branch (107:23): [True: 21.6k, False: 0] | Branch (107:41): [True: 21.6k, False: 0] ------------------ 108| 127k| for (int32_t i=count; i>index; --i) { ------------------ | Branch (108:31): [True: 105k, False: 21.6k] ------------------ 109| 105k| elements[i] = elements[i-1]; 110| 105k| } 111| 21.6k| elements[index] = elem; 112| 21.6k| ++count; 113| 21.6k| } 114| | /* else index out of range */ 115| 21.6k|} _ZN6icu_789UVector3217removeAllElementsEv: 168| 3.19k|void UVector32::removeAllElements() { 169| 3.19k| count = 0; 170| 3.19k|} _ZN6icu_789UVector3214expandCapacityEiR10UErrorCode: 200| 30.4k|UBool UVector32::expandCapacity(int32_t minimumCapacity, UErrorCode &status) { 201| 30.4k| if (U_FAILURE(status)) { ------------------ | Branch (201:9): [True: 0, False: 30.4k] ------------------ 202| 0| return false; 203| 0| } 204| 30.4k| if (minimumCapacity < 0) { ------------------ | Branch (204:9): [True: 0, False: 30.4k] ------------------ 205| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 206| 0| return false; 207| 0| } 208| 30.4k| if (capacity >= minimumCapacity) { ------------------ | Branch (208:9): [True: 0, False: 30.4k] ------------------ 209| 0| return true; 210| 0| } 211| 30.4k| if (maxCapacity>0 && minimumCapacity>maxCapacity) { ------------------ | Branch (211:9): [True: 0, False: 30.4k] | Branch (211:26): [True: 0, False: 0] ------------------ 212| 0| status = U_BUFFER_OVERFLOW_ERROR; 213| 0| return false; 214| 0| } 215| 30.4k| if (capacity > (INT32_MAX - 1) / 2) { // integer overflow check ------------------ | Branch (215:9): [True: 0, False: 30.4k] ------------------ 216| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 217| 0| return false; 218| 0| } 219| 30.4k| int32_t newCap = capacity * 2; 220| 30.4k| if (newCap < minimumCapacity) { ------------------ | Branch (220:9): [True: 0, False: 30.4k] ------------------ 221| 0| newCap = minimumCapacity; 222| 0| } 223| 30.4k| if (maxCapacity > 0 && newCap > maxCapacity) { ------------------ | Branch (223:9): [True: 0, False: 30.4k] | Branch (223:28): [True: 0, False: 0] ------------------ 224| 0| newCap = maxCapacity; 225| 0| } 226| 30.4k| if (newCap > static_cast(INT32_MAX / sizeof(int32_t))) { // integer overflow check ------------------ | Branch (226:9): [True: 0, False: 30.4k] ------------------ 227| | // We keep the original memory contents on bad minimumCapacity/maxCapacity. 228| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 229| 0| return false; 230| 0| } 231| 30.4k| int32_t* newElems = static_cast(uprv_realloc(elements, sizeof(int32_t) * newCap)); ------------------ | | 1536| 30.4k|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 30.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 30.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 30.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 232| 30.4k| if (newElems == nullptr) { ------------------ | Branch (232:9): [True: 0, False: 30.4k] ------------------ 233| | // We keep the original contents on the memory failure on realloc. 234| 0| status = U_MEMORY_ALLOCATION_ERROR; 235| 0| return false; 236| 0| } 237| 30.4k| elements = newElems; 238| 30.4k| capacity = newCap; 239| 30.4k| return true; 240| 30.4k|} _ZN6icu_789UVector327setSizeEi: 278| 422k|void UVector32::setSize(int32_t newSize) { 279| 422k| int32_t i; 280| 422k| if (newSize < 0) { ------------------ | Branch (280:9): [True: 0, False: 422k] ------------------ 281| 0| return; 282| 0| } 283| 422k| if (newSize > count) { ------------------ | Branch (283:9): [True: 0, False: 422k] ------------------ 284| 0| UErrorCode ec = U_ZERO_ERROR; 285| 0| if (!ensureCapacity(newSize, ec)) { ------------------ | Branch (285:13): [True: 0, False: 0] ------------------ 286| 0| return; 287| 0| } 288| 0| for (i=count; i= 0 && count > 0 && count - index > 0) ? elements[index] : 0; ------------------ | Branch (224:13): [True: 5.00G, False: 0] | Branch (224:27): [True: 5.00G, False: 0] | Branch (224:40): [True: 5.00G, False: 0] ------------------ 225| 5.00G|} _ZN6icu_789UVector3214ensureCapacityEiR10UErrorCode: 215| 4.69M|inline UBool UVector32::ensureCapacity(int32_t minimumCapacity, UErrorCode &status) { 216| 4.69M| if ((minimumCapacity >= 0) && (capacity >= minimumCapacity)) { ------------------ | Branch (216:9): [True: 4.69M, False: 0] | Branch (216:35): [True: 4.66M, False: 30.4k] ------------------ 217| 4.66M| return true; 218| 4.66M| } else { 219| 30.4k| return expandCapacity(minimumCapacity, status); 220| 30.4k| } 221| 4.69M|} _ZN6icu_789UVector3210addElementEiR10UErrorCode: 228| 4.67M|inline void UVector32::addElement(int32_t elem, UErrorCode &status) { 229| 4.67M| if (ensureCapacity(count + 1, status)) { ------------------ | Branch (229:9): [True: 4.67M, False: 0] ------------------ 230| 4.67M| elements[count] = elem; 231| 4.67M| count++; 232| 4.67M| } 233| 4.67M|} _ZNK6icu_789UVector327isEmptyEv: 259| 467k|inline UBool UVector32::isEmpty() const { 260| 467k| return count == 0; 261| 467k|} _ZN6icu_789UVector64C2ER10UErrorCode: 27| 27.2k| count(0), 28| 27.2k| capacity(0), 29| 27.2k| maxCapacity(0), 30| 27.2k| elements(nullptr) 31| 27.2k|{ 32| 27.2k| _init(DEFAULT_CAPACITY, status); ------------------ | | 16| 27.2k|#define DEFAULT_CAPACITY 8 ------------------ 33| 27.2k|} _ZN6icu_789UVector645_initEiR10UErrorCode: 46| 27.2k|void UVector64::_init(int32_t initialCapacity, UErrorCode &status) { 47| | // Fix bogus initialCapacity values; avoid malloc(0) 48| 27.2k| if (initialCapacity < 1) { ------------------ | Branch (48:9): [True: 0, False: 27.2k] ------------------ 49| 0| initialCapacity = DEFAULT_CAPACITY; ------------------ | | 16| 0|#define DEFAULT_CAPACITY 8 ------------------ 50| 0| } 51| 27.2k| if (maxCapacity>0 && maxCapacity static_cast(INT32_MAX / sizeof(int64_t))) { ------------------ | Branch (54:9): [True: 0, False: 27.2k] ------------------ 55| 0| initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); ------------------ | | 1529| 0|#define uprv_min U_ICU_ENTRY_POINT_RENAME(uprv_min) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); ------------------ | | 16| 0|#define DEFAULT_CAPACITY 8 ------------------ 56| 0| } 57| 27.2k| elements = static_cast(uprv_malloc(sizeof(int64_t) * initialCapacity)); ------------------ | | 1524| 27.2k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 27.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 27.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 27.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 58| 27.2k| if (elements == nullptr) { ------------------ | Branch (58:9): [True: 0, False: 27.2k] ------------------ 59| 0| status = U_MEMORY_ALLOCATION_ERROR; 60| 27.2k| } else { 61| 27.2k| capacity = initialCapacity; 62| 27.2k| } 63| 27.2k|} _ZN6icu_789UVector64D2Ev: 65| 27.2k|UVector64::~UVector64() { 66| 27.2k| uprv_free(elements); ------------------ | | 1503| 27.2k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 27.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 27.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 27.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 67| 27.2k| elements = nullptr; 68| 27.2k|} _ZN6icu_789UVector6412setElementAtEli: 95| 5.59M|void UVector64::setElementAt(int64_t elem, int32_t index) { 96| 5.59M| if (0 <= index && index < count) { ------------------ | Branch (96:9): [True: 5.59M, False: 0] | Branch (96:23): [True: 5.59M, False: 0] ------------------ 97| 5.59M| elements[index] = elem; 98| 5.59M| } 99| | /* else index out of range */ 100| 5.59M|} _ZN6icu_789UVector6415insertElementAtEliR10UErrorCode: 102| 836k|void UVector64::insertElementAt(int64_t elem, int32_t index, UErrorCode &status) { 103| | // must have 0 <= index <= count 104| 836k| if (0 <= index && index <= count && ensureCapacity(count + 1, status)) { ------------------ | Branch (104:9): [True: 836k, False: 0] | Branch (104:23): [True: 836k, False: 0] | Branch (104:41): [True: 836k, False: 0] ------------------ 105| 44.2M| for (int32_t i=count; i>index; --i) { ------------------ | Branch (105:31): [True: 43.4M, False: 836k] ------------------ 106| 43.4M| elements[i] = elements[i-1]; 107| 43.4M| } 108| 836k| elements[index] = elem; 109| 836k| ++count; 110| 836k| } 111| | /* else index out of range */ 112| 836k|} _ZN6icu_789UVector6417removeAllElementsEv: 114| 8.34k|void UVector64::removeAllElements() { 115| 8.34k| count = 0; 116| 8.34k|} _ZN6icu_789UVector6414expandCapacityEiR10UErrorCode: 118| 40.4k|UBool UVector64::expandCapacity(int32_t minimumCapacity, UErrorCode &status) { 119| 40.4k| if (U_FAILURE(status)) { ------------------ | Branch (119:9): [True: 0, False: 40.4k] ------------------ 120| 0| return false; 121| 0| } 122| 40.4k| if (minimumCapacity < 0) { ------------------ | Branch (122:9): [True: 0, False: 40.4k] ------------------ 123| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 124| 0| return false; 125| 0| } 126| 40.4k| if (capacity >= minimumCapacity) { ------------------ | Branch (126:9): [True: 0, False: 40.4k] ------------------ 127| 0| return true; 128| 0| } 129| 40.4k| if (maxCapacity>0 && minimumCapacity>maxCapacity) { ------------------ | Branch (129:9): [True: 0, False: 40.4k] | Branch (129:26): [True: 0, False: 0] ------------------ 130| 0| status = U_BUFFER_OVERFLOW_ERROR; 131| 0| return false; 132| 0| } 133| 40.4k| if (capacity > (INT32_MAX - 1) / 2) { // integer overflow check ------------------ | Branch (133:9): [True: 0, False: 40.4k] ------------------ 134| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 135| 0| return false; 136| 0| } 137| 40.4k| int32_t newCap = capacity * 2; 138| 40.4k| if (newCap < minimumCapacity) { ------------------ | Branch (138:9): [True: 0, False: 40.4k] ------------------ 139| 0| newCap = minimumCapacity; 140| 0| } 141| 40.4k| if (maxCapacity > 0 && newCap > maxCapacity) { ------------------ | Branch (141:9): [True: 0, False: 40.4k] | Branch (141:28): [True: 0, False: 0] ------------------ 142| 0| newCap = maxCapacity; 143| 0| } 144| 40.4k| if (newCap > static_cast(INT32_MAX / sizeof(int64_t))) { // integer overflow check ------------------ | Branch (144:9): [True: 0, False: 40.4k] ------------------ 145| | // We keep the original memory contents on bad minimumCapacity/maxCapacity. 146| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 147| 0| return false; 148| 0| } 149| 40.4k| int64_t* newElems = static_cast(uprv_realloc(elements, sizeof(int64_t) * newCap)); ------------------ | | 1536| 40.4k|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 40.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 40.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 40.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 150| 40.4k| if (newElems == nullptr) { ------------------ | Branch (150:9): [True: 0, False: 40.4k] ------------------ 151| | // We keep the original contents on the memory failure on realloc. 152| 0| status = U_MEMORY_ALLOCATION_ERROR; 153| 0| return false; 154| 0| } 155| 40.4k| elements = newElems; 156| 40.4k| capacity = newCap; 157| 40.4k| return true; 158| 40.4k|} _ZNK6icu_789UVector6410elementAtiEi: 212| 5.20G|inline int64_t UVector64::elementAti(int32_t index) const { 213| 5.20G| return (0 <= index && index < count) ? elements[index] : 0; ------------------ | Branch (213:13): [True: 5.20G, False: 0] | Branch (213:27): [True: 5.20G, False: 0] ------------------ 214| 5.20G|} _ZNK6icu_789UVector649getBufferEv: 256| 30.8M|inline int64_t *UVector64::getBuffer() const { 257| 30.8M| return elements; 258| 30.8M|} _ZNK6icu_789UVector644sizeEv: 244| 11.0M|inline int32_t UVector64::size() const { 245| 11.0M| return count; 246| 11.0M|} _ZN6icu_789UVector6410addElementElR10UErrorCode: 217| 6.97M|inline void UVector64::addElement(int64_t elem, UErrorCode &status) { 218| 6.97M| if (ensureCapacity(count + 1, status)) { ------------------ | Branch (218:9): [True: 6.97M, False: 0] ------------------ 219| 6.97M| elements[count] = elem; 220| 6.97M| count++; 221| 6.97M| } 222| 6.97M|} _ZN6icu_789UVector6414ensureCapacityEiR10UErrorCode: 204| 7.81M|inline UBool UVector64::ensureCapacity(int32_t minimumCapacity, UErrorCode &status) { 205| 7.81M| if ((minimumCapacity >= 0) && (capacity >= minimumCapacity)) { ------------------ | Branch (205:9): [True: 7.81M, False: 0] | Branch (205:35): [True: 7.77M, False: 40.4k] ------------------ 206| 7.77M| return true; 207| 7.77M| } else { 208| 40.4k| return expandCapacity(minimumCapacity, status); 209| 40.4k| } 210| 7.81M|} u_writeIdenticalLevelRun_78: 101| 662|u_writeIdenticalLevelRun(UChar32 prev, const char16_t *s, int32_t length, icu::ByteSink &sink) { 102| 662| char scratch[64]; 103| 662| int32_t capacity; 104| | 105| 662| int32_t i=0; 106| 3.14k| while(i=SLOPE_MAX_BYTES in case u_writeDiff() writes that much, 110| | // but we do not want to force the sink.GetAppendBuffer() to allocate 111| | // for a large min_capacity because we might actually only write one byte. 112| 2.48k| if(capacity<16) { ------------------ | Branch (112:12): [True: 110, False: 2.37k] ------------------ 113| 110| buffer=scratch; 114| 110| capacity=(int32_t)sizeof(scratch); 115| 110| } 116| 2.48k| p=reinterpret_cast(buffer); 117| 2.48k| uint8_t *lastSafe=p+capacity-SLOPE_MAX_BYTES; ------------------ | | 93| 2.48k|#define SLOPE_MAX_BYTES 4 ------------------ 118| 120k| while(i=0xa000) { ------------------ | Branch (119:16): [True: 94.0k, False: 24.3k] | Branch (119:31): [True: 9.28k, False: 15.0k] ------------------ 120| 103k| prev=(prev&~0x7f)-SLOPE_REACH_NEG_1; ------------------ | | 125| 103k|#define SLOPE_REACH_NEG_1 (-SLOPE_SINGLE) | | ------------------ | | | | 118| 103k|#define SLOPE_SINGLE 80 | | ------------------ ------------------ 121| 103k| } else { 122| | /* 123| | * Unihan U+4e00..U+9fa5: 124| | * double-bytes down from the upper end 125| | */ 126| 15.0k| prev=0x9fff-SLOPE_REACH_POS_2; ------------------ | | 128| 15.0k|#define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | ------------------ | | | | 119| 15.0k|#define SLOPE_LEAD_2 42 | | ------------------ | | #define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | ------------------ | | | | 91| 15.0k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 88| 15.0k|#define SLOPE_MAX 0xff | | | | ------------------ | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 87| 15.0k|#define SLOPE_MIN 3 | | | | ------------------ | | ------------------ | | #define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | ------------------ | | | | 119| 15.0k|#define SLOPE_LEAD_2 42 | | ------------------ ------------------ 127| 15.0k| } 128| | 129| 118k| UChar32 c; 130| 118k| U16_NEXT(s, i, length, c); ------------------ | | 309| 118k|#define U16_NEXT(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 118k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 310| 118k| (c)=(s)[(i)++]; \ | | 311| 118k| if(U16_IS_LEAD(c)) { \ | | ------------------ | | | | 59| 118k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 2.70k, False: 115k] | | | | ------------------ | | ------------------ | | 312| 2.70k| uint16_t __c2; \ | | 313| 2.70k| if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \ | | ------------------ | | | | 67| 2.69k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 1.12k, False: 1.57k] | | | | ------------------ | | ------------------ | | | Branch (313:12): [True: 2.69k, False: 12] | | ------------------ | | 314| 1.12k| ++(i); \ | | 315| 1.12k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 1.12k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 1.12k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 316| 1.12k| } \ | | 317| 2.70k| } \ | | 318| 118k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 118k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 131| 118k| if(c==0xfffe) { ------------------ | Branch (131:16): [True: 84, False: 118k] ------------------ 132| 84| *p++=2; // merge separator 133| 84| prev=0; 134| 118k| } else { 135| 118k| p=u_writeDiff(c-prev, p); 136| 118k| prev=c; 137| 118k| } 138| 118k| } 139| 2.48k| sink.Append(buffer, (int32_t)(p-reinterpret_cast(buffer))); 140| 2.48k| } 141| 662| return prev; 142| 662|} bocsu.cpp:_ZL11u_writeDiffiPh: 33| 118k|u_writeDiff(int32_t diff, uint8_t *p) { 34| 118k| if(diff>=SLOPE_REACH_NEG_1) { ------------------ | | 125| 118k|#define SLOPE_REACH_NEG_1 (-SLOPE_SINGLE) | | ------------------ | | | | 118| 118k|#define SLOPE_SINGLE 80 | | ------------------ ------------------ | Branch (34:8): [True: 80.9k, False: 37.3k] ------------------ 35| 80.9k| if(diff<=SLOPE_REACH_POS_1) { ------------------ | | 124| 80.9k|#define SLOPE_REACH_POS_1 SLOPE_SINGLE | | ------------------ | | | | 118| 80.9k|#define SLOPE_SINGLE 80 | | ------------------ ------------------ | Branch (35:12): [True: 43.2k, False: 37.7k] ------------------ 36| 43.2k| *p++ = static_cast(SLOPE_MIDDLE + diff); ------------------ | | 89| 43.2k|#define SLOPE_MIDDLE 0x81 ------------------ 37| 43.2k| } else if(diff<=SLOPE_REACH_POS_2) { ------------------ | | 128| 37.7k|#define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | ------------------ | | | | 119| 37.7k|#define SLOPE_LEAD_2 42 | | ------------------ | | #define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | ------------------ | | | | 91| 37.7k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 88| 37.7k|#define SLOPE_MAX 0xff | | | | ------------------ | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 87| 37.7k|#define SLOPE_MIN 3 | | | | ------------------ | | ------------------ | | #define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | ------------------ | | | | 119| 37.7k|#define SLOPE_LEAD_2 42 | | ------------------ ------------------ | Branch (37:19): [True: 23.7k, False: 13.9k] ------------------ 38| 23.7k| *p++ = static_cast(SLOPE_START_POS_2 + (diff / SLOPE_TAIL_COUNT)); ------------------ | | 136| 23.7k|#define SLOPE_START_POS_2 (SLOPE_MIDDLE+SLOPE_SINGLE+1) | | ------------------ | | | | 89| 23.7k|#define SLOPE_MIDDLE 0x81 | | ------------------ | | #define SLOPE_START_POS_2 (SLOPE_MIDDLE+SLOPE_SINGLE+1) | | ------------------ | | | | 118| 23.7k|#define SLOPE_SINGLE 80 | | ------------------ ------------------ *p++ = static_cast(SLOPE_START_POS_2 + (diff / SLOPE_TAIL_COUNT)); ------------------ | | 91| 23.7k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 23.7k|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 23.7k|#define SLOPE_MIN 3 | | ------------------ ------------------ 39| 23.7k| *p++ = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 87| 23.7k|#define SLOPE_MIN 3 ------------------ *p++ = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 91| 23.7k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 23.7k|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 23.7k|#define SLOPE_MIN 3 | | ------------------ ------------------ 40| 23.7k| } else if(diff<=SLOPE_REACH_POS_3) { ------------------ | | 132| 13.9k|#define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | ------------------ | | | | 120| 13.9k|#define SLOPE_LEAD_3 3 | | ------------------ | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | ------------------ | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | ------------------ | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | ------------------ | | ------------------ | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | ------------------ | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | ------------------ | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | ------------------ | | ------------------ | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | ------------------ | | | | 120| 13.9k|#define SLOPE_LEAD_3 3 | | ------------------ | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | ------------------ | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | ------------------ | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | ------------------ | | ------------------ | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | ------------------ | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | ------------------ | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | ------------------ | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | ------------------ | | ------------------ ------------------ | Branch (40:19): [True: 13.4k, False: 486] ------------------ 41| 13.4k| p[2] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 87| 13.4k|#define SLOPE_MIN 3 ------------------ p[2] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 91| 13.4k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 13.4k|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 13.4k|#define SLOPE_MIN 3 | | ------------------ ------------------ 42| 13.4k| diff/=SLOPE_TAIL_COUNT; ------------------ | | 91| 13.4k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 13.4k|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 13.4k|#define SLOPE_MIN 3 | | ------------------ ------------------ 43| 13.4k| p[1] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 87| 13.4k|#define SLOPE_MIN 3 ------------------ p[1] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 91| 13.4k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 13.4k|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 13.4k|#define SLOPE_MIN 3 | | ------------------ ------------------ 44| 13.4k| *p = static_cast(SLOPE_START_POS_3 + (diff / SLOPE_TAIL_COUNT)); ------------------ | | 137| 13.4k|#define SLOPE_START_POS_3 (SLOPE_START_POS_2+SLOPE_LEAD_2) | | ------------------ | | | | 136| 13.4k|#define SLOPE_START_POS_2 (SLOPE_MIDDLE+SLOPE_SINGLE+1) | | | | ------------------ | | | | | | 89| 13.4k|#define SLOPE_MIDDLE 0x81 | | | | ------------------ | | | | #define SLOPE_START_POS_2 (SLOPE_MIDDLE+SLOPE_SINGLE+1) | | | | ------------------ | | | | | | 118| 13.4k|#define SLOPE_SINGLE 80 | | | | ------------------ | | ------------------ | | #define SLOPE_START_POS_3 (SLOPE_START_POS_2+SLOPE_LEAD_2) | | ------------------ | | | | 119| 13.4k|#define SLOPE_LEAD_2 42 | | ------------------ ------------------ *p = static_cast(SLOPE_START_POS_3 + (diff / SLOPE_TAIL_COUNT)); ------------------ | | 91| 13.4k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 13.4k|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 13.4k|#define SLOPE_MIN 3 | | ------------------ ------------------ 45| 13.4k| p+=3; 46| 13.4k| } else { 47| 486| p[3] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ p[3] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 91| 486|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 486|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 486|#define SLOPE_MIN 3 | | ------------------ ------------------ 48| 486| diff/=SLOPE_TAIL_COUNT; ------------------ | | 91| 486|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 486|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 486|#define SLOPE_MIN 3 | | ------------------ ------------------ 49| 486| p[2] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ p[2] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 91| 486|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 486|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 486|#define SLOPE_MIN 3 | | ------------------ ------------------ 50| 486| diff/=SLOPE_TAIL_COUNT; ------------------ | | 91| 486|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 486|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 486|#define SLOPE_MIN 3 | | ------------------ ------------------ 51| 486| p[1] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ p[1] = static_cast(SLOPE_MIN + diff % SLOPE_TAIL_COUNT); ------------------ | | 91| 486|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 88| 486|#define SLOPE_MAX 0xff | | ------------------ | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | ------------------ | | | | 87| 486|#define SLOPE_MIN 3 | | ------------------ ------------------ 52| 486| *p=SLOPE_MAX; ------------------ | | 88| 486|#define SLOPE_MAX 0xff ------------------ 53| 486| p+=4; 54| 486| } 55| 80.9k| } else { 56| 37.3k| int32_t m; 57| | 58| 37.3k| if(diff>=SLOPE_REACH_NEG_2) { ------------------ | | 129| 37.3k|#define SLOPE_REACH_NEG_2 (-SLOPE_REACH_POS_2-1) | | ------------------ | | | | 128| 37.3k|#define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | | | ------------------ | | | | | | 119| 37.3k|#define SLOPE_LEAD_2 42 | | | | ------------------ | | | | #define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | | | ------------------ | | | | | | 91| 37.3k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 88| 37.3k|#define SLOPE_MAX 0xff | | | | | | ------------------ | | | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 87| 37.3k|#define SLOPE_MIN 3 | | | | | | ------------------ | | | | ------------------ | | | | #define SLOPE_REACH_POS_2 (SLOPE_LEAD_2*SLOPE_TAIL_COUNT+(SLOPE_LEAD_2-1)) | | | | ------------------ | | | | | | 119| 37.3k|#define SLOPE_LEAD_2 42 | | | | ------------------ | | ------------------ ------------------ | Branch (58:12): [True: 23.3k, False: 13.9k] ------------------ 59| 23.3k| NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m); ------------------ | | 147| 23.3k|#define NEGDIVMOD(n, d, m) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 23.3k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 148| 23.3k| (m)=(n)%(d); \ | | 149| 23.3k| (n)/=(d); \ | | 150| 23.3k| if((m)<0) { \ | | ------------------ | | | Branch (150:8): [True: 23.3k, False: 32] | | ------------------ | | 151| 23.3k| --(n); \ | | 152| 23.3k| (m)+=(d); \ | | 153| 23.3k| } \ | | 154| 23.3k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 23.3k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 60| 23.3k| *p++ = static_cast(SLOPE_START_NEG_2 + diff); ------------------ | | 139| 23.3k|#define SLOPE_START_NEG_2 (SLOPE_MIDDLE+SLOPE_REACH_NEG_1) | | ------------------ | | | | 89| 23.3k|#define SLOPE_MIDDLE 0x81 | | ------------------ | | #define SLOPE_START_NEG_2 (SLOPE_MIDDLE+SLOPE_REACH_NEG_1) | | ------------------ | | | | 125| 23.3k|#define SLOPE_REACH_NEG_1 (-SLOPE_SINGLE) | | | | ------------------ | | | | | | 118| 23.3k|#define SLOPE_SINGLE 80 | | | | ------------------ | | ------------------ ------------------ 61| 23.3k| *p++ = static_cast(SLOPE_MIN + m); ------------------ | | 87| 23.3k|#define SLOPE_MIN 3 ------------------ 62| 23.3k| } else if(diff>=SLOPE_REACH_NEG_3) { ------------------ | | 133| 13.9k|#define SLOPE_REACH_NEG_3 (-SLOPE_REACH_POS_3-1) | | ------------------ | | | | 132| 13.9k|#define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | | | ------------------ | | | | | | 120| 13.9k|#define SLOPE_LEAD_3 3 | | | | ------------------ | | | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | | | ------------------ | | | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | | | ------------------ | | | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | | | ------------------ | | | | ------------------ | | | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | | | ------------------ | | | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | | | ------------------ | | | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | | | ------------------ | | | | ------------------ | | | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | | | ------------------ | | | | | | 120| 13.9k|#define SLOPE_LEAD_3 3 | | | | ------------------ | | | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | | | ------------------ | | | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | | | ------------------ | | | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | | | ------------------ | | | | ------------------ | | | | #define SLOPE_REACH_POS_3 (SLOPE_LEAD_3*SLOPE_TAIL_COUNT*SLOPE_TAIL_COUNT+(SLOPE_LEAD_3-1)*SLOPE_TAIL_COUNT+(SLOPE_TAIL_COUNT-1)) | | | | ------------------ | | | | | | 91| 13.9k|#define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 88| 13.9k|#define SLOPE_MAX 0xff | | | | | | ------------------ | | | | | | #define SLOPE_TAIL_COUNT (SLOPE_MAX-SLOPE_MIN+1) | | | | | | ------------------ | | | | | | | | 87| 13.9k|#define SLOPE_MIN 3 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (62:19): [True: 13.4k, False: 486] ------------------ 63| 13.4k| NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m); ------------------ | | 147| 13.4k|#define NEGDIVMOD(n, d, m) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 13.4k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 148| 13.4k| (m)=(n)%(d); \ | | 149| 13.4k| (n)/=(d); \ | | 150| 13.4k| if((m)<0) { \ | | ------------------ | | | Branch (150:8): [True: 13.3k, False: 134] | | ------------------ | | 151| 13.3k| --(n); \ | | 152| 13.3k| (m)+=(d); \ | | 153| 13.3k| } \ | | 154| 13.4k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 13.4k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 64| 13.4k| p[2] = static_cast(SLOPE_MIN + m); ------------------ | | 87| 13.4k|#define SLOPE_MIN 3 ------------------ 65| 13.4k| NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m); ------------------ | | 147| 13.4k|#define NEGDIVMOD(n, d, m) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 13.4k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 148| 13.4k| (m)=(n)%(d); \ | | 149| 13.4k| (n)/=(d); \ | | 150| 13.4k| if((m)<0) { \ | | ------------------ | | | Branch (150:8): [True: 13.3k, False: 136] | | ------------------ | | 151| 13.3k| --(n); \ | | 152| 13.3k| (m)+=(d); \ | | 153| 13.3k| } \ | | 154| 13.4k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 13.4k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 66| 13.4k| p[1] = static_cast(SLOPE_MIN + m); ------------------ | | 87| 13.4k|#define SLOPE_MIN 3 ------------------ 67| 13.4k| *p = static_cast(SLOPE_START_NEG_3 + diff); ------------------ | | 140| 13.4k|#define SLOPE_START_NEG_3 (SLOPE_START_NEG_2-SLOPE_LEAD_2) | | ------------------ | | | | 139| 13.4k|#define SLOPE_START_NEG_2 (SLOPE_MIDDLE+SLOPE_REACH_NEG_1) | | | | ------------------ | | | | | | 89| 13.4k|#define SLOPE_MIDDLE 0x81 | | | | ------------------ | | | | #define SLOPE_START_NEG_2 (SLOPE_MIDDLE+SLOPE_REACH_NEG_1) | | | | ------------------ | | | | | | 125| 13.4k|#define SLOPE_REACH_NEG_1 (-SLOPE_SINGLE) | | | | | | ------------------ | | | | | | | | 118| 13.4k|#define SLOPE_SINGLE 80 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define SLOPE_START_NEG_3 (SLOPE_START_NEG_2-SLOPE_LEAD_2) | | ------------------ | | | | 119| 13.4k|#define SLOPE_LEAD_2 42 | | ------------------ ------------------ 68| 13.4k| p+=3; 69| 13.4k| } else { 70| 486| NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m); ------------------ | | 147| 486|#define NEGDIVMOD(n, d, m) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 486|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 148| 486| (m)=(n)%(d); \ | | 149| 486| (n)/=(d); \ | | 150| 486| if((m)<0) { \ | | ------------------ | | | Branch (150:8): [True: 446, False: 40] | | ------------------ | | 151| 446| --(n); \ | | 152| 446| (m)+=(d); \ | | 153| 446| } \ | | 154| 486|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 486|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 71| 486| p[3] = static_cast(SLOPE_MIN + m); ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ 72| 486| NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m); ------------------ | | 147| 486|#define NEGDIVMOD(n, d, m) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 486|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 148| 486| (m)=(n)%(d); \ | | 149| 486| (n)/=(d); \ | | 150| 486| if((m)<0) { \ | | ------------------ | | | Branch (150:8): [True: 462, False: 24] | | ------------------ | | 151| 462| --(n); \ | | 152| 462| (m)+=(d); \ | | 153| 462| } \ | | 154| 486|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 486|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 73| 486| p[2] = static_cast(SLOPE_MIN + m); ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ 74| 486| NEGDIVMOD(diff, SLOPE_TAIL_COUNT, m); ------------------ | | 147| 486|#define NEGDIVMOD(n, d, m) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 486|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 148| 486| (m)=(n)%(d); \ | | 149| 486| (n)/=(d); \ | | 150| 486| if((m)<0) { \ | | ------------------ | | | Branch (150:8): [True: 486, False: 0] | | ------------------ | | 151| 486| --(n); \ | | 152| 486| (m)+=(d); \ | | 153| 486| } \ | | 154| 486|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 486|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 75| 486| p[1] = static_cast(SLOPE_MIN + m); ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ 76| 486| *p=SLOPE_MIN; ------------------ | | 87| 486|#define SLOPE_MIN 3 ------------------ 77| 486| p+=4; 78| 486| } 79| 37.3k| } 80| 118k| return p; 81| 118k|} _ZN6icu_788CollatorC2Ev: 612| 7.71k|: UObject() 613| 7.71k|{ 614| 7.71k|} _ZN6icu_788CollatorD2Ev: 632| 7.71k|{ 633| 7.71k|} _ZNK6icu_788Collator11getStrengthEv: 916| 4.09k|Collator::getStrength() const { 917| 4.09k| UErrorCode intStatus = U_ZERO_ERROR; 918| 4.09k| return static_cast(getAttribute(UCOL_STRENGTH, intStatus)); 919| 4.09k|} _ZN6icu_789Collation25incTwoBytePrimaryByOffsetEjai: 24| 2.31k|Collation::incTwoBytePrimaryByOffset(uint32_t basePrimary, UBool isCompressible, int32_t offset) { 25| | // Extract the second byte, minus the minimum byte value, 26| | // plus the offset, modulo the number of usable byte values, plus the minimum. 27| | // Reserve the PRIMARY_COMPRESSION_LOW_BYTE and high byte if necessary. 28| 2.31k| uint32_t primary; 29| 2.31k| if(isCompressible) { ------------------ | Branch (29:8): [True: 1.73k, False: 586] ------------------ 30| 1.73k| offset += (static_cast(basePrimary >> 16) & 0xff) - 4; 31| 1.73k| primary = static_cast((offset % 251) + 4) << 16; 32| 1.73k| offset /= 251; 33| 1.73k| } else { 34| 586| offset += (static_cast(basePrimary >> 16) & 0xff) - 2; 35| 586| primary = static_cast((offset % 254) + 2) << 16; 36| 586| offset /= 254; 37| 586| } 38| | // First byte, assume no further overflow. 39| 2.31k| return primary | ((basePrimary & 0xff000000) + static_cast(offset << 24)); 40| 2.31k|} _ZN6icu_789Collation27incThreeBytePrimaryByOffsetEjai: 43| 7.91M|Collation::incThreeBytePrimaryByOffset(uint32_t basePrimary, UBool isCompressible, int32_t offset) { 44| | // Extract the third byte, minus the minimum byte value, 45| | // plus the offset, modulo the number of usable byte values, plus the minimum. 46| 7.91M| offset += (static_cast(basePrimary >> 8) & 0xff) - 2; 47| 7.91M| uint32_t primary = static_cast((offset % 254) + 2) << 8; 48| 7.91M| offset /= 254; 49| | // Same with the second byte, 50| | // but reserve the PRIMARY_COMPRESSION_LOW_BYTE and high byte if necessary. 51| 7.91M| if(isCompressible) { ------------------ | Branch (51:8): [True: 750k, False: 7.16M] ------------------ 52| 750k| offset += (static_cast(basePrimary >> 16) & 0xff) - 4; 53| 750k| primary |= static_cast((offset % 251) + 4) << 16; 54| 750k| offset /= 251; 55| 7.16M| } else { 56| 7.16M| offset += (static_cast(basePrimary >> 16) & 0xff) - 2; 57| 7.16M| primary |= static_cast((offset % 254) + 2) << 16; 58| 7.16M| offset /= 254; 59| 7.16M| } 60| | // First byte, assume no further overflow. 61| 7.91M| return primary | ((basePrimary & 0xff000000) + static_cast(offset << 24)); 62| 7.91M|} _ZN6icu_789Collation26decTwoBytePrimaryByOneStepEjai: 65| 2.26k|Collation::decTwoBytePrimaryByOneStep(uint32_t basePrimary, UBool isCompressible, int32_t step) { 66| | // Extract the second byte, minus the minimum byte value, 67| | // minus the step, modulo the number of usable byte values, plus the minimum. 68| | // Reserve the PRIMARY_COMPRESSION_LOW_BYTE and high byte if necessary. 69| | // Assume no further underflow for the first byte. 70| 2.26k| U_ASSERT(0 < step && step <= 0x7f); ------------------ | | 35| 2.26k|# define U_ASSERT(exp) (void)0 ------------------ 71| 2.26k| int32_t byte2 = (static_cast(basePrimary >> 16) & 0xff) - step; 72| 2.26k| if(isCompressible) { ------------------ | Branch (72:8): [True: 1.56k, False: 703] ------------------ 73| 1.56k| if(byte2 < 4) { ------------------ | Branch (73:12): [True: 0, False: 1.56k] ------------------ 74| 0| byte2 += 251; 75| 0| basePrimary -= 0x1000000; 76| 0| } 77| 1.56k| } else { 78| 703| if(byte2 < 2) { ------------------ | Branch (78:12): [True: 0, False: 703] ------------------ 79| 0| byte2 += 254; 80| 0| basePrimary -= 0x1000000; 81| 0| } 82| 703| } 83| 2.26k| return (basePrimary & 0xff000000) | (static_cast(byte2) << 16); 84| 2.26k|} _ZN6icu_789Collation28decThreeBytePrimaryByOneStepEjai: 87| 377|Collation::decThreeBytePrimaryByOneStep(uint32_t basePrimary, UBool isCompressible, int32_t step) { 88| | // Extract the third byte, minus the minimum byte value, 89| | // minus the step, modulo the number of usable byte values, plus the minimum. 90| 377| U_ASSERT(0 < step && step <= 0x7f); ------------------ | | 35| 377|# define U_ASSERT(exp) (void)0 ------------------ 91| 377| int32_t byte3 = (static_cast(basePrimary >> 8) & 0xff) - step; 92| 377| if(byte3 >= 2) { ------------------ | Branch (92:8): [True: 245, False: 132] ------------------ 93| 245| return (basePrimary & 0xffff0000) | (static_cast(byte3) << 8); 94| 245| } 95| 132| byte3 += 254; 96| | // Same with the second byte, 97| | // but reserve the PRIMARY_COMPRESSION_LOW_BYTE and high byte if necessary. 98| 132| int32_t byte2 = (static_cast(basePrimary >> 16) & 0xff) - 1; 99| 132| if(isCompressible) { ------------------ | Branch (99:8): [True: 106, False: 26] ------------------ 100| 106| if(byte2 < 4) { ------------------ | Branch (100:12): [True: 0, False: 106] ------------------ 101| 0| byte2 = 0xfe; 102| 0| basePrimary -= 0x1000000; 103| 0| } 104| 106| } else { 105| 26| if(byte2 < 2) { ------------------ | Branch (105:12): [True: 6, False: 20] ------------------ 106| 6| byte2 = 0xff; 107| 6| basePrimary -= 0x1000000; 108| 6| } 109| 26| } 110| | // First byte, assume no further underflow. 111| 132| return (basePrimary & 0xff000000) | (static_cast(byte2) << 16) | (static_cast(byte3) << 8); 112| 377|} _ZN6icu_789Collation32getThreeBytePrimaryForOffsetDataEil: 115| 7.91M|Collation::getThreeBytePrimaryForOffsetData(UChar32 c, int64_t dataCE) { 116| 7.91M| uint32_t p = static_cast(dataCE >> 32); // three-byte primary pppppp00 117| 7.91M| int32_t lower32 = static_cast(dataCE); // base code point b & step s: bbbbbbss (bit 7: isCompressible) 118| 7.91M| int32_t offset = (c - (lower32 >> 8)) * (lower32 & 0x7f); // delta * increment 119| 7.91M| UBool isCompressible = (lower32 & 0x80) != 0; 120| 7.91M| return Collation::incThreeBytePrimaryByOffset(p, isCompressible, offset); 121| 7.91M|} _ZN6icu_789Collation30unassignedPrimaryFromCodePointEi: 124| 1.52M|Collation::unassignedPrimaryFromCodePoint(UChar32 c) { 125| | // Create a gap before U+0000. Use c=-1 for [first unassigned]. 126| 1.52M| ++c; 127| | // Fourth byte: 18 values, every 14th byte value (gap of 13). 128| 1.52M| uint32_t primary = 2 + (c % 18) * 14; 129| 1.52M| c /= 18; 130| | // Third byte: 254 values. 131| 1.52M| primary |= (2 + (c % 254)) << 8; 132| 1.52M| c /= 254; 133| | // Second byte: 251 values 04..FE excluding the primary compression bytes. 134| 1.52M| primary |= (4 + (c % 251)) << 16; 135| | // One lead byte covers all code points (c < 0x1182B4 = 1*251*254*18). 136| 1.52M| return primary | (UNASSIGNED_IMPLICIT_BYTE << 24); 137| 1.52M|} _ZN6icu_789Collation14isAssignedCE32Ej: 278| 263k| static UBool isAssignedCE32(uint32_t ce32) { 279| 263k| return ce32 != FALLBACK_CE32 && ce32 != UNASSIGNED_CE32; ------------------ | Branch (279:16): [True: 3.68k, False: 259k] | Branch (279:41): [True: 3.68k, False: 0] ------------------ 280| 263k| } _ZN6icu_789Collation19makeLongPrimaryCE32Ej: 313| 2.63M| static uint32_t makeLongPrimaryCE32(uint32_t p) { return p | LONG_PRIMARY_CE32_LOW_BYTE; } _ZN6icu_789Collation26primaryFromLongPrimaryCE32Ej: 316| 848k| static inline uint32_t primaryFromLongPrimaryCE32(uint32_t ce32) { 317| 848k| return ce32 & 0xffffff00; 318| 848k| } _ZN6icu_789Collation21ceFromLongPrimaryCE32Ej: 319| 11.2M| static inline int64_t ceFromLongPrimaryCE32(uint32_t ce32) { 320| 11.2M| return (static_cast(ce32 & 0xffffff00) << 32) | COMMON_SEC_AND_TER_CE; 321| 11.2M| } _ZN6icu_789Collation21makeLongSecondaryCE32Ej: 323| 73.7k| static uint32_t makeLongSecondaryCE32(uint32_t lower32) { 324| 73.7k| return lower32 | SPECIAL_CE32_LOW_BYTE | LONG_SECONDARY_TAG; 325| 73.7k| } _ZN6icu_789Collation23ceFromLongSecondaryCE32Ej: 326| 378k| static inline int64_t ceFromLongSecondaryCE32(uint32_t ce32) { 327| 378k| return ce32 & 0xffffff00; 328| 378k| } _ZN6icu_789Collation29makeCE32FromTagIndexAndLengthEiii: 331| 3.24M| static uint32_t makeCE32FromTagIndexAndLength(int32_t tag, int32_t index, int32_t length) { 332| 3.24M| return (index << 13) | (length << 8) | SPECIAL_CE32_LOW_BYTE | tag; 333| 3.24M| } _ZN6icu_789Collation23makeCE32FromTagAndIndexEii: 335| 5.76M| static uint32_t makeCE32FromTagAndIndex(int32_t tag, int32_t index) { 336| 5.76M| return (index << 13) | SPECIAL_CE32_LOW_BYTE | tag; 337| 5.76M| } _ZN6icu_789Collation13isSpecialCE32Ej: 339| 470M| static inline UBool isSpecialCE32(uint32_t ce32) { 340| 470M| return (ce32 & 0xff) >= SPECIAL_CE32_LOW_BYTE; 341| 470M| } _ZN6icu_789Collation11tagFromCE32Ej: 343| 536M| static inline int32_t tagFromCE32(uint32_t ce32) { 344| 536M| return static_cast(ce32 & 0xf); 345| 536M| } _ZN6icu_789Collation10hasCE32TagEji: 347| 196M| static inline UBool hasCE32Tag(uint32_t ce32, int32_t tag) { 348| 196M| return isSpecialCE32(ce32) && tagFromCE32(ce32) == tag; ------------------ | Branch (348:16): [True: 193M, False: 2.38M] | Branch (348:39): [True: 1.31M, False: 192M] ------------------ 349| 196M| } _ZN6icu_789Collation17isLongPrimaryCE32Ej: 351| 1.26M| static inline UBool isLongPrimaryCE32(uint32_t ce32) { 352| 1.26M| return hasCE32Tag(ce32, LONG_PRIMARY_TAG); 353| 1.26M| } _ZN6icu_789Collation18isSimpleOrLongCE32Ej: 355| 1.88M| static UBool isSimpleOrLongCE32(uint32_t ce32) { 356| 1.88M| return !isSpecialCE32(ce32) || ------------------ | Branch (356:16): [True: 1.00M, False: 879k] ------------------ 357| 1.88M| tagFromCE32(ce32) == LONG_PRIMARY_TAG || ------------------ | Branch (357:17): [True: 22.1k, False: 857k] ------------------ 358| 1.88M| tagFromCE32(ce32) == LONG_SECONDARY_TAG; ------------------ | Branch (358:17): [True: 562, False: 856k] ------------------ 359| 1.88M| } _ZN6icu_789Collation19isSelfContainedCE32Ej: 364| 51.9M| static UBool isSelfContainedCE32(uint32_t ce32) { 365| 51.9M| return !isSpecialCE32(ce32) || ------------------ | Branch (365:16): [True: 1.51M, False: 50.4M] ------------------ 366| 51.9M| tagFromCE32(ce32) == LONG_PRIMARY_TAG || ------------------ | Branch (366:17): [True: 3.43M, False: 47.0M] ------------------ 367| 51.9M| tagFromCE32(ce32) == LONG_SECONDARY_TAG || ------------------ | Branch (367:17): [True: 31.7k, False: 46.9M] ------------------ 368| 51.9M| tagFromCE32(ce32) == LATIN_EXPANSION_TAG; ------------------ | Branch (368:17): [True: 407k, False: 46.5M] ------------------ 369| 51.9M| } _ZN6icu_789Collation12isPrefixCE32Ej: 371| 93.2M| static inline UBool isPrefixCE32(uint32_t ce32) { 372| 93.2M| return hasCE32Tag(ce32, PREFIX_TAG); 373| 93.2M| } _ZN6icu_789Collation17isContractionCE32Ej: 375| 93.2M| static inline UBool isContractionCE32(uint32_t ce32) { 376| 93.2M| return hasCE32Tag(ce32, CONTRACTION_TAG); 377| 93.2M| } _ZN6icu_789Collation14ce32HasContextEj: 379| 3.91M| static inline UBool ce32HasContext(uint32_t ce32) { 380| 3.91M| return isSpecialCE32(ce32) && ------------------ | Branch (380:16): [True: 3.75M, False: 162k] ------------------ 381| 3.91M| (tagFromCE32(ce32) == PREFIX_TAG || ------------------ | Branch (381:18): [True: 372, False: 3.75M] ------------------ 382| 3.75M| tagFromCE32(ce32) == CONTRACTION_TAG); ------------------ | Branch (382:17): [True: 969, False: 3.75M] ------------------ 383| 3.91M| } _ZN6icu_789Collation16latinCE0FromCE32Ej: 389| 2.44M| static inline int64_t latinCE0FromCE32(uint32_t ce32) { 390| 2.44M| return (static_cast(ce32 & 0xff000000) << 32) | COMMON_SECONDARY_CE | ((ce32 & 0xff0000) >> 8); 391| 2.44M| } _ZN6icu_789Collation16latinCE1FromCE32Ej: 397| 2.44M| static inline int64_t latinCE1FromCE32(uint32_t ce32) { 398| 2.44M| return ((ce32 & 0xff00) << 16) | COMMON_TERTIARY_CE; 399| 2.44M| } _ZN6icu_789Collation13indexFromCE32Ej: 404| 22.0M| static inline int32_t indexFromCE32(uint32_t ce32) { 405| 22.0M| return static_cast(ce32 >> 13); 406| 22.0M| } _ZN6icu_789Collation14lengthFromCE32Ej: 411| 7.65M| static inline int32_t lengthFromCE32(uint32_t ce32) { 412| 7.65M| return (ce32 >> 8) & 31; 413| 7.65M| } _ZN6icu_789Collation16ceFromSimpleCE32Ej: 423| 20.9M| static inline int64_t ceFromSimpleCE32(uint32_t ce32) { 424| | // normal form ppppsstt -> pppp0000ss00tt00 425| | // assert (ce32 & 0xff) < SPECIAL_CE32_LOW_BYTE 426| 20.9M| return (static_cast(ce32 & 0xffff0000) << 32) | ((ce32 & 0xff00) << 16) | ((ce32 & 0xff) << 8); 427| 20.9M| } _ZN6icu_789Collation10ceFromCE32Ej: 430| 19.4M| static inline int64_t ceFromCE32(uint32_t ce32) { 431| 19.4M| uint32_t tertiary = ce32 & 0xff; 432| 19.4M| if(tertiary < SPECIAL_CE32_LOW_BYTE) { ------------------ | Branch (432:12): [True: 18.1M, False: 1.29M] ------------------ 433| | // normal form ppppsstt -> pppp0000ss00tt00 434| 18.1M| return (static_cast(ce32 & 0xffff0000) << 32) | ((ce32 & 0xff00) << 16) | (tertiary << 8); 435| 18.1M| } else { 436| 1.29M| ce32 -= tertiary; 437| 1.29M| if((tertiary & 0xf) == LONG_PRIMARY_TAG) { ------------------ | Branch (437:16): [True: 978k, False: 316k] ------------------ 438| | // long-primary form ppppppC1 -> pppppp00050000500 439| 978k| return (static_cast(ce32) << 32) | COMMON_SEC_AND_TER_CE; 440| 978k| } else { 441| | // long-secondary form ssssttC2 -> 00000000sssstt00 442| | // assert (tertiary & 0xf) == LONG_SECONDARY_TAG 443| 316k| return ce32; 444| 316k| } 445| 1.29M| } 446| 19.4M| } _ZN6icu_789Collation6makeCEEj: 449| 8.02M| static inline int64_t makeCE(uint32_t p) { 450| 8.02M| return (static_cast(p) << 32) | COMMON_SEC_AND_TER_CE; 451| 8.02M| } _ZN6icu_789Collation6makeCEEjjjj: 456| 3.15M| static inline int64_t makeCE(uint32_t p, uint32_t s, uint32_t t, uint32_t q) { 457| 3.15M| return (static_cast(p) << 32) | (s << 16) | t | (q << 6); 458| 3.15M| } _ZN6icu_789Collation25unassignedCEFromCodePointEi: 492| 1.52M| static inline int64_t unassignedCEFromCodePoint(UChar32 c) { 493| 1.52M| return makeCE(unassignedPrimaryFromCodePoint(c)); 494| 1.52M| } _ZN6icu_7817RuleBasedCollatorC2ERKNS_13UnicodeStringER10UErrorCode: 96| 7.71k| : data(nullptr), 97| 7.71k| settings(nullptr), 98| 7.71k| tailoring(nullptr), 99| 7.71k| cacheEntry(nullptr), 100| 7.71k| validLocale(""), 101| 7.71k| explicitlySetAttributes(0), 102| 7.71k| actualLocaleIsSameAsValid(false) { 103| 7.71k| internalBuildTailoring(rules, UCOL_DEFAULT, UCOL_DEFAULT, nullptr, nullptr, errorCode); 104| 7.71k|} _ZN6icu_7817RuleBasedCollator22internalBuildTailoringERKNS_13UnicodeStringEi18UColAttributeValueP11UParseErrorPS1_R10UErrorCode: 163| 7.71k| UErrorCode &errorCode) { 164| 7.71k| const CollationTailoring *base = CollationRoot::getRoot(errorCode); 165| 7.71k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (165:8): [True: 0, False: 7.71k] ------------------ 166| 7.71k| if(outReason != nullptr) { outReason->remove(); } ------------------ | Branch (166:8): [True: 0, False: 7.71k] ------------------ 167| 7.71k| CollationBuilder builder(base, errorCode); 168| 7.71k| UVersionInfo noVersion = { 0, 0, 0, 0 }; 169| 7.71k| BundleImporter importer; 170| 7.71k| LocalPointer t(builder.parseAndBuild(rules, noVersion, 171| 7.71k| &importer, 172| 7.71k| outParseError, errorCode)); 173| 7.71k| if(U_FAILURE(errorCode)) { ------------------ | Branch (173:8): [True: 3.61k, False: 4.09k] ------------------ 174| 3.61k| const char *reason = builder.getErrorReason(); 175| 3.61k| if(reason != nullptr && outReason != nullptr) { ------------------ | Branch (175:12): [True: 3.61k, False: 0] | Branch (175:33): [True: 0, False: 3.61k] ------------------ 176| 0| *outReason = UnicodeString(reason, -1, US_INV); ------------------ | | 98| 0|#define US_INV icu::UnicodeString::kInvariant ------------------ 177| 0| } 178| 3.61k| return; 179| 3.61k| } 180| 4.09k| t->actualLocale.setToBogus(); 181| 4.09k| adoptTailoring(t.orphan(), errorCode); 182| | // Set attributes after building the collator, 183| | // to keep the default settings consistent with the rule string. 184| 4.09k| if(strength != UCOL_DEFAULT) { ------------------ | Branch (184:8): [True: 0, False: 4.09k] ------------------ 185| 0| setAttribute(UCOL_STRENGTH, static_cast(strength), errorCode); 186| 0| } 187| 4.09k| if(decompositionMode != UCOL_DEFAULT) { ------------------ | Branch (187:8): [True: 0, False: 4.09k] ------------------ 188| 0| setAttribute(UCOL_NORMALIZATION_MODE, decompositionMode, errorCode); 189| 0| } 190| 4.09k|} _ZN6icu_7816CollationBuilderC2EPKNS_18CollationTailoringEaR10UErrorCode: 195| 7.71k| : nfd(*Normalizer2::getNFDInstance(errorCode)), 196| 7.71k| fcd(*Normalizer2Factory::getFCDInstance(errorCode)), 197| 7.71k| nfcImpl(*Normalizer2Factory::getNFCImpl(errorCode)), 198| 7.71k| base(b), 199| 7.71k| baseData(b->data), 200| 7.71k| rootElements(b->data->rootElements, b->data->rootElementsLength), 201| 7.71k| variableTop(0), 202| 7.71k| dataBuilder(new CollationDataBuilder(icu4xMode, errorCode)), fastLatinEnabled(true), 203| 7.71k| icu4xMode(icu4xMode), 204| 7.71k| errorReason(nullptr), 205| 7.71k| cesLength(0), 206| 7.71k| rootPrimaryIndexes(errorCode), nodes(errorCode) { 207| 7.71k| nfcImpl.ensureCanonIterData(errorCode); 208| 7.71k| if(U_FAILURE(errorCode)) { ------------------ | Branch (208:8): [True: 0, False: 7.71k] ------------------ 209| 0| errorReason = "CollationBuilder fields initialization failed"; 210| 0| return; 211| 0| } 212| 7.71k| if(dataBuilder == nullptr) { ------------------ | Branch (212:8): [True: 0, False: 7.71k] ------------------ 213| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 214| 0| return; 215| 0| } 216| 7.71k| dataBuilder->initForTailoring(baseData, errorCode); 217| 7.71k| if(U_FAILURE(errorCode)) { ------------------ | Branch (217:8): [True: 0, False: 7.71k] ------------------ 218| 0| errorReason = "CollationBuilder initialization failed"; 219| 0| } 220| 7.71k|} _ZN6icu_7816CollationBuilderC2EPKNS_18CollationTailoringER10UErrorCode: 223| 7.71k| : CollationBuilder(b, false, errorCode) 224| 7.71k|{} _ZN6icu_7816CollationBuilderD2Ev: 226| 7.71k|CollationBuilder::~CollationBuilder() { 227| 7.71k| delete dataBuilder; 228| 7.71k|} _ZN6icu_7816CollationBuilder13parseAndBuildERKNS_13UnicodeStringEPKhPNS_19CollationRuleParser8ImporterEP11UParseErrorR10UErrorCode: 235| 7.71k| UErrorCode &errorCode) { 236| 7.71k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (236:8): [True: 0, False: 7.71k] ------------------ 237| 7.71k| if(baseData->rootElements == nullptr) { ------------------ | Branch (237:8): [True: 0, False: 7.71k] ------------------ 238| 0| errorCode = U_MISSING_RESOURCE_ERROR; 239| 0| errorReason = "missing root elements data, tailoring not supported"; 240| 0| return nullptr; 241| 0| } 242| 7.71k| LocalPointer tailoring(new CollationTailoring(base->settings)); 243| 7.71k| if(tailoring.isNull() || tailoring->isBogus()) { ------------------ | Branch (243:8): [True: 0, False: 7.71k] | Branch (243:30): [True: 0, False: 7.71k] ------------------ 244| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 245| 0| return nullptr; 246| 0| } 247| 7.71k| CollationRuleParser parser(baseData, errorCode); 248| 7.71k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (248:8): [True: 0, False: 7.71k] ------------------ 249| | // Note: This always bases &[last variable] and &[first regular] 250| | // on the root collator's maxVariable/variableTop. 251| | // If we wanted this to change after [maxVariable x], then we would keep 252| | // the tailoring.settings pointer here and read its variableTop when we need it. 253| | // See http://unicode.org/cldr/trac/ticket/6070 254| 7.71k| variableTop = base->settings->variableTop; 255| 7.71k| parser.setSink(this); 256| 7.71k| parser.setImporter(importer); 257| 7.71k| CollationSettings &ownedSettings = *SharedObject::copyOnWrite(tailoring->settings); 258| 7.71k| parser.parse(ruleString, ownedSettings, outParseError, errorCode); 259| 7.71k| errorReason = parser.getErrorReason(); 260| 7.71k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (260:8): [True: 3.57k, False: 4.13k] ------------------ 261| 4.13k| if(dataBuilder->hasMappings()) { ------------------ | Branch (261:8): [True: 3.96k, False: 168] ------------------ 262| 3.96k| makeTailoredCEs(errorCode); 263| 3.96k| if (!icu4xMode) { ------------------ | Branch (263:13): [True: 3.96k, False: 0] ------------------ 264| 3.96k| closeOverComposites(errorCode); 265| 3.96k| } 266| 3.96k| finalizeCEs(errorCode); 267| 3.96k| if (!icu4xMode) { ------------------ | Branch (267:13): [True: 3.96k, False: 0] ------------------ 268| | // Copy all of ASCII, and Latin-1 letters, into each tailoring. 269| 3.96k| optimizeSet.add(0, 0x7f); 270| 3.96k| optimizeSet.add(0xc0, 0xff); 271| | // Hangul is decomposed on the fly during collation, 272| | // and the tailoring data is always built with HANGUL_TAG specials. 273| 3.96k| optimizeSet.remove(Hangul::HANGUL_BASE, Hangul::HANGUL_END); 274| 3.96k| dataBuilder->optimize(optimizeSet, errorCode); 275| 3.96k| } 276| 3.96k| tailoring->ensureOwnedData(errorCode); 277| 3.96k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (277:12): [True: 41, False: 3.92k] ------------------ 278| 3.92k| if(fastLatinEnabled) { dataBuilder->enableFastLatin(); } ------------------ | Branch (278:12): [True: 3.92k, False: 0] ------------------ 279| 3.92k| dataBuilder->build(*tailoring->ownedData, errorCode); 280| 3.92k| tailoring->builder = dataBuilder; 281| 3.92k| dataBuilder = nullptr; 282| 3.92k| } else { 283| 168| tailoring->data = baseData; 284| 168| } 285| 4.09k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (285:8): [True: 0, False: 4.09k] ------------------ 286| 4.09k| ownedSettings.fastLatinOptions = CollationFastLatin::getOptions( 287| 4.09k| tailoring->data, ownedSettings, 288| 4.09k| ownedSettings.fastLatinPrimaries, UPRV_LENGTHOF(ownedSettings.fastLatinPrimaries)); ------------------ | | 99| 4.09k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 289| 4.09k| tailoring->rules = ruleString; 290| 4.09k| tailoring->rules.getTerminatedBuffer(); // ensure NUL-termination 291| 4.09k| tailoring->setVersion(base->version, rulesVersion); 292| 4.09k| return tailoring.orphan(); 293| 4.09k|} _ZN6icu_7816CollationBuilder8addResetEiRKNS_13UnicodeStringERPKcR10UErrorCode: 297| 317k| const char *&parserErrorReason, UErrorCode &errorCode) { 298| 317k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (298:8): [True: 81, False: 317k] ------------------ 299| 317k| U_ASSERT(!str.isEmpty()); ------------------ | | 35| 317k|# define U_ASSERT(exp) (void)0 ------------------ 300| 317k| if(str.charAt(0) == CollationRuleParser::POS_LEAD) { ------------------ | Branch (300:8): [True: 910, False: 316k] ------------------ 301| 910| ces[0] = getSpecialResetPosition(str, parserErrorReason, errorCode); 302| 910| cesLength = 1; 303| 910| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (303:12): [True: 1, False: 909] ------------------ 304| 909| U_ASSERT((ces[0] & Collation::CASE_AND_QUATERNARY_MASK) == 0); ------------------ | | 35| 909|# define U_ASSERT(exp) (void)0 ------------------ 305| 316k| } else { 306| | // normal reset to a character or string 307| 316k| UnicodeString nfdString = nfd.normalize(str, errorCode); 308| 316k| if(U_FAILURE(errorCode)) { ------------------ | Branch (308:12): [True: 0, False: 316k] ------------------ 309| 0| parserErrorReason = "normalizing the reset position"; 310| 0| return; 311| 0| } 312| 316k| cesLength = dataBuilder->getCEs(nfdString, ces, 0); 313| 316k| if(cesLength > Collation::MAX_EXPANSION_LENGTH) { ------------------ | Branch (313:12): [True: 64, False: 316k] ------------------ 314| 64| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 315| 64| parserErrorReason = "reset position maps to too many collation elements (more than 31)"; 316| 64| return; 317| 64| } 318| 316k| } 319| 317k| if(strength == UCOL_IDENTICAL) { return; } // simple reset-at-position ------------------ | Branch (319:8): [True: 310k, False: 6.61k] ------------------ 320| | 321| | // &[before strength]position 322| 6.61k| U_ASSERT(UCOL_PRIMARY <= strength && strength <= UCOL_TERTIARY); ------------------ | | 35| 6.61k|# define U_ASSERT(exp) (void)0 ------------------ 323| 6.61k| int32_t index = findOrInsertNodeForCEs(strength, parserErrorReason, errorCode); 324| 6.61k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (324:8): [True: 1, False: 6.61k] ------------------ 325| | 326| 6.61k| int64_t node = nodes.elementAti(index); 327| | // If the index is for a "weaker" node, 328| | // then skip backwards over this and further "weaker" nodes. 329| 40.5k| while(strengthFromNode(node) > strength) { ------------------ | Branch (329:11): [True: 33.9k, False: 6.61k] ------------------ 330| 33.9k| index = previousIndexFromNode(node); 331| 33.9k| node = nodes.elementAti(index); 332| 33.9k| } 333| | 334| | // Find or insert a node whose index we will put into a temporary CE. 335| 6.61k| if(strengthFromNode(node) == strength && isTailoredNode(node)) { ------------------ | Branch (335:8): [True: 5.54k, False: 1.06k] | Branch (335:46): [True: 267, False: 5.27k] ------------------ 336| | // Reset to just before this same-strength tailored node. 337| 267| index = previousIndexFromNode(node); 338| 6.34k| } else if(strength == UCOL_PRIMARY) { ------------------ | Branch (338:15): [True: 4.65k, False: 1.69k] ------------------ 339| | // root primary node (has no previous index) 340| 4.65k| uint32_t p = weight32FromNode(node); 341| 4.65k| if(p == 0) { ------------------ | Branch (341:12): [True: 1, False: 4.65k] ------------------ 342| 1| errorCode = U_UNSUPPORTED_ERROR; 343| 1| parserErrorReason = "reset primary-before ignorable not possible"; 344| 1| return; 345| 1| } 346| 4.65k| if(p <= rootElements.getFirstPrimary()) { ------------------ | Branch (346:12): [True: 0, False: 4.65k] ------------------ 347| | // There is no primary gap between ignorables and the space-first-primary. 348| 0| errorCode = U_UNSUPPORTED_ERROR; 349| 0| parserErrorReason = "reset primary-before first non-ignorable not supported"; 350| 0| return; 351| 0| } 352| 4.65k| if(p == Collation::FIRST_TRAILING_PRIMARY) { ------------------ | Branch (352:12): [True: 0, False: 4.65k] ------------------ 353| | // We do not support tailoring to an unassigned-implicit CE. 354| 0| errorCode = U_UNSUPPORTED_ERROR; 355| 0| parserErrorReason = "reset primary-before [first trailing] not supported"; 356| 0| return; 357| 0| } 358| 4.65k| p = rootElements.getPrimaryBefore(p, baseData->isCompressiblePrimary(p)); 359| 4.65k| index = findOrInsertNodeForPrimary(p, errorCode); 360| | // Go to the last node in this list: 361| | // Tailor after the last node between adjacent root nodes. 362| 28.7k| for(;;) { 363| 28.7k| node = nodes.elementAti(index); 364| 28.7k| int32_t nextIndex = nextIndexFromNode(node); 365| 28.7k| if(nextIndex == 0) { break; } ------------------ | Branch (365:16): [True: 4.65k, False: 24.0k] ------------------ 366| 24.0k| index = nextIndex; 367| 24.0k| } 368| 4.65k| } else { 369| | // &[before 2] or &[before 3] 370| 1.69k| index = findCommonNode(index, UCOL_SECONDARY); 371| 1.69k| if(strength >= UCOL_TERTIARY) { ------------------ | Branch (371:12): [True: 220, False: 1.47k] ------------------ 372| 220| index = findCommonNode(index, UCOL_TERTIARY); 373| 220| } 374| | // findCommonNode() stayed on the stronger node or moved to 375| | // an explicit common-weight node of the reset-before strength. 376| 1.69k| node = nodes.elementAti(index); 377| 1.69k| if(strengthFromNode(node) == strength) { ------------------ | Branch (377:12): [True: 984, False: 708] ------------------ 378| | // Found a same-strength node with an explicit weight. 379| 984| uint32_t weight16 = weight16FromNode(node); 380| 984| if(weight16 == 0) { ------------------ | Branch (380:16): [True: 0, False: 984] ------------------ 381| 0| errorCode = U_UNSUPPORTED_ERROR; 382| 0| if(strength == UCOL_SECONDARY) { ------------------ | Branch (382:20): [True: 0, False: 0] ------------------ 383| 0| parserErrorReason = "reset secondary-before secondary ignorable not possible"; 384| 0| } else { 385| 0| parserErrorReason = "reset tertiary-before completely ignorable not possible"; 386| 0| } 387| 0| return; 388| 0| } 389| 984| U_ASSERT(weight16 > Collation::BEFORE_WEIGHT16); ------------------ | | 35| 984|# define U_ASSERT(exp) (void)0 ------------------ 390| | // Reset to just before this node. 391| | // Insert the preceding same-level explicit weight if it is not there already. 392| | // Which explicit weight immediately precedes this one? 393| 984| weight16 = getWeight16Before(index, node, strength); 394| | // Does this preceding weight have a node? 395| 984| uint32_t previousWeight16; 396| 984| int32_t previousIndex = previousIndexFromNode(node); 397| 6.81k| for(int32_t i = previousIndex;; i = previousIndexFromNode(node)) { 398| 6.81k| node = nodes.elementAti(i); 399| 6.81k| int32_t previousStrength = strengthFromNode(node); 400| 6.81k| if(previousStrength < strength) { ------------------ | Branch (400:20): [True: 20, False: 6.79k] ------------------ 401| 20| U_ASSERT(weight16 >= Collation::COMMON_WEIGHT16 || i == previousIndex); ------------------ | | 35| 20|# define U_ASSERT(exp) (void)0 ------------------ 402| | // Either the reset element has an above-common weight and 403| | // the parent node provides the implied common weight, 404| | // or the reset element has a weight<=common in the node 405| | // right after the parent, and we need to insert the preceding weight. 406| 20| previousWeight16 = Collation::COMMON_WEIGHT16; 407| 20| break; 408| 6.79k| } else if(previousStrength == strength && !isTailoredNode(node)) { ------------------ | Branch (408:27): [True: 5.97k, False: 819] | Branch (408:59): [True: 964, False: 5.00k] ------------------ 409| 964| previousWeight16 = weight16FromNode(node); 410| 964| break; 411| 964| } 412| | // Skip weaker nodes and same-level tailored nodes. 413| 6.81k| } 414| 984| if(previousWeight16 == weight16) { ------------------ | Branch (414:16): [True: 964, False: 20] ------------------ 415| | // The preceding weight has a node, 416| | // maybe with following weaker or tailored nodes. 417| | // Reset to the last of them. 418| 964| index = previousIndex; 419| 964| } else { 420| | // Insert a node with the preceding weight, reset to that. 421| 20| node = nodeFromWeight16(weight16) | nodeFromStrength(strength); 422| 20| index = insertNodeBetween(previousIndex, index, node, errorCode); 423| 20| } 424| 984| } else { 425| | // Found a stronger node with implied strength-common weight. 426| 708| uint32_t weight16 = getWeight16Before(index, node, strength); 427| 708| index = findOrInsertWeakNode(index, weight16, strength, errorCode); 428| 708| } 429| | // Strength of the temporary CE = strength of its reset position. 430| | // Code above raises an error if the before-strength is stronger. 431| 1.69k| strength = ceStrength(ces[cesLength - 1]); 432| 1.69k| } 433| 6.61k| if(U_FAILURE(errorCode)) { ------------------ | Branch (433:8): [True: 0, False: 6.61k] ------------------ 434| 0| parserErrorReason = "inserting reset position for &[before n]"; 435| 0| return; 436| 0| } 437| 6.61k| ces[cesLength - 1] = tempCEFromIndexAndStrength(index, strength); 438| 6.61k|} _ZN6icu_7816CollationBuilder17getWeight16BeforeEili: 441| 1.69k|CollationBuilder::getWeight16Before(int32_t index, int64_t node, int32_t level) { 442| 1.69k| U_ASSERT(strengthFromNode(node) < level || !isTailoredNode(node)); ------------------ | | 35| 1.69k|# define U_ASSERT(exp) (void)0 ------------------ 443| | // Collect the root CE weights if this node is for a root CE. 444| | // If it is not, then return the low non-primary boundary for a tailored CE. 445| 1.69k| uint32_t t; 446| 1.69k| if(strengthFromNode(node) == UCOL_TERTIARY) { ------------------ | Branch (446:8): [True: 44, False: 1.64k] ------------------ 447| 44| t = weight16FromNode(node); 448| 1.64k| } else { 449| 1.64k| t = Collation::COMMON_WEIGHT16; // Stronger node with implied common weight. 450| 1.64k| } 451| 1.82k| while(strengthFromNode(node) > UCOL_SECONDARY) { ------------------ | Branch (451:11): [True: 136, False: 1.69k] ------------------ 452| 136| index = previousIndexFromNode(node); 453| 136| node = nodes.elementAti(index); 454| 136| } 455| 1.69k| if(isTailoredNode(node)) { ------------------ | Branch (455:8): [True: 330, False: 1.36k] ------------------ 456| 330| return Collation::BEFORE_WEIGHT16; 457| 330| } 458| 1.36k| uint32_t s; 459| 1.36k| if(strengthFromNode(node) == UCOL_SECONDARY) { ------------------ | Branch (459:8): [True: 948, False: 414] ------------------ 460| 948| s = weight16FromNode(node); 461| 948| } else { 462| 414| s = Collation::COMMON_WEIGHT16; // Stronger node with implied common weight. 463| 414| } 464| 9.07k| while(strengthFromNode(node) > UCOL_PRIMARY) { ------------------ | Branch (464:11): [True: 7.70k, False: 1.36k] ------------------ 465| 7.70k| index = previousIndexFromNode(node); 466| 7.70k| node = nodes.elementAti(index); 467| 7.70k| } 468| 1.36k| if(isTailoredNode(node)) { ------------------ | Branch (468:8): [True: 359, False: 1.00k] ------------------ 469| 359| return Collation::BEFORE_WEIGHT16; 470| 359| } 471| | // [p, s, t] is a root CE. Return the preceding weight for the requested level. 472| 1.00k| uint32_t p = weight32FromNode(node); 473| 1.00k| uint32_t weight16; 474| 1.00k| if(level == UCOL_SECONDARY) { ------------------ | Branch (474:8): [True: 783, False: 220] ------------------ 475| 783| weight16 = rootElements.getSecondaryBefore(p, s); 476| 783| } else { 477| 220| weight16 = rootElements.getTertiaryBefore(p, s, t); 478| 220| U_ASSERT((weight16 & ~Collation::ONLY_TERTIARY_MASK) == 0); ------------------ | | 35| 220|# define U_ASSERT(exp) (void)0 ------------------ 479| 220| } 480| 1.00k| return weight16; 481| 1.36k|} _ZN6icu_7816CollationBuilder23getSpecialResetPositionERKNS_13UnicodeStringERPKcR10UErrorCode: 485| 910| const char *&parserErrorReason, UErrorCode &errorCode) { 486| 910| U_ASSERT(str.length() == 2); ------------------ | | 35| 910|# define U_ASSERT(exp) (void)0 ------------------ 487| 910| int64_t ce; 488| 910| int32_t strength = UCOL_PRIMARY; 489| 910| UBool isBoundary = false; 490| 910| UChar32 pos = str.charAt(1) - CollationRuleParser::POS_BASE; 491| 910| U_ASSERT(0 <= pos && pos <= CollationRuleParser::LAST_TRAILING); ------------------ | | 35| 910|# define U_ASSERT(exp) (void)0 ------------------ 492| 910| switch(pos) { 493| 0| case CollationRuleParser::FIRST_TERTIARY_IGNORABLE: ------------------ | Branch (493:5): [True: 0, False: 910] ------------------ 494| | // Quaternary CEs are not supported. 495| | // Non-zero quaternary weights are possible only on tertiary or stronger CEs. 496| 0| return 0; 497| 168| case CollationRuleParser::LAST_TERTIARY_IGNORABLE: ------------------ | Branch (497:5): [True: 168, False: 742] ------------------ 498| 168| return 0; 499| 0| case CollationRuleParser::FIRST_SECONDARY_IGNORABLE: { ------------------ | Branch (499:5): [True: 0, False: 910] ------------------ 500| | // Look for a tailored tertiary node after [0, 0, 0]. 501| 0| int32_t index = findOrInsertNodeForRootCE(0, UCOL_TERTIARY, errorCode); 502| 0| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (502:12): [True: 0, False: 0] ------------------ 503| 0| int64_t node = nodes.elementAti(index); 504| 0| if((index = nextIndexFromNode(node)) != 0) { ------------------ | Branch (504:12): [True: 0, False: 0] ------------------ 505| 0| node = nodes.elementAti(index); 506| 0| U_ASSERT(strengthFromNode(node) <= UCOL_TERTIARY); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 507| 0| if(isTailoredNode(node) && strengthFromNode(node) == UCOL_TERTIARY) { ------------------ | Branch (507:16): [True: 0, False: 0] | Branch (507:40): [True: 0, False: 0] ------------------ 508| 0| return tempCEFromIndexAndStrength(index, UCOL_TERTIARY); 509| 0| } 510| 0| } 511| 0| return rootElements.getFirstTertiaryCE(); 512| | // No need to look for nodeHasAnyBefore() on a tertiary node. 513| 0| } 514| 736| case CollationRuleParser::LAST_SECONDARY_IGNORABLE: ------------------ | Branch (514:5): [True: 736, False: 174] ------------------ 515| 736| ce = rootElements.getLastTertiaryCE(); 516| 736| strength = UCOL_TERTIARY; 517| 736| break; 518| 0| case CollationRuleParser::FIRST_PRIMARY_IGNORABLE: { ------------------ | Branch (518:5): [True: 0, False: 910] ------------------ 519| | // Look for a tailored secondary node after [0, 0, *]. 520| 0| int32_t index = findOrInsertNodeForRootCE(0, UCOL_SECONDARY, errorCode); 521| 0| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (521:12): [True: 0, False: 0] ------------------ 522| 0| int64_t node = nodes.elementAti(index); 523| 0| while((index = nextIndexFromNode(node)) != 0) { ------------------ | Branch (523:15): [True: 0, False: 0] ------------------ 524| 0| node = nodes.elementAti(index); 525| 0| strength = strengthFromNode(node); 526| 0| if(strength < UCOL_SECONDARY) { break; } ------------------ | Branch (526:16): [True: 0, False: 0] ------------------ 527| 0| if(strength == UCOL_SECONDARY) { ------------------ | Branch (527:16): [True: 0, False: 0] ------------------ 528| 0| if(isTailoredNode(node)) { ------------------ | Branch (528:20): [True: 0, False: 0] ------------------ 529| 0| if(nodeHasBefore3(node)) { ------------------ | Branch (529:24): [True: 0, False: 0] ------------------ 530| 0| index = nextIndexFromNode(nodes.elementAti(nextIndexFromNode(node))); 531| 0| U_ASSERT(isTailoredNode(nodes.elementAti(index))); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 532| 0| } 533| 0| return tempCEFromIndexAndStrength(index, UCOL_SECONDARY); 534| 0| } else { 535| 0| break; 536| 0| } 537| 0| } 538| 0| } 539| 0| ce = rootElements.getFirstSecondaryCE(); 540| 0| strength = UCOL_SECONDARY; 541| 0| break; 542| 0| } 543| 0| case CollationRuleParser::LAST_PRIMARY_IGNORABLE: ------------------ | Branch (543:5): [True: 0, False: 910] ------------------ 544| 0| ce = rootElements.getLastSecondaryCE(); 545| 0| strength = UCOL_SECONDARY; 546| 0| break; 547| 1| case CollationRuleParser::FIRST_VARIABLE: ------------------ | Branch (547:5): [True: 1, False: 909] ------------------ 548| 1| ce = rootElements.getFirstPrimaryCE(); 549| 1| isBoundary = true; // FractionalUCA.txt: FDD1 00A0, SPACE first primary 550| 1| break; 551| 0| case CollationRuleParser::LAST_VARIABLE: ------------------ | Branch (551:5): [True: 0, False: 910] ------------------ 552| 0| ce = rootElements.lastCEWithPrimaryBefore(variableTop + 1); 553| 0| break; 554| 0| case CollationRuleParser::FIRST_REGULAR: ------------------ | Branch (554:5): [True: 0, False: 910] ------------------ 555| 0| ce = rootElements.firstCEWithPrimaryAtLeast(variableTop + 1); 556| 0| isBoundary = true; // FractionalUCA.txt: FDD1 263A, SYMBOL first primary 557| 0| break; 558| 4| case CollationRuleParser::LAST_REGULAR: ------------------ | Branch (558:5): [True: 4, False: 906] ------------------ 559| | // Use the Hani-first-primary rather than the actual last "regular" CE before it, 560| | // for backward compatibility with behavior before the introduction of 561| | // script-first-primary CEs in the root collator. 562| 4| ce = rootElements.firstCEWithPrimaryAtLeast( 563| 4| baseData->getFirstPrimaryForGroup(USCRIPT_HAN)); 564| 4| break; 565| 0| case CollationRuleParser::FIRST_IMPLICIT: ------------------ | Branch (565:5): [True: 0, False: 910] ------------------ 566| 0| ce = baseData->getSingleCE(0x4e00, errorCode); 567| 0| break; 568| 0| case CollationRuleParser::LAST_IMPLICIT: ------------------ | Branch (568:5): [True: 0, False: 910] ------------------ 569| | // We do not support tailoring to an unassigned-implicit CE. 570| 0| errorCode = U_UNSUPPORTED_ERROR; 571| 0| parserErrorReason = "reset to [last implicit] not supported"; 572| 0| return 0; 573| 0| case CollationRuleParser::FIRST_TRAILING: ------------------ | Branch (573:5): [True: 0, False: 910] ------------------ 574| 0| ce = Collation::makeCE(Collation::FIRST_TRAILING_PRIMARY); 575| 0| isBoundary = true; // trailing first primary (there is no mapping for it) 576| 0| break; 577| 1| case CollationRuleParser::LAST_TRAILING: ------------------ | Branch (577:5): [True: 1, False: 909] ------------------ 578| 1| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 579| 1| parserErrorReason = "LDML forbids tailoring to U+FFFF"; 580| 1| return 0; 581| 0| default: ------------------ | Branch (581:5): [True: 0, False: 910] ------------------ 582| 0| UPRV_UNREACHABLE_EXIT; ------------------ | | 68| 0|# define UPRV_UNREACHABLE_EXIT abort() ------------------ 583| 910| } 584| | 585| 741| int32_t index = findOrInsertNodeForRootCE(ce, strength, errorCode); 586| 741| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (586:8): [True: 0, False: 741] ------------------ 587| 741| int64_t node = nodes.elementAti(index); 588| 741| if((pos & 1) == 0) { ------------------ | Branch (588:8): [True: 1, False: 740] ------------------ 589| | // even pos = [first xyz] 590| 1| if(!nodeHasAnyBefore(node) && isBoundary) { ------------------ | Branch (590:12): [True: 1, False: 0] | Branch (590:39): [True: 1, False: 0] ------------------ 591| | // A first primary boundary is artificially added to FractionalUCA.txt. 592| | // It is reachable via its special contraction, but is not normally used. 593| | // Find the first character tailored after the boundary CE, 594| | // or the first real root CE after it. 595| 1| if((index = nextIndexFromNode(node)) != 0) { ------------------ | Branch (595:16): [True: 0, False: 1] ------------------ 596| | // If there is a following node, then it must be tailored 597| | // because there are no root CEs with a boundary primary 598| | // and non-common secondary/tertiary weights. 599| 0| node = nodes.elementAti(index); 600| 0| U_ASSERT(isTailoredNode(node)); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 601| 0| ce = tempCEFromIndexAndStrength(index, strength); 602| 1| } else { 603| 1| U_ASSERT(strength == UCOL_PRIMARY); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 604| 1| uint32_t p = static_cast(ce >> 32); 605| 1| int32_t pIndex = rootElements.findPrimary(p); 606| 1| UBool isCompressible = baseData->isCompressiblePrimary(p); 607| 1| p = rootElements.getPrimaryAfter(p, pIndex, isCompressible); 608| 1| ce = Collation::makeCE(p); 609| 1| index = findOrInsertNodeForRootCE(ce, UCOL_PRIMARY, errorCode); 610| 1| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (610:20): [True: 0, False: 1] ------------------ 611| 1| node = nodes.elementAti(index); 612| 1| } 613| 1| } 614| 1| if(nodeHasAnyBefore(node)) { ------------------ | Branch (614:12): [True: 0, False: 1] ------------------ 615| | // Get the first node that was tailored before this one at a weaker strength. 616| 0| if(nodeHasBefore2(node)) { ------------------ | Branch (616:16): [True: 0, False: 0] ------------------ 617| 0| index = nextIndexFromNode(nodes.elementAti(nextIndexFromNode(node))); 618| 0| node = nodes.elementAti(index); 619| 0| } 620| 0| if(nodeHasBefore3(node)) { ------------------ | Branch (620:16): [True: 0, False: 0] ------------------ 621| 0| index = nextIndexFromNode(nodes.elementAti(nextIndexFromNode(node))); 622| 0| } 623| 0| U_ASSERT(isTailoredNode(nodes.elementAti(index))); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 624| 0| ce = tempCEFromIndexAndStrength(index, strength); 625| 0| } 626| 740| } else { 627| | // odd pos = [last xyz] 628| | // Find the last node that was tailored after the [last xyz] 629| | // at a strength no greater than the position's strength. 630| 153k| for(;;) { 631| 153k| int32_t nextIndex = nextIndexFromNode(node); 632| 153k| if(nextIndex == 0) { break; } ------------------ | Branch (632:16): [True: 406, False: 153k] ------------------ 633| 153k| int64_t nextNode = nodes.elementAti(nextIndex); 634| 153k| if(strengthFromNode(nextNode) < strength) { break; } ------------------ | Branch (634:16): [True: 334, False: 152k] ------------------ 635| 152k| index = nextIndex; 636| 152k| node = nextNode; 637| 152k| } 638| | // Do not make a temporary CE for a root node. 639| | // This last node might be the node for the root CE itself, 640| | // or a node with a common secondary or tertiary weight. 641| 740| if(isTailoredNode(node)) { ------------------ | Branch (641:12): [True: 570, False: 170] ------------------ 642| 570| ce = tempCEFromIndexAndStrength(index, strength); 643| 570| } 644| 740| } 645| 741| return ce; 646| 741|} _ZN6icu_7816CollationBuilder11addRelationEiRKNS_13UnicodeStringES3_S3_RPKcR10UErrorCode: 651| 5.98M| const char *&parserErrorReason, UErrorCode &errorCode) { 652| 5.98M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (652:8): [True: 4, False: 5.98M] ------------------ 653| 5.98M| UnicodeString nfdPrefix; 654| 5.98M| if(!prefix.isEmpty()) { ------------------ | Branch (654:8): [True: 4.28k, False: 5.98M] ------------------ 655| 4.28k| nfd.normalize(prefix, nfdPrefix, errorCode); 656| 4.28k| if(U_FAILURE(errorCode)) { ------------------ | Branch (656:12): [True: 0, False: 4.28k] ------------------ 657| 0| parserErrorReason = "normalizing the relation prefix"; 658| 0| return; 659| 0| } 660| 4.28k| } 661| 5.98M| UnicodeString nfdString = nfd.normalize(str, errorCode); 662| 5.98M| if(U_FAILURE(errorCode)) { ------------------ | Branch (662:8): [True: 0, False: 5.98M] ------------------ 663| 0| parserErrorReason = "normalizing the relation string"; 664| 0| return; 665| 0| } 666| | 667| | // The runtime code decomposes Hangul syllables on the fly, 668| | // with recursive processing but without making the Jamo pieces visible for matching. 669| | // It does not work with certain types of contextual mappings. 670| 5.98M| int32_t nfdLength = nfdString.length(); 671| 5.98M| if(nfdLength >= 2) { ------------------ | Branch (671:8): [True: 770k, False: 5.21M] ------------------ 672| 770k| char16_t c = nfdString.charAt(0); 673| 770k| if(Hangul::isJamoL(c) || Hangul::isJamoV(c)) { ------------------ | Branch (673:12): [True: 10, False: 770k] | Branch (673:34): [True: 1, False: 770k] ------------------ 674| | // While handling a Hangul syllable, contractions starting with Jamo L or V 675| | // would not see the following Jamo of that syllable. 676| 11| errorCode = U_UNSUPPORTED_ERROR; 677| 11| parserErrorReason = "contractions starting with conjoining Jamo L or V not supported"; 678| 11| return; 679| 11| } 680| 770k| c = nfdString.charAt(nfdLength - 1); 681| 770k| if(Hangul::isJamoL(c) || ------------------ | Branch (681:12): [True: 1, False: 770k] ------------------ 682| 770k| (Hangul::isJamoV(c) && Hangul::isJamoL(nfdString.charAt(nfdLength - 2)))) { ------------------ | Branch (682:18): [True: 473, False: 770k] | Branch (682:40): [True: 2, False: 471] ------------------ 683| | // A contraction ending with Jamo L or L+V would require 684| | // generating Hangul syllables in addTailComposites() (588 for a Jamo L), 685| | // or decomposing a following Hangul syllable on the fly, during contraction matching. 686| 3| errorCode = U_UNSUPPORTED_ERROR; 687| 3| parserErrorReason = "contractions ending with conjoining Jamo L or L+V not supported"; 688| 3| return; 689| 3| } 690| | // A Hangul syllable completely inside a contraction is ok. 691| 770k| } 692| | // Note: If there is a prefix, then the parser checked that 693| | // both the prefix and the string begin with NFC boundaries (not Jamo V or T). 694| | // Therefore: prefix.isEmpty() || !isJamoVOrT(nfdString.charAt(0)) 695| | // (While handling a Hangul syllable, prefixes on Jamo V or T 696| | // would not see the previous Jamo of that syllable.) 697| | 698| 5.98M| if(strength != UCOL_IDENTICAL) { ------------------ | Branch (698:8): [True: 4.37M, False: 1.61M] ------------------ 699| | // Find the node index after which we insert the new tailored node. 700| 4.37M| int32_t index = findOrInsertNodeForCEs(strength, parserErrorReason, errorCode); 701| 4.37M| U_ASSERT(cesLength > 0); ------------------ | | 35| 4.37M|# define U_ASSERT(exp) (void)0 ------------------ 702| 4.37M| int64_t ce = ces[cesLength - 1]; 703| 4.37M| if (strength == UCOL_PRIMARY && !isTempCE(ce) && static_cast(ce >> 32) == 0) { ------------------ | Branch (703:13): [True: 3.52M, False: 854k] | Branch (703:41): [True: 10.9k, False: 3.50M] | Branch (703:58): [True: 6, False: 10.9k] ------------------ 704| | // There is no primary gap between ignorables and the space-first-primary. 705| 6| errorCode = U_UNSUPPORTED_ERROR; 706| 6| parserErrorReason = "tailoring primary after ignorables not supported"; 707| 6| return; 708| 6| } 709| 4.37M| if(strength == UCOL_QUATERNARY && ce == 0) { ------------------ | Branch (709:12): [True: 1.06k, False: 4.37M] | Branch (709:43): [True: 1, False: 1.06k] ------------------ 710| | // The CE data structure does not support non-zero quaternary weights 711| | // on tertiary ignorables. 712| 1| errorCode = U_UNSUPPORTED_ERROR; 713| 1| parserErrorReason = "tailoring quaternary after tertiary ignorables not supported"; 714| 1| return; 715| 1| } 716| | // Insert the new tailored node. 717| 4.37M| index = insertTailoredNodeAfter(index, strength, errorCode); 718| 4.37M| if(U_FAILURE(errorCode)) { ------------------ | Branch (718:12): [True: 4, False: 4.37M] ------------------ 719| 4| parserErrorReason = "modifying collation elements"; 720| 4| return; 721| 4| } 722| | // Strength of the temporary CE: 723| | // The new relation may yield a stronger CE but not a weaker one. 724| 4.37M| int32_t tempStrength = ceStrength(ce); 725| 4.37M| if(strength < tempStrength) { tempStrength = strength; } ------------------ | Branch (725:12): [True: 908, False: 4.37M] ------------------ 726| 4.37M| ces[cesLength - 1] = tempCEFromIndexAndStrength(index, tempStrength); 727| 4.37M| } 728| | 729| 5.98M| setCaseBits(nfdString, parserErrorReason, errorCode); 730| 5.98M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (730:8): [True: 0, False: 5.98M] ------------------ 731| | 732| 5.98M| int32_t cesLengthBeforeExtension = cesLength; 733| 5.98M| if(!extension.isEmpty()) { ------------------ | Branch (733:8): [True: 979, False: 5.98M] ------------------ 734| 979| UnicodeString nfdExtension = nfd.normalize(extension, errorCode); 735| 979| if(U_FAILURE(errorCode)) { ------------------ | Branch (735:12): [True: 0, False: 979] ------------------ 736| 0| parserErrorReason = "normalizing the relation extension"; 737| 0| return; 738| 0| } 739| 979| cesLength = dataBuilder->getCEs(nfdExtension, ces, cesLength); 740| 979| if(cesLength > Collation::MAX_EXPANSION_LENGTH) { ------------------ | Branch (740:12): [True: 1, False: 978] ------------------ 741| 1| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 742| 1| parserErrorReason = 743| 1| "extension string adds too many collation elements (more than 31 total)"; 744| 1| return; 745| 1| } 746| 979| } 747| 5.98M| uint32_t ce32 = Collation::UNASSIGNED_CE32; 748| 5.98M| if(!icu4xMode && (prefix != nfdPrefix || str != nfdString) && ------------------ | Branch (748:8): [True: 5.98M, False: 0] | Branch (748:23): [True: 1.95k, False: 5.98M] | Branch (748:46): [True: 18.3k, False: 5.96M] ------------------ 749| 5.98M| !ignorePrefix(prefix, errorCode) && !ignoreString(str, errorCode)) { ------------------ | Branch (749:13): [True: 20.1k, False: 161] | Branch (749:49): [True: 18.9k, False: 1.26k] ------------------ 750| | // Map from the original input to the CEs. 751| | // We do this in case the canonical closure is incomplete, 752| | // so that it is possible to explicitly provide the missing mappings. 753| 18.9k| ce32 = addIfDifferent(prefix, str, ces, cesLength, ce32, errorCode); 754| 18.9k| } 755| 5.98M| if (!icu4xMode) { ------------------ | Branch (755:9): [True: 5.98M, False: 0] ------------------ 756| 5.98M| addWithClosure(nfdPrefix, nfdString, ces, cesLength, ce32, errorCode); 757| 5.98M| } else { 758| 0| addIfDifferent(nfdPrefix, nfdString, ces, cesLength, ce32, errorCode); 759| 0| } 760| 5.98M| if(U_FAILURE(errorCode)) { ------------------ | Branch (760:8): [True: 293, False: 5.98M] ------------------ 761| 293| parserErrorReason = "writing collation elements"; 762| 293| return; 763| 293| } 764| 5.98M| cesLength = cesLengthBeforeExtension; 765| 5.98M|} _ZN6icu_7816CollationBuilder22findOrInsertNodeForCEsEiRPKcR10UErrorCode: 769| 4.38M| UErrorCode &errorCode) { 770| 4.38M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (770:8): [True: 0, False: 4.38M] ------------------ 771| 4.38M| U_ASSERT(UCOL_PRIMARY <= strength && strength <= UCOL_QUATERNARY); ------------------ | | 35| 4.38M|# define U_ASSERT(exp) (void)0 ------------------ 772| | 773| | // Find the last CE that is at least as "strong" as the requested difference. 774| | // Note: Stronger is smaller (UCOL_PRIMARY=0). 775| 4.38M| int64_t ce; 776| 4.38M| for(;; --cesLength) { 777| 4.38M| if(cesLength == 0) { ------------------ | Branch (777:12): [True: 916, False: 4.38M] ------------------ 778| 916| ce = ces[0] = 0; 779| 916| cesLength = 1; 780| 916| break; 781| 4.38M| } else { 782| 4.38M| ce = ces[cesLength - 1]; 783| 4.38M| } 784| 4.38M| if(ceStrength(ce) <= strength) { break; } ------------------ | Branch (784:12): [True: 4.38M, False: 1.61k] ------------------ 785| 4.38M| } 786| | 787| 4.38M| if(isTempCE(ce)) { ------------------ | Branch (787:8): [True: 4.34M, False: 41.3k] ------------------ 788| | // No need to findCommonNode() here for lower levels 789| | // because insertTailoredNodeAfter() will do that anyway. 790| 4.34M| return indexFromTempCE(ce); 791| 4.34M| } 792| | 793| | // root CE 794| 41.3k| if (static_cast(ce >> 56) == Collation::UNASSIGNED_IMPLICIT_BYTE) { ------------------ | Branch (794:9): [True: 5, False: 41.3k] ------------------ 795| 5| errorCode = U_UNSUPPORTED_ERROR; 796| 5| parserErrorReason = "tailoring relative to an unassigned code point not supported"; 797| 5| return 0; 798| 5| } 799| 41.3k| return findOrInsertNodeForRootCE(ce, strength, errorCode); 800| 41.3k|} _ZN6icu_7816CollationBuilder25findOrInsertNodeForRootCEEliR10UErrorCode: 803| 42.1k|CollationBuilder::findOrInsertNodeForRootCE(int64_t ce, int32_t strength, UErrorCode &errorCode) { 804| 42.1k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (804:8): [True: 0, False: 42.1k] ------------------ 805| 42.1k| U_ASSERT((uint8_t)(ce >> 56) != Collation::UNASSIGNED_IMPLICIT_BYTE); ------------------ | | 35| 42.1k|# define U_ASSERT(exp) (void)0 ------------------ 806| | 807| | // Find or insert the node for each of the root CE's weights, 808| | // down to the requested level/strength. 809| | // Root CEs must have common=zero quaternary weights (for which we never insert any nodes). 810| 42.1k| U_ASSERT((ce & 0xc0) == 0); ------------------ | | 35| 42.1k|# define U_ASSERT(exp) (void)0 ------------------ 811| 42.1k| int32_t index = findOrInsertNodeForPrimary(static_cast(ce >> 32), errorCode); 812| 42.1k| if(strength >= UCOL_SECONDARY) { ------------------ | Branch (812:8): [True: 27.1k, False: 14.9k] ------------------ 813| 27.1k| uint32_t lower32 = static_cast(ce); 814| 27.1k| index = findOrInsertWeakNode(index, lower32 >> 16, UCOL_SECONDARY, errorCode); 815| 27.1k| if(strength >= UCOL_TERTIARY) { ------------------ | Branch (815:12): [True: 12.4k, False: 14.7k] ------------------ 816| 12.4k| index = findOrInsertWeakNode(index, lower32 & Collation::ONLY_TERTIARY_MASK, 817| 12.4k| UCOL_TERTIARY, errorCode); 818| 12.4k| } 819| 27.1k| } 820| 42.1k| return index; 821| 42.1k|} _ZN6icu_7816CollationBuilder26findOrInsertNodeForPrimaryEjR10UErrorCode: 861| 46.7k|CollationBuilder::findOrInsertNodeForPrimary(uint32_t p, UErrorCode &errorCode) { 862| 46.7k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (862:8): [True: 0, False: 46.7k] ------------------ 863| | 864| 46.7k| int32_t rootIndex = binarySearchForRootPrimaryNode( 865| 46.7k| rootPrimaryIndexes.getBuffer(), rootPrimaryIndexes.size(), nodes.getBuffer(), p); 866| 46.7k| if(rootIndex >= 0) { ------------------ | Branch (866:8): [True: 25.1k, False: 21.6k] ------------------ 867| 25.1k| return rootPrimaryIndexes.elementAti(rootIndex); 868| 25.1k| } else { 869| | // Start a new list of nodes with this primary. 870| 21.6k| int32_t index = nodes.size(); 871| 21.6k| nodes.addElement(nodeFromWeight32(p), errorCode); 872| 21.6k| rootPrimaryIndexes.insertElementAt(index, ~rootIndex, errorCode); 873| 21.6k| return index; 874| 21.6k| } 875| 46.7k|} _ZN6icu_7816CollationBuilder20findOrInsertWeakNodeEijiR10UErrorCode: 878| 40.2k|CollationBuilder::findOrInsertWeakNode(int32_t index, uint32_t weight16, int32_t level, UErrorCode &errorCode) { 879| 40.2k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (879:8): [True: 0, False: 40.2k] ------------------ 880| 40.2k| U_ASSERT(0 <= index && index < nodes.size()); ------------------ | | 35| 40.2k|# define U_ASSERT(exp) (void)0 ------------------ 881| 40.2k| U_ASSERT(UCOL_SECONDARY <= level && level <= UCOL_TERTIARY); ------------------ | | 35| 40.2k|# define U_ASSERT(exp) (void)0 ------------------ 882| | 883| 40.2k| if(weight16 == Collation::COMMON_WEIGHT16) { ------------------ | Branch (883:8): [True: 33.3k, False: 6.88k] ------------------ 884| 33.3k| return findCommonNode(index, level); 885| 33.3k| } 886| | 887| | // If this will be the first below-common weight for the parent node, 888| | // then we will also need to insert a common weight after it. 889| 6.88k| int64_t node = nodes.elementAti(index); 890| 6.88k| U_ASSERT(strengthFromNode(node) < level); // parent node is stronger ------------------ | | 35| 6.88k|# define U_ASSERT(exp) (void)0 ------------------ 891| 6.88k| if(weight16 != 0 && weight16 < Collation::COMMON_WEIGHT16) { ------------------ | Branch (891:8): [True: 4.53k, False: 2.35k] | Branch (891:25): [True: 1.05k, False: 3.48k] ------------------ 892| 1.05k| int32_t hasThisLevelBefore = level == UCOL_SECONDARY ? HAS_BEFORE2 : HAS_BEFORE3; ------------------ | Branch (892:38): [True: 532, False: 522] ------------------ 893| 1.05k| if((node & hasThisLevelBefore) == 0) { ------------------ | Branch (893:12): [True: 849, False: 205] ------------------ 894| | // The parent node has an implied level-common weight. 895| 849| int64_t commonNode = 896| 849| nodeFromWeight16(Collation::COMMON_WEIGHT16) | nodeFromStrength(level); 897| 849| if(level == UCOL_SECONDARY) { ------------------ | Branch (897:16): [True: 532, False: 317] ------------------ 898| | // Move the HAS_BEFORE3 flag from the parent node 899| | // to the new secondary common node. 900| 532| commonNode |= node & HAS_BEFORE3; 901| 532| node &= ~static_cast(HAS_BEFORE3); 902| 532| } 903| 849| nodes.setElementAt(node | hasThisLevelBefore, index); 904| | // Insert below-common-weight node. 905| 849| int32_t nextIndex = nextIndexFromNode(node); 906| 849| node = nodeFromWeight16(weight16) | nodeFromStrength(level); 907| 849| index = insertNodeBetween(index, nextIndex, node, errorCode); 908| | // Insert common-weight node. 909| 849| insertNodeBetween(index, nextIndex, commonNode, errorCode); 910| | // Return index of below-common-weight node. 911| 849| return index; 912| 849| } 913| 1.05k| } 914| | 915| | // Find the root CE's weight for this level. 916| | // Postpone insertion if not found: 917| | // Insert the new root node before the next stronger node, 918| | // or before the next root node with the same strength and a larger weight. 919| 6.03k| int32_t nextIndex; 920| 33.2k| while((nextIndex = nextIndexFromNode(node)) != 0) { ------------------ | Branch (920:11): [True: 30.7k, False: 2.44k] ------------------ 921| 30.7k| node = nodes.elementAti(nextIndex); 922| 30.7k| int32_t nextStrength = strengthFromNode(node); 923| 30.7k| if(nextStrength <= level) { ------------------ | Branch (923:12): [True: 13.7k, False: 17.0k] ------------------ 924| | // Insert before a stronger node. 925| 13.7k| if(nextStrength < level) { break; } ------------------ | Branch (925:16): [True: 159, False: 13.6k] ------------------ 926| | // nextStrength == level 927| 13.6k| if(!isTailoredNode(node)) { ------------------ | Branch (927:16): [True: 4.50k, False: 9.12k] ------------------ 928| 4.50k| uint32_t nextWeight16 = weight16FromNode(node); 929| 4.50k| if(nextWeight16 == weight16) { ------------------ | Branch (929:20): [True: 3.08k, False: 1.42k] ------------------ 930| | // Found the node for the root CE up to this level. 931| 3.08k| return nextIndex; 932| 3.08k| } 933| | // Insert before a node with a larger same-strength weight. 934| 1.42k| if(nextWeight16 > weight16) { break; } ------------------ | Branch (934:20): [True: 347, False: 1.07k] ------------------ 935| 1.42k| } 936| 13.6k| } 937| | // Skip the next node. 938| 27.2k| index = nextIndex; 939| 27.2k| } 940| 2.95k| node = nodeFromWeight16(weight16) | nodeFromStrength(level); 941| 2.95k| return insertNodeBetween(index, nextIndex, node, errorCode); 942| 6.03k|} _ZN6icu_7816CollationBuilder23insertTailoredNodeAfterEiiR10UErrorCode: 945| 4.37M|CollationBuilder::insertTailoredNodeAfter(int32_t index, int32_t strength, UErrorCode &errorCode) { 946| 4.37M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (946:8): [True: 4, False: 4.37M] ------------------ 947| 4.37M| U_ASSERT(0 <= index && index < nodes.size()); ------------------ | | 35| 4.37M|# define U_ASSERT(exp) (void)0 ------------------ 948| 4.37M| if(strength >= UCOL_SECONDARY) { ------------------ | Branch (948:8): [True: 854k, False: 3.52M] ------------------ 949| 854k| index = findCommonNode(index, UCOL_SECONDARY); 950| 854k| if(strength >= UCOL_TERTIARY) { ------------------ | Branch (950:12): [True: 132k, False: 721k] ------------------ 951| 132k| index = findCommonNode(index, UCOL_TERTIARY); 952| 132k| } 953| 854k| } 954| | // Postpone insertion: 955| | // Insert the new node before the next one with a strength at least as strong. 956| 4.37M| int64_t node = nodes.elementAti(index); 957| 4.37M| int32_t nextIndex; 958| 4.39M| while((nextIndex = nextIndexFromNode(node)) != 0) { ------------------ | Branch (958:11): [True: 1.23M, False: 3.16M] ------------------ 959| 1.23M| node = nodes.elementAti(nextIndex); 960| 1.23M| if(strengthFromNode(node) <= strength) { break; } ------------------ | Branch (960:12): [True: 1.21M, False: 21.5k] ------------------ 961| | // Skip the next node which has a weaker (larger) strength than the new one. 962| 21.5k| index = nextIndex; 963| 21.5k| } 964| 4.37M| node = IS_TAILORED | nodeFromStrength(strength); 965| 4.37M| return insertNodeBetween(index, nextIndex, node, errorCode); 966| 4.37M|} _ZN6icu_7816CollationBuilder17insertNodeBetweenEiilR10UErrorCode: 970| 4.37M| UErrorCode &errorCode) { 971| 4.37M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (971:8): [True: 0, False: 4.37M] ------------------ 972| 4.37M| U_ASSERT(previousIndexFromNode(node) == 0); ------------------ | | 35| 4.37M|# define U_ASSERT(exp) (void)0 ------------------ 973| 4.37M| U_ASSERT(nextIndexFromNode(node) == 0); ------------------ | | 35| 4.37M|# define U_ASSERT(exp) (void)0 ------------------ 974| 4.37M| U_ASSERT(nextIndexFromNode(nodes.elementAti(index)) == nextIndex); ------------------ | | 35| 4.37M|# define U_ASSERT(exp) (void)0 ------------------ 975| | // Append the new node and link it to the existing nodes. 976| 4.37M| int32_t newIndex = nodes.size(); 977| 4.37M| node |= nodeFromPreviousIndex(index) | nodeFromNextIndex(nextIndex); 978| 4.37M| nodes.addElement(node, errorCode); 979| 4.37M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (979:8): [True: 0, False: 4.37M] ------------------ 980| | // nodes[index].nextIndex = newIndex 981| 4.37M| node = nodes.elementAti(index); 982| 4.37M| nodes.setElementAt(changeNodeNextIndex(node, newIndex), index); 983| | // nodes[nextIndex].previousIndex = newIndex 984| 4.37M| if(nextIndex != 0) { ------------------ | Branch (984:8): [True: 1.21M, False: 3.16M] ------------------ 985| 1.21M| node = nodes.elementAti(nextIndex); 986| 1.21M| nodes.setElementAt(changeNodePreviousIndex(node, newIndex), nextIndex); 987| 1.21M| } 988| 4.37M| return newIndex; 989| 4.37M|} _ZNK6icu_7816CollationBuilder14findCommonNodeEii: 992| 1.02M|CollationBuilder::findCommonNode(int32_t index, int32_t strength) const { 993| 1.02M| U_ASSERT(UCOL_SECONDARY <= strength && strength <= UCOL_TERTIARY); ------------------ | | 35| 1.02M|# define U_ASSERT(exp) (void)0 ------------------ 994| 1.02M| int64_t node = nodes.elementAti(index); 995| 1.02M| if(strengthFromNode(node) >= strength) { ------------------ | Branch (995:8): [True: 937k, False: 85.1k] ------------------ 996| | // The current node is no stronger. 997| 937k| return index; 998| 937k| } 999| 85.1k| if(strength == UCOL_SECONDARY ? !nodeHasBefore2(node) : !nodeHasBefore3(node)) { ------------------ | Branch (999:8): [True: 54.4k, False: 30.6k] | Branch (999:8): [True: 83.7k, False: 1.37k] ------------------ 1000| | // The current node implies the strength-common weight. 1001| 83.7k| return index; 1002| 83.7k| } 1003| 1.37k| index = nextIndexFromNode(node); 1004| 1.37k| node = nodes.elementAti(index); 1005| 1.37k| U_ASSERT(!isTailoredNode(node) && strengthFromNode(node) == strength && ------------------ | | 35| 1.37k|# define U_ASSERT(exp) (void)0 ------------------ 1006| 1.37k| weight16FromNode(node) < Collation::COMMON_WEIGHT16); 1007| | // Skip to the explicit common node. 1008| 8.14k| do { 1009| 8.14k| index = nextIndexFromNode(node); 1010| 8.14k| node = nodes.elementAti(index); 1011| 8.14k| U_ASSERT(strengthFromNode(node) >= strength); ------------------ | | 35| 8.14k|# define U_ASSERT(exp) (void)0 ------------------ 1012| 8.14k| } while(isTailoredNode(node) || strengthFromNode(node) > strength || ------------------ | Branch (1012:13): [True: 6.73k, False: 1.41k] | Branch (1012:37): [True: 0, False: 1.41k] ------------------ 1013| 8.14k| weight16FromNode(node) < Collation::COMMON_WEIGHT16); ------------------ | Branch (1013:13): [True: 40, False: 1.37k] ------------------ 1014| 1.37k| U_ASSERT(weight16FromNode(node) == Collation::COMMON_WEIGHT16); ------------------ | | 35| 1.37k|# define U_ASSERT(exp) (void)0 ------------------ 1015| 1.37k| return index; 1016| 85.1k|} _ZN6icu_7816CollationBuilder11setCaseBitsERKNS_13UnicodeStringERPKcR10UErrorCode: 1020| 5.98M| const char *&parserErrorReason, UErrorCode &errorCode) { 1021| 5.98M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1021:8): [True: 0, False: 5.98M] ------------------ 1022| 5.98M| int32_t numTailoredPrimaries = 0; 1023| 17.7M| for(int32_t i = 0; i < cesLength; ++i) { ------------------ | Branch (1023:24): [True: 11.7M, False: 5.98M] ------------------ 1024| 11.7M| if(ceStrength(ces[i]) == UCOL_PRIMARY) { ++numTailoredPrimaries; } ------------------ | Branch (1024:12): [True: 11.3M, False: 439k] ------------------ 1025| 11.7M| } 1026| | // We should not be able to get too many case bits because 1027| | // cesLength<=31==MAX_EXPANSION_LENGTH. 1028| | // 31 pairs of case bits fit into an int64_t without setting its sign bit. 1029| 5.98M| U_ASSERT(numTailoredPrimaries <= 31); ------------------ | | 35| 5.98M|# define U_ASSERT(exp) (void)0 ------------------ 1030| | 1031| 5.98M| int64_t cases = 0; 1032| 5.98M| if(numTailoredPrimaries > 0) { ------------------ | Branch (1032:8): [True: 5.82M, False: 161k] ------------------ 1033| 5.82M| const char16_t *s = nfdString.getBuffer(); 1034| 5.82M| UTF16CollationIterator baseCEs(baseData, false, s, s, s + nfdString.length()); 1035| 5.82M| int32_t baseCEsLength = baseCEs.fetchCEs(errorCode) - 1; 1036| 5.82M| if(U_FAILURE(errorCode)) { ------------------ | Branch (1036:12): [True: 0, False: 5.82M] ------------------ 1037| 0| parserErrorReason = "fetching root CEs for tailored string"; 1038| 0| return; 1039| 0| } 1040| 5.82M| U_ASSERT(baseCEsLength >= 0 && baseCEs.getCE(baseCEsLength) == Collation::NO_CE); ------------------ | | 35| 5.82M|# define U_ASSERT(exp) (void)0 ------------------ 1041| | 1042| 5.82M| uint32_t lastCase = 0; 1043| 5.82M| int32_t numBasePrimaries = 0; 1044| 12.3M| for(int32_t i = 0; i < baseCEsLength; ++i) { ------------------ | Branch (1044:28): [True: 6.50M, False: 5.81M] ------------------ 1045| 6.50M| int64_t ce = baseCEs.getCE(i); 1046| 6.50M| if((ce >> 32) != 0) { ------------------ | Branch (1046:16): [True: 6.40M, False: 108k] ------------------ 1047| 6.40M| ++numBasePrimaries; 1048| 6.40M| uint32_t c = (static_cast(ce) >> 14) & 3; 1049| 6.40M| U_ASSERT(c == 0 || c == 2); // lowercase or uppercase, no mixed case in any base CE ------------------ | | 35| 6.40M|# define U_ASSERT(exp) (void)0 ------------------ 1050| 6.40M| if(numBasePrimaries < numTailoredPrimaries) { ------------------ | Branch (1050:20): [True: 1.25M, False: 5.14M] ------------------ 1051| 1.25M| cases |= static_cast(c) << ((numBasePrimaries - 1) * 2); 1052| 5.14M| } else if(numBasePrimaries == numTailoredPrimaries) { ------------------ | Branch (1052:27): [True: 5.00M, False: 143k] ------------------ 1053| 5.00M| lastCase = c; 1054| 5.00M| } else if(c != lastCase) { ------------------ | Branch (1054:27): [True: 7.20k, False: 136k] ------------------ 1055| | // There are more base primary CEs than tailored primaries. 1056| | // Set mixed case if the case bits of the remainder differ. 1057| 7.20k| lastCase = 1; 1058| | // Nothing more can change. 1059| 7.20k| break; 1060| 7.20k| } 1061| 6.40M| } 1062| 6.50M| } 1063| 5.82M| if(numBasePrimaries >= numTailoredPrimaries) { ------------------ | Branch (1063:12): [True: 5.00M, False: 822k] ------------------ 1064| 5.00M| cases |= static_cast(lastCase) << ((numTailoredPrimaries - 1) * 2); 1065| 5.00M| } 1066| 5.82M| } 1067| | 1068| 17.7M| for(int32_t i = 0; i < cesLength; ++i) { ------------------ | Branch (1068:24): [True: 11.7M, False: 5.98M] ------------------ 1069| 11.7M| int64_t ce = ces[i] & INT64_C(0xffffffffffff3fff); // clear old case bits 1070| 11.7M| int32_t strength = ceStrength(ce); 1071| 11.7M| if(strength == UCOL_PRIMARY) { ------------------ | Branch (1071:12): [True: 11.3M, False: 439k] ------------------ 1072| 11.3M| ce |= (cases & 3) << 14; 1073| 11.3M| cases >>= 2; 1074| 11.3M| } else if(strength == UCOL_TERTIARY) { ------------------ | Branch (1074:19): [True: 64.0k, False: 375k] ------------------ 1075| | // Tertiary CEs must have uppercase bits. 1076| | // See the LDML spec, and comments in class CollationCompare. 1077| 64.0k| ce |= 0x8000; 1078| 64.0k| } 1079| | // Tertiary ignorable CEs must have 0 case bits. 1080| | // We set 0 case bits for secondary CEs too 1081| | // since currently only U+0345 is cased and maps to a secondary CE, 1082| | // and it is lowercase. Other secondaries are uncased. 1083| | // See [[:Cased:]&[:uca1=:]] where uca1 queries the root primary weight. 1084| 11.7M| ces[i] = ce; 1085| 11.7M| } 1086| 5.98M|} _ZN6icu_7816CollationBuilder20suppressContractionsERKNS_10UnicodeSetERPKcR10UErrorCode: 1090| 296| UErrorCode &errorCode) { 1091| 296| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1091:8): [True: 0, False: 296] ------------------ 1092| 296| dataBuilder->suppressContractions(set, errorCode); 1093| 296| if(U_FAILURE(errorCode)) { ------------------ | Branch (1093:8): [True: 0, False: 296] ------------------ 1094| 0| parserErrorReason = "application of [suppressContractions [set]] failed"; 1095| 0| } 1096| 296|} _ZN6icu_7816CollationBuilder8optimizeERKNS_10UnicodeSetERPKcR10UErrorCode: 1100| 90| UErrorCode &errorCode) { 1101| 90| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1101:8): [True: 0, False: 90] ------------------ 1102| 90| optimizeSet.addAll(set); 1103| 90|} _ZN6icu_7816CollationBuilder14addWithClosureERKNS_13UnicodeStringES3_PKlijR10UErrorCode: 1108| 5.98M| UErrorCode &errorCode) { 1109| | // Map from the NFD input to the CEs. 1110| 5.98M| ce32 = addIfDifferent(nfdPrefix, nfdString, newCEs, newCEsLength, ce32, errorCode); 1111| 5.98M| ce32 = addOnlyClosure(nfdPrefix, nfdString, newCEs, newCEsLength, ce32, errorCode); 1112| 5.98M| addTailComposites(nfdPrefix, nfdString, errorCode); 1113| 5.98M| return ce32; 1114| 5.98M|} _ZN6icu_7816CollationBuilder14addOnlyClosureERKNS_13UnicodeStringES3_PKlijR10UErrorCode: 1129| 6.75M| UErrorCode &errorCode) { 1130| 6.75M| if(U_FAILURE(errorCode)) { return ce32; } ------------------ | Branch (1130:8): [True: 0, False: 6.75M] ------------------ 1131| | 1132| 6.75M| int32_t loop = 0; 1133| | // Map from canonically equivalent input to the CEs. (But not from the all-NFD input.) 1134| 6.75M| if(nfdPrefix.isEmpty()) { ------------------ | Branch (1134:8): [True: 6.74M, False: 6.40k] ------------------ 1135| 6.74M| CanonicalIterator stringIter(nfdString, errorCode); 1136| 6.74M| if(U_FAILURE(errorCode)) { return ce32; } ------------------ | Branch (1136:12): [True: 137, False: 6.74M] ------------------ 1137| 6.74M| UnicodeString prefix; 1138| 16.1M| for(;;) { 1139| 16.1M| UnicodeString str = stringIter.next(); 1140| 16.1M| if(str.isBogus()) { break; } ------------------ | Branch (1140:16): [True: 6.74M, False: 9.38M] ------------------ 1141| 9.38M| if (loop++ > kClosureLoopLimit) { ------------------ | Branch (1141:17): [True: 105, False: 9.38M] ------------------ 1142| | // To avoid hang as in ICU-22517, return with error. 1143| 105| errorCode = U_INPUT_TOO_LONG_ERROR; 1144| 105| return ce32; 1145| 105| } 1146| 9.38M| if(ignoreString(str, errorCode) || str == nfdString) { continue; } ------------------ | Branch (1146:16): [True: 930k, False: 8.45M] | Branch (1146:48): [True: 6.74M, False: 1.70M] ------------------ 1147| 1.70M| ce32 = addIfDifferent(prefix, str, newCEs, newCEsLength, ce32, errorCode); 1148| 1.70M| if(U_FAILURE(errorCode)) { return ce32; } ------------------ | Branch (1148:16): [True: 0, False: 1.70M] ------------------ 1149| 1.70M| } 1150| 6.74M| } else { 1151| 6.40k| CanonicalIterator prefixIter(nfdPrefix, errorCode); 1152| 6.40k| CanonicalIterator stringIter(nfdString, errorCode); 1153| 6.40k| if(U_FAILURE(errorCode)) { return ce32; } ------------------ | Branch (1153:12): [True: 12, False: 6.39k] ------------------ 1154| 99.6k| for(;;) { 1155| 99.6k| UnicodeString prefix = prefixIter.next(); 1156| 99.6k| if(prefix.isBogus()) { break; } ------------------ | Branch (1156:16): [True: 6.35k, False: 93.2k] ------------------ 1157| 93.2k| if(ignorePrefix(prefix, errorCode)) { continue; } ------------------ | Branch (1157:16): [True: 48.9k, False: 44.3k] ------------------ 1158| 44.3k| UBool samePrefix = prefix == nfdPrefix; 1159| 335k| for(;;) { 1160| 335k| UnicodeString str = stringIter.next(); 1161| 335k| if(str.isBogus()) { break; } ------------------ | Branch (1161:20): [True: 44.2k, False: 291k] ------------------ 1162| 291k| if (loop++ > kClosureLoopLimit) { ------------------ | Branch (1162:21): [True: 39, False: 291k] ------------------ 1163| | // To avoid hang as in ICU-22517, return with error. 1164| 39| errorCode = U_INPUT_TOO_LONG_ERROR; 1165| 39| return ce32; 1166| 39| } 1167| 291k| if(ignoreString(str, errorCode) || (samePrefix && str == nfdString)) { continue; } ------------------ | Branch (1167:20): [True: 150k, False: 140k] | Branch (1167:53): [True: 50.7k, False: 89.7k] | Branch (1167:67): [True: 6.35k, False: 44.4k] ------------------ 1168| 134k| ce32 = addIfDifferent(prefix, str, newCEs, newCEsLength, ce32, errorCode); 1169| 134k| if(U_FAILURE(errorCode)) { return ce32; } ------------------ | Branch (1169:20): [True: 0, False: 134k] ------------------ 1170| 134k| } 1171| 44.2k| stringIter.reset(); 1172| 44.2k| } 1173| 6.39k| } 1174| 6.75M| return ce32; 1175| 6.75M|} _ZN6icu_7816CollationBuilder17addTailCompositesERKNS_13UnicodeStringES3_R10UErrorCode: 1179| 5.98M| UErrorCode &errorCode) { 1180| 5.98M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1180:8): [True: 281, False: 5.98M] ------------------ 1181| | 1182| | // Look for the last starter in the NFD string. 1183| 5.98M| UChar32 lastStarter; 1184| 5.98M| int32_t indexAfterLastStarter = nfdString.length(); 1185| 6.04M| for(;;) { 1186| 6.04M| if(indexAfterLastStarter == 0) { return; } // no starter at all ------------------ | Branch (1186:12): [True: 34.4k, False: 6.00M] ------------------ 1187| 6.00M| lastStarter = nfdString.char32At(indexAfterLastStarter - 1); 1188| 6.00M| if(nfd.getCombiningClass(lastStarter) == 0) { break; } ------------------ | Branch (1188:12): [True: 5.95M, False: 55.4k] ------------------ 1189| 55.4k| indexAfterLastStarter -= U16_LENGTH(lastStarter); ------------------ | | 141| 55.4k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 55.2k, False: 174] | | ------------------ ------------------ 1190| 55.4k| } 1191| | // No closure to Hangul syllables since we decompose them on the fly. 1192| 5.95M| if(Hangul::isJamoL(lastStarter)) { return; } ------------------ | Branch (1192:8): [True: 1.13k, False: 5.95M] ------------------ 1193| | 1194| | // Are there any composites whose decomposition starts with the lastStarter? 1195| | // Note: Normalizer2Impl does not currently return start sets for NFC_QC=Maybe characters. 1196| | // We might find some more equivalent mappings here if it did. 1197| 5.95M| UnicodeSet composites; 1198| 5.95M| if(!nfcImpl.getCanonStartSet(lastStarter, composites)) { return; } ------------------ | Branch (1198:8): [True: 5.68M, False: 263k] ------------------ 1199| | 1200| 263k| UnicodeString decomp; 1201| 263k| UnicodeString newNFDString, newString; 1202| 263k| int64_t newCEs[Collation::MAX_EXPANSION_LENGTH]; 1203| 263k| UnicodeSetIterator iter(composites); 1204| 1.58M| while(iter.next()) { ------------------ | Branch (1204:11): [True: 1.31M, False: 263k] ------------------ 1205| 1.31M| U_ASSERT(!iter.isString()); ------------------ | | 35| 1.31M|# define U_ASSERT(exp) (void)0 ------------------ 1206| 1.31M| UChar32 composite = iter.getCodepoint(); 1207| 1.31M| nfd.getDecomposition(composite, decomp); 1208| 1.31M| if(!mergeCompositeIntoString(nfdString, indexAfterLastStarter, composite, decomp, ------------------ | Branch (1208:12): [True: 315k, False: 1.00M] ------------------ 1209| 1.31M| newNFDString, newString, errorCode)) { 1210| 315k| continue; 1211| 315k| } 1212| 1.00M| int32_t newCEsLength = dataBuilder->getCEs(nfdPrefix, newNFDString, newCEs, 0); 1213| 1.00M| if(newCEsLength > Collation::MAX_EXPANSION_LENGTH) { ------------------ | Branch (1213:12): [True: 5.52k, False: 998k] ------------------ 1214| | // Ignore mappings that we cannot store. 1215| 5.52k| continue; 1216| 5.52k| } 1217| | // Note: It is possible that the newCEs do not make use of the mapping 1218| | // for which we are adding the tail composites, in which case we might be adding 1219| | // unnecessary mappings. 1220| | // For example, when we add tail composites for ae^ (^=combining circumflex), 1221| | // UCA discontiguous-contraction matching does not find any matches 1222| | // for ae_^ (_=any combining diacritic below) *unless* there is also 1223| | // a contraction mapping for ae. 1224| | // Thus, if there is no ae contraction, then the ae^ mapping is ignored 1225| | // while fetching the newCEs for ae_^. 1226| | // TODO: Try to detect this effectively. 1227| | // (Alternatively, print a warning when prefix contractions are missing.) 1228| | 1229| | // We do not need an explicit mapping for the NFD strings. 1230| | // It is fine if the NFD input collates like this via a sequence of mappings. 1231| | // It also saves a little bit of space, and may reduce the set of characters with contractions. 1232| 998k| uint32_t ce32 = addIfDifferent(nfdPrefix, newString, 1233| 998k| newCEs, newCEsLength, Collation::UNASSIGNED_CE32, errorCode); 1234| 998k| if(ce32 != Collation::UNASSIGNED_CE32) { ------------------ | Branch (1234:12): [True: 767k, False: 231k] ------------------ 1235| | // was different, was added 1236| 767k| addOnlyClosure(nfdPrefix, newNFDString, newCEs, newCEsLength, ce32, errorCode); 1237| 767k| } 1238| 998k| } 1239| 263k|} _ZNK6icu_7816CollationBuilder24mergeCompositeIntoStringERKNS_13UnicodeStringEiiS3_RS1_S4_R10UErrorCode: 1246| 1.31M| UErrorCode &errorCode) const { 1247| 1.31M| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (1247:8): [True: 103, False: 1.31M] ------------------ 1248| 1.31M| U_ASSERT(nfdString.char32At(indexAfterLastStarter - 1) == decomp.char32At(0)); ------------------ | | 35| 1.31M|# define U_ASSERT(exp) (void)0 ------------------ 1249| 1.31M| int32_t lastStarterLength = decomp.moveIndex32(0, 1); 1250| 1.31M| if(lastStarterLength == decomp.length()) { ------------------ | Branch (1250:8): [True: 159k, False: 1.15M] ------------------ 1251| | // Singleton decompositions should be found by addWithClosure() 1252| | // and the CanonicalIterator, so we can ignore them here. 1253| 159k| return false; 1254| 159k| } 1255| 1.15M| if(nfdString.compare(indexAfterLastStarter, 0x7fffffff, ------------------ | Branch (1255:8): [True: 13.7k, False: 1.14M] ------------------ 1256| 1.15M| decomp, lastStarterLength, 0x7fffffff) == 0) { 1257| | // same strings, nothing new to be found here 1258| 13.7k| return false; 1259| 13.7k| } 1260| | 1261| | // Make new FCD strings that combine a composite, or its decomposition, 1262| | // into the nfdString's last starter and the combining marks following it. 1263| | // Make an NFD version, and a version with the composite. 1264| 1.14M| newNFDString.setTo(nfdString, 0, indexAfterLastStarter); 1265| 1.14M| newString.setTo(nfdString, 0, indexAfterLastStarter - lastStarterLength).append(composite); 1266| | 1267| | // The following is related to discontiguous contraction matching, 1268| | // but builds only FCD strings (or else returns false). 1269| 1.14M| int32_t sourceIndex = indexAfterLastStarter; 1270| 1.14M| int32_t decompIndex = lastStarterLength; 1271| | // Small optimization: We keep the source character across loop iterations 1272| | // because we do not always consume it, 1273| | // and then need not fetch it again nor look up its combining class again. 1274| 1.14M| UChar32 sourceChar = U_SENTINEL; ------------------ | | 469| 1.14M|#define U_SENTINEL (-1) ------------------ 1275| | // The cc variables need to be declared before the loop so that at the end 1276| | // they are set to the last combining classes seen. 1277| 1.14M| uint8_t sourceCC = 0; 1278| 1.14M| uint8_t decompCC = 0; 1279| 1.20M| for(;;) { 1280| 1.20M| if(sourceChar < 0) { ------------------ | Branch (1280:12): [True: 1.15M, False: 45.9k] ------------------ 1281| 1.15M| if(sourceIndex >= nfdString.length()) { break; } ------------------ | Branch (1281:16): [True: 976k, False: 180k] ------------------ 1282| 180k| sourceChar = nfdString.char32At(sourceIndex); 1283| 180k| sourceCC = nfd.getCombiningClass(sourceChar); 1284| 180k| U_ASSERT(sourceCC != 0); ------------------ | | 35| 180k|# define U_ASSERT(exp) (void)0 ------------------ 1285| 180k| } 1286| | // We consume a decomposition character in each iteration. 1287| 226k| if(decompIndex >= decomp.length()) { break; } ------------------ | Branch (1287:12): [True: 28.1k, False: 198k] ------------------ 1288| 198k| UChar32 decompChar = decomp.char32At(decompIndex); 1289| 198k| decompCC = nfd.getCombiningClass(decompChar); 1290| | // Compare the two characters and their combining classes. 1291| 198k| if(decompCC == 0) { ------------------ | Branch (1291:12): [True: 432, False: 197k] ------------------ 1292| | // Unable to merge because the source contains a non-zero combining mark 1293| | // but the composite's decomposition contains another starter. 1294| | // The strings would not be equivalent. 1295| 432| return false; 1296| 197k| } else if(sourceCC < decompCC) { ------------------ | Branch (1296:19): [True: 26.4k, False: 171k] ------------------ 1297| | // Composite + sourceChar would not be FCD. 1298| 26.4k| return false; 1299| 171k| } else if(decompCC < sourceCC) { ------------------ | Branch (1299:19): [True: 45.9k, False: 125k] ------------------ 1300| 45.9k| newNFDString.append(decompChar); 1301| 45.9k| decompIndex += U16_LENGTH(decompChar); ------------------ | | 141| 45.9k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 45.8k, False: 13] | | ------------------ ------------------ 1302| 125k| } else if(decompChar != sourceChar) { ------------------ | Branch (1302:19): [True: 114k, False: 10.5k] ------------------ 1303| | // Blocked because same combining class. 1304| 114k| return false; 1305| 114k| } else { // match: decompChar == sourceChar 1306| 10.5k| newNFDString.append(decompChar); 1307| 10.5k| decompIndex += U16_LENGTH(decompChar); ------------------ | | 141| 10.5k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 10.5k, False: 20] | | ------------------ ------------------ 1308| 10.5k| sourceIndex += U16_LENGTH(decompChar); ------------------ | | 141| 10.5k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 10.5k, False: 20] | | ------------------ ------------------ 1309| 10.5k| sourceChar = U_SENTINEL; ------------------ | | 469| 10.5k|#define U_SENTINEL (-1) ------------------ 1310| 10.5k| } 1311| 198k| } 1312| | // We are at the end of at least one of the two inputs. 1313| 1.00M| if(sourceChar >= 0) { // more characters from nfdString but not from decomp ------------------ | Branch (1313:8): [True: 28.1k, False: 976k] ------------------ 1314| 28.1k| if(sourceCC < decompCC) { ------------------ | Branch (1314:12): [True: 0, False: 28.1k] ------------------ 1315| | // Appending the next source character to the composite would not be FCD. 1316| 0| return false; 1317| 0| } 1318| 28.1k| newNFDString.append(nfdString, sourceIndex, 0x7fffffff); 1319| 28.1k| newString.append(nfdString, sourceIndex, 0x7fffffff); 1320| 976k| } else if(decompIndex < decomp.length()) { // more characters from decomp, not from nfdString ------------------ | Branch (1320:15): [True: 975k, False: 1.01k] ------------------ 1321| 975k| newNFDString.append(decomp, decompIndex, 0x7fffffff); 1322| 975k| } 1323| 1.00M| U_ASSERT(nfd.isNormalized(newNFDString, errorCode)); ------------------ | | 35| 1.00M|# define U_ASSERT(exp) (void)0 ------------------ 1324| 1.00M| U_ASSERT(fcd.isNormalized(newString, errorCode)); ------------------ | | 35| 1.00M|# define U_ASSERT(exp) (void)0 ------------------ 1325| 1.00M| U_ASSERT(nfd.normalize(newString, errorCode) == newNFDString); // canonically equivalent ------------------ | | 35| 1.00M|# define U_ASSERT(exp) (void)0 ------------------ 1326| 1.00M| return true; 1327| 1.00M|} _ZNK6icu_7816CollationBuilder12ignorePrefixERKNS_13UnicodeStringER10UErrorCode: 1330| 113k|CollationBuilder::ignorePrefix(const UnicodeString &s, UErrorCode &errorCode) const { 1331| | // Do not map non-FCD prefixes. 1332| 113k| return !isFCD(s, errorCode); 1333| 113k|} _ZNK6icu_7816CollationBuilder12ignoreStringERKNS_13UnicodeStringER10UErrorCode: 1336| 9.69M|CollationBuilder::ignoreString(const UnicodeString &s, UErrorCode &errorCode) const { 1337| | // Do not map non-FCD strings. 1338| | // Do not map strings that start with Hangul syllables: We decompose those on the fly. 1339| 9.69M| return !isFCD(s, errorCode) || Hangul::isHangul(s.charAt(0)); ------------------ | Branch (1339:12): [True: 1.08M, False: 8.61M] | Branch (1339:36): [True: 0, False: 8.61M] ------------------ 1340| 9.69M|} _ZNK6icu_7816CollationBuilder5isFCDERKNS_13UnicodeStringER10UErrorCode: 1343| 9.80M|CollationBuilder::isFCD(const UnicodeString &s, UErrorCode &errorCode) const { 1344| 9.80M| return U_SUCCESS(errorCode) && fcd.isNormalized(s, errorCode); ------------------ | Branch (1344:12): [True: 9.80M, False: 0] | Branch (1344:36): [True: 8.67M, False: 1.13M] ------------------ 1345| 9.80M|} _ZN6icu_7816CollationBuilder19closeOverCompositesER10UErrorCode: 1348| 3.96k|CollationBuilder::closeOverComposites(UErrorCode &errorCode) { 1349| 3.96k| UnicodeSet composites(UNICODE_STRING_SIMPLE("[:NFD_QC=N:]"), errorCode); // Java: static final ------------------ | | 135| 3.96k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 3.96k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ 1350| 3.96k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1350:8): [True: 41, False: 3.92k] ------------------ 1351| | // Hangul is decomposed on the fly during collation. 1352| 3.92k| composites.remove(Hangul::HANGUL_BASE, Hangul::HANGUL_END); 1353| 3.92k| UnicodeString prefix; // empty 1354| 3.92k| UnicodeString nfdString; 1355| 3.92k| UnicodeSetIterator iter(composites); 1356| 8.17M| while(iter.next()) { ------------------ | Branch (1356:11): [True: 8.17M, False: 3.92k] ------------------ 1357| 8.17M| U_ASSERT(!iter.isString()); ------------------ | | 35| 8.17M|# define U_ASSERT(exp) (void)0 ------------------ 1358| 8.17M| nfd.getDecomposition(iter.getCodepoint(), nfdString); 1359| 8.17M| cesLength = dataBuilder->getCEs(nfdString, ces, 0); 1360| 8.17M| if(cesLength > Collation::MAX_EXPANSION_LENGTH) { ------------------ | Branch (1360:12): [True: 3.23k, False: 8.16M] ------------------ 1361| | // Too many CEs from the decomposition (unusual), ignore this composite. 1362| | // We could add a capacity parameter to getCEs() and reallocate if necessary. 1363| | // However, this can only really happen in contrived cases. 1364| 3.23k| continue; 1365| 3.23k| } 1366| 8.16M| const UnicodeString &composite(iter.getString()); 1367| 8.16M| addIfDifferent(prefix, composite, ces, cesLength, Collation::UNASSIGNED_CE32, errorCode); 1368| 8.16M| } 1369| 3.92k|} _ZN6icu_7816CollationBuilder14addIfDifferentERKNS_13UnicodeStringES3_PKlijR10UErrorCode: 1374| 17.0M| UErrorCode &errorCode) { 1375| 17.0M| if(U_FAILURE(errorCode)) { return ce32; } ------------------ | Branch (1375:8): [True: 0, False: 17.0M] ------------------ 1376| 17.0M| int64_t oldCEs[Collation::MAX_EXPANSION_LENGTH]; 1377| 17.0M| int32_t oldCEsLength = dataBuilder->getCEs(prefix, str, oldCEs, 0); 1378| 17.0M| if(!sameCEs(newCEs, newCEsLength, oldCEs, oldCEsLength)) { ------------------ | Branch (1378:8): [True: 6.85M, False: 10.1M] ------------------ 1379| 6.85M| if(ce32 == Collation::UNASSIGNED_CE32) { ------------------ | Branch (1379:12): [True: 6.41M, False: 444k] ------------------ 1380| 6.41M| ce32 = dataBuilder->encodeCEs(newCEs, newCEsLength, errorCode); 1381| 6.41M| } 1382| 6.85M| dataBuilder->addCE32(prefix, str, ce32, errorCode); 1383| 6.85M| } 1384| 17.0M| return ce32; 1385| 17.0M|} _ZN6icu_7816CollationBuilder7sameCEsEPKliS2_i: 1389| 17.0M| const int64_t ces2[], int32_t ces2Length) { 1390| 17.0M| if(ces1Length != ces2Length) { ------------------ | Branch (1390:8): [True: 1.24M, False: 15.7M] ------------------ 1391| 1.24M| return false; 1392| 1.24M| } 1393| 15.7M| U_ASSERT(ces1Length <= Collation::MAX_EXPANSION_LENGTH); ------------------ | | 35| 15.7M|# define U_ASSERT(exp) (void)0 ------------------ 1394| 35.9M| for(int32_t i = 0; i < ces1Length; ++i) { ------------------ | Branch (1394:24): [True: 25.8M, False: 10.1M] ------------------ 1395| 25.8M| if(ces1[i] != ces2[i]) { return false; } ------------------ | Branch (1395:12): [True: 5.61M, False: 20.2M] ------------------ 1396| 25.8M| } 1397| 10.1M| return true; 1398| 15.7M|} _ZN6icu_7816CollationBuilder15makeTailoredCEsER10UErrorCode: 1413| 3.96k|CollationBuilder::makeTailoredCEs(UErrorCode &errorCode) { 1414| 3.96k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1414:8): [True: 0, False: 3.96k] ------------------ 1415| | 1416| 3.96k| CollationWeights primaries, secondaries, tertiaries; 1417| 3.96k| int64_t *nodesArray = nodes.getBuffer(); 1418| |#ifdef DEBUG_COLLATION_BUILDER 1419| | puts("\nCollationBuilder::makeTailoredCEs()"); 1420| |#endif 1421| | 1422| 18.2k| for(int32_t rpi = 0; rpi < rootPrimaryIndexes.size(); ++rpi) { ------------------ | Branch (1422:26): [True: 14.3k, False: 3.92k] ------------------ 1423| 14.3k| int32_t i = rootPrimaryIndexes.elementAti(rpi); 1424| 14.3k| int64_t node = nodesArray[i]; 1425| 14.3k| uint32_t p = weight32FromNode(node); 1426| 14.3k| uint32_t s = p == 0 ? 0 : Collation::COMMON_WEIGHT16; ------------------ | Branch (1426:22): [True: 1.03k, False: 13.3k] ------------------ 1427| 14.3k| uint32_t t = s; 1428| 14.3k| uint32_t q = 0; 1429| 14.3k| UBool pIsTailored = false; 1430| 14.3k| UBool sIsTailored = false; 1431| 14.3k| UBool tIsTailored = false; 1432| |#ifdef DEBUG_COLLATION_BUILDER 1433| | printf("\nprimary %lx\n", (long)alignWeightRight(p)); 1434| |#endif 1435| 14.3k| int32_t pIndex = p == 0 ? 0 : rootElements.findPrimary(p); ------------------ | Branch (1435:26): [True: 1.03k, False: 13.3k] ------------------ 1436| 14.3k| int32_t nextIndex = nextIndexFromNode(node); 1437| 3.17M| while(nextIndex != 0) { ------------------ | Branch (1437:15): [True: 3.15M, False: 14.3k] ------------------ 1438| 3.15M| i = nextIndex; 1439| 3.15M| node = nodesArray[i]; 1440| 3.15M| nextIndex = nextIndexFromNode(node); 1441| 3.15M| int32_t strength = strengthFromNode(node); 1442| 3.15M| if(strength == UCOL_QUATERNARY) { ------------------ | Branch (1442:16): [True: 412, False: 3.15M] ------------------ 1443| 412| U_ASSERT(isTailoredNode(node)); ------------------ | | 35| 412|# define U_ASSERT(exp) (void)0 ------------------ 1444| |#ifdef DEBUG_COLLATION_BUILDER 1445| | printf(" quat+ "); 1446| |#endif 1447| 412| if(q == 3) { ------------------ | Branch (1447:20): [True: 13, False: 399] ------------------ 1448| 13| errorCode = U_BUFFER_OVERFLOW_ERROR; 1449| 13| errorReason = "quaternary tailoring gap too small"; 1450| 13| return; 1451| 13| } 1452| 399| ++q; 1453| 3.15M| } else { 1454| 3.15M| if(strength == UCOL_TERTIARY) { ------------------ | Branch (1454:20): [True: 82.6k, False: 3.07M] ------------------ 1455| 82.6k| if(isTailoredNode(node)) { ------------------ | Branch (1455:24): [True: 81.6k, False: 927] ------------------ 1456| |#ifdef DEBUG_COLLATION_BUILDER 1457| | printf(" ter+ "); 1458| |#endif 1459| 81.6k| if(!tIsTailored) { ------------------ | Branch (1459:28): [True: 7.22k, False: 74.4k] ------------------ 1460| | // First tailored tertiary node for [p, s]. 1461| 7.22k| int32_t tCount = countTailoredNodes(nodesArray, nextIndex, 1462| 7.22k| UCOL_TERTIARY) + 1; 1463| 7.22k| uint32_t tLimit; 1464| 7.22k| if(t == 0) { ------------------ | Branch (1464:32): [True: 165, False: 7.06k] ------------------ 1465| | // Gap at the beginning of the tertiary CE range. 1466| 165| t = rootElements.getTertiaryBoundary() - 0x100; 1467| 165| tLimit = rootElements.getFirstTertiaryCE() & Collation::ONLY_TERTIARY_MASK; 1468| 7.06k| } else if(!pIsTailored && !sIsTailored) { ------------------ | Branch (1468:39): [True: 3.22k, False: 3.83k] | Branch (1468:55): [True: 2.05k, False: 1.17k] ------------------ 1469| | // p and s are root weights. 1470| 2.05k| tLimit = rootElements.getTertiaryAfter(pIndex, s, t); 1471| 5.00k| } else if(t == Collation::BEFORE_WEIGHT16) { ------------------ | Branch (1471:39): [True: 0, False: 5.00k] ------------------ 1472| 0| tLimit = Collation::COMMON_WEIGHT16; 1473| 5.00k| } else { 1474| | // [p, s] is tailored. 1475| 5.00k| U_ASSERT(t == Collation::COMMON_WEIGHT16); ------------------ | | 35| 5.00k|# define U_ASSERT(exp) (void)0 ------------------ 1476| 5.00k| tLimit = rootElements.getTertiaryBoundary(); 1477| 5.00k| } 1478| 7.22k| U_ASSERT(tLimit == 0x4000 || (tLimit & ~Collation::ONLY_TERTIARY_MASK) == 0); ------------------ | | 35| 7.22k|# define U_ASSERT(exp) (void)0 ------------------ 1479| 7.22k| tertiaries.initForTertiary(); 1480| 7.22k| if(!tertiaries.allocWeights(t, tLimit, tCount)) { ------------------ | Branch (1480:32): [True: 7, False: 7.21k] ------------------ 1481| 7| errorCode = U_BUFFER_OVERFLOW_ERROR; 1482| 7| errorReason = "tertiary tailoring gap too small"; 1483| 7| return; 1484| 7| } 1485| 7.21k| tIsTailored = true; 1486| 7.21k| } 1487| 81.6k| t = tertiaries.nextWeight(); 1488| 81.6k| U_ASSERT(t != 0xffffffff); ------------------ | | 35| 81.6k|# define U_ASSERT(exp) (void)0 ------------------ 1489| 81.6k| } else { 1490| 927| t = weight16FromNode(node); 1491| 927| tIsTailored = false; 1492| |#ifdef DEBUG_COLLATION_BUILDER 1493| | printf(" ter %lx\n", (long)alignWeightRight(t)); 1494| |#endif 1495| 927| } 1496| 3.07M| } else { 1497| 3.07M| if(strength == UCOL_SECONDARY) { ------------------ | Branch (1497:24): [True: 240k, False: 2.83M] ------------------ 1498| 240k| if(isTailoredNode(node)) { ------------------ | Branch (1498:28): [True: 238k, False: 1.95k] ------------------ 1499| |#ifdef DEBUG_COLLATION_BUILDER 1500| | printf(" sec+ "); 1501| |#endif 1502| 238k| if(!sIsTailored) { ------------------ | Branch (1502:32): [True: 5.65k, False: 233k] ------------------ 1503| | // First tailored secondary node for p. 1504| 5.65k| int32_t sCount = countTailoredNodes(nodesArray, nextIndex, 1505| 5.65k| UCOL_SECONDARY) + 1; 1506| 5.65k| uint32_t sLimit; 1507| 5.65k| if(s == 0) { ------------------ | Branch (1507:36): [True: 67, False: 5.59k] ------------------ 1508| | // Gap at the beginning of the secondary CE range. 1509| 67| s = rootElements.getSecondaryBoundary() - 0x100; 1510| 67| sLimit = rootElements.getFirstSecondaryCE() >> 16; 1511| 5.59k| } else if(!pIsTailored) { ------------------ | Branch (1511:43): [True: 3.86k, False: 1.73k] ------------------ 1512| | // p is a root primary. 1513| 3.86k| sLimit = rootElements.getSecondaryAfter(pIndex, s); 1514| 3.86k| } else if(s == Collation::BEFORE_WEIGHT16) { ------------------ | Branch (1514:43): [True: 78, False: 1.65k] ------------------ 1515| 78| sLimit = Collation::COMMON_WEIGHT16; 1516| 1.65k| } else { 1517| | // p is a tailored primary. 1518| 1.65k| U_ASSERT(s == Collation::COMMON_WEIGHT16); ------------------ | | 35| 1.65k|# define U_ASSERT(exp) (void)0 ------------------ 1519| 1.65k| sLimit = rootElements.getSecondaryBoundary(); 1520| 1.65k| } 1521| 5.65k| if(s == Collation::COMMON_WEIGHT16) { ------------------ | Branch (1521:36): [True: 4.32k, False: 1.33k] ------------------ 1522| | // Do not tailor into the getSortKey() range of 1523| | // compressed common secondaries. 1524| 4.32k| s = rootElements.getLastCommonSecondary(); 1525| 4.32k| } 1526| 5.65k| secondaries.initForSecondary(); 1527| 5.65k| if(!secondaries.allocWeights(s, sLimit, sCount)) { ------------------ | Branch (1527:36): [True: 2, False: 5.65k] ------------------ 1528| 2| errorCode = U_BUFFER_OVERFLOW_ERROR; 1529| 2| errorReason = "secondary tailoring gap too small"; 1530| |#ifdef DEBUG_COLLATION_BUILDER 1531| | printf("!secondaries.allocWeights(%lx, %lx, sCount=%ld)\n", 1532| | (long)alignWeightRight(s), (long)alignWeightRight(sLimit), 1533| | (long)alignWeightRight(sCount)); 1534| |#endif 1535| 2| return; 1536| 2| } 1537| 5.65k| sIsTailored = true; 1538| 5.65k| } 1539| 238k| s = secondaries.nextWeight(); 1540| 238k| U_ASSERT(s != 0xffffffff); ------------------ | | 35| 238k|# define U_ASSERT(exp) (void)0 ------------------ 1541| 238k| } else { 1542| 1.95k| s = weight16FromNode(node); 1543| 1.95k| sIsTailored = false; 1544| |#ifdef DEBUG_COLLATION_BUILDER 1545| | printf(" sec %lx\n", (long)alignWeightRight(s)); 1546| |#endif 1547| 1.95k| } 1548| 2.83M| } else /* UCOL_PRIMARY */ { 1549| 2.83M| U_ASSERT(isTailoredNode(node)); ------------------ | | 35| 2.83M|# define U_ASSERT(exp) (void)0 ------------------ 1550| |#ifdef DEBUG_COLLATION_BUILDER 1551| | printf("pri+ "); 1552| |#endif 1553| 2.83M| if(!pIsTailored) { ------------------ | Branch (1553:28): [True: 7.57k, False: 2.82M] ------------------ 1554| | // First tailored primary node in this list. 1555| 7.57k| int32_t pCount = countTailoredNodes(nodesArray, nextIndex, 1556| 7.57k| UCOL_PRIMARY) + 1; 1557| 7.57k| UBool isCompressible = baseData->isCompressiblePrimary(p); 1558| 7.57k| uint32_t pLimit = 1559| 7.57k| rootElements.getPrimaryAfter(p, pIndex, isCompressible); 1560| 7.57k| primaries.initForPrimary(isCompressible); 1561| 7.57k| if(!primaries.allocWeights(p, pLimit, pCount)) { ------------------ | Branch (1561:32): [True: 19, False: 7.55k] ------------------ 1562| 19| errorCode = U_BUFFER_OVERFLOW_ERROR; // TODO: introduce a more specific UErrorCode? 1563| 19| errorReason = "primary tailoring gap too small"; 1564| 19| return; 1565| 19| } 1566| 7.55k| pIsTailored = true; 1567| 7.55k| } 1568| 2.83M| p = primaries.nextWeight(); 1569| 2.83M| U_ASSERT(p != 0xffffffff); ------------------ | | 35| 2.83M|# define U_ASSERT(exp) (void)0 ------------------ 1570| 2.83M| s = Collation::COMMON_WEIGHT16; 1571| 2.83M| sIsTailored = false; 1572| 2.83M| } 1573| 3.07M| t = s == 0 ? 0 : Collation::COMMON_WEIGHT16; ------------------ | Branch (1573:25): [True: 254, False: 3.07M] ------------------ 1574| 3.07M| tIsTailored = false; 1575| 3.07M| } 1576| 3.15M| q = 0; 1577| 3.15M| } 1578| 3.15M| if(isTailoredNode(node)) { ------------------ | Branch (1578:16): [True: 3.15M, False: 2.87k] ------------------ 1579| 3.15M| nodesArray[i] = Collation::makeCE(p, s, t, q); 1580| |#ifdef DEBUG_COLLATION_BUILDER 1581| | printf("%016llx\n", (long long)nodesArray[i]); 1582| |#endif 1583| 3.15M| } 1584| 3.15M| } 1585| 14.3k| } 1586| 3.96k|} _ZN6icu_7816CollationBuilder18countTailoredNodesEPKlii: 1589| 20.4k|CollationBuilder::countTailoredNodes(const int64_t *nodesArray, int32_t i, int32_t strength) { 1590| 20.4k| int32_t count = 0; 1591| 3.76M| for(;;) { 1592| 3.76M| if(i == 0) { break; } ------------------ | Branch (1592:12): [True: 14.5k, False: 3.75M] ------------------ 1593| 3.75M| int64_t node = nodesArray[i]; 1594| 3.75M| if(strengthFromNode(node) < strength) { break; } ------------------ | Branch (1594:12): [True: 5.19k, False: 3.74M] ------------------ 1595| 3.74M| if(strengthFromNode(node) == strength) { ------------------ | Branch (1595:12): [True: 3.42M, False: 325k] ------------------ 1596| 3.42M| if(isTailoredNode(node)) { ------------------ | Branch (1596:16): [True: 3.42M, False: 674] ------------------ 1597| 3.42M| ++count; 1598| 3.42M| } else { 1599| 674| break; 1600| 674| } 1601| 3.42M| } 1602| 3.74M| i = nextIndexFromNode(node); 1603| 3.74M| } 1604| 20.4k| return count; 1605| 20.4k|} _ZN6icu_7811CEFinalizerD2Ev: 1633| 3.92k|CEFinalizer::~CEFinalizer() {} _ZN6icu_7816CollationBuilder11finalizeCEsER10UErrorCode: 1636| 3.96k|CollationBuilder::finalizeCEs(UErrorCode &errorCode) { 1637| 3.96k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1637:8): [True: 41, False: 3.92k] ------------------ 1638| 3.92k| LocalPointer newBuilder(new CollationDataBuilder(icu4xMode, errorCode), errorCode); 1639| 3.92k| if(U_FAILURE(errorCode)) { ------------------ | Branch (1639:8): [True: 0, False: 3.92k] ------------------ 1640| 0| return; 1641| 0| } 1642| 3.92k| newBuilder->initForTailoring(baseData, errorCode); 1643| 3.92k| CEFinalizer finalizer(nodes.getBuffer()); 1644| 3.92k| newBuilder->copyFrom(*dataBuilder, finalizer, errorCode); 1645| 3.92k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1645:8): [True: 0, False: 3.92k] ------------------ 1646| 3.92k| delete dataBuilder; 1647| 3.92k| dataBuilder = newBuilder.orphan(); 1648| 3.92k|} _ZN6icu_7816CollationBuilder10ceStrengthEl: 1651| 32.3M|CollationBuilder::ceStrength(int64_t ce) { 1652| 32.3M| return 1653| 32.3M| isTempCE(ce) ? strengthFromTempCE(ce) : ------------------ | Branch (1653:9): [True: 18.4M, False: 13.8M] ------------------ 1654| 32.3M| (ce & INT64_C(0xff00000000000000)) != 0 ? UCOL_PRIMARY : ------------------ | Branch (1654:9): [True: 13.1M, False: 718k] ------------------ 1655| 13.8M| (static_cast(ce) & 0xff000000) != 0 ? UCOL_SECONDARY : ------------------ | Branch (1655:9): [True: 716k, False: 1.75k] ------------------ 1656| 718k| ce != 0 ? UCOL_TERTIARY : ------------------ | Branch (1656:9): [True: 332, False: 1.42k] ------------------ 1657| 1.75k| UCOL_IDENTICAL; 1658| 32.3M|} collationbuilder.cpp:_ZN6icu_7812_GLOBAL__N_114BundleImporterC2Ev: 57| 7.71k| BundleImporter() {} collationbuilder.cpp:_ZN6icu_7812_GLOBAL__N_114BundleImporter8getRulesEPKcS3_RNS_13UnicodeStringERS3_R10UErrorCode: 71| 4.87k| const char *& /*errorReason*/, UErrorCode &errorCode) { 72| 4.87k| CollationLoader::loadRules(localeID, collationType, rules, errorCode); 73| 4.87k|} collationbuilder.cpp:_ZN6icu_7812_GLOBAL__N_130binarySearchForRootPrimaryNodeEPKiiPKlj: 834| 46.7k| const int64_t *nodes, uint32_t p) { 835| 46.7k| if(length == 0) { return ~0; } ------------------ | Branch (835:8): [True: 4.38k, False: 42.3k] ------------------ 836| 42.3k| int32_t start = 0; 837| 42.3k| int32_t limit = length; 838| 171k| for (;;) { 839| 171k| int32_t i = (start + limit) / 2; 840| 171k| int64_t node = nodes[rootPrimaryIndexes[i]]; 841| 171k| uint32_t nodePrimary = static_cast(node >> 32); // weight32FromNode(node) 842| 171k| if (p == nodePrimary) { ------------------ | Branch (842:13): [True: 25.1k, False: 146k] ------------------ 843| 25.1k| return i; 844| 146k| } else if (p < nodePrimary) { ------------------ | Branch (844:20): [True: 56.7k, False: 89.8k] ------------------ 845| 56.7k| if (i == start) { ------------------ | Branch (845:17): [True: 1.95k, False: 54.8k] ------------------ 846| 1.95k| return ~start; // insert s before i 847| 1.95k| } 848| 54.8k| limit = i; 849| 89.8k| } else { 850| 89.8k| if (i == start) { ------------------ | Branch (850:17): [True: 15.2k, False: 74.5k] ------------------ 851| 15.2k| return ~(start + 1); // insert s after i 852| 15.2k| } 853| 74.5k| start = i; 854| 74.5k| } 855| 171k| } 856| 42.3k|} _ZN6icu_7811CEFinalizerC2EPKl: 1609| 3.92k| CEFinalizer(const int64_t *ces) : finalCEs(ces) {} _ZNK6icu_7811CEFinalizer10modifyCE32Ej: 1611| 2.69M| virtual int64_t modifyCE32(uint32_t ce32) const override { 1612| 2.69M| U_ASSERT(!Collation::isSpecialCE32(ce32)); ------------------ | | 35| 2.69M|# define U_ASSERT(exp) (void)0 ------------------ 1613| 2.69M| if(CollationBuilder::isTempCE32(ce32)) { ------------------ | Branch (1613:12): [True: 1.72M, False: 968k] ------------------ 1614| | // retain case bits 1615| 1.72M| return finalCEs[CollationBuilder::indexFromTempCE32(ce32)] | ((ce32 & 0xc0) << 8); 1616| 1.72M| } else { 1617| 968k| return Collation::NO_CE; 1618| 968k| } 1619| 2.69M| } _ZNK6icu_7811CEFinalizer8modifyCEEl: 1620| 705k| virtual int64_t modifyCE(int64_t ce) const override { 1621| 705k| if(CollationBuilder::isTempCE(ce)) { ------------------ | Branch (1621:12): [True: 61.0k, False: 644k] ------------------ 1622| | // retain case bits 1623| 61.0k| return finalCEs[CollationBuilder::indexFromTempCE(ce)] | (ce & 0xc000); 1624| 644k| } else { 1625| 644k| return Collation::NO_CE; 1626| 644k| } 1627| 705k| } _ZNK6icu_7816CollationBuilder14getErrorReasonEv: 54| 3.61k| const char *getErrorReason() const { return errorReason; } _ZN6icu_7816CollationBuilder16strengthFromNodeEl: 272| 13.1M| static inline int32_t strengthFromNode(int64_t node) { 273| 13.1M| return static_cast(node) & 3; 274| 13.1M| } _ZN6icu_7816CollationBuilder21previousIndexFromNodeEl: 266| 48.8k| static inline int32_t previousIndexFromNode(int64_t node) { 267| 48.8k| return static_cast(node >> 28) & MAX_INDEX; 268| 48.8k| } _ZN6icu_7816CollationBuilder14isTailoredNodeEl: 285| 6.94M| static inline UBool isTailoredNode(int64_t node) { 286| 6.94M| return (node & IS_TAILORED) != 0; 287| 6.94M| } _ZN6icu_7816CollationBuilder16weight32FromNodeEl: 260| 20.0k| static inline uint32_t weight32FromNode(int64_t node) { 261| 20.0k| return static_cast(node >> 32); 262| 20.0k| } _ZN6icu_7816CollationBuilder17nextIndexFromNodeEl: 269| 11.5M| static inline int32_t nextIndexFromNode(int64_t node) { 270| 11.5M| return (static_cast(node) >> 8) & MAX_INDEX; 271| 11.5M| } _ZN6icu_7816CollationBuilder16weight16FromNodeEl: 263| 11.7k| static inline uint32_t weight16FromNode(int64_t node) { 264| 11.7k| return static_cast(node >> 48) & 0xffff; 265| 11.7k| } _ZN6icu_7816CollationBuilder16nodeFromWeight16Ej: 247| 4.67k| static inline int64_t nodeFromWeight16(uint32_t weight16) { 248| 4.67k| return static_cast(weight16) << 48; 249| 4.67k| } _ZN6icu_7816CollationBuilder16nodeFromStrengthEi: 256| 4.37M| static inline int64_t nodeFromStrength(int32_t strength) { 257| 4.37M| return strength; 258| 4.37M| } _ZN6icu_7816CollationBuilder26tempCEFromIndexAndStrengthEii: 183| 4.38M| static inline int64_t tempCEFromIndexAndStrength(int32_t index, int32_t strength) { 184| 4.38M| return 185| | // CE byte offsets, to ensure valid CE bytes, and case bits 11 186| 4.38M| INT64_C(0x4040000006002000) + 187| | // index bits 19..13 -> primary byte 1 = CE bits 63..56 (byte values 40..BF) 188| 4.38M| (static_cast(index & 0xfe000) << 43) + 189| | // index bits 12..6 -> primary byte 2 = CE bits 55..48 (byte values 40..BF) 190| 4.38M| (static_cast(index & 0x1fc0) << 42) + 191| | // index bits 5..0 -> secondary byte 1 = CE bits 31..24 (byte values 06..45) 192| 4.38M| ((index & 0x3f) << 24) + 193| | // strength bits 1..0 -> tertiary byte 1 = CE bits 13..8 (byte values 20..23) 194| 4.38M| (strength << 8); 195| 4.38M| } _ZN6icu_7816CollationBuilder14nodeHasBefore3El: 279| 30.6k| static inline UBool nodeHasBefore3(int64_t node) { 280| 30.6k| return (node & HAS_BEFORE3) != 0; 281| 30.6k| } _ZN6icu_7816CollationBuilder16nodeHasAnyBeforeEl: 282| 2| static inline UBool nodeHasAnyBefore(int64_t node) { 283| 2| return (node & (HAS_BEFORE2 | HAS_BEFORE3)) != 0; 284| 2| } _ZN6icu_7816CollationBuilder14nodeHasBefore2El: 276| 54.4k| static inline UBool nodeHasBefore2(int64_t node) { 277| 54.4k| return (node & HAS_BEFORE2) != 0; 278| 54.4k| } _ZN6icu_7816CollationBuilder8isTempCEEl: 206| 40.9M| static inline UBool isTempCE(int64_t ce) { 207| 40.9M| uint32_t sec = static_cast(ce) >> 24; 208| 40.9M| return 6 <= sec && sec <= 0x45; ------------------ | Branch (208:16): [True: 27.2M, False: 13.7M] | Branch (208:28): [True: 26.3M, False: 809k] ------------------ 209| 40.9M| } _ZN6icu_7816CollationBuilder15indexFromTempCEEl: 196| 4.40M| static inline int32_t indexFromTempCE(int64_t tempCE) { 197| 4.40M| tempCE -= INT64_C(0x4040000006002000); 198| 4.40M| return 199| 4.40M| (static_cast(tempCE >> 43) & 0xfe000) | 200| 4.40M| (static_cast(tempCE >> 42) & 0x1fc0) | 201| 4.40M| (static_cast(tempCE >> 24) & 0x3f); 202| 4.40M| } _ZN6icu_7816CollationBuilder16nodeFromWeight32Ej: 244| 21.6k| static inline int64_t nodeFromWeight32(uint32_t weight32) { 245| 21.6k| return static_cast(weight32) << 32; 246| 21.6k| } _ZN6icu_7816CollationBuilder21nodeFromPreviousIndexEi: 250| 5.59M| static inline int64_t nodeFromPreviousIndex(int32_t previous) { 251| 5.59M| return static_cast(previous) << 28; 252| 5.59M| } _ZN6icu_7816CollationBuilder17nodeFromNextIndexEi: 253| 8.75M| static inline int64_t nodeFromNextIndex(int32_t next) { 254| 8.75M| return next << 8; 255| 8.75M| } _ZN6icu_7816CollationBuilder19changeNodeNextIndexEli: 292| 4.37M| static inline int64_t changeNodeNextIndex(int64_t node, int32_t next) { 293| 4.37M| return (node & INT64_C(0xfffffffff00000ff)) | nodeFromNextIndex(next); 294| 4.37M| } _ZN6icu_7816CollationBuilder23changeNodePreviousIndexEli: 289| 1.21M| static inline int64_t changeNodePreviousIndex(int64_t node, int32_t previous) { 290| 1.21M| return (node & INT64_C(0xffff00000fffffff)) | nodeFromPreviousIndex(previous); 291| 1.21M| } _ZN6icu_7816CollationBuilder18strengthFromTempCEEl: 203| 18.4M| static inline int32_t strengthFromTempCE(int64_t tempCE) { 204| 18.4M| return (static_cast(tempCE) >> 8) & 3; 205| 18.4M| } _ZN6icu_7816CollationBuilder10isTempCE32Ej: 218| 2.69M| static inline UBool isTempCE32(uint32_t ce32) { 219| 2.69M| return 220| 2.69M| (ce32 & 0xff) >= 2 && // not a long-primary/long-secondary CE32 ------------------ | Branch (220:13): [True: 2.69M, False: 4.63k] ------------------ 221| 2.69M| 6 <= ((ce32 >> 8) & 0xff) && ((ce32 >> 8) & 0xff) <= 0x45; ------------------ | Branch (221:13): [True: 2.13M, False: 558k] | Branch (221:42): [True: 1.72M, False: 405k] ------------------ 222| 2.69M| } _ZN6icu_7816CollationBuilder17indexFromTempCE32Ej: 211| 1.72M| static inline int32_t indexFromTempCE32(uint32_t tempCE32) { 212| 1.72M| tempCE32 -= 0x40400620; 213| 1.72M| return 214| 1.72M| (static_cast(tempCE32 >> 11) & 0xfe000) | 215| 1.72M| (static_cast(tempCE32 >> 10) & 0x1fc0) | 216| 1.72M| (static_cast(tempCE32 >> 8) & 0x3f); 217| 1.72M| } _ZNK6icu_7813CollationData15getIndirectCE32Ej: 31| 57.9M|CollationData::getIndirectCE32(uint32_t ce32) const { 32| 57.9M| U_ASSERT(Collation::isSpecialCE32(ce32)); ------------------ | | 35| 57.9M|# define U_ASSERT(exp) (void)0 ------------------ 33| 57.9M| int32_t tag = Collation::tagFromCE32(ce32); 34| 57.9M| if(tag == Collation::DIGIT_TAG) { ------------------ | Branch (34:8): [True: 198k, False: 57.7M] ------------------ 35| | // Fetch the non-numeric-collation CE32. 36| 198k| ce32 = ce32s[Collation::indexFromCE32(ce32)]; 37| 57.7M| } else if(tag == Collation::LEAD_SURROGATE_TAG) { ------------------ | Branch (37:15): [True: 0, False: 57.7M] ------------------ 38| 0| ce32 = Collation::UNASSIGNED_CE32; 39| 57.7M| } else if(tag == Collation::U0000_TAG) { ------------------ | Branch (39:15): [True: 16.2k, False: 57.7M] ------------------ 40| | // Fetch the normal ce32 for U+0000. 41| 16.2k| ce32 = ce32s[0]; 42| 16.2k| } 43| 57.9M| return ce32; 44| 57.9M|} _ZNK6icu_7813CollationData12getFinalCE32Ej: 47| 57.0M|CollationData::getFinalCE32(uint32_t ce32) const { 48| 57.0M| if(Collation::isSpecialCE32(ce32)) { ------------------ | Branch (48:8): [True: 54.6M, False: 2.42M] ------------------ 49| 54.6M| ce32 = getIndirectCE32(ce32); 50| 54.6M| } 51| 57.0M| return ce32; 52| 57.0M|} _ZNK6icu_7813CollationData23getFirstPrimaryForGroupEi: 119| 12.2k|CollationData::getFirstPrimaryForGroup(int32_t script) const { 120| 12.2k| int32_t index = getScriptIndex(script); 121| 12.2k| return index == 0 ? 0 : static_cast(scriptStarts[index]) << 16; ------------------ | Branch (121:12): [True: 1.45k, False: 10.7k] ------------------ 122| 12.2k|} _ZNK6icu_7813CollationData22getLastPrimaryForGroupEi: 125| 19.6k|CollationData::getLastPrimaryForGroup(int32_t script) const { 126| 19.6k| int32_t index = getScriptIndex(script); 127| 19.6k| if(index == 0) { ------------------ | Branch (127:8): [True: 0, False: 19.6k] ------------------ 128| 0| return 0; 129| 0| } 130| 19.6k| uint32_t limit = scriptStarts[index + 1]; 131| 19.6k| return (limit << 16) - 1; 132| 19.6k|} _ZNK6icu_7813CollationData14getScriptIndexEi: 156| 40.5k|CollationData::getScriptIndex(int32_t script) const { 157| 40.5k| if(script < 0) { ------------------ | Branch (157:8): [True: 0, False: 40.5k] ------------------ 158| 0| return 0; 159| 40.5k| } else if(script < numScripts) { ------------------ | Branch (159:15): [True: 17.0k, False: 23.5k] ------------------ 160| 17.0k| return scriptsIndex[script]; 161| 23.5k| } else if(script < UCOL_REORDER_CODE_FIRST) { ------------------ | Branch (161:15): [True: 0, False: 23.5k] ------------------ 162| 0| return 0; 163| 23.5k| } else { 164| 23.5k| script -= UCOL_REORDER_CODE_FIRST; 165| 23.5k| if(script < MAX_NUM_SPECIAL_REORDER_CODES) { ------------------ | Branch (165:12): [True: 23.5k, False: 0] ------------------ 166| 23.5k| return scriptsIndex[numScripts + script]; 167| 23.5k| } else { 168| 0| return 0; 169| 0| } 170| 23.5k| } 171| 40.5k|} _ZNK6icu_7813CollationData17makeReorderRangesEPKiiRNS_9UVector32ER10UErrorCode: 207| 3.19k| UVector32 &ranges, UErrorCode &errorCode) const { 208| 3.19k| makeReorderRanges(reorder, length, false, ranges, errorCode); 209| 3.19k|} _ZNK6icu_7813CollationData17makeReorderRangesEPKiiaRNS_9UVector32ER10UErrorCode: 214| 3.19k| UVector32 &ranges, UErrorCode &errorCode) const { 215| 3.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (215:8): [True: 0, False: 3.19k] ------------------ 216| 3.19k| ranges.removeAllElements(); 217| 3.19k| if(length == 0 || (length == 1 && reorder[0] == USCRIPT_UNKNOWN)) { ------------------ | Branch (217:8): [True: 0, False: 3.19k] | Branch (217:24): [True: 2.56k, False: 626] | Branch (217:39): [True: 0, False: 2.56k] ------------------ 218| 0| return; 219| 0| } 220| | 221| | // Maps each script-or-group range to a new lead byte. 222| 3.19k| uint8_t table[MAX_NUM_SCRIPT_RANGES]; 223| 3.19k| uprv_memset(table, 0, sizeof(table)); ------------------ | | 100| 3.19k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 3.19k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 224| | 225| 3.19k| { 226| | // Set "don't care" values for reserved ranges. 227| 3.19k| int32_t index = scriptsIndex[ 228| 3.19k| numScripts + REORDER_RESERVED_BEFORE_LATIN - UCOL_REORDER_CODE_FIRST]; 229| 3.19k| if(index != 0) { ------------------ | Branch (229:12): [True: 3.19k, False: 0] ------------------ 230| 3.19k| table[index] = 0xff; 231| 3.19k| } 232| 3.19k| index = scriptsIndex[ 233| 3.19k| numScripts + REORDER_RESERVED_AFTER_LATIN - UCOL_REORDER_CODE_FIRST]; 234| 3.19k| if(index != 0) { ------------------ | Branch (234:12): [True: 3.19k, False: 0] ------------------ 235| 3.19k| table[index] = 0xff; 236| 3.19k| } 237| 3.19k| } 238| | 239| | // Never reorder special low and high primary lead bytes. 240| 3.19k| U_ASSERT(scriptStartsLength >= 2); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 241| 3.19k| U_ASSERT(scriptStarts[0] == 0); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 242| 3.19k| int32_t lowStart = scriptStarts[1]; 243| 3.19k| U_ASSERT(lowStart == ((Collation::MERGE_SEPARATOR_BYTE + 1) << 8)); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 244| 3.19k| int32_t highLimit = scriptStarts[scriptStartsLength - 1]; 245| 3.19k| U_ASSERT(highLimit == (Collation::TRAIL_WEIGHT_BYTE << 8)); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 246| | 247| | // Get the set of special reorder codes in the input list. 248| | // This supports a fixed number of special reorder codes; 249| | // it works for data with codes beyond UCOL_REORDER_CODE_LIMIT. 250| 3.19k| uint32_t specials = 0; 251| 11.8k| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (251:24): [True: 8.65k, False: 3.19k] ------------------ 252| 8.65k| int32_t reorderCode = reorder[i] - UCOL_REORDER_CODE_FIRST; 253| 8.65k| if(0 <= reorderCode && reorderCode < MAX_NUM_SPECIAL_REORDER_CODES) { ------------------ | Branch (253:12): [True: 0, False: 8.65k] | Branch (253:32): [True: 0, False: 0] ------------------ 254| 0| specials |= static_cast(1) << reorderCode; 255| 0| } 256| 8.65k| } 257| | 258| | // Start the reordering with the special low reorder codes that do not occur in the input. 259| 28.7k| for(int32_t i = 0; i < MAX_NUM_SPECIAL_REORDER_CODES; ++i) { ------------------ | Branch (259:24): [True: 25.5k, False: 3.19k] ------------------ 260| 25.5k| int32_t index = scriptsIndex[numScripts + i]; 261| 25.5k| if (index != 0 && (specials & (static_cast(1) << i)) == 0) { ------------------ | Branch (261:13): [True: 15.9k, False: 9.57k] | Branch (261:27): [True: 15.9k, False: 0] ------------------ 262| 15.9k| lowStart = addLowScriptRange(table, index, lowStart); 263| 15.9k| } 264| 25.5k| } 265| | 266| | // Skip the reserved range before Latin if Latin is the first script, 267| | // so that we do not move it unnecessarily. 268| 3.19k| int32_t skippedReserved = 0; 269| 3.19k| if(specials == 0 && reorder[0] == USCRIPT_LATIN && !latinMustMove) { ------------------ | Branch (269:8): [True: 3.19k, False: 0] | Branch (269:25): [True: 17, False: 3.17k] | Branch (269:56): [True: 17, False: 0] ------------------ 270| 17| int32_t index = scriptsIndex[USCRIPT_LATIN]; 271| 17| U_ASSERT(index != 0); ------------------ | | 35| 17|# define U_ASSERT(exp) (void)0 ------------------ 272| 17| int32_t start = scriptStarts[index]; 273| 17| U_ASSERT(lowStart <= start); ------------------ | | 35| 17|# define U_ASSERT(exp) (void)0 ------------------ 274| 17| skippedReserved = start - lowStart; 275| 17| lowStart = start; 276| 17| } 277| | 278| | // Reorder according to the input scripts, continuing from the bottom of the primary range. 279| 3.19k| int32_t originalLength = length; // length will be decremented if "others" is in the list. 280| 3.19k| UBool hasReorderToEnd = false; 281| 11.8k| for(int32_t i = 0; i < length;) { ------------------ | Branch (281:24): [True: 8.65k, False: 3.19k] ------------------ 282| 8.65k| int32_t script = reorder[i++]; 283| 8.65k| if(script == USCRIPT_UNKNOWN) { ------------------ | Branch (283:12): [True: 0, False: 8.65k] ------------------ 284| | // Put the remaining scripts at the top. 285| 0| hasReorderToEnd = true; 286| 0| while(i < length) { ------------------ | Branch (286:19): [True: 0, False: 0] ------------------ 287| 0| script = reorder[--length]; 288| 0| if(script == USCRIPT_UNKNOWN || // Must occur at most once. ------------------ | Branch (288:20): [True: 0, False: 0] ------------------ 289| 0| script == UCOL_REORDER_CODE_DEFAULT) { ------------------ | Branch (289:25): [True: 0, False: 0] ------------------ 290| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 291| 0| return; 292| 0| } 293| 0| int32_t index = getScriptIndex(script); 294| 0| if(index == 0) { continue; } ------------------ | Branch (294:20): [True: 0, False: 0] ------------------ 295| 0| if(table[index] != 0) { // Duplicate or equivalent script. ------------------ | Branch (295:20): [True: 0, False: 0] ------------------ 296| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 297| 0| return; 298| 0| } 299| 0| highLimit = addHighScriptRange(table, index, highLimit); 300| 0| } 301| 0| break; 302| 0| } 303| 8.65k| if(script == UCOL_REORDER_CODE_DEFAULT) { ------------------ | Branch (303:12): [True: 0, False: 8.65k] ------------------ 304| | // The default code must be the only one in the list, and that is handled by the caller. 305| | // Otherwise it must not be used. 306| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 307| 0| return; 308| 0| } 309| 8.65k| int32_t index = getScriptIndex(script); 310| 8.65k| if(index == 0) { continue; } ------------------ | Branch (310:12): [True: 0, False: 8.65k] ------------------ 311| 8.65k| if(table[index] != 0) { // Duplicate or equivalent script. ------------------ | Branch (311:12): [True: 0, False: 8.65k] ------------------ 312| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 313| 0| return; 314| 0| } 315| 8.65k| lowStart = addLowScriptRange(table, index, lowStart); 316| 8.65k| } 317| | 318| | // Put all remaining scripts into the middle. 319| 552k| for(int32_t i = 1; i < scriptStartsLength - 1; ++i) { ------------------ | Branch (319:24): [True: 548k, False: 3.19k] ------------------ 320| 548k| int32_t leadByte = table[i]; 321| 548k| if(leadByte != 0) { continue; } ------------------ | Branch (321:12): [True: 30.9k, False: 517k] ------------------ 322| 517k| int32_t start = scriptStarts[i]; 323| 517k| if(!hasReorderToEnd && start > lowStart) { ------------------ | Branch (323:12): [True: 517k, False: 0] | Branch (323:32): [True: 8.33k, False: 509k] ------------------ 324| | // No need to move this script. 325| 8.33k| lowStart = start; 326| 8.33k| } 327| 517k| lowStart = addLowScriptRange(table, i, lowStart); 328| 517k| } 329| 3.19k| if(lowStart > highLimit) { ------------------ | Branch (329:8): [True: 0, False: 3.19k] ------------------ 330| 0| if((lowStart - (skippedReserved & 0xff00)) <= highLimit) { ------------------ | Branch (330:12): [True: 0, False: 0] ------------------ 331| | // Try not skipping the before-Latin reserved range. 332| 0| makeReorderRanges(reorder, originalLength, true, ranges, errorCode); 333| 0| return; 334| 0| } 335| | // We need more primary lead bytes than available, despite the reserved ranges. 336| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 337| 0| return; 338| 0| } 339| | 340| | // Turn lead bytes into a list of (limit, offset) pairs. 341| | // Encode each pair in one list element: 342| | // Upper 16 bits = limit, lower 16 = signed lead byte offset. 343| 3.19k| int32_t offset = 0; 344| 12.2k| for(int32_t i = 1;; ++i) { 345| 12.2k| int32_t nextOffset = offset; 346| 552k| while(i < scriptStartsLength - 1) { ------------------ | Branch (346:15): [True: 548k, False: 3.19k] ------------------ 347| 548k| int32_t newLeadByte = table[i]; 348| 548k| if(newLeadByte == 0xff) { ------------------ | Branch (348:16): [True: 6.38k, False: 542k] ------------------ 349| | // "Don't care" lead byte for reserved range, continue with current offset. 350| 542k| } else { 351| 542k| nextOffset = newLeadByte - (scriptStarts[i] >> 8); 352| 542k| if(nextOffset != offset) { break; } ------------------ | Branch (352:20): [True: 9.06k, False: 533k] ------------------ 353| 542k| } 354| 539k| ++i; 355| 539k| } 356| 12.2k| if(offset != 0 || i < scriptStartsLength - 1) { ------------------ | Branch (356:12): [True: 5.87k, False: 6.38k] | Branch (356:27): [True: 3.19k, False: 3.19k] ------------------ 357| 9.06k| ranges.addElement((static_cast(scriptStarts[i]) << 16) | (offset & 0xffff), errorCode); 358| 9.06k| } 359| 12.2k| if(i == scriptStartsLength - 1) { break; } ------------------ | Branch (359:12): [True: 3.19k, False: 9.06k] ------------------ 360| 9.06k| offset = nextOffset; 361| 9.06k| } 362| 3.19k|} _ZNK6icu_7813CollationData17addLowScriptRangeEPhii: 365| 542k|CollationData::addLowScriptRange(uint8_t table[], int32_t index, int32_t lowStart) const { 366| 542k| int32_t start = scriptStarts[index]; 367| 542k| if((start & 0xff) < (lowStart & 0xff)) { ------------------ | Branch (367:8): [True: 592, False: 541k] ------------------ 368| 592| lowStart += 0x100; 369| 592| } 370| 542k| table[index] = static_cast(lowStart >> 8); 371| 542k| int32_t limit = scriptStarts[index + 1]; 372| 542k| lowStart = ((lowStart & 0xff00) + ((limit & 0xff00) - (start & 0xff00))) | (limit & 0xff); 373| 542k| return lowStart; 374| 542k|} _ZN6icu_7813CollationDataC2ERKNS_15Normalizer2ImplE: 52| 9.56k| : trie(nullptr), 53| 9.56k| ce32s(nullptr), ces(nullptr), contexts(nullptr), base(nullptr), 54| 9.56k| jamoCE32s(nullptr), 55| 9.56k| nfcImpl(nfc), 56| 9.56k| numericPrimary(0x12000000), 57| 9.56k| ce32sLength(0), cesLength(0), contextsLength(0), 58| 9.56k| compressibleBytes(nullptr), 59| 9.56k| unsafeBackwardSet(nullptr), 60| 9.56k| fastLatinTable(nullptr), fastLatinTableLength(0), 61| 9.56k| numScripts(0), scriptsIndex(nullptr), scriptStarts(nullptr), scriptStartsLength(0), 62| 9.56k| rootElements(nullptr), rootElementsLength(0) {} _ZNK6icu_7813CollationData7getCE32Ei: 64| 96.1M| uint32_t getCE32(UChar32 c) const { 65| 96.1M| return UTRIE2_GET32(trie, c); ------------------ | | 370| 96.1M|#define UTRIE2_GET32(trie, c) _UTRIE2_GET((trie), data32, 0, (c)) | | ------------------ | | | | 871| 96.1M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 96.1M| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 86.2M, False: 9.90M] | | | | | | ------------------ | | | | | | 846| 96.1M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 86.2M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 86.2M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 17.1k, False: 3.15M] | | | | | | | | ------------------ | | | | | | | | 816| 3.17M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 9.90M| (trie)->index, c) : \ | | | | | | 851| 9.90M| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 723k, False: 6.00M] | | | | | | ------------------ | | | | | | 852| 6.72M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 6.72M| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 19.9k, False: 5.98M] | | | | | | ------------------ | | | | | | 854| 6.00M| (trie)->highValueIndex : \ | | | | | | 855| 6.00M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 5.98M| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 5.98M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 5.98M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 5.98M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 5.98M| <data[(c)>=(trie)->highStart ? (trie)->highValueIndex : \ | | | | ------------------ | | | | | Branch (863:18): [True: 226, False: 294k] | | | | ------------------ | | | | 864| 294k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)] | | | | ------------------ | | | | | | 833| 294k| (((int32_t)((trieIndex)[ \ | | | | | | 834| 294k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | 835| 294k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | 836| 294k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | 837| 294k| <> 24); 87| 12.2k| } _ZN6icu_7813CollationData8readCE32EPKDs: 93| 3.12M| static uint32_t readCE32(const char16_t *p) { 94| 3.12M| return (static_cast(p[0]) << 16) | p[1]; 95| 3.12M| } _ZNK6icu_7813CollationData19getCEFromOffsetCE32Eij: 111| 6.49M| int64_t getCEFromOffsetCE32(UChar32 c, uint32_t ce32) const { 112| 6.49M| int64_t dataCE = ces[Collation::indexFromCE32(ce32)]; 113| 6.49M| return Collation::makeCE(Collation::getThreeBytePrimaryForOffsetData(c, dataCE)); 114| 6.49M| } _ZNK6icu_7813CollationData8getFCD16Ei: 125| 25.9M| uint16_t getFCD16(UChar32 c) const { 126| 25.9M| return nfcImpl.getFCD16(c); 127| 25.9M| } _ZN6icu_7820CollationDataBuilder10CEModifierD2Ev: 42| 3.92k|CollationDataBuilder::CEModifier::~CEModifier() {} uprv_deleteConditionalCE32_78: 113| 713k|uprv_deleteConditionalCE32(void *obj) { 114| 713k| delete static_cast(obj); 115| 713k|} _ZN6icu_7828DataBuilderCollationIteratorC2ERNS_20CollationDataBuilderE: 167| 5.63k| : CollationIterator(&builderData, /*numeric=*/ false), 168| 5.63k| builder(b), builderData(b.nfcImpl), 169| 5.63k| s(nullptr), pos(0) { 170| 5.63k| builderData.base = builder.base; 171| | // Set all of the jamoCE32s[] to indirection CE32s. 172| 383k| for(int32_t j = 0; j < CollationData::JAMO_CE32S_LENGTH; ++j) { // Count across Jamo types. ------------------ | Branch (172:24): [True: 377k, False: 5.63k] ------------------ 173| 377k| UChar32 jamo = CollationDataBuilder::jamoCpFromIndex(j); 174| 377k| jamoCE32s[j] = Collation::makeCE32FromTagAndIndex(Collation::BUILDER_DATA_TAG, jamo) | 175| 377k| CollationDataBuilder::IS_BUILDER_JAMO_CE32; 176| 377k| } 177| 5.63k| builderData.jamoCE32s = jamoCE32s; 178| 5.63k|} _ZN6icu_7828DataBuilderCollationIteratorD2Ev: 180| 5.63k|DataBuilderCollationIterator::~DataBuilderCollationIterator() {} _ZN6icu_7828DataBuilderCollationIterator8fetchCEsERKNS_13UnicodeStringEiPli: 184| 26.5M| int64_t ces[], int32_t cesLength) { 185| | // Set the pointers each time, in case they changed due to reallocation. 186| 26.5M| builderData.ce32s = reinterpret_cast(builder.ce32s.getBuffer()); 187| 26.5M| builderData.ces = builder.ce64s.getBuffer(); 188| 26.5M| builderData.contexts = builder.contexts.getBuffer(); 189| | // Modified copy of CollationIterator::nextCE() and CollationIterator::nextCEFromCE32(). 190| 26.5M| reset(); 191| 26.5M| s = &str; 192| 26.5M| pos = start; 193| 26.5M| UErrorCode errorCode = U_ZERO_ERROR; 194| 71.3M| while(U_SUCCESS(errorCode) && pos < s->length()) { ------------------ | Branch (194:11): [True: 71.3M, False: 0] | Branch (194:35): [True: 44.8M, False: 26.5M] ------------------ 195| | // No need to keep all CEs in the iterator buffer. 196| 44.8M| clearCEs(); 197| 44.8M| UChar32 c = s->char32At(pos); 198| 44.8M| pos += U16_LENGTH(c); ------------------ | | 141| 44.8M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 40.9M, False: 3.90M] | | ------------------ ------------------ 199| 44.8M| uint32_t ce32 = utrie2_get32(builder.trie, c); ------------------ | | 1966| 44.8M|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 44.8M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 44.8M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 44.8M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 44.8M| const CollationData *d; 201| 44.8M| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (201:12): [True: 36.8M, False: 8.01M] ------------------ 202| 36.8M| d = builder.base; 203| 36.8M| ce32 = builder.base->getCE32(c); 204| 36.8M| } else { 205| 8.01M| d = &builderData; 206| 8.01M| } 207| 44.8M| appendCEsFromCE32(d, c, ce32, /*forward=*/ true, errorCode); 208| 44.8M| U_ASSERT(U_SUCCESS(errorCode)); ------------------ | | 35| 44.8M|# define U_ASSERT(exp) (void)0 ------------------ 209| 111M| for(int32_t i = 0; i < getCEsLength(); ++i) { ------------------ | Branch (209:28): [True: 66.6M, False: 44.8M] ------------------ 210| 66.6M| int64_t ce = getCE(i); 211| 66.6M| if(ce != 0) { ------------------ | Branch (211:16): [True: 65.5M, False: 1.06M] ------------------ 212| 65.5M| if(cesLength < Collation::MAX_EXPANSION_LENGTH) { ------------------ | Branch (212:20): [True: 49.9M, False: 15.6M] ------------------ 213| 49.9M| ces[cesLength] = ce; 214| 49.9M| } 215| 65.5M| ++cesLength; 216| 65.5M| } 217| 66.6M| } 218| 44.8M| } 219| 26.5M| return cesLength; 220| 26.5M|} _ZN6icu_7828DataBuilderCollationIterator13nextCodePointER10UErrorCode: 234| 15.7M|DataBuilderCollationIterator::nextCodePoint(UErrorCode & /*errorCode*/) { 235| 15.7M| if(pos == s->length()) { ------------------ | Branch (235:8): [True: 346k, False: 15.3M] ------------------ 236| 346k| return U_SENTINEL; ------------------ | | 469| 346k|#define U_SENTINEL (-1) ------------------ 237| 346k| } 238| 15.3M| UChar32 c = s->char32At(pos); 239| 15.3M| pos += U16_LENGTH(c); ------------------ | | 141| 15.3M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 15.1M, False: 228k] | | ------------------ ------------------ 240| 15.3M| return c; 241| 15.7M|} _ZN6icu_7828DataBuilderCollationIterator17previousCodePointER10UErrorCode: 244| 3.26M|DataBuilderCollationIterator::previousCodePoint(UErrorCode & /*errorCode*/) { 245| 3.26M| if(pos == 0) { ------------------ | Branch (245:8): [True: 40.8k, False: 3.22M] ------------------ 246| 40.8k| return U_SENTINEL; ------------------ | | 469| 40.8k|#define U_SENTINEL (-1) ------------------ 247| 40.8k| } 248| 3.22M| UChar32 c = s->char32At(pos - 1); 249| 3.22M| pos -= U16_LENGTH(c); ------------------ | | 141| 3.22M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 3.20M, False: 15.5k] | | ------------------ ------------------ 250| 3.22M| return c; 251| 3.26M|} _ZN6icu_7828DataBuilderCollationIterator20forwardNumCodePointsEiR10UErrorCode: 254| 1.33M|DataBuilderCollationIterator::forwardNumCodePoints(int32_t num, UErrorCode & /*errorCode*/) { 255| 1.33M| pos = s->moveIndex32(pos, num); 256| 1.33M|} _ZN6icu_7828DataBuilderCollationIterator21backwardNumCodePointsEiR10UErrorCode: 259| 2.11M|DataBuilderCollationIterator::backwardNumCodePoints(int32_t num, UErrorCode & /*errorCode*/) { 260| 2.11M| pos = s->moveIndex32(pos, -num); 261| 2.11M|} _ZNK6icu_7828DataBuilderCollationIterator11getDataCE32Ei: 264| 92.9k|DataBuilderCollationIterator::getDataCE32(UChar32 c) const { 265| 92.9k| return utrie2_get32(builder.trie, c); ------------------ | | 1966| 92.9k|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 92.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 92.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 92.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 266| 92.9k|} _ZN6icu_7828DataBuilderCollationIterator22getCE32FromBuilderDataEjR10UErrorCode: 269| 2.65M|DataBuilderCollationIterator::getCE32FromBuilderData(uint32_t ce32, UErrorCode &errorCode) { 270| 2.65M| if (U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (270:9): [True: 0, False: 2.65M] ------------------ 271| 2.65M| U_ASSERT(Collation::hasCE32Tag(ce32, Collation::BUILDER_DATA_TAG)); ------------------ | | 35| 2.65M|# define U_ASSERT(exp) (void)0 ------------------ 272| 2.65M| if((ce32 & CollationDataBuilder::IS_BUILDER_JAMO_CE32) != 0) { ------------------ | Branch (272:8): [True: 724k, False: 1.93M] ------------------ 273| 724k| UChar32 jamo = Collation::indexFromCE32(ce32); 274| 724k| return utrie2_get32(builder.trie, jamo); ------------------ | | 1966| 724k|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 724k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 724k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 724k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 275| 1.93M| } else { 276| 1.93M| ConditionalCE32 *cond = builder.getConditionalCE32ForCE32(ce32); 277| 1.93M| if (cond == nullptr) { ------------------ | Branch (277:13): [True: 0, False: 1.93M] ------------------ 278| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 279| | // TODO: ICU-21531 figure out why this happens. 280| 0| return 0; 281| 0| } 282| 1.93M| if(cond->builtCE32 == Collation::NO_CE32 || cond->era != builder.contextsEra) { ------------------ | Branch (282:12): [True: 404k, False: 1.52M] | Branch (282:53): [True: 162, False: 1.52M] ------------------ 283| | // Build the context-sensitive mappings into their runtime form and cache the result. 284| 404k| cond->builtCE32 = builder.buildContext(cond, errorCode); 285| 404k| if(errorCode == U_BUFFER_OVERFLOW_ERROR) { ------------------ | Branch (285:16): [True: 102, False: 404k] ------------------ 286| 102| errorCode = U_ZERO_ERROR; 287| 102| builder.clearContexts(); 288| 102| cond->builtCE32 = builder.buildContext(cond, errorCode); 289| 102| } 290| 404k| cond->era = builder.contextsEra; 291| 404k| builderData.contexts = builder.contexts.getBuffer(); 292| 404k| } 293| 1.93M| return cond->builtCE32; 294| 1.93M| } 295| 2.65M|} _ZN6icu_7820CollationDataBuilderC2EaR10UErrorCode: 300| 11.6k| : nfcImpl(*Normalizer2Factory::getNFCImpl(errorCode)), 301| 11.6k| base(nullptr), baseSettings(nullptr), 302| 11.6k| trie(nullptr), 303| 11.6k| ce32s(errorCode), ce64s(errorCode), conditionalCE32s(errorCode), 304| 11.6k| modified(false), 305| 11.6k| icu4xMode(icu4xMode), 306| 11.6k| fastLatinEnabled(false), fastLatinBuilder(nullptr), 307| 11.6k| collIter(nullptr) { 308| | // Reserve the first CE32 for U+0000. 309| 11.6k| if (!icu4xMode) { ------------------ | Branch (309:9): [True: 11.6k, False: 0] ------------------ 310| 11.6k| ce32s.addElement(0, errorCode); 311| 11.6k| } 312| 11.6k| conditionalCE32s.setDeleter(uprv_deleteConditionalCE32); ------------------ | | 1488| 11.6k|#define uprv_deleteConditionalCE32 U_ICU_ENTRY_POINT_RENAME(uprv_deleteConditionalCE32) | | ------------------ | | | | 123| 11.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 313| 11.6k|} _ZN6icu_7820CollationDataBuilderD2Ev: 315| 11.6k|CollationDataBuilder::~CollationDataBuilder() { 316| 11.6k| utrie2_close(trie); ------------------ | | 1961| 11.6k|#define utrie2_close U_ICU_ENTRY_POINT_RENAME(utrie2_close) | | ------------------ | | | | 123| 11.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 317| 11.6k| delete fastLatinBuilder; 318| 11.6k| delete collIter; 319| 11.6k|} _ZN6icu_7820CollationDataBuilder16initForTailoringEPKNS_13CollationDataER10UErrorCode: 322| 11.6k|CollationDataBuilder::initForTailoring(const CollationData *b, UErrorCode &errorCode) { 323| 11.6k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (323:8): [True: 0, False: 11.6k] ------------------ 324| 11.6k| if(trie != nullptr) { ------------------ | Branch (324:8): [True: 0, False: 11.6k] ------------------ 325| 0| errorCode = U_INVALID_STATE_ERROR; 326| 0| return; 327| 0| } 328| 11.6k| if(b == nullptr) { ------------------ | Branch (328:8): [True: 0, False: 11.6k] ------------------ 329| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 330| 0| return; 331| 0| } 332| 11.6k| base = b; 333| | 334| | // For a tailoring, the default is to fall back to the base. 335| | // For ICU4X, use the same value for fallback as for the default 336| | // to avoid having to have different blocks for the two. 337| 11.6k| trie = utrie2_open(Collation::FALLBACK_CE32, icu4xMode ? Collation::FALLBACK_CE32 : Collation::FFFD_CE32, &errorCode); ------------------ | | 1971| 11.6k|#define utrie2_open U_ICU_ENTRY_POINT_RENAME(utrie2_open) | | ------------------ | | | | 123| 11.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (337:50): [True: 0, False: 11.6k] ------------------ 338| | 339| 11.6k| if (!icu4xMode) { ------------------ | Branch (339:9): [True: 11.6k, False: 0] ------------------ 340| | // Set the Latin-1 letters block so that it is allocated first in the data array, 341| | // to try to improve locality of reference when sorting Latin-1 text. 342| | // Do not use utrie2_setRange32() since that will not actually allocate blocks 343| | // that are filled with the default value. 344| | // ASCII (0..7F) is already preallocated anyway. 345| 756k| for(UChar32 c = 0xc0; c <= 0xff; ++c) { ------------------ | Branch (345:31): [True: 745k, False: 11.6k] ------------------ 346| 745k| utrie2_set32(trie, c, Collation::FALLBACK_CE32, &errorCode); ------------------ | | 1975| 745k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 745k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 745k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 745k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 347| 745k| } 348| | 349| | // Hangul syllables are not tailorable (except via tailoring Jamos). 350| | // Always set the Hangul tag to help performance. 351| | // Do this here, rather than in buildMappings(), 352| | // so that we see the HANGUL_TAG in various assertions. 353| 11.6k| uint32_t hangulCE32 = Collation::makeCE32FromTagAndIndex(Collation::HANGUL_TAG, 0); 354| 11.6k| utrie2_setRange32(trie, Hangul::HANGUL_BASE, Hangul::HANGUL_END, hangulCE32, true, &errorCode); ------------------ | | 1977| 11.6k|#define utrie2_setRange32 U_ICU_ENTRY_POINT_RENAME(utrie2_setRange32) | | ------------------ | | | | 123| 11.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 355| | 356| | // Copy the set contents but don't copy/clone the set as a whole because 357| | // that would copy the isFrozen state too. 358| 11.6k| unsafeBackwardSet.addAll(*b->unsafeBackwardSet); 359| 11.6k| } 360| | 361| 11.6k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (361:8): [True: 0, False: 11.6k] ------------------ 362| 11.6k|} _ZNK6icu_7820CollationDataBuilder21getCE32FromOffsetCE32Eaij: 423| 573k|CollationDataBuilder::getCE32FromOffsetCE32(UBool fromBase, UChar32 c, uint32_t ce32) const { 424| 573k| int32_t i = Collation::indexFromCE32(ce32); 425| 573k| int64_t dataCE = fromBase ? base->ces[i] : ce64s.elementAti(i); ------------------ | Branch (425:22): [True: 573k, False: 0] ------------------ 426| 573k| uint32_t p = Collation::getThreeBytePrimaryForOffsetData(c, dataCE); 427| 573k| return Collation::makeLongPrimaryCE32(p); 428| 573k|} _ZN6icu_7820CollationDataBuilder5addCEElR10UErrorCode: 516| 799k|CollationDataBuilder::addCE(int64_t ce, UErrorCode &errorCode) { 517| 799k| int32_t length = ce64s.size(); 518| 3.82G| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (518:24): [True: 3.82G, False: 724k] ------------------ 519| 3.82G| if(ce == ce64s.elementAti(i)) { return i; } ------------------ | Branch (519:12): [True: 74.7k, False: 3.82G] ------------------ 520| 3.82G| } 521| 724k| ce64s.addElement(ce, errorCode); 522| 724k| return length; 523| 799k|} _ZN6icu_7820CollationDataBuilder7addCE32EjR10UErrorCode: 526| 50.8k|CollationDataBuilder::addCE32(uint32_t ce32, UErrorCode &errorCode) { 527| 50.8k| int32_t length = ce32s.size(); 528| 62.3M| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (528:24): [True: 62.2M, False: 38.3k] ------------------ 529| 62.2M| if (ce32 == static_cast(ce32s.elementAti(i))) { return i; } ------------------ | Branch (529:13): [True: 12.5k, False: 62.2M] ------------------ 530| 62.2M| } 531| 38.3k| ce32s.addElement(static_cast(ce32), errorCode); 532| 38.3k| return length; 533| 50.8k|} _ZN6icu_7820CollationDataBuilder18addConditionalCE32ERKNS_13UnicodeStringEjR10UErrorCode: 537| 713k| UErrorCode &errorCode) { 538| 713k| if(U_FAILURE(errorCode)) { return -1; } ------------------ | Branch (538:8): [True: 0, False: 713k] ------------------ 539| 713k| U_ASSERT(!context.isEmpty()); ------------------ | | 35| 713k|# define U_ASSERT(exp) (void)0 ------------------ 540| 713k| int32_t index = conditionalCE32s.size(); 541| 713k| if(index > Collation::MAX_INDEX) { ------------------ | Branch (541:8): [True: 0, False: 713k] ------------------ 542| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 543| 0| return -1; 544| 0| } 545| 713k| LocalPointer cond(new ConditionalCE32(context, ce32), errorCode); 546| 713k| conditionalCE32s.adoptElement(cond.orphan(), errorCode); 547| 713k| if(U_FAILURE(errorCode)) { ------------------ | Branch (547:8): [True: 0, False: 713k] ------------------ 548| 0| return -1; 549| 0| } 550| 713k| return index; 551| 713k|} _ZN6icu_7820CollationDataBuilder7addCE32ERKNS_13UnicodeStringES3_jR10UErrorCode: 563| 6.85M| uint32_t ce32, UErrorCode &errorCode) { 564| 6.85M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (564:8): [True: 0, False: 6.85M] ------------------ 565| 6.85M| if(s.isEmpty()) { ------------------ | Branch (565:8): [True: 0, False: 6.85M] ------------------ 566| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 567| 0| return; 568| 0| } 569| 6.85M| if(trie == nullptr || utrie2_isFrozen(trie)) { ------------------ | | 1970| 6.85M|#define utrie2_isFrozen U_ICU_ENTRY_POINT_RENAME(utrie2_isFrozen) | | ------------------ | | | | 123| 6.85M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.85M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.85M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (569:8): [True: 0, False: 6.85M] | Branch (569:27): [True: 0, False: 6.85M] ------------------ 570| 0| errorCode = U_INVALID_STATE_ERROR; 571| 0| return; 572| 0| } 573| 6.85M| UChar32 c = s.char32At(0); 574| 6.85M| int32_t cLength = U16_LENGTH(c); ------------------ | | 141| 6.85M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 6.05M, False: 800k] | | ------------------ ------------------ 575| 6.85M| uint32_t oldCE32 = utrie2_get32(trie, c); ------------------ | | 1966| 6.85M|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 6.85M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.85M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.85M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 576| 6.85M| UBool hasContext = !prefix.isEmpty() || s.length() > cLength; ------------------ | Branch (576:24): [True: 70.2k, False: 6.78M] | Branch (576:45): [True: 328k, False: 6.46M] ------------------ 577| | 578| 6.85M| if (icu4xMode) { ------------------ | Branch (578:9): [True: 0, False: 6.85M] ------------------ 579| 0| if (base && c >= 0x1100 && c < 0x1200) { ------------------ | Branch (579:13): [True: 0, False: 0] | Branch (579:21): [True: 0, False: 0] | Branch (579:36): [True: 0, False: 0] ------------------ 580| | // Omit jamo tailorings. 581| | // TODO(https://github.com/unicode-org/icu4x/issues/1941). 582| 0| } 583| 0| const Normalizer2* nfdNormalizer = Normalizer2::getNFDInstance(errorCode); 584| 0| UnicodeString sInNfd; 585| 0| nfdNormalizer->normalize(s, sInNfd, errorCode); 586| 0| if (s != sInNfd) { ------------------ | Branch (586:13): [True: 0, False: 0] ------------------ 587| | // s is not in NFD, so it cannot match in ICU4X, since ICU4X only 588| | // does NFD lookups. 589| | 590| | // As of Unicode 16 alpha, the cases that come here are: 591| | // 592| | // 1. The second character is a special decomposing Tibetan vowel 593| | // sign. These are OK to ignore in the precomposed form, since 594| | // the decomposed form is added also. 595| | // 2. Likewise for KIRAT RAI VOWEL SIGN AA followed by KIRAT RAI VOWEL SIGN AI 596| | // and other such cases. 597| | // For details see the normalization section of 598| | // https://www.unicode.org/review/pri497/pri497-background.html 599| | // 3. U+FDD1 followed by U+AC00 is a marker for the alphabetical 600| | // index feature of ICU4C, which at this time does not have 601| | // a counterpart in ICU4X. 602| 0| return; 603| 0| } 604| | 605| 0| if (!prefix.isEmpty()) { ------------------ | Branch (605:13): [True: 0, False: 0] ------------------ 606| 0| UnicodeString prefixInNfd; 607| 0| nfdNormalizer->normalize(prefix, prefixInNfd, errorCode); 608| 0| if (prefix != prefixInNfd) { ------------------ | Branch (608:17): [True: 0, False: 0] ------------------ 609| 0| errorCode = U_UNSUPPORTED_ERROR; 610| 0| return; 611| 0| } 612| | 613| 0| int32_t count = prefix.countChar32(); 614| 0| if (count > 2) { ------------------ | Branch (614:17): [True: 0, False: 0] ------------------ 615| | // Prefix too long for ICU4X. 616| 0| errorCode = U_UNSUPPORTED_ERROR; 617| 0| return; 618| 0| } 619| 0| UChar32 utf32[4]; 620| 0| int32_t len = prefix.toUTF32(utf32, 4, errorCode); 621| 0| if (len != count) { ------------------ | Branch (621:17): [True: 0, False: 0] ------------------ 622| 0| errorCode = U_INVALID_STATE_ERROR; 623| 0| return; 624| 0| } 625| 0| UChar32 c = utf32[0]; 626| 0| if (u_getCombiningClass(c)) { ------------------ | | 270| 0|#define u_getCombiningClass U_ICU_ENTRY_POINT_RENAME(u_getCombiningClass) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (626:17): [True: 0, False: 0] ------------------ 627| | // Prefix must start with as starter for ICU4X. 628| 0| errorCode = U_UNSUPPORTED_ERROR; 629| 0| return; 630| 0| } 631| | // XXX: Korean searchjl has jamo in prefix, so commenting out this 632| | // check for now. ICU4X currently ignores non-root jamo tables anyway. 633| | // searchjl was added in 634| | // https://unicode-org.atlassian.net/browse/CLDR-3560 635| | // Contractions were changed to prefixes in 636| | // https://unicode-org.atlassian.net/browse/CLDR-6546 637| | // 638| | // if ((c >= 0x1100 && c < 0x1200) || (c >= 0xAC00 && c < 0xD7A4)) { 639| | // errorCode = U_UNSUPPORTED_ERROR; 640| | // return; 641| | // } 642| 0| if ((len > 1) && !(utf32[1] == 0x3099 || utf32[1] == 0x309A)) { ------------------ | Branch (642:17): [True: 0, False: 0] | Branch (642:32): [True: 0, False: 0] | Branch (642:54): [True: 0, False: 0] ------------------ 643| | // Second character in prefix, if present, must be a kana voicing mark for ICU4X. 644| 0| errorCode = U_UNSUPPORTED_ERROR; 645| 0| return; 646| 0| } 647| 0| } 648| | 649| 0| if (s.length() > cLength) { ------------------ | Branch (649:13): [True: 0, False: 0] ------------------ 650| | // Check that there's no modern Hangul in contractions. 651| 0| for (int32_t i = 0; i < s.length(); ++i) { ------------------ | Branch (651:33): [True: 0, False: 0] ------------------ 652| 0| char16_t c = s.charAt(i); 653| 0| if ((c >= 0x1100 && c < 0x1100 + 19) || (c >= 0x1161 && c < 0x1161 + 21) || (c >= 0x11A7 && c < 0x11A7 + 28) || (c >= 0xAC00 && c < 0xD7A4)) { ------------------ | Branch (653:22): [True: 0, False: 0] | Branch (653:37): [True: 0, False: 0] | Branch (653:58): [True: 0, False: 0] | Branch (653:73): [True: 0, False: 0] | Branch (653:94): [True: 0, False: 0] | Branch (653:109): [True: 0, False: 0] | Branch (653:130): [True: 0, False: 0] | Branch (653:145): [True: 0, False: 0] ------------------ 654| 0| errorCode = U_UNSUPPORTED_ERROR; 655| 0| return; 656| 0| } 657| 0| } 658| 0| int32_t sCount = s.countChar32(); 659| 0| UChar32 sUtf32[32]; 660| 0| int32_t sLen = s.toUTF32(sUtf32, 32, errorCode); 661| 0| if (sLen != sCount) { ------------------ | Branch (661:17): [True: 0, False: 0] ------------------ 662| | // If this error is ever reached, just increase the buffer 663| | // size above. 664| 0| errorCode = U_UNSUPPORTED_ERROR; 665| 0| return; 666| 0| } 667| 0| for (int32_t i = 1; i < sLen - 1; ++i) { ------------------ | Branch (667:33): [True: 0, False: 0] ------------------ 668| 0| if (u_getCombiningClass(sUtf32[i]) == 0) { ------------------ | | 270| 0|#define u_getCombiningClass U_ICU_ENTRY_POINT_RENAME(u_getCombiningClass) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (668:21): [True: 0, False: 0] ------------------ 669| 0| contractionMiddleStarter.add(sUtf32[i]); 670| 0| } 671| 0| } 672| 0| } 673| 0| } 674| | 675| 6.85M| if(oldCE32 == Collation::FALLBACK_CE32) { ------------------ | Branch (675:8): [True: 3.94M, False: 2.91M] ------------------ 676| | // First tailoring for c. 677| | // If c has contextual base mappings or if we add a contextual mapping, 678| | // then copy the base mappings. 679| | // Otherwise we just override the base mapping. 680| 3.94M| uint32_t baseCE32 = base->getFinalCE32(base->getCE32(c)); 681| 3.94M| if(hasContext || Collation::ce32HasContext(baseCE32)) { ------------------ | Branch (681:12): [True: 29.1k, False: 3.91M] | Branch (681:26): [True: 1.20k, False: 3.91M] ------------------ 682| 30.3k| oldCE32 = copyFromBaseCE32(c, baseCE32, true, errorCode); 683| 30.3k| utrie2_set32(trie, c, oldCE32, &errorCode); ------------------ | | 1975| 30.3k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 30.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 30.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 30.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 684| 30.3k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (684:16): [True: 0, False: 30.3k] ------------------ 685| 30.3k| } 686| 3.94M| } 687| 6.85M| if(!hasContext) { ------------------ | Branch (687:8): [True: 6.46M, False: 399k] ------------------ 688| | // No prefix, no contraction. 689| 6.46M| if(!isBuilderContextCE32(oldCE32)) { ------------------ | Branch (689:12): [True: 6.44M, False: 15.2k] ------------------ 690| 6.44M| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 6.44M|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 6.44M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.44M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.44M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 691| 6.44M| } else { 692| 15.2k| ConditionalCE32 *cond = getConditionalCE32ForCE32(oldCE32); 693| 15.2k| cond->builtCE32 = Collation::NO_CE32; 694| 15.2k| cond->ce32 = ce32; 695| 15.2k| } 696| 6.46M| } else { 697| 399k| ConditionalCE32 *cond; 698| 399k| if(!isBuilderContextCE32(oldCE32)) { ------------------ | Branch (698:12): [True: 32.2k, False: 367k] ------------------ 699| | // Replace the simple oldCE32 with a builder context CE32 700| | // pointing to a new ConditionalCE32 list head. 701| 32.2k| int32_t index = addConditionalCE32(UnicodeString(static_cast(0)), oldCE32, errorCode); 702| 32.2k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (702:16): [True: 0, False: 32.2k] ------------------ 703| 32.2k| uint32_t contextCE32 = makeBuilderContextCE32(index); 704| 32.2k| utrie2_set32(trie, c, contextCE32, &errorCode); ------------------ | | 1975| 32.2k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 32.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 32.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 32.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 705| 32.2k| contextChars.add(c); 706| 32.2k| cond = getConditionalCE32(index); 707| 367k| } else { 708| 367k| cond = getConditionalCE32ForCE32(oldCE32); 709| 367k| cond->builtCE32 = Collation::NO_CE32; 710| 367k| } 711| 399k| UnicodeString suffix(s, cLength); 712| 399k| UnicodeString context(static_cast(prefix.length())); 713| 399k| context.append(prefix).append(suffix); 714| 399k| if (icu4xMode && !suffix.isEmpty() && !prefix.isEmpty()) { ------------------ | Branch (714:13): [True: 0, False: 399k] | Branch (714:26): [True: 0, False: 0] | Branch (714:47): [True: 0, False: 0] ------------------ 715| | // ICU4X does not support the combination of prefix and contraction. 716| | // This combination is supported by LDML but does not occur in the 717| | // root or any tailorings in CLDR as of February 2025. 718| | // If support for this case becomes necessary, a practical change 719| | // would be allocating a flag on prefix ce32 and setting the 720| | // flag on a prefix ce32 if any ce32 that can be found under 721| | // the prefix ce32 (either the default or any UCharsTrie value) is 722| | // a contraction ce32 or if the prefix ce32 is the utrie2 value 723| | // for a character that is a starter that occurs in a middle 724| | // (neither first nor last) position in a contraction. 725| 0| errorCode = U_UNSUPPORTED_ERROR; 726| 0| return; 727| 0| } 728| 399k| unsafeBackwardSet.addAll(suffix); 729| 20.1M| for(;;) { 730| | // invariant: context > cond->context 731| 20.1M| int32_t next = cond->next; 732| 20.1M| if(next < 0) { ------------------ | Branch (732:16): [True: 79.8k, False: 20.0M] ------------------ 733| | // Append a new ConditionalCE32 after cond. 734| 79.8k| int32_t index = addConditionalCE32(context, ce32, errorCode); 735| 79.8k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (735:20): [True: 0, False: 79.8k] ------------------ 736| 79.8k| cond->next = index; 737| 79.8k| break; 738| 79.8k| } 739| 20.0M| ConditionalCE32 *nextCond = getConditionalCE32(next); 740| 20.0M| int8_t cmp = context.compare(nextCond->context); 741| 20.0M| if(cmp < 0) { ------------------ | Branch (741:16): [True: 264k, False: 19.8M] ------------------ 742| | // Insert a new ConditionalCE32 between cond and nextCond. 743| 264k| int32_t index = addConditionalCE32(context, ce32, errorCode); 744| 264k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (744:20): [True: 0, False: 264k] ------------------ 745| 264k| cond->next = index; 746| 264k| getConditionalCE32(index)->next = next; 747| 264k| break; 748| 19.8M| } else if(cmp == 0) { ------------------ | Branch (748:23): [True: 54.8k, False: 19.7M] ------------------ 749| | // Same context as before, overwrite its ce32. 750| 54.8k| nextCond->ce32 = ce32; 751| 54.8k| break; 752| 54.8k| } 753| 19.7M| cond = nextCond; 754| 19.7M| } 755| 399k| } 756| 6.85M| modified = true; 757| 6.85M|} _ZN6icu_7820CollationDataBuilder17encodeOneCEAsCE32El: 760| 14.9M|CollationDataBuilder::encodeOneCEAsCE32(int64_t ce) { 761| 14.9M| uint32_t p = static_cast(ce >> 32); 762| 14.9M| uint32_t lower32 = static_cast(ce); 763| 14.9M| uint32_t t = static_cast(ce & 0xffff); 764| 14.9M| U_ASSERT((t & 0xc000) != 0xc000); // Impossible case bits 11 mark special CE32s. ------------------ | | 35| 14.9M|# define U_ASSERT(exp) (void)0 ------------------ 765| 14.9M| if((ce & INT64_C(0xffff00ff00ff)) == 0) { ------------------ | Branch (765:8): [True: 11.5M, False: 3.41M] ------------------ 766| | // normal form ppppsstt 767| 11.5M| return p | (lower32 >> 16) | (t >> 8); 768| 11.5M| } else if((ce & INT64_C(0xffffffffff)) == Collation::COMMON_SEC_AND_TER_CE) { ------------------ | Branch (768:15): [True: 2.06M, False: 1.35M] ------------------ 769| | // long-primary form ppppppC1 770| 2.06M| return Collation::makeLongPrimaryCE32(p); 771| 2.06M| } else if(p == 0 && (t & 0xff) == 0) { ------------------ | Branch (771:15): [True: 81.5k, False: 1.27M] | Branch (771:25): [True: 73.7k, False: 7.78k] ------------------ 772| | // long-secondary form ssssttC2 773| 73.7k| return Collation::makeLongSecondaryCE32(lower32); 774| 73.7k| } 775| 1.28M| return Collation::NO_CE32; 776| 14.9M|} _ZN6icu_7820CollationDataBuilder11encodeOneCEElR10UErrorCode: 779| 5.96M|CollationDataBuilder::encodeOneCE(int64_t ce, UErrorCode &errorCode) { 780| | // Try to encode one CE as one CE32. 781| 5.96M| uint32_t ce32 = encodeOneCEAsCE32(ce); 782| 5.96M| if(ce32 != Collation::NO_CE32) { return ce32; } ------------------ | Branch (782:8): [True: 5.16M, False: 799k] ------------------ 783| 799k| int32_t index = addCE(ce, errorCode); 784| 799k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (784:8): [True: 0, False: 799k] ------------------ 785| 799k| if(index > Collation::MAX_INDEX) { ------------------ | Branch (785:8): [True: 0, False: 799k] ------------------ 786| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 787| 0| return 0; 788| 0| } 789| 799k| return Collation::makeCE32FromTagIndexAndLength(Collation::EXPANSION_TAG, index, 1); 790| 799k|} _ZN6icu_7820CollationDataBuilder9encodeCEsEPKliR10UErrorCode: 794| 6.87M| UErrorCode &errorCode) { 795| 6.87M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (795:8): [True: 0, False: 6.87M] ------------------ 796| 6.87M| if(cesLength < 0 || cesLength > Collation::MAX_EXPANSION_LENGTH) { ------------------ | Branch (796:8): [True: 0, False: 6.87M] | Branch (796:25): [True: 0, False: 6.87M] ------------------ 797| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 798| 0| return 0; 799| 0| } 800| 6.87M| if(trie == nullptr || utrie2_isFrozen(trie)) { ------------------ | | 1970| 6.87M|#define utrie2_isFrozen U_ICU_ENTRY_POINT_RENAME(utrie2_isFrozen) | | ------------------ | | | | 123| 6.87M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.87M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.87M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (800:8): [True: 0, False: 6.87M] | Branch (800:27): [True: 0, False: 6.87M] ------------------ 801| 0| errorCode = U_INVALID_STATE_ERROR; 802| 0| return 0; 803| 0| } 804| 6.87M| if(cesLength == 0) { ------------------ | Branch (804:8): [True: 70.3k, False: 6.80M] ------------------ 805| | // Convenience: We cannot map to nothing, but we can map to a completely ignorable CE. 806| | // Do this here so that callers need not do it. 807| 70.3k| return encodeOneCEAsCE32(0); 808| 6.80M| } else if(cesLength == 1) { ------------------ | Branch (808:15): [True: 4.57M, False: 2.23M] ------------------ 809| 4.57M| return encodeOneCE(ces[0], errorCode); 810| 4.57M| } else if(cesLength == 2 && !icu4xMode) { ------------------ | Branch (810:15): [True: 1.15M, False: 1.08M] | Branch (810:33): [True: 1.15M, False: 0] ------------------ 811| | // Try to encode two CEs as one CE32. 812| | // Turn this off for ICU4X, because without the canonical closure 813| | // these are so rare that it doesn't make sense to spend a branch 814| | // on checking this tag when using the data. 815| 1.15M| int64_t ce0 = ces[0]; 816| 1.15M| int64_t ce1 = ces[1]; 817| 1.15M| uint32_t p0 = static_cast(ce0 >> 32); 818| 1.15M| if((ce0 & INT64_C(0xffffffffff00ff)) == Collation::COMMON_SECONDARY_CE && ------------------ | Branch (818:12): [True: 172k, False: 979k] ------------------ 819| 1.15M| (ce1 & INT64_C(0xffffffff00ffffff)) == Collation::COMMON_TERTIARY_CE && ------------------ | Branch (819:17): [True: 9.99k, False: 162k] ------------------ 820| 1.15M| p0 != 0) { ------------------ | Branch (820:17): [True: 9.99k, False: 0] ------------------ 821| | // Latin mini expansion 822| 9.99k| return 823| 9.99k| p0 | 824| 9.99k| ((static_cast(ce0) & 0xff00u) << 8) | 825| 9.99k| static_cast(ce1 >> 16) | 826| 9.99k| Collation::SPECIAL_CE32_LOW_BYTE | 827| 9.99k| Collation::LATIN_EXPANSION_TAG; 828| 9.99k| } 829| 1.15M| } 830| | // Try to encode two or more CEs as CE32s. 831| 2.22M| int32_t newCE32s[Collation::MAX_EXPANSION_LENGTH]; 832| 10.6M| for(int32_t i = 0;; ++i) { 833| 10.6M| if(i == cesLength) { ------------------ | Branch (833:12): [True: 1.73M, False: 8.93M] ------------------ 834| 1.73M| return encodeExpansion32(newCE32s, cesLength, errorCode); 835| 1.73M| } 836| 8.93M| uint32_t ce32 = encodeOneCEAsCE32(ces[i]); 837| 8.93M| if(ce32 == Collation::NO_CE32) { break; } ------------------ | Branch (837:12): [True: 485k, False: 8.44M] ------------------ 838| 8.44M| newCE32s[i] = static_cast(ce32); 839| 8.44M| } 840| 485k| return encodeExpansion(ces, cesLength, errorCode); 841| 2.22M|} _ZN6icu_7820CollationDataBuilder15encodeExpansionEPKliR10UErrorCode: 844| 529k|CollationDataBuilder::encodeExpansion(const int64_t ces[], int32_t length, UErrorCode &errorCode) { 845| 529k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (845:8): [True: 0, False: 529k] ------------------ 846| | // See if this sequence of CEs has already been stored. 847| 529k| int64_t first = ces[0]; 848| 529k| int32_t ce64sMax = ce64s.size() - length; 849| 839M| for(int32_t i = 0; i <= ce64sMax; ++i) { ------------------ | Branch (849:24): [True: 839M, False: 263k] ------------------ 850| 839M| if(first == ce64s.elementAti(i)) { ------------------ | Branch (850:12): [True: 97.0M, False: 742M] ------------------ 851| 97.0M| if(i > Collation::MAX_INDEX) { ------------------ | Branch (851:16): [True: 0, False: 97.0M] ------------------ 852| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 853| 0| return 0; 854| 0| } 855| 526M| for(int32_t j = 1;; ++j) { 856| 526M| if(j == length) { ------------------ | Branch (856:20): [True: 265k, False: 526M] ------------------ 857| 265k| return Collation::makeCE32FromTagIndexAndLength( 858| 265k| Collation::EXPANSION_TAG, i, length); 859| 265k| } 860| 526M| if(ce64s.elementAti(i + j) != ces[j]) { break; } ------------------ | Branch (860:20): [True: 96.8M, False: 429M] ------------------ 861| 526M| } 862| 97.0M| } 863| 839M| } 864| | // Store the new sequence. 865| 263k| int32_t i = ce64s.size(); 866| 263k| if(i > Collation::MAX_INDEX) { ------------------ | Branch (866:8): [True: 0, False: 263k] ------------------ 867| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 868| 0| return 0; 869| 0| } 870| 2.04M| for(int32_t j = 0; j < length; ++j) { ------------------ | Branch (870:24): [True: 1.77M, False: 263k] ------------------ 871| 1.77M| ce64s.addElement(ces[j], errorCode); 872| 1.77M| } 873| 263k| return Collation::makeCE32FromTagIndexAndLength(Collation::EXPANSION_TAG, i, length); 874| 263k|} _ZN6icu_7820CollationDataBuilder17encodeExpansion32EPKiiR10UErrorCode: 878| 1.86M| UErrorCode &errorCode) { 879| 1.86M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (879:8): [True: 0, False: 1.86M] ------------------ 880| | // See if this sequence of CE32s has already been stored. 881| 1.86M| int32_t first = newCE32s[0]; 882| 1.86M| int32_t ce32sMax = ce32s.size() - length; 883| 4.26G| for(int32_t i = 0; i <= ce32sMax; ++i) { ------------------ | Branch (883:24): [True: 4.26G, False: 1.32M] ------------------ 884| 4.26G| if(first == ce32s.elementAti(i)) { ------------------ | Branch (884:12): [True: 371M, False: 3.88G] ------------------ 885| 371M| if(i > Collation::MAX_INDEX) { ------------------ | Branch (885:16): [True: 0, False: 371M] ------------------ 886| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 887| 0| return 0; 888| 0| } 889| 686M| for(int32_t j = 1;; ++j) { 890| 686M| if(j == length) { ------------------ | Branch (890:20): [True: 533k, False: 686M] ------------------ 891| 533k| return Collation::makeCE32FromTagIndexAndLength( 892| 533k| Collation::EXPANSION32_TAG, i, length); 893| 533k| } 894| 686M| if(ce32s.elementAti(i + j) != newCE32s[j]) { break; } ------------------ | Branch (894:20): [True: 371M, False: 314M] ------------------ 895| 686M| } 896| 371M| } 897| 4.26G| } 898| | // Store the new sequence. 899| 1.32M| int32_t i = ce32s.size(); 900| 1.32M| if(i > Collation::MAX_INDEX) { ------------------ | Branch (900:8): [True: 0, False: 1.32M] ------------------ 901| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 902| 0| return 0; 903| 0| } 904| 5.06M| for(int32_t j = 0; j < length; ++j) { ------------------ | Branch (904:24): [True: 3.74M, False: 1.32M] ------------------ 905| 3.74M| ce32s.addElement(newCE32s[j], errorCode); 906| 3.74M| } 907| 1.32M| return Collation::makeCE32FromTagIndexAndLength(Collation::EXPANSION32_TAG, i, length); 908| 1.32M|} _ZN6icu_7820CollationDataBuilder16copyFromBaseCE32EijaR10UErrorCode: 912| 2.42M| UErrorCode &errorCode) { 913| 2.42M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (913:8): [True: 0, False: 2.42M] ------------------ 914| 2.42M| if(!Collation::isSpecialCE32(ce32)) { return ce32; } ------------------ | Branch (914:8): [True: 656k, False: 1.77M] ------------------ 915| 1.77M| switch(Collation::tagFromCE32(ce32)) { 916| 782k| case Collation::LONG_PRIMARY_TAG: ------------------ | Branch (916:5): [True: 782k, False: 987k] ------------------ 917| 792k| case Collation::LONG_SECONDARY_TAG: ------------------ | Branch (917:5): [True: 9.39k, False: 1.76M] ------------------ 918| 996k| case Collation::LATIN_EXPANSION_TAG: ------------------ | Branch (918:5): [True: 204k, False: 1.56M] ------------------ 919| | // copy as is 920| 996k| break; 921| 74.6k| case Collation::EXPANSION32_TAG: { ------------------ | Branch (921:5): [True: 74.6k, False: 1.69M] ------------------ 922| 74.6k| const uint32_t *baseCE32s = base->ce32s + Collation::indexFromCE32(ce32); 923| 74.6k| int32_t length = Collation::lengthFromCE32(ce32); 924| 74.6k| ce32 = encodeExpansion32( 925| 74.6k| reinterpret_cast(baseCE32s), length, errorCode); 926| 74.6k| break; 927| 792k| } 928| 18.7k| case Collation::EXPANSION_TAG: { ------------------ | Branch (928:5): [True: 18.7k, False: 1.75M] ------------------ 929| 18.7k| const int64_t *baseCEs = base->ces + Collation::indexFromCE32(ce32); 930| 18.7k| int32_t length = Collation::lengthFromCE32(ce32); 931| 18.7k| ce32 = encodeExpansion(baseCEs, length, errorCode); 932| 18.7k| break; 933| 792k| } 934| 453| case Collation::PREFIX_TAG: { ------------------ | Branch (934:5): [True: 453, False: 1.77M] ------------------ 935| | // Flatten prefixes and nested suffixes (contractions) 936| | // into a linear list of ConditionalCE32. 937| 453| const char16_t *p = base->contexts + Collation::indexFromCE32(ce32); 938| 453| ce32 = CollationData::readCE32(p); // Default if no prefix match. 939| 453| if(!withContext) { ------------------ | Branch (939:12): [True: 0, False: 453] ------------------ 940| 0| return copyFromBaseCE32(c, ce32, false, errorCode); 941| 0| } 942| 453| ConditionalCE32 head; 943| 453| UnicodeString context(static_cast(0)); 944| 453| int32_t index; 945| 453| if(Collation::isContractionCE32(ce32)) { ------------------ | Branch (945:12): [True: 0, False: 453] ------------------ 946| 0| index = copyContractionsFromBaseCE32(context, c, ce32, &head, errorCode); 947| 453| } else { 948| 453| ce32 = copyFromBaseCE32(c, ce32, true, errorCode); 949| 453| head.next = index = addConditionalCE32(context, ce32, errorCode); 950| 453| } 951| 453| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (951:12): [True: 0, False: 453] ------------------ 952| 453| ConditionalCE32 *cond = getConditionalCE32(index); // the last ConditionalCE32 so far 953| 453| UCharsTrie::Iterator prefixes(p + 2, 0, errorCode); 954| 1.35k| while(prefixes.next(errorCode)) { ------------------ | Branch (954:15): [True: 906, False: 453] ------------------ 955| 906| context = prefixes.getString(); 956| 906| context.reverse(); 957| 906| context.insert(0, static_cast(context.length())); 958| 906| ce32 = static_cast(prefixes.getValue()); 959| 906| if(Collation::isContractionCE32(ce32)) { ------------------ | Branch (959:16): [True: 0, False: 906] ------------------ 960| 0| index = copyContractionsFromBaseCE32(context, c, ce32, cond, errorCode); 961| 906| } else { 962| 906| ce32 = copyFromBaseCE32(c, ce32, true, errorCode); 963| 906| cond->next = index = addConditionalCE32(context, ce32, errorCode); 964| 906| } 965| 906| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (965:16): [True: 0, False: 906] ------------------ 966| 906| cond = getConditionalCE32(index); 967| 906| } 968| 453| ce32 = makeBuilderContextCE32(head.next); 969| 453| contextChars.add(c); 970| 453| break; 971| 453| } 972| 3.61k| case Collation::CONTRACTION_TAG: { ------------------ | Branch (972:5): [True: 3.61k, False: 1.76M] ------------------ 973| 3.61k| if(!withContext) { ------------------ | Branch (973:12): [True: 135, False: 3.48k] ------------------ 974| 135| const char16_t *p = base->contexts + Collation::indexFromCE32(ce32); 975| 135| ce32 = CollationData::readCE32(p); // Default if no suffix match. 976| 135| return copyFromBaseCE32(c, ce32, false, errorCode); 977| 135| } 978| 3.48k| ConditionalCE32 head; 979| 3.48k| UnicodeString context(static_cast(0)); 980| 3.48k| copyContractionsFromBaseCE32(context, c, ce32, &head, errorCode); 981| 3.48k| ce32 = makeBuilderContextCE32(head.next); 982| 3.48k| contextChars.add(c); 983| 3.48k| break; 984| 3.61k| } 985| 0| case Collation::HANGUL_TAG: ------------------ | Branch (985:5): [True: 0, False: 1.77M] ------------------ 986| 0| errorCode = U_UNSUPPORTED_ERROR; // We forbid tailoring of Hangul syllables. 987| 0| break; 988| 573k| case Collation::OFFSET_TAG: ------------------ | Branch (988:5): [True: 573k, False: 1.19M] ------------------ 989| 573k| ce32 = getCE32FromOffsetCE32(true, c, ce32); 990| 573k| break; 991| 103k| case Collation::IMPLICIT_TAG: ------------------ | Branch (991:5): [True: 103k, False: 1.66M] ------------------ 992| 103k| ce32 = encodeOneCE(Collation::unassignedCEFromCodePoint(c), errorCode); 993| 103k| break; 994| 0| default: ------------------ | Branch (994:5): [True: 0, False: 1.77M] ------------------ 995| 0| UPRV_UNREACHABLE_EXIT; // require ce32 == base->getFinalCE32(ce32) ------------------ | | 68| 0|# define UPRV_UNREACHABLE_EXIT abort() ------------------ 996| 1.77M| } 997| 1.77M| return ce32; 998| 1.77M|} _ZN6icu_7820CollationDataBuilder28copyContractionsFromBaseCE32ERNS_13UnicodeStringEijPNS_15ConditionalCE32ER10UErrorCode: 1002| 3.48k| ConditionalCE32 *cond, UErrorCode &errorCode) { 1003| 3.48k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1003:8): [True: 0, False: 3.48k] ------------------ 1004| 3.48k| const char16_t *p = base->contexts + Collation::indexFromCE32(ce32); 1005| 3.48k| int32_t index; 1006| 3.48k| if((ce32 & Collation::CONTRACT_SINGLE_CP_NO_MATCH) != 0) { ------------------ | Branch (1006:8): [True: 0, False: 3.48k] ------------------ 1007| | // No match on the single code point. 1008| | // We are underneath a prefix, and the default mapping is just 1009| | // a fallback to the mappings for a shorter prefix. 1010| 0| U_ASSERT(context.length() > 1); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1011| 0| index = -1; 1012| 3.48k| } else { 1013| 3.48k| ce32 = CollationData::readCE32(p); // Default if no suffix match. 1014| 3.48k| U_ASSERT(!Collation::isContractionCE32(ce32)); ------------------ | | 35| 3.48k|# define U_ASSERT(exp) (void)0 ------------------ 1015| 3.48k| ce32 = copyFromBaseCE32(c, ce32, true, errorCode); 1016| 3.48k| cond->next = index = addConditionalCE32(context, ce32, errorCode); 1017| 3.48k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1017:12): [True: 0, False: 3.48k] ------------------ 1018| 3.48k| cond = getConditionalCE32(index); 1019| 3.48k| } 1020| | 1021| 3.48k| int32_t suffixStart = context.length(); 1022| 3.48k| UCharsTrie::Iterator suffixes(p + 2, 0, errorCode); 1023| 46.0k| while(suffixes.next(errorCode)) { ------------------ | Branch (1023:11): [True: 42.5k, False: 3.48k] ------------------ 1024| 42.5k| context.append(suffixes.getString()); 1025| 42.5k| ce32 = copyFromBaseCE32(c, static_cast(suffixes.getValue()), true, errorCode); 1026| 42.5k| cond->next = index = addConditionalCE32(context, ce32, errorCode); 1027| 42.5k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1027:12): [True: 0, False: 42.5k] ------------------ 1028| | // No need to update the unsafeBackwardSet because the tailoring set 1029| | // is already a copy of the base set. 1030| 42.5k| cond = getConditionalCE32(index); 1031| 42.5k| context.truncate(suffixStart); 1032| 42.5k| } 1033| 3.48k| U_ASSERT(index >= 0); ------------------ | | 35| 3.48k|# define U_ASSERT(exp) (void)0 ------------------ 1034| 3.48k| return index; 1035| 3.48k|} _ZN6icu_7820CollationDataBuilder8copyFromERKS0_RKNS0_10CEModifierER10UErrorCode: 1169| 3.92k| UErrorCode &errorCode) { 1170| 3.92k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1170:8): [True: 0, False: 3.92k] ------------------ 1171| 3.92k| if(trie == nullptr || utrie2_isFrozen(trie)) { ------------------ | | 1970| 3.92k|#define utrie2_isFrozen U_ICU_ENTRY_POINT_RENAME(utrie2_isFrozen) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1171:8): [True: 0, False: 3.92k] | Branch (1171:27): [True: 0, False: 3.92k] ------------------ 1172| 0| errorCode = U_INVALID_STATE_ERROR; 1173| 0| return; 1174| 0| } 1175| 3.92k| CopyHelper helper(src, *this, modifier, errorCode); 1176| 3.92k| utrie2_enum(src.trie, nullptr, enumRangeForCopy, &helper); ------------------ | | 1962| 3.92k|#define utrie2_enum U_ICU_ENTRY_POINT_RENAME(utrie2_enum) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1177| 3.92k| errorCode = helper.errorCode; 1178| | // Update the contextChars and the unsafeBackwardSet while copying, 1179| | // in case a character had conditional mappings in the source builder 1180| | // and they were removed later. 1181| 3.92k| modified |= src.modified; 1182| 3.92k|} _ZN6icu_7820CollationDataBuilder8optimizeERKNS_10UnicodeSetER10UErrorCode: 1185| 3.96k|CollationDataBuilder::optimize(const UnicodeSet &set, UErrorCode &errorCode) { 1186| 3.96k| if(U_FAILURE(errorCode) || set.isEmpty()) { return; } ------------------ | Branch (1186:8): [True: 41, False: 3.92k] | Branch (1186:32): [True: 0, False: 3.92k] ------------------ 1187| 3.92k| UnicodeSetIterator iter(set); 1188| 2.43M| while(iter.next() && !iter.isString()) { ------------------ | Branch (1188:11): [True: 2.43M, False: 3.92k] | Branch (1188:26): [True: 2.43M, False: 5] ------------------ 1189| 2.43M| UChar32 c = iter.getCodepoint(); 1190| 2.43M| uint32_t ce32 = utrie2_get32(trie, c); ------------------ | | 1966| 2.43M|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 2.43M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.43M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.43M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1191| 2.43M| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (1191:12): [True: 2.34M, False: 82.9k] ------------------ 1192| 2.34M| ce32 = base->getFinalCE32(base->getCE32(c)); 1193| 2.34M| ce32 = copyFromBaseCE32(c, ce32, true, errorCode); 1194| 2.34M| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 2.34M|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 2.34M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.34M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.34M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1195| 2.34M| } 1196| 2.43M| } 1197| 3.92k| modified = true; 1198| 3.92k|} _ZN6icu_7820CollationDataBuilder20suppressContractionsERKNS_10UnicodeSetER10UErrorCode: 1201| 296|CollationDataBuilder::suppressContractions(const UnicodeSet &set, UErrorCode &errorCode) { 1202| 296| if(U_FAILURE(errorCode) || set.isEmpty()) { return; } ------------------ | Branch (1202:8): [True: 0, False: 296] | Branch (1202:32): [True: 0, False: 296] ------------------ 1203| 296| UnicodeSetIterator iter(set); 1204| 888| while(iter.next() && !iter.isString()) { ------------------ | Branch (1204:11): [True: 592, False: 296] | Branch (1204:26): [True: 592, False: 0] ------------------ 1205| 592| UChar32 c = iter.getCodepoint(); 1206| 592| uint32_t ce32 = utrie2_get32(trie, c); ------------------ | | 1966| 592|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 592|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 592|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 592|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1207| 592| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (1207:12): [True: 135, False: 457] ------------------ 1208| 135| ce32 = base->getFinalCE32(base->getCE32(c)); 1209| 135| if(Collation::ce32HasContext(ce32)) { ------------------ | Branch (1209:16): [True: 135, False: 0] ------------------ 1210| 135| ce32 = copyFromBaseCE32(c, ce32, false /* without context */, errorCode); 1211| 135| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 135|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 135|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 135|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 135|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1212| 135| } 1213| 457| } else if(isBuilderContextCE32(ce32)) { ------------------ | Branch (1213:19): [True: 13, False: 444] ------------------ 1214| 13| ce32 = getConditionalCE32ForCE32(ce32)->ce32; 1215| | // Simply abandon the list of ConditionalCE32. 1216| | // The caller will copy this builder in the end, 1217| | // eliminating unreachable data. 1218| 13| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 13|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 13|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 13|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 13|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1219| 13| contextChars.remove(c); 1220| 13| } 1221| 592| } 1222| 296| modified = true; 1223| 296|} _ZN6icu_7820CollationDataBuilder12getJamoCE32sEPjR10UErrorCode: 1226| 3.92k|CollationDataBuilder::getJamoCE32s(uint32_t jamoCE32s[], UErrorCode &errorCode) { 1227| 3.92k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (1227:8): [True: 0, False: 3.92k] ------------------ 1228| 3.92k| UBool anyJamoAssigned = base == nullptr; // always set jamoCE32s in the base data 1229| 3.92k| UBool needToCopyFromBase = false; 1230| 267k| for(int32_t j = 0; j < CollationData::JAMO_CE32S_LENGTH; ++j) { // Count across Jamo types. ------------------ | Branch (1230:24): [True: 263k, False: 3.92k] ------------------ 1231| 263k| UChar32 jamo = jamoCpFromIndex(j); 1232| 263k| UBool fromBase = false; 1233| 263k| uint32_t ce32 = utrie2_get32(trie, jamo); ------------------ | | 1966| 263k|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 263k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 263k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 263k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1234| 263k| anyJamoAssigned |= Collation::isAssignedCE32(ce32); 1235| | // TODO: Try to prevent [optimize [Jamo]] from counting as anyJamoAssigned. 1236| | // (As of CLDR 24 [2013] the Korean tailoring does not optimize conjoining Jamo.) 1237| 263k| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (1237:12): [True: 259k, False: 3.68k] ------------------ 1238| 259k| fromBase = true; 1239| 259k| ce32 = base->getCE32(jamo); 1240| 259k| } 1241| 263k| if(Collation::isSpecialCE32(ce32)) { ------------------ | Branch (1241:12): [True: 1.79k, False: 261k] ------------------ 1242| 1.79k| switch(Collation::tagFromCE32(ce32)) { ------------------ | Branch (1242:20): [True: 0, False: 1.79k] ------------------ 1243| 322| case Collation::LONG_PRIMARY_TAG: ------------------ | Branch (1243:13): [True: 322, False: 1.47k] ------------------ 1244| 339| case Collation::LONG_SECONDARY_TAG: ------------------ | Branch (1244:13): [True: 17, False: 1.77k] ------------------ 1245| 339| case Collation::LATIN_EXPANSION_TAG: ------------------ | Branch (1245:13): [True: 0, False: 1.79k] ------------------ 1246| | // Copy the ce32 as-is. 1247| 339| break; 1248| 933| case Collation::EXPANSION32_TAG: ------------------ | Branch (1248:13): [True: 933, False: 862] ------------------ 1249| 1.43k| case Collation::EXPANSION_TAG: ------------------ | Branch (1249:13): [True: 499, False: 1.29k] ------------------ 1250| 1.44k| case Collation::PREFIX_TAG: ------------------ | Branch (1250:13): [True: 12, False: 1.78k] ------------------ 1251| 1.45k| case Collation::CONTRACTION_TAG: ------------------ | Branch (1251:13): [True: 12, False: 1.78k] ------------------ 1252| 1.45k| if(fromBase) { ------------------ | Branch (1252:20): [True: 0, False: 1.45k] ------------------ 1253| | // Defer copying until we know if anyJamoAssigned. 1254| 0| ce32 = Collation::FALLBACK_CE32; 1255| 0| needToCopyFromBase = true; 1256| 0| } 1257| 1.45k| break; 1258| 0| case Collation::IMPLICIT_TAG: ------------------ | Branch (1258:13): [True: 0, False: 1.79k] ------------------ 1259| | // An unassigned Jamo should only occur in tests with incomplete bases. 1260| 0| U_ASSERT(fromBase); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1261| 0| ce32 = Collation::FALLBACK_CE32; 1262| 0| needToCopyFromBase = true; 1263| 0| break; 1264| 0| case Collation::OFFSET_TAG: ------------------ | Branch (1264:13): [True: 0, False: 1.79k] ------------------ 1265| 0| ce32 = getCE32FromOffsetCE32(fromBase, jamo, ce32); 1266| 0| break; 1267| 0| case Collation::FALLBACK_TAG: ------------------ | Branch (1267:13): [True: 0, False: 1.79k] ------------------ 1268| 0| case Collation::RESERVED_TAG_3: ------------------ | Branch (1268:13): [True: 0, False: 1.79k] ------------------ 1269| 0| case Collation::BUILDER_DATA_TAG: ------------------ | Branch (1269:13): [True: 0, False: 1.79k] ------------------ 1270| 0| case Collation::DIGIT_TAG: ------------------ | Branch (1270:13): [True: 0, False: 1.79k] ------------------ 1271| 0| case Collation::U0000_TAG: ------------------ | Branch (1271:13): [True: 0, False: 1.79k] ------------------ 1272| 0| case Collation::HANGUL_TAG: ------------------ | Branch (1272:13): [True: 0, False: 1.79k] ------------------ 1273| 0| case Collation::LEAD_SURROGATE_TAG: ------------------ | Branch (1273:13): [True: 0, False: 1.79k] ------------------ 1274| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 1275| 0| return false; 1276| 1.79k| } 1277| 1.79k| } 1278| 263k| jamoCE32s[j] = ce32; 1279| 263k| } 1280| 3.92k| if(anyJamoAssigned && needToCopyFromBase) { ------------------ | Branch (1280:8): [True: 250, False: 3.67k] | Branch (1280:27): [True: 0, False: 250] ------------------ 1281| 0| for(int32_t j = 0; j < CollationData::JAMO_CE32S_LENGTH; ++j) { ------------------ | Branch (1281:28): [True: 0, False: 0] ------------------ 1282| 0| if(jamoCE32s[j] == Collation::FALLBACK_CE32) { ------------------ | Branch (1282:16): [True: 0, False: 0] ------------------ 1283| 0| UChar32 jamo = jamoCpFromIndex(j); 1284| 0| jamoCE32s[j] = copyFromBaseCE32(jamo, base->getCE32(jamo), 1285| 0| /*withContext=*/ true, errorCode); 1286| 0| } 1287| 0| } 1288| 0| } 1289| 3.92k| return anyJamoAssigned && U_SUCCESS(errorCode); ------------------ | Branch (1289:12): [True: 250, False: 3.67k] | Branch (1289:31): [True: 250, False: 0] ------------------ 1290| 3.92k|} _ZN6icu_7820CollationDataBuilder12setDigitTagsER10UErrorCode: 1293| 3.92k|CollationDataBuilder::setDigitTags(UErrorCode &errorCode) { 1294| 3.92k| UnicodeSet digits(UNICODE_STRING_SIMPLE("[:Nd:]"), errorCode); ------------------ | | 135| 3.92k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 3.92k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ 1295| 3.92k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1295:8): [True: 0, False: 3.92k] ------------------ 1296| 3.92k| UnicodeSetIterator iter(digits); 1297| 2.98M| while(iter.next()) { ------------------ | Branch (1297:11): [True: 2.98M, False: 3.92k] ------------------ 1298| 2.98M| U_ASSERT(!iter.isString()); ------------------ | | 35| 2.98M|# define U_ASSERT(exp) (void)0 ------------------ 1299| 2.98M| UChar32 c = iter.getCodepoint(); 1300| 2.98M| uint32_t ce32 = utrie2_get32(trie, c); ------------------ | | 1966| 2.98M|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 2.98M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.98M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.98M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1301| 2.98M| if(ce32 != Collation::FALLBACK_CE32 && ce32 != Collation::UNASSIGNED_CE32) { ------------------ | Branch (1301:12): [True: 50.8k, False: 2.93M] | Branch (1301:48): [True: 50.8k, False: 0] ------------------ 1302| 50.8k| int32_t index = addCE32(ce32, errorCode); 1303| 50.8k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1303:16): [True: 0, False: 50.8k] ------------------ 1304| 50.8k| if(index > Collation::MAX_INDEX) { ------------------ | Branch (1304:16): [True: 0, False: 50.8k] ------------------ 1305| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 1306| 0| return; 1307| 0| } 1308| 50.8k| ce32 = Collation::makeCE32FromTagIndexAndLength( 1309| 50.8k| Collation::DIGIT_TAG, index, u_charDigitValue(c)); ------------------ | | 220| 50.8k|#define u_charDigitValue U_ICU_ENTRY_POINT_RENAME(u_charDigitValue) | | ------------------ | | | | 123| 50.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 50.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 50.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1310| 50.8k| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 50.8k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 50.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 50.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 50.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1311| 50.8k| } 1312| 2.98M| } 1313| 3.92k|} _ZN6icu_7820CollationDataBuilder17setLeadSurrogatesER10UErrorCode: 1340| 3.92k|CollationDataBuilder::setLeadSurrogates(UErrorCode &errorCode) { 1341| 4.02M| for(char16_t lead = 0xd800; lead < 0xdc00; ++lead) { ------------------ | Branch (1341:33): [True: 4.02M, False: 3.92k] ------------------ 1342| 4.02M| int32_t value = -1; 1343| 4.02M| utrie2_enumForLeadSurrogate(trie, lead, nullptr, enumRangeLeadValue, &value); ------------------ | | 1963| 4.02M|#define utrie2_enumForLeadSurrogate U_ICU_ENTRY_POINT_RENAME(utrie2_enumForLeadSurrogate) | | ------------------ | | | | 123| 4.02M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.02M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.02M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1344| 4.02M| utrie2_set32ForLeadSurrogateCodeUnit( ------------------ | | 1976| 4.02M|#define utrie2_set32ForLeadSurrogateCodeUnit U_ICU_ENTRY_POINT_RENAME(utrie2_set32ForLeadSurrogateCodeUnit) | | ------------------ | | | | 123| 4.02M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.02M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.02M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1345| 4.02M| trie, lead, 1346| 4.02M| Collation::makeCE32FromTagAndIndex(Collation::LEAD_SURROGATE_TAG, 0) | static_cast(value), 1347| 4.02M| &errorCode); 1348| 4.02M| } 1349| 3.92k|} _ZN6icu_7820CollationDataBuilder5buildERNS_13CollationDataER10UErrorCode: 1352| 3.92k|CollationDataBuilder::build(CollationData &data, UErrorCode &errorCode) { 1353| 3.92k| buildMappings(data, errorCode); 1354| 3.92k| if(base != nullptr) { ------------------ | Branch (1354:8): [True: 3.92k, False: 0] ------------------ 1355| 3.92k| data.numericPrimary = base->numericPrimary; 1356| 3.92k| data.compressibleBytes = base->compressibleBytes; 1357| 3.92k| data.numScripts = base->numScripts; 1358| 3.92k| data.scriptsIndex = base->scriptsIndex; 1359| 3.92k| data.scriptStarts = base->scriptStarts; 1360| 3.92k| data.scriptStartsLength = base->scriptStartsLength; 1361| 3.92k| } 1362| 3.92k| buildFastLatinTable(data, errorCode); 1363| 3.92k|} _ZN6icu_7820CollationDataBuilder13buildMappingsERNS_13CollationDataER10UErrorCode: 1366| 3.92k|CollationDataBuilder::buildMappings(CollationData &data, UErrorCode &errorCode) { 1367| 3.92k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1367:8): [True: 0, False: 3.92k] ------------------ 1368| 3.92k| if(trie == nullptr || utrie2_isFrozen(trie)) { ------------------ | | 1970| 3.92k|#define utrie2_isFrozen U_ICU_ENTRY_POINT_RENAME(utrie2_isFrozen) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1368:8): [True: 0, False: 3.92k] | Branch (1368:27): [True: 0, False: 3.92k] ------------------ 1369| 0| errorCode = U_INVALID_STATE_ERROR; 1370| 0| return; 1371| 0| } 1372| | 1373| 3.92k| buildContexts(errorCode); 1374| | 1375| 3.92k| uint32_t jamoCE32s[CollationData::JAMO_CE32S_LENGTH]; 1376| 3.92k| int32_t jamoIndex = -1; 1377| 3.92k| if(getJamoCE32s(jamoCE32s, errorCode)) { ------------------ | Branch (1377:8): [True: 250, False: 3.67k] ------------------ 1378| 250| jamoIndex = ce32s.size(); 1379| 17.0k| for(int32_t i = 0; i < CollationData::JAMO_CE32S_LENGTH; ++i) { ------------------ | Branch (1379:28): [True: 16.7k, False: 250] ------------------ 1380| 16.7k| ce32s.addElement(static_cast(jamoCE32s[i]), errorCode); 1381| 16.7k| } 1382| | // Small optimization: Use a bit in the Hangul ce32 1383| | // to indicate that none of the Jamo CE32s are isSpecialCE32() 1384| | // (as it should be in the root collator). 1385| | // It allows CollationIterator to avoid recursive function calls and per-Jamo tests. 1386| | // In order to still have good trie compression and keep this code simple, 1387| | // we only set this flag if a whole block of 588 Hangul syllables starting with 1388| | // a common leading consonant (Jamo L) has this property. 1389| 250| UBool isAnyJamoVTSpecial = false; 1390| 9.30k| for(int32_t i = Hangul::JAMO_L_COUNT; i < CollationData::JAMO_CE32S_LENGTH; ++i) { ------------------ | Branch (1390:47): [True: 9.12k, False: 176] ------------------ 1391| 9.12k| if(Collation::isSpecialCE32(jamoCE32s[i])) { ------------------ | Branch (1391:16): [True: 74, False: 9.05k] ------------------ 1392| 74| isAnyJamoVTSpecial = true; 1393| 74| break; 1394| 74| } 1395| 9.12k| } 1396| 250| uint32_t hangulCE32 = Collation::makeCE32FromTagAndIndex(Collation::HANGUL_TAG, 0); 1397| 250| UChar32 c = Hangul::HANGUL_BASE; 1398| 5.00k| for(int32_t i = 0; i < Hangul::JAMO_L_COUNT; ++i) { // iterate over the Jamo L ------------------ | Branch (1398:28): [True: 4.75k, False: 250] ------------------ 1399| 4.75k| uint32_t ce32 = hangulCE32; 1400| 4.75k| if(!isAnyJamoVTSpecial && !Collation::isSpecialCE32(jamoCE32s[i])) { ------------------ | Branch (1400:16): [True: 3.34k, False: 1.40k] | Branch (1400:39): [True: 3.06k, False: 276] ------------------ 1401| 3.06k| ce32 |= Collation::HANGUL_NO_SPECIAL_JAMO; 1402| 3.06k| } 1403| 4.75k| UChar32 limit = c + Hangul::JAMO_VT_COUNT; 1404| 4.75k| utrie2_setRange32(trie, c, limit - 1, ce32, true, &errorCode); ------------------ | | 1977| 4.75k|#define utrie2_setRange32 U_ICU_ENTRY_POINT_RENAME(utrie2_setRange32) | | ------------------ | | | | 123| 4.75k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.75k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.75k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1405| 4.75k| c = limit; 1406| 4.75k| } 1407| 3.67k| } else { 1408| | // Copy the Hangul CE32s from the base in blocks per Jamo L, 1409| | // assuming that HANGUL_NO_SPECIAL_JAMO is set or not set for whole blocks. 1410| 73.5k| for(UChar32 c = Hangul::HANGUL_BASE; c < Hangul::HANGUL_LIMIT;) { ------------------ | Branch (1410:46): [True: 69.8k, False: 3.67k] ------------------ 1411| 69.8k| uint32_t ce32 = base->getCE32(c); 1412| 69.8k| U_ASSERT(Collation::hasCE32Tag(ce32, Collation::HANGUL_TAG)); ------------------ | | 35| 69.8k|# define U_ASSERT(exp) (void)0 ------------------ 1413| 69.8k| UChar32 limit = c + Hangul::JAMO_VT_COUNT; 1414| 69.8k| utrie2_setRange32(trie, c, limit - 1, ce32, true, &errorCode); ------------------ | | 1977| 69.8k|#define utrie2_setRange32 U_ICU_ENTRY_POINT_RENAME(utrie2_setRange32) | | ------------------ | | | | 123| 69.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 69.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 69.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1415| 69.8k| c = limit; 1416| 69.8k| } 1417| 3.67k| } 1418| | 1419| 3.92k| setDigitTags(errorCode); 1420| 3.92k| setLeadSurrogates(errorCode); 1421| | 1422| 3.92k| if (icu4xMode) { ------------------ | Branch (1422:9): [True: 0, False: 3.92k] ------------------ 1423| | // Make sure that starters that occur is the middle of a 1424| | // contraction have contraction ce32 with the 1425| | // `CONTRACT_HAS_STARTER` flag set so that starters that 1426| | // can occur in a non-final position in a contraction can 1427| | // be easily recognized from having a contraction ce32 1428| | // that has the `CONTRACT_HAS_STARTER` flag set. 1429| | 1430| 0| UCharsTrieBuilder contractionBuilder(errorCode); 1431| | // Intentionally unpaired low surrogate to make it never 1432| | // match well-formed UTF-16 which ICU4X feeds to the 1433| | // matcher. 1434| 0| UnicodeString placeholder(0xDC00); 1435| | 1436| 0| for (UChar32 c : contractionMiddleStarter.codePoints()) { ------------------ | Branch (1436:24): [True: 0, False: 0] ------------------ 1437| 0| uint32_t ce32 = utrie2_get32(trie, c); ------------------ | | 1966| 0|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1438| 0| UBool fromBase = false; 1439| 0| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (1439:16): [True: 0, False: 0] ------------------ 1440| 0| fromBase = true; 1441| 0| ce32 = base->getCE32(c); 1442| 0| } 1443| 0| if (!(Collation::hasCE32Tag(ce32, Collation::CONTRACTION_TAG) && (ce32 & Collation::CONTRACT_HAS_STARTER))) { ------------------ | Branch (1443:19): [True: 0, False: 0] | Branch (1443:78): [True: 0, False: 0] ------------------ 1444| 0| if (fromBase) { ------------------ | Branch (1444:21): [True: 0, False: 0] ------------------ 1445| | // This case does not actually happen as of February 2025. 1446| 0| ce32 = copyFromBaseCE32(c, ce32, true, errorCode); 1447| 0| } 1448| 0| if (Collation::hasCE32Tag(ce32, Collation::CONTRACTION_TAG)) { ------------------ | Branch (1448:21): [True: 0, False: 0] ------------------ 1449| | // This middle starter is also the first character of another 1450| | // contraction, but that contraction does not have the 1451| | // CONTRACT_HAS_STARTER flag. Let's add the flag to 1452| | // mark this at the expense of pessimizing the matching 1453| | // of this contraction. 1454| | // As of February 2025, this case does not actually occur 1455| | // in CLDR. 1456| 0| ce32 |= Collation::CONTRACT_HAS_STARTER; 1457| 0| } else { 1458| | // This middle starter is not also the first character 1459| | // in another contraction. 1460| | 1461| | // The UCharsTrie needs to contain some placeholder 1462| | // because it cannot be empty. We build a trie 1463| | // that never actually matches anything that ICU4X can try to 1464| | // match, since ICU4X always passes well-formed UTF-16 to the 1465| | // matcher and we put an unpaired low surrogate into the trie. 1466| | // This pessimizes the character to CE mapping of the `c`, 1467| | // since useless trie matching will be attempted but as of 1468| | // February 2025, only two relatively rare characters are affected. 1469| 0| contractionBuilder.clear(); 1470| 0| contractionBuilder.add(placeholder, static_cast(ce32), errorCode); 1471| | 1472| 0| int32_t index = addContextTrie(ce32, contractionBuilder, errorCode); 1473| 0| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1473:24): [True: 0, False: 0] ------------------ 1474| 0| if(index > Collation::MAX_INDEX) { ------------------ | Branch (1474:24): [True: 0, False: 0] ------------------ 1475| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 1476| 0| return; 1477| 0| } 1478| | // Set CONTRACT_HAS_STARTER to make identical prefix matching able to catch this. 1479| 0| ce32 = Collation::makeCE32FromTagAndIndex(Collation::CONTRACTION_TAG, index) | Collation::CONTRACT_HAS_STARTER; 1480| 0| } 1481| 0| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 0|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1482| 0| } 1483| 0| } 1484| 3.92k| } else { 1485| | // For U+0000, move its normal ce32 into CE32s[0] and set U0000_TAG. 1486| 3.92k| ce32s.setElementAt(static_cast(utrie2_get32(trie, 0)), 0); ------------------ | | 1966| 3.92k|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1487| 3.92k| utrie2_set32(trie, 0, Collation::makeCE32FromTagAndIndex(Collation::U0000_TAG, 0), &errorCode); ------------------ | | 1975| 3.92k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1488| 3.92k| } 1489| | 1490| 3.92k| utrie2_freeze(trie, UTRIE2_32_VALUE_BITS, &errorCode); ------------------ | | 1964| 3.92k|#define utrie2_freeze U_ICU_ENTRY_POINT_RENAME(utrie2_freeze) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1491| 3.92k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1491:8): [True: 0, False: 3.92k] ------------------ 1492| | 1493| | // Mark each lead surrogate as "unsafe" 1494| | // if any of its 1024 associated supplementary code points is "unsafe". 1495| 3.92k| UChar32 c = 0x10000; 1496| 4.02M| for(char16_t lead = 0xd800; lead < 0xdc00; ++lead, c += 0x400) { ------------------ | Branch (1496:33): [True: 4.02M, False: 3.92k] ------------------ 1497| 4.02M| if(unsafeBackwardSet.containsSome(c, c + 0x3ff)) { ------------------ | Branch (1497:12): [True: 90.6k, False: 3.93M] ------------------ 1498| 90.6k| unsafeBackwardSet.add(lead); 1499| 90.6k| } 1500| 4.02M| } 1501| 3.92k| unsafeBackwardSet.freeze(); 1502| | 1503| 3.92k| data.trie = trie; 1504| 3.92k| data.ce32s = reinterpret_cast(ce32s.getBuffer()); 1505| 3.92k| data.ces = ce64s.getBuffer(); 1506| 3.92k| data.contexts = contexts.getBuffer(); 1507| | 1508| 3.92k| data.ce32sLength = ce32s.size(); 1509| 3.92k| data.cesLength = ce64s.size(); 1510| 3.92k| data.contextsLength = contexts.length(); 1511| | 1512| 3.92k| data.base = base; 1513| 3.92k| if(jamoIndex >= 0) { ------------------ | Branch (1513:8): [True: 250, False: 3.67k] ------------------ 1514| 250| data.jamoCE32s = data.ce32s + jamoIndex; 1515| 3.67k| } else { 1516| 3.67k| data.jamoCE32s = base->jamoCE32s; 1517| 3.67k| } 1518| 3.92k| data.unsafeBackwardSet = &unsafeBackwardSet; 1519| 3.92k|} _ZN6icu_7820CollationDataBuilder13clearContextsEv: 1522| 4.02k|CollationDataBuilder::clearContexts() { 1523| 4.02k| contexts.remove(); 1524| | // Incrementing the contexts build "era" invalidates all of the builtCE32 1525| | // from before this clearContexts() call. 1526| | // Simpler than finding and resetting all of those fields. 1527| 4.02k| ++contextsEra; 1528| 4.02k|} _ZN6icu_7820CollationDataBuilder13buildContextsER10UErrorCode: 1531| 3.92k|CollationDataBuilder::buildContexts(UErrorCode &errorCode) { 1532| 3.92k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1532:8): [True: 0, False: 3.92k] ------------------ 1533| | // Ignore abandoned lists and the cached builtCE32, 1534| | // and build all contexts from scratch. 1535| 3.92k| clearContexts(); 1536| 3.92k| UnicodeSetIterator iter(contextChars); 1537| 28.6k| while(U_SUCCESS(errorCode) && iter.next()) { ------------------ | Branch (1537:11): [True: 28.6k, False: 0] | Branch (1537:35): [True: 24.7k, False: 3.92k] ------------------ 1538| 24.7k| U_ASSERT(!iter.isString()); ------------------ | | 35| 24.7k|# define U_ASSERT(exp) (void)0 ------------------ 1539| 24.7k| UChar32 c = iter.getCodepoint(); 1540| 24.7k| uint32_t ce32 = utrie2_get32(trie, c); ------------------ | | 1966| 24.7k|#define utrie2_get32 U_ICU_ENTRY_POINT_RENAME(utrie2_get32) | | ------------------ | | | | 123| 24.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 24.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 24.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1541| 24.7k| if(!isBuilderContextCE32(ce32)) { ------------------ | Branch (1541:12): [True: 0, False: 24.7k] ------------------ 1542| | // Impossible: No context data for c in contextChars. 1543| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 1544| 0| return; 1545| 0| } 1546| 24.7k| ConditionalCE32 *cond = getConditionalCE32ForCE32(ce32); 1547| 24.7k| ce32 = buildContext(cond, errorCode); 1548| 24.7k| utrie2_set32(trie, c, ce32, &errorCode); ------------------ | | 1975| 24.7k|#define utrie2_set32 U_ICU_ENTRY_POINT_RENAME(utrie2_set32) | | ------------------ | | | | 123| 24.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 24.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 24.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1549| 24.7k| } 1550| 3.92k|} _ZN6icu_7820CollationDataBuilder12buildContextEPNS_15ConditionalCE32ER10UErrorCode: 1553| 429k|CollationDataBuilder::buildContext(ConditionalCE32 *head, UErrorCode &errorCode) { 1554| 429k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1554:8): [True: 0, False: 429k] ------------------ 1555| | // The list head must have no context. 1556| 429k| U_ASSERT(!head->hasContext()); ------------------ | | 35| 429k|# define U_ASSERT(exp) (void)0 ------------------ 1557| | // The list head must be followed by one or more nodes that all do have context. 1558| 429k| U_ASSERT(head->next >= 0); ------------------ | | 35| 429k|# define U_ASSERT(exp) (void)0 ------------------ 1559| 429k| UCharsTrieBuilder prefixBuilder(errorCode); 1560| 429k| UCharsTrieBuilder contractionBuilder(errorCode); 1561| | // This outer loop goes from each prefix to the next. 1562| | // For each prefix it finds the one or more same-prefix entries (firstCond..lastCond). 1563| | // If there are multiple suffixes for the same prefix, 1564| | // then an inner loop builds a contraction trie for them. 1565| 3.15M| for(ConditionalCE32 *cond = head;; cond = getConditionalCE32(cond->next)) { 1566| 3.15M| if(U_FAILURE(errorCode)) { return 0; } // early out for memory allocation errors ------------------ | Branch (1566:12): [True: 0, False: 3.15M] ------------------ 1567| | // After the list head, the prefix or suffix can be empty, but not both. 1568| 3.15M| U_ASSERT(cond == head || cond->hasContext()); ------------------ | | 35| 3.15M|# define U_ASSERT(exp) (void)0 ------------------ 1569| 3.15M| int32_t prefixLength = cond->prefixLength(); 1570| 3.15M| UnicodeString prefix(cond->context, 0, prefixLength + 1); 1571| | // Collect all contraction suffixes for one prefix. 1572| 3.15M| ConditionalCE32 *firstCond = cond; 1573| 3.15M| ConditionalCE32 *lastCond; 1574| 45.6M| do { 1575| 45.6M| lastCond = cond; 1576| | // Clear the defaultCE32 fields as we go. 1577| | // They are left over from building a previous version of this list of contexts. 1578| | // 1579| | // One of the code paths below may copy a preceding defaultCE32 1580| | // into its emptySuffixCE32. 1581| | // If a new suffix has been inserted before what used to be 1582| | // the firstCond for its prefix, then that previous firstCond could still 1583| | // contain an outdated defaultCE32 from an earlier buildContext() and 1584| | // result in an incorrect emptySuffixCE32. 1585| | // So we reset all defaultCE32 before reading and setting new values. 1586| 45.6M| cond->defaultCE32 = Collation::NO_CE32; 1587| 45.6M| } while(cond->next >= 0 && ------------------ | Branch (1587:17): [True: 45.2M, False: 429k] ------------------ 1588| 45.6M| (cond = getConditionalCE32(cond->next))->context.startsWith(prefix)); ------------------ | Branch (1588:17): [True: 42.5M, False: 2.72M] ------------------ 1589| 3.15M| uint32_t ce32; 1590| 3.15M| int32_t suffixStart = prefixLength + 1; // == prefix.length() 1591| 3.15M| if(lastCond->context.length() == suffixStart) { ------------------ | Branch (1591:12): [True: 1.94M, False: 1.21M] ------------------ 1592| | // One prefix without contraction suffix. 1593| 1.94M| U_ASSERT(firstCond == lastCond); ------------------ | | 35| 1.94M|# define U_ASSERT(exp) (void)0 ------------------ 1594| 1.94M| ce32 = lastCond->ce32; 1595| 1.94M| cond = lastCond; 1596| 1.94M| } else { 1597| | // Build the contractions trie. 1598| 1.21M| contractionBuilder.clear(); 1599| | // Entry for an empty suffix, to be stored before the trie. 1600| 1.21M| uint32_t emptySuffixCE32 = 0; 1601| 1.21M| uint32_t flags = 0; 1602| 1.21M| if(firstCond->context.length() == suffixStart) { ------------------ | Branch (1602:16): [True: 363k, False: 849k] ------------------ 1603| | // There is a mapping for the prefix and the single character c. (p|c) 1604| | // If no other suffix matches, then we return this value. 1605| 363k| emptySuffixCE32 = firstCond->ce32; 1606| 363k| cond = getConditionalCE32(firstCond->next); 1607| 849k| } else { 1608| | // There is no mapping for the prefix and just the single character. 1609| | // (There is no p|c, only p|cd, p|ce etc.) 1610| 849k| flags |= Collation::CONTRACT_SINGLE_CP_NO_MATCH; 1611| | // When the prefix matches but none of the prefix-specific suffixes, 1612| | // then we fall back to the mappings with the next-longest prefix, 1613| | // and ultimately to mappings with no prefix. 1614| | // Each fallback might be another set of contractions. 1615| | // For example, if there are mappings for ch, p|cd, p|ce, but not for p|c, 1616| | // then in text "pch" we find the ch contraction. 1617| 86.5M| for(cond = head;; cond = getConditionalCE32(cond->next)) { 1618| 86.5M| int32_t length = cond->prefixLength(); 1619| 86.5M| if(length == prefixLength) { break; } ------------------ | Branch (1619:24): [True: 849k, False: 85.7M] ------------------ 1620| 85.7M| if(cond->defaultCE32 != Collation::NO_CE32 && ------------------ | Branch (1620:24): [True: 40.6M, False: 45.0M] ------------------ 1621| 85.7M| (length==0 || prefix.endsWith(cond->context, 1, length))) { ------------------ | Branch (1621:30): [True: 849k, False: 39.8M] | Branch (1621:43): [True: 89.2k, False: 39.7M] ------------------ 1622| 938k| emptySuffixCE32 = cond->defaultCE32; 1623| 938k| } 1624| 85.7M| } 1625| 849k| cond = firstCond; 1626| 849k| } 1627| | // Optimization: Set a flag when 1628| | // the first character of every contraction suffix has lccc!=0. 1629| | // Short-circuits contraction matching when a normal letter follows. 1630| 1.21M| flags |= Collation::CONTRACT_NEXT_CCC; 1631| | // Add all of the non-empty suffixes into the contraction trie. 1632| 43.3M| for(;;) { 1633| 43.3M| UnicodeString suffix(cond->context, suffixStart); 1634| 43.3M| uint16_t fcd16 = nfcImpl.getFCD16(suffix.char32At(0)); 1635| 43.3M| if(fcd16 <= 0xff) { ------------------ | Branch (1635:20): [True: 33.8M, False: 9.53M] ------------------ 1636| 33.8M| flags &= ~Collation::CONTRACT_NEXT_CCC; 1637| 33.8M| } 1638| 43.3M| fcd16 = nfcImpl.getFCD16(suffix.char32At(suffix.length() - 1)); 1639| 43.3M| if(fcd16 > 0xff) { ------------------ | Branch (1639:20): [True: 6.02M, False: 37.3M] ------------------ 1640| | // The last suffix character has lccc!=0, allowing for discontiguous contractions. 1641| 6.02M| flags |= Collation::CONTRACT_TRAILING_CCC; 1642| 6.02M| } 1643| 43.3M| if (icu4xMode && (flags & Collation::CONTRACT_HAS_STARTER) == 0) { ------------------ | Branch (1643:21): [True: 0, False: 43.3M] | Branch (1643:34): [True: 0, False: 0] ------------------ 1644| 0| for (int32_t i = 0; i < suffix.length();) { ------------------ | Branch (1644:41): [True: 0, False: 0] ------------------ 1645| 0| UChar32 c = suffix.char32At(i); 1646| 0| if (!u_getCombiningClass(c)) { ------------------ | | 270| 0|#define u_getCombiningClass U_ICU_ENTRY_POINT_RENAME(u_getCombiningClass) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1646:33): [True: 0, False: 0] ------------------ 1647| 0| flags |= Collation::CONTRACT_HAS_STARTER; 1648| 0| break; 1649| 0| } 1650| 0| if (c > 0xFFFF) { ------------------ | Branch (1650:29): [True: 0, False: 0] ------------------ 1651| 0| i += 2; 1652| 0| } else { 1653| 0| ++i; 1654| 0| } 1655| 0| } 1656| 0| } 1657| 43.3M| contractionBuilder.add(suffix, static_cast(cond->ce32), errorCode); 1658| 43.3M| if(cond == lastCond) { break; } ------------------ | Branch (1658:20): [True: 1.21M, False: 42.1M] ------------------ 1659| 42.1M| cond = getConditionalCE32(cond->next); 1660| 42.1M| } 1661| 1.21M| int32_t index = addContextTrie(emptySuffixCE32, contractionBuilder, errorCode); 1662| 1.21M| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1662:16): [True: 0, False: 1.21M] ------------------ 1663| 1.21M| if(index > Collation::MAX_INDEX) { ------------------ | Branch (1663:16): [True: 53, False: 1.21M] ------------------ 1664| 53| errorCode = U_BUFFER_OVERFLOW_ERROR; 1665| 53| return 0; 1666| 53| } 1667| 1.21M| ce32 = Collation::makeCE32FromTagAndIndex(Collation::CONTRACTION_TAG, index) | flags; 1668| 1.21M| } 1669| 3.15M| U_ASSERT(cond == lastCond); ------------------ | | 35| 3.15M|# define U_ASSERT(exp) (void)0 ------------------ 1670| 3.15M| firstCond->defaultCE32 = ce32; 1671| 3.15M| if(prefixLength == 0) { ------------------ | Branch (1671:12): [True: 429k, False: 2.72M] ------------------ 1672| 429k| if(cond->next < 0) { ------------------ | Branch (1672:16): [True: 352k, False: 76.8k] ------------------ 1673| | // No non-empty prefixes, only contractions. 1674| 352k| return ce32; 1675| 352k| } 1676| 2.72M| } else { 1677| 2.72M| prefix.remove(0, 1); // Remove the length unit. 1678| 2.72M| prefix.reverse(); 1679| 2.72M| prefixBuilder.add(prefix, static_cast(ce32), errorCode); 1680| 2.72M| if(cond->next < 0) { break; } ------------------ | Branch (1680:16): [True: 76.8k, False: 2.64M] ------------------ 1681| 2.72M| } 1682| 3.15M| } 1683| 76.8k| U_ASSERT(head->defaultCE32 != Collation::NO_CE32); ------------------ | | 35| 76.8k|# define U_ASSERT(exp) (void)0 ------------------ 1684| 76.8k| int32_t index = addContextTrie(head->defaultCE32, prefixBuilder, errorCode); 1685| 76.8k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1685:8): [True: 0, False: 76.8k] ------------------ 1686| 76.8k| if(index > Collation::MAX_INDEX) { ------------------ | Branch (1686:8): [True: 49, False: 76.8k] ------------------ 1687| 49| errorCode = U_BUFFER_OVERFLOW_ERROR; 1688| 49| return 0; 1689| 49| } 1690| 76.8k| return Collation::makeCE32FromTagAndIndex(Collation::PREFIX_TAG, index); 1691| 76.8k|} _ZN6icu_7820CollationDataBuilder14addContextTrieEjRNS_17UCharsTrieBuilderER10UErrorCode: 1695| 1.28M| UErrorCode &errorCode) { 1696| 1.28M| UnicodeString context; 1697| 1.28M| context.append(static_cast(defaultCE32 >> 16)).append(static_cast(defaultCE32)); 1698| 1.28M| UnicodeString trieString; 1699| 1.28M| context.append(trieBuilder.buildUnicodeString(USTRINGTRIE_BUILD_SMALL, trieString, errorCode)); 1700| 1.28M| if(U_FAILURE(errorCode)) { return -1; } ------------------ | Branch (1700:8): [True: 0, False: 1.28M] ------------------ 1701| 1.28M| int32_t index = contexts.indexOf(context); 1702| 1.28M| if(index < 0) { ------------------ | Branch (1702:8): [True: 458k, False: 831k] ------------------ 1703| 458k| index = contexts.length(); 1704| 458k| contexts.append(context); 1705| 458k| } 1706| 1.28M| return index; 1707| 1.28M|} _ZN6icu_7820CollationDataBuilder19buildFastLatinTableERNS_13CollationDataER10UErrorCode: 1710| 3.92k|CollationDataBuilder::buildFastLatinTable(CollationData &data, UErrorCode &errorCode) { 1711| 3.92k| if(U_FAILURE(errorCode) || !fastLatinEnabled) { return; } ------------------ | Branch (1711:8): [True: 0, False: 3.92k] | Branch (1711:32): [True: 0, False: 3.92k] ------------------ 1712| | 1713| 3.92k| delete fastLatinBuilder; 1714| 3.92k| fastLatinBuilder = new CollationFastLatinBuilder(errorCode); 1715| 3.92k| if(fastLatinBuilder == nullptr) { ------------------ | Branch (1715:8): [True: 0, False: 3.92k] ------------------ 1716| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1717| 0| return; 1718| 0| } 1719| 3.92k| if(fastLatinBuilder->forData(data, errorCode)) { ------------------ | Branch (1719:8): [True: 3.76k, False: 161] ------------------ 1720| 3.76k| const uint16_t *table = fastLatinBuilder->getTable(); 1721| 3.76k| int32_t length = fastLatinBuilder->lengthOfTable(); 1722| 3.76k| if(base != nullptr && length == base->fastLatinTableLength && ------------------ | Branch (1722:12): [True: 3.76k, False: 0] | Branch (1722:31): [True: 2.13k, False: 1.63k] ------------------ 1723| 3.76k| uprv_memcmp(table, base->fastLatinTable, length * 2) == 0) { ------------------ | | 101| 2.13k|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 2.13k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1723:17): [True: 1.56k, False: 564] ------------------ 1724| | // Same fast Latin table as in the base, use that one instead. 1725| 1.56k| delete fastLatinBuilder; 1726| 1.56k| fastLatinBuilder = nullptr; 1727| 1.56k| table = base->fastLatinTable; 1728| 1.56k| } 1729| 3.76k| data.fastLatinTable = table; 1730| 3.76k| data.fastLatinTableLength = length; 1731| 3.76k| } else { 1732| 161| delete fastLatinBuilder; 1733| 161| fastLatinBuilder = nullptr; 1734| 161| } 1735| 3.92k|} _ZN6icu_7820CollationDataBuilder6getCEsERKNS_13UnicodeStringEPli: 1738| 8.48M|CollationDataBuilder::getCEs(const UnicodeString &s, int64_t ces[], int32_t cesLength) { 1739| 8.48M| return getCEs(s, 0, ces, cesLength); 1740| 8.48M|} _ZN6icu_7820CollationDataBuilder6getCEsERKNS_13UnicodeStringES3_Pli: 1744| 18.0M| int64_t ces[], int32_t cesLength) { 1745| 18.0M| int32_t prefixLength = prefix.length(); 1746| 18.0M| if(prefixLength == 0) { ------------------ | Branch (1746:8): [True: 17.8M, False: 146k] ------------------ 1747| 17.8M| return getCEs(s, 0, ces, cesLength); 1748| 17.8M| } else { 1749| 146k| return getCEs(prefix + s, prefixLength, ces, cesLength); 1750| 146k| } 1751| 18.0M|} _ZN6icu_7820CollationDataBuilder6getCEsERKNS_13UnicodeStringEiPli: 1755| 26.5M| int64_t ces[], int32_t cesLength) { 1756| 26.5M| if(collIter == nullptr) { ------------------ | Branch (1756:8): [True: 5.63k, False: 26.5M] ------------------ 1757| 5.63k| collIter = new DataBuilderCollationIterator(*this); 1758| 5.63k| if(collIter == nullptr) { return 0; } ------------------ | Branch (1758:12): [True: 0, False: 5.63k] ------------------ 1759| 5.63k| } 1760| 26.5M| return collIter->fetchCEs(s, start, ces, cesLength); 1761| 26.5M|} _ZN6icu_7815ConditionalCE32C2ERKNS_13UnicodeStringEj: 59| 713k| : context(ct), 60| 713k| ce32(ce), defaultCE32(Collation::NO_CE32), builtCE32(Collation::NO_CE32), 61| 713k| next(-1) {} _ZN6icu_7815ConditionalCE32C2Ev: 55| 3.93k| : context(), 56| 3.93k| ce32(0), defaultCE32(Collation::NO_CE32), builtCE32(Collation::NO_CE32), 57| 3.93k| next(-1) {} _ZN6icu_7810CopyHelperC2ERKNS_20CollationDataBuilderERS1_RKNS1_10CEModifierER10UErrorCode: 1041| 3.92k| : src(s), dest(d), modifier(m), 1042| 3.92k| errorCode(initialErrorCode) {} collationdatabuilder.cpp:_ZN6icu_78L16enumRangeForCopyEPKviij: 1159| 1.74M|enumRangeForCopy(const void *context, UChar32 start, UChar32 end, uint32_t value) { 1160| 1.74M| return 1161| 1.74M| value == Collation::UNASSIGNED_CE32 || value == Collation::FALLBACK_CE32 || ------------------ | Branch (1161:9): [True: 0, False: 1.74M] | Branch (1161:48): [True: 132k, False: 1.61M] ------------------ 1162| 1.74M| ((CopyHelper *)context)->copyRangeCE32(start, end, value); ------------------ | Branch (1162:9): [True: 1.61M, False: 0] ------------------ 1163| 1.74M|} _ZN6icu_7810CopyHelper13copyRangeCE32Eiij: 1044| 1.61M| UBool copyRangeCE32(UChar32 start, UChar32 end, uint32_t ce32) { 1045| 1.61M| ce32 = copyCE32(ce32); 1046| 1.61M| utrie2_setRange32(dest.trie, start, end, ce32, true, &errorCode); ------------------ | | 1977| 1.61M|#define utrie2_setRange32 U_ICU_ENTRY_POINT_RENAME(utrie2_setRange32) | | ------------------ | | | | 123| 1.61M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.61M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.61M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1047| 1.61M| if(CollationDataBuilder::isBuilderContextCE32(ce32)) { ------------------ | Branch (1047:12): [True: 23.0k, False: 1.59M] ------------------ 1048| 23.0k| dest.contextChars.add(start, end); 1049| 23.0k| } 1050| 1.61M| return U_SUCCESS(errorCode); 1051| 1.61M| } _ZN6icu_7810CopyHelper8copyCE32Ej: 1053| 1.90M| uint32_t copyCE32(uint32_t ce32) { 1054| 1.90M| if(!Collation::isSpecialCE32(ce32)) { ------------------ | Branch (1054:12): [True: 1.30M, False: 597k] ------------------ 1055| 1.30M| int64_t ce = modifier.modifyCE32(ce32); 1056| 1.30M| if(ce != Collation::NO_CE) { ------------------ | Branch (1056:16): [True: 1.28M, False: 24.3k] ------------------ 1057| 1.28M| ce32 = dest.encodeOneCE(ce, errorCode); 1058| 1.28M| } 1059| 1.30M| } else { 1060| 597k| int32_t tag = Collation::tagFromCE32(ce32); 1061| 597k| if(tag == Collation::EXPANSION32_TAG) { ------------------ | Branch (1061:16): [True: 469k, False: 127k] ------------------ 1062| 469k| const uint32_t *srcCE32s = reinterpret_cast(src.ce32s.getBuffer()); 1063| 469k| srcCE32s += Collation::indexFromCE32(ce32); 1064| 469k| int32_t length = Collation::lengthFromCE32(ce32); 1065| | // Inspect the source CE32s. Just copy them if none are modified. 1066| | // Otherwise copy to modifiedCEs, with modifications. 1067| 469k| UBool isModified = false; 1068| 2.02M| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (1068:36): [True: 1.55M, False: 469k] ------------------ 1069| 1.55M| ce32 = srcCE32s[i]; 1070| 1.55M| int64_t ce; 1071| 1.55M| if(Collation::isSpecialCE32(ce32) || ------------------ | Branch (1071:24): [True: 165k, False: 1.39M] ------------------ 1072| 1.55M| (ce = modifier.modifyCE32(ce32)) == Collation::NO_CE) { ------------------ | Branch (1072:29): [True: 944k, False: 445k] ------------------ 1073| 1.10M| if(isModified) { ------------------ | Branch (1073:28): [True: 394k, False: 715k] ------------------ 1074| 394k| modifiedCEs[i] = Collation::ceFromCE32(ce32); 1075| 394k| } 1076| 1.10M| } else { 1077| 445k| if(!isModified) { ------------------ | Branch (1077:28): [True: 420k, False: 24.5k] ------------------ 1078| 965k| for(int32_t j = 0; j < i; ++j) { ------------------ | Branch (1078:48): [True: 544k, False: 420k] ------------------ 1079| 544k| modifiedCEs[j] = Collation::ceFromCE32(srcCE32s[j]); 1080| 544k| } 1081| 420k| isModified = true; 1082| 420k| } 1083| 445k| modifiedCEs[i] = ce; 1084| 445k| } 1085| 1.55M| } 1086| 469k| if(isModified) { ------------------ | Branch (1086:20): [True: 420k, False: 48.9k] ------------------ 1087| 420k| ce32 = dest.encodeCEs(modifiedCEs, length, errorCode); 1088| 420k| } else { 1089| 48.9k| ce32 = dest.encodeExpansion32( 1090| 48.9k| reinterpret_cast(srcCE32s), length, errorCode); 1091| 48.9k| } 1092| 469k| } else if(tag == Collation::EXPANSION_TAG) { ------------------ | Branch (1092:23): [True: 65.8k, False: 61.8k] ------------------ 1093| 65.8k| const int64_t *srcCEs = src.ce64s.getBuffer(); 1094| 65.8k| srcCEs += Collation::indexFromCE32(ce32); 1095| 65.8k| int32_t length = Collation::lengthFromCE32(ce32); 1096| | // Inspect the source CEs. Just copy them if none are modified. 1097| | // Otherwise copy to modifiedCEs, with modifications. 1098| 65.8k| UBool isModified = false; 1099| 771k| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (1099:36): [True: 705k, False: 65.8k] ------------------ 1100| 705k| int64_t srcCE = srcCEs[i]; 1101| 705k| int64_t ce = modifier.modifyCE(srcCE); 1102| 705k| if(ce == Collation::NO_CE) { ------------------ | Branch (1102:24): [True: 644k, False: 61.0k] ------------------ 1103| 644k| if(isModified) { ------------------ | Branch (1103:28): [True: 142k, False: 502k] ------------------ 1104| 142k| modifiedCEs[i] = srcCE; 1105| 142k| } 1106| 644k| } else { 1107| 61.0k| if(!isModified) { ------------------ | Branch (1107:28): [True: 41.2k, False: 19.8k] ------------------ 1108| 389k| for(int32_t j = 0; j < i; ++j) { ------------------ | Branch (1108:48): [True: 348k, False: 41.2k] ------------------ 1109| 348k| modifiedCEs[j] = srcCEs[j]; 1110| 348k| } 1111| 41.2k| isModified = true; 1112| 41.2k| } 1113| 61.0k| modifiedCEs[i] = ce; 1114| 61.0k| } 1115| 705k| } 1116| 65.8k| if(isModified) { ------------------ | Branch (1116:20): [True: 41.2k, False: 24.5k] ------------------ 1117| 41.2k| ce32 = dest.encodeCEs(modifiedCEs, length, errorCode); 1118| 41.2k| } else { 1119| 24.5k| ce32 = dest.encodeExpansion(srcCEs, length, errorCode); 1120| 24.5k| } 1121| 65.8k| } else if(tag == Collation::BUILDER_DATA_TAG) { ------------------ | Branch (1121:23): [True: 23.0k, False: 38.7k] ------------------ 1122| | // Copy the list of ConditionalCE32. 1123| 23.0k| ConditionalCE32 *cond = src.getConditionalCE32ForCE32(ce32); 1124| 23.0k| U_ASSERT(!cond->hasContext()); ------------------ | | 35| 23.0k|# define U_ASSERT(exp) (void)0 ------------------ 1125| 23.0k| int32_t destIndex = dest.addConditionalCE32( 1126| 23.0k| cond->context, copyCE32(cond->ce32), errorCode); 1127| 23.0k| ce32 = CollationDataBuilder::makeBuilderContextCE32(destIndex); 1128| 289k| while(cond->next >= 0) { ------------------ | Branch (1128:23): [True: 266k, False: 23.0k] ------------------ 1129| 266k| cond = src.getConditionalCE32(cond->next); 1130| 266k| ConditionalCE32 *prevDestCond = dest.getConditionalCE32(destIndex); 1131| 266k| destIndex = dest.addConditionalCE32( 1132| 266k| cond->context, copyCE32(cond->ce32), errorCode); 1133| 266k| int32_t suffixStart = cond->prefixLength() + 1; 1134| 266k| dest.unsafeBackwardSet.addAll(cond->context.tempSubString(suffixStart)); 1135| 266k| prevDestCond->next = destIndex; 1136| 266k| } 1137| 38.7k| } else { 1138| | // Just copy long CEs and Latin mini expansions (and other expected values) as is, 1139| | // assuming that the modifier would not modify them. 1140| 38.7k| U_ASSERT(tag == Collation::LONG_PRIMARY_TAG || ------------------ | | 35| 38.7k|# define U_ASSERT(exp) (void)0 ------------------ 1141| 38.7k| tag == Collation::LONG_SECONDARY_TAG || 1142| 38.7k| tag == Collation::LATIN_EXPANSION_TAG || 1143| 38.7k| tag == Collation::HANGUL_TAG); 1144| 38.7k| } 1145| 597k| } 1146| 1.90M| return ce32; 1147| 1.90M| } collationdatabuilder.cpp:_ZN6icu_78L18enumRangeLeadValueEPKviij: 1318| 4.02M|enumRangeLeadValue(const void *context, UChar32 /*start*/, UChar32 /*end*/, uint32_t value) { 1319| 4.02M| int32_t *pValue = (int32_t *)context; 1320| 4.02M| if(value == Collation::UNASSIGNED_CE32) { ------------------ | Branch (1320:8): [True: 0, False: 4.02M] ------------------ 1321| 0| value = Collation::LEAD_ALL_UNASSIGNED; 1322| 4.02M| } else if(value == Collation::FALLBACK_CE32) { ------------------ | Branch (1322:15): [True: 4.02M, False: 2.06k] ------------------ 1323| 4.02M| value = Collation::LEAD_ALL_FALLBACK; 1324| 4.02M| } else { 1325| 2.06k| *pValue = Collation::LEAD_MIXED; 1326| 2.06k| return false; 1327| 2.06k| } 1328| 4.02M| if(*pValue < 0) { ------------------ | Branch (1328:8): [True: 4.02M, False: 0] ------------------ 1329| 4.02M| *pValue = (int32_t)value; 1330| 4.02M| } else if(*pValue != (int32_t)value) { ------------------ | Branch (1330:15): [True: 0, False: 0] ------------------ 1331| 0| *pValue = Collation::LEAD_MIXED; 1332| 0| return false; 1333| 0| } 1334| 4.02M| return true; 1335| 4.02M|} _ZNK6icu_7815ConditionalCE3212prefixLengthEv: 64| 90.0M| inline int32_t prefixLength() const { return context.charAt(0); } _ZNK6icu_7820CollationDataBuilder11hasMappingsEv: 78| 4.13k| UBool hasMappings() const { return modified; } _ZN6icu_7820CollationDataBuilder15enableFastLatinEv: 153| 3.92k| void enableFastLatin() { fastLatinEnabled = true; } _ZNK6icu_7820CollationDataBuilder18getConditionalCE32Ei: 179| 199M| inline ConditionalCE32 *getConditionalCE32(int32_t index) const { 180| 199M| return static_cast(conditionalCE32s[index]); 181| 199M| } _ZNK6icu_7820CollationDataBuilder25getConditionalCE32ForCE32Ej: 182| 2.36M| inline ConditionalCE32 *getConditionalCE32ForCE32(uint32_t ce32) const { 183| 2.36M| return getConditionalCE32(Collation::indexFromCE32(ce32)); 184| 2.36M| } _ZN6icu_7820CollationDataBuilder22makeBuilderContextCE32Ei: 186| 59.2k| static uint32_t makeBuilderContextCE32(int32_t index) { 187| 59.2k| return Collation::makeCE32FromTagAndIndex(Collation::BUILDER_DATA_TAG, index); 188| 59.2k| } _ZN6icu_7820CollationDataBuilder20isBuilderContextCE32Ej: 189| 8.50M| static inline UBool isBuilderContextCE32(uint32_t ce32) { 190| 8.50M| return Collation::hasCE32Tag(ce32, Collation::BUILDER_DATA_TAG); 191| 8.50M| } _ZN6icu_7820CollationDataBuilder15jamoCpFromIndexEi: 223| 640k| static UChar32 jamoCpFromIndex(int32_t i) { 224| | // 0 <= i < CollationData::JAMO_CE32S_LENGTH = 19 + 21 + 27 225| 640k| if(i < Hangul::JAMO_L_COUNT) { return Hangul::JAMO_L_BASE + i; } ------------------ | Branch (225:12): [True: 181k, False: 459k] ------------------ 226| 459k| i -= Hangul::JAMO_L_COUNT; 227| 459k| if(i < Hangul::JAMO_V_COUNT) { return Hangul::JAMO_V_BASE + i; } ------------------ | Branch (227:12): [True: 200k, False: 258k] ------------------ 228| 258k| i -= Hangul::JAMO_V_COUNT; 229| | // i < 27 230| 258k| return Hangul::JAMO_T_BASE + 1 + i; 231| 459k| } _ZN6icu_7819CollationDataReader4readEPKNS_18CollationTailoringEPKhiRS1_R10UErrorCode: 48| 1| CollationTailoring &tailoring, UErrorCode &errorCode) { 49| 1| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (49:8): [True: 0, False: 1] ------------------ 50| 1| if(base != nullptr) { ------------------ | Branch (50:8): [True: 0, False: 1] ------------------ 51| 0| if(inBytes == nullptr || (0 <= inLength && inLength < 24)) { ------------------ | Branch (51:12): [True: 0, False: 0] | Branch (51:35): [True: 0, False: 0] | Branch (51:52): [True: 0, False: 0] ------------------ 52| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 53| 0| return; 54| 0| } 55| 0| const DataHeader *header = reinterpret_cast(inBytes); 56| 0| if(!(header->dataHeader.magic1 == 0xda && header->dataHeader.magic2 == 0x27 && ------------------ | Branch (56:14): [True: 0, False: 0] | Branch (56:51): [True: 0, False: 0] ------------------ 57| 0| isAcceptable(tailoring.version, nullptr, nullptr, &header->info))) { ------------------ | Branch (57:17): [True: 0, False: 0] ------------------ 58| 0| errorCode = U_INVALID_FORMAT_ERROR; 59| 0| return; 60| 0| } 61| 0| if(base->getUCAVersion() != tailoring.getUCAVersion()) { ------------------ | Branch (61:12): [True: 0, False: 0] ------------------ 62| 0| errorCode = U_COLLATOR_VERSION_MISMATCH; 63| 0| return; 64| 0| } 65| 0| int32_t headerLength = header->dataHeader.headerSize; 66| 0| inBytes += headerLength; 67| 0| if(inLength >= 0) { ------------------ | Branch (67:12): [True: 0, False: 0] ------------------ 68| 0| inLength -= headerLength; 69| 0| } 70| 0| } 71| | 72| 1| if(inBytes == nullptr || (0 <= inLength && inLength < 8)) { ------------------ | Branch (72:8): [True: 0, False: 1] | Branch (72:31): [True: 1, False: 0] | Branch (72:48): [True: 0, False: 1] ------------------ 73| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 74| 0| return; 75| 0| } 76| 1| const int32_t *inIndexes = reinterpret_cast(inBytes); 77| 1| int32_t indexesLength = inIndexes[IX_INDEXES_LENGTH]; 78| 1| if(indexesLength < 2 || (0 <= inLength && inLength < indexesLength * 4)) { ------------------ | Branch (78:8): [True: 0, False: 1] | Branch (78:30): [True: 1, False: 0] | Branch (78:47): [True: 0, False: 1] ------------------ 79| 0| errorCode = U_INVALID_FORMAT_ERROR; // Not enough indexes. 80| 0| return; 81| 0| } 82| | 83| | // Assume that the tailoring data is in initial state, 84| | // with nullptr pointers and 0 lengths. 85| | 86| | // Set pointers to non-empty data parts. 87| | // Do this in order of their byte offsets. (Should help porting to Java.) 88| | 89| 1| int32_t index; // one of the indexes[] slots 90| 1| int32_t offset; // byte offset for the index part 91| 1| int32_t length; // number of bytes in the index part 92| | 93| 1| if(indexesLength > IX_TOTAL_SIZE) { ------------------ | Branch (93:8): [True: 1, False: 0] ------------------ 94| 1| length = inIndexes[IX_TOTAL_SIZE]; 95| 1| } else if(indexesLength > IX_REORDER_CODES_OFFSET) { ------------------ | Branch (95:15): [True: 0, False: 0] ------------------ 96| 0| length = inIndexes[indexesLength - 1]; 97| 0| } else { 98| 0| length = 0; // only indexes, and inLength was already checked for them 99| 0| } 100| 1| if(0 <= inLength && inLength < length) { ------------------ | Branch (100:8): [True: 1, False: 0] | Branch (100:25): [True: 0, False: 1] ------------------ 101| 0| errorCode = U_INVALID_FORMAT_ERROR; 102| 0| return; 103| 0| } 104| | 105| 1| const CollationData *baseData = base == nullptr ? nullptr : base->data; ------------------ | Branch (105:37): [True: 1, False: 0] ------------------ 106| 1| const int32_t *reorderCodes = nullptr; 107| 1| int32_t reorderCodesLength = 0; 108| 1| const uint32_t *reorderRanges = nullptr; 109| 1| int32_t reorderRangesLength = 0; 110| 1| index = IX_REORDER_CODES_OFFSET; 111| 1| offset = getIndex(inIndexes, indexesLength, index); 112| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 113| 1| if(length >= 4) { ------------------ | Branch (113:8): [True: 0, False: 1] ------------------ 114| 0| if(baseData == nullptr) { ------------------ | Branch (114:12): [True: 0, False: 0] ------------------ 115| | // We assume for collation settings that 116| | // the base data does not have a reordering. 117| 0| errorCode = U_INVALID_FORMAT_ERROR; 118| 0| return; 119| 0| } 120| 0| reorderCodes = reinterpret_cast(inBytes + offset); 121| 0| reorderCodesLength = length / 4; 122| | 123| | // The reorderRanges (if any) are the trailing reorderCodes entries. 124| | // Split the array at the boundary. 125| | // Script or reorder codes do not exceed 16-bit values. 126| | // Range limits are stored in the upper 16 bits, and are never 0. 127| 0| while(reorderRangesLength < reorderCodesLength && ------------------ | Branch (127:15): [True: 0, False: 0] ------------------ 128| 0| (reorderCodes[reorderCodesLength - reorderRangesLength - 1] & 0xffff0000) != 0) { ------------------ | Branch (128:17): [True: 0, False: 0] ------------------ 129| 0| ++reorderRangesLength; 130| 0| } 131| 0| U_ASSERT(reorderRangesLength < reorderCodesLength); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 132| 0| if(reorderRangesLength != 0) { ------------------ | Branch (132:12): [True: 0, False: 0] ------------------ 133| 0| reorderCodesLength -= reorderRangesLength; 134| 0| reorderRanges = reinterpret_cast(reorderCodes + reorderCodesLength); 135| 0| } 136| 0| } 137| | 138| | // There should be a reorder table only if there are reorder codes. 139| | // However, when there are reorder codes the reorder table may be omitted to reduce 140| | // the data size. 141| 1| const uint8_t *reorderTable = nullptr; 142| 1| index = IX_REORDER_TABLE_OFFSET; 143| 1| offset = getIndex(inIndexes, indexesLength, index); 144| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 145| 1| if(length >= 256) { ------------------ | Branch (145:8): [True: 0, False: 1] ------------------ 146| 0| if(reorderCodesLength == 0) { ------------------ | Branch (146:12): [True: 0, False: 0] ------------------ 147| 0| errorCode = U_INVALID_FORMAT_ERROR; // Reordering table without reordering codes. 148| 0| return; 149| 0| } 150| 0| reorderTable = inBytes + offset; 151| 1| } else { 152| | // If we have reorder codes, then build the reorderTable at the end, 153| | // when the CollationData is otherwise complete. 154| 1| } 155| | 156| 1| if(baseData != nullptr && baseData->numericPrimary != (inIndexes[IX_OPTIONS] & 0xff000000)) { ------------------ | Branch (156:8): [True: 0, False: 1] | Branch (156:31): [True: 0, False: 0] ------------------ 157| 0| errorCode = U_INVALID_FORMAT_ERROR; 158| 0| return; 159| 0| } 160| 1| CollationData *data = nullptr; // Remains nullptr if there are no mappings. 161| | 162| 1| index = IX_TRIE_OFFSET; 163| 1| offset = getIndex(inIndexes, indexesLength, index); 164| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 165| 1| if(length >= 8) { ------------------ | Branch (165:8): [True: 1, False: 0] ------------------ 166| 1| if(!tailoring.ensureOwnedData(errorCode)) { return; } ------------------ | Branch (166:12): [True: 0, False: 1] ------------------ 167| 1| data = tailoring.ownedData; 168| 1| data->base = baseData; 169| 1| data->numericPrimary = inIndexes[IX_OPTIONS] & 0xff000000; 170| 1| data->trie = tailoring.trie = utrie2_openFromSerialized( ------------------ | | 1973| 1|#define utrie2_openFromSerialized U_ICU_ENTRY_POINT_RENAME(utrie2_openFromSerialized) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 1| UTRIE2_32_VALUE_BITS, inBytes + offset, length, nullptr, 172| 1| &errorCode); 173| 1| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (173:12): [True: 0, False: 1] ------------------ 174| 1| } else if(baseData != nullptr) { ------------------ | Branch (174:15): [True: 0, False: 0] ------------------ 175| | // Use the base data. Only the settings are tailored. 176| 0| tailoring.data = baseData; 177| 0| } else { 178| 0| errorCode = U_INVALID_FORMAT_ERROR; // No mappings. 179| 0| return; 180| 0| } 181| | 182| 1| index = IX_CES_OFFSET; 183| 1| offset = getIndex(inIndexes, indexesLength, index); 184| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 185| 1| if(length >= 8) { ------------------ | Branch (185:8): [True: 1, False: 0] ------------------ 186| 1| if(data == nullptr) { ------------------ | Branch (186:12): [True: 0, False: 1] ------------------ 187| 0| errorCode = U_INVALID_FORMAT_ERROR; // Tailored ces without tailored trie. 188| 0| return; 189| 0| } 190| 1| data->ces = reinterpret_cast(inBytes + offset); 191| 1| data->cesLength = length / 8; 192| 1| } 193| | 194| 1| index = IX_CE32S_OFFSET; 195| 1| offset = getIndex(inIndexes, indexesLength, index); 196| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 197| 1| if(length >= 4) { ------------------ | Branch (197:8): [True: 1, False: 0] ------------------ 198| 1| if(data == nullptr) { ------------------ | Branch (198:12): [True: 0, False: 1] ------------------ 199| 0| errorCode = U_INVALID_FORMAT_ERROR; // Tailored ce32s without tailored trie. 200| 0| return; 201| 0| } 202| 1| data->ce32s = reinterpret_cast(inBytes + offset); 203| 1| data->ce32sLength = length / 4; 204| 1| } 205| | 206| 1| int32_t jamoCE32sStart = getIndex(inIndexes, indexesLength, IX_JAMO_CE32S_START); 207| 1| if(jamoCE32sStart >= 0) { ------------------ | Branch (207:8): [True: 1, False: 0] ------------------ 208| 1| if(data == nullptr || data->ce32s == nullptr) { ------------------ | Branch (208:12): [True: 0, False: 1] | Branch (208:31): [True: 0, False: 1] ------------------ 209| 0| errorCode = U_INVALID_FORMAT_ERROR; // Index into non-existent ce32s[]. 210| 0| return; 211| 0| } 212| 1| data->jamoCE32s = data->ce32s + jamoCE32sStart; 213| 1| } else if(data == nullptr) { ------------------ | Branch (213:15): [True: 0, False: 0] ------------------ 214| | // Nothing to do. 215| 0| } else if(baseData != nullptr) { ------------------ | Branch (215:15): [True: 0, False: 0] ------------------ 216| 0| data->jamoCE32s = baseData->jamoCE32s; 217| 0| } else { 218| 0| errorCode = U_INVALID_FORMAT_ERROR; // No Jamo CE32s for Hangul processing. 219| 0| return; 220| 0| } 221| | 222| 1| index = IX_ROOT_ELEMENTS_OFFSET; 223| 1| offset = getIndex(inIndexes, indexesLength, index); 224| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 225| 1| if(length >= 4) { ------------------ | Branch (225:8): [True: 1, False: 0] ------------------ 226| 1| length /= 4; 227| 1| if(data == nullptr || length <= CollationRootElements::IX_SEC_TER_BOUNDARIES) { ------------------ | Branch (227:12): [True: 0, False: 1] | Branch (227:31): [True: 0, False: 1] ------------------ 228| 0| errorCode = U_INVALID_FORMAT_ERROR; 229| 0| return; 230| 0| } 231| 1| data->rootElements = reinterpret_cast(inBytes + offset); 232| 1| data->rootElementsLength = length; 233| 1| uint32_t commonSecTer = data->rootElements[CollationRootElements::IX_COMMON_SEC_AND_TER_CE]; 234| 1| if(commonSecTer != Collation::COMMON_SEC_AND_TER_CE) { ------------------ | Branch (234:12): [True: 0, False: 1] ------------------ 235| 0| errorCode = U_INVALID_FORMAT_ERROR; 236| 0| return; 237| 0| } 238| 1| uint32_t secTerBoundaries = data->rootElements[CollationRootElements::IX_SEC_TER_BOUNDARIES]; 239| 1| if((secTerBoundaries >> 24) < CollationKeys::SEC_COMMON_HIGH) { ------------------ | Branch (239:12): [True: 0, False: 1] ------------------ 240| | // [fixed last secondary common byte] is too low, 241| | // and secondary weights would collide with compressed common secondaries. 242| 0| errorCode = U_INVALID_FORMAT_ERROR; 243| 0| return; 244| 0| } 245| 1| } 246| | 247| 1| index = IX_CONTEXTS_OFFSET; 248| 1| offset = getIndex(inIndexes, indexesLength, index); 249| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 250| 1| if(length >= 2) { ------------------ | Branch (250:8): [True: 1, False: 0] ------------------ 251| 1| if(data == nullptr) { ------------------ | Branch (251:12): [True: 0, False: 1] ------------------ 252| 0| errorCode = U_INVALID_FORMAT_ERROR; // Tailored contexts without tailored trie. 253| 0| return; 254| 0| } 255| 1| data->contexts = reinterpret_cast(inBytes + offset); 256| 1| data->contextsLength = length / 2; 257| 1| } 258| | 259| 1| index = IX_UNSAFE_BWD_OFFSET; 260| 1| offset = getIndex(inIndexes, indexesLength, index); 261| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 262| 1| if(length >= 2) { ------------------ | Branch (262:8): [True: 1, False: 0] ------------------ 263| 1| if(data == nullptr) { ------------------ | Branch (263:12): [True: 0, False: 1] ------------------ 264| 0| errorCode = U_INVALID_FORMAT_ERROR; 265| 0| return; 266| 0| } 267| 1| if(baseData == nullptr) { ------------------ | Branch (267:12): [True: 1, False: 0] ------------------ 268| 1|#if defined(COLLUNSAFE_COLL_VERSION) && defined (COLLUNSAFE_SERIALIZE) 269| 1| tailoring.unsafeBackwardSet = new UnicodeSet(unsafe_serializedData, unsafe_serializedCount, UnicodeSet::kSerialized, errorCode); 270| 1| if(tailoring.unsafeBackwardSet == nullptr) { ------------------ | Branch (270:14): [True: 0, False: 1] ------------------ 271| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 272| 0| return; 273| 1| } else if (U_FAILURE(errorCode)) { ------------------ | Branch (273:22): [True: 0, False: 1] ------------------ 274| 0| return; 275| 0| } 276| |#else 277| | // Create the unsafe-backward set for the root collator. 278| | // Include all non-zero combining marks and trail surrogates. 279| | // We do this at load time, rather than at build time, 280| | // to simplify Unicode version bootstrapping: 281| | // The root data builder only needs the new FractionalUCA.txt data, 282| | // but it need not be built with a version of ICU already updated to 283| | // the corresponding new Unicode Character Database. 284| | // 285| | // The following is an optimized version of 286| | // new UnicodeSet("[[:^lccc=0:][\\udc00-\\udfff]]"). 287| | // It is faster and requires fewer code dependencies. 288| | tailoring.unsafeBackwardSet = new UnicodeSet(0xdc00, 0xdfff); // trail surrogates 289| | if(tailoring.unsafeBackwardSet == nullptr) { 290| | errorCode = U_MEMORY_ALLOCATION_ERROR; 291| | return; 292| | } 293| | data->nfcImpl.addLcccChars(*tailoring.unsafeBackwardSet); 294| |#endif // !COLLUNSAFE_SERIALIZE || !COLLUNSAFE_COLL_VERSION 295| 1| } else { 296| | // Clone the root collator's set contents. 297| 0| tailoring.unsafeBackwardSet = static_cast( 298| 0| baseData->unsafeBackwardSet->cloneAsThawed()); 299| 0| if(tailoring.unsafeBackwardSet == nullptr) { ------------------ | Branch (299:16): [True: 0, False: 0] ------------------ 300| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 301| 0| return; 302| 0| } 303| 0| } 304| | // Add the ranges from the data file to the unsafe-backward set. 305| 1| USerializedSet sset; 306| 1| const uint16_t *unsafeData = reinterpret_cast(inBytes + offset); 307| 1| if(!uset_getSerializedSet(&sset, unsafeData, length / 2)) { ------------------ | | 1782| 1|#define uset_getSerializedSet U_ICU_ENTRY_POINT_RENAME(uset_getSerializedSet) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (307:12): [True: 0, False: 1] ------------------ 308| 0| errorCode = U_INVALID_FORMAT_ERROR; 309| 0| return; 310| 0| } 311| 1| int32_t count = uset_getSerializedRangeCount(&sset); ------------------ | | 1781| 1|#define uset_getSerializedRangeCount U_ICU_ENTRY_POINT_RENAME(uset_getSerializedRangeCount) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 312| 227| for(int32_t i = 0; i < count; ++i) { ------------------ | Branch (312:28): [True: 226, False: 1] ------------------ 313| 226| UChar32 start, end; 314| 226| uset_getSerializedRange(&sset, i, &start, &end); ------------------ | | 1780| 226|#define uset_getSerializedRange U_ICU_ENTRY_POINT_RENAME(uset_getSerializedRange) | | ------------------ | | | | 123| 226|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 226|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 226|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 315| 226| tailoring.unsafeBackwardSet->add(start, end); 316| 226| } 317| | // Mark each lead surrogate as "unsafe" 318| | // if any of its 1024 associated supplementary code points is "unsafe". 319| 1| UChar32 c = 0x10000; 320| 1.02k| for(char16_t lead = 0xd800; lead < 0xdc00; ++lead, c += 0x400) { ------------------ | Branch (320:37): [True: 1.02k, False: 1] ------------------ 321| 1.02k| if(!tailoring.unsafeBackwardSet->containsNone(c, c + 0x3ff)) { ------------------ | Branch (321:16): [True: 23, False: 1.00k] ------------------ 322| 23| tailoring.unsafeBackwardSet->add(lead); 323| 23| } 324| 1.02k| } 325| 1| tailoring.unsafeBackwardSet->freeze(); 326| 1| data->unsafeBackwardSet = tailoring.unsafeBackwardSet; 327| 1| } else if(data == nullptr) { ------------------ | Branch (327:15): [True: 0, False: 0] ------------------ 328| | // Nothing to do. 329| 0| } else if(baseData != nullptr) { ------------------ | Branch (329:15): [True: 0, False: 0] ------------------ 330| | // No tailoring-specific data: Alias the root collator's set. 331| 0| data->unsafeBackwardSet = baseData->unsafeBackwardSet; 332| 0| } else { 333| 0| errorCode = U_INVALID_FORMAT_ERROR; // No unsafeBackwardSet. 334| 0| return; 335| 0| } 336| | 337| | // If the fast Latin format version is different, 338| | // or the version is set to 0 for "no fast Latin table", 339| | // then just always use the normal string comparison path. 340| 1| if(data != nullptr) { ------------------ | Branch (340:8): [True: 1, False: 0] ------------------ 341| 1| data->fastLatinTable = nullptr; 342| 1| data->fastLatinTableLength = 0; 343| 1| if(((inIndexes[IX_OPTIONS] >> 16) & 0xff) == CollationFastLatin::VERSION) { ------------------ | Branch (343:12): [True: 1, False: 0] ------------------ 344| 1| index = IX_FAST_LATIN_TABLE_OFFSET; 345| 1| offset = getIndex(inIndexes, indexesLength, index); 346| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 347| 1| if(length >= 2) { ------------------ | Branch (347:16): [True: 1, False: 0] ------------------ 348| 1| data->fastLatinTable = reinterpret_cast(inBytes + offset); 349| 1| data->fastLatinTableLength = length / 2; 350| 1| if((*data->fastLatinTable >> 8) != CollationFastLatin::VERSION) { ------------------ | Branch (350:20): [True: 0, False: 1] ------------------ 351| 0| errorCode = U_INVALID_FORMAT_ERROR; // header vs. table version mismatch 352| 0| return; 353| 0| } 354| 1| } else if(baseData != nullptr) { ------------------ | Branch (354:23): [True: 0, False: 0] ------------------ 355| 0| data->fastLatinTable = baseData->fastLatinTable; 356| 0| data->fastLatinTableLength = baseData->fastLatinTableLength; 357| 0| } 358| 1| } 359| 1| } 360| | 361| 1| index = IX_SCRIPTS_OFFSET; 362| 1| offset = getIndex(inIndexes, indexesLength, index); 363| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 364| 1| if(length >= 2) { ------------------ | Branch (364:8): [True: 1, False: 0] ------------------ 365| 1| if(data == nullptr) { ------------------ | Branch (365:12): [True: 0, False: 1] ------------------ 366| 0| errorCode = U_INVALID_FORMAT_ERROR; 367| 0| return; 368| 0| } 369| 1| const uint16_t *scripts = reinterpret_cast(inBytes + offset); 370| 1| int32_t scriptsLength = length / 2; 371| 1| data->numScripts = scripts[0]; 372| | // There must be enough entries for both arrays, including more than two range starts. 373| 1| data->scriptStartsLength = scriptsLength - (1 + data->numScripts + 16); 374| 1| if(data->scriptStartsLength <= 2 || ------------------ | Branch (374:12): [True: 0, False: 1] ------------------ 375| 1| CollationData::MAX_NUM_SCRIPT_RANGES < data->scriptStartsLength) { ------------------ | Branch (375:17): [True: 0, False: 1] ------------------ 376| 0| errorCode = U_INVALID_FORMAT_ERROR; 377| 0| return; 378| 0| } 379| 1| data->scriptsIndex = scripts + 1; 380| 1| data->scriptStarts = scripts + 1 + data->numScripts + 16; 381| 1| if(!(data->scriptStarts[0] == 0 && ------------------ | Branch (381:14): [True: 1, False: 0] ------------------ 382| 1| data->scriptStarts[1] == ((Collation::MERGE_SEPARATOR_BYTE + 1) << 8) && ------------------ | Branch (382:17): [True: 1, False: 0] ------------------ 383| 1| data->scriptStarts[data->scriptStartsLength - 1] == ------------------ | Branch (383:17): [True: 1, False: 0] ------------------ 384| 1| (Collation::TRAIL_WEIGHT_BYTE << 8))) { 385| 0| errorCode = U_INVALID_FORMAT_ERROR; 386| 0| return; 387| 0| } 388| 1| } else if(data == nullptr) { ------------------ | Branch (388:15): [True: 0, False: 0] ------------------ 389| | // Nothing to do. 390| 0| } else if(baseData != nullptr) { ------------------ | Branch (390:15): [True: 0, False: 0] ------------------ 391| 0| data->numScripts = baseData->numScripts; 392| 0| data->scriptsIndex = baseData->scriptsIndex; 393| 0| data->scriptStarts = baseData->scriptStarts; 394| 0| data->scriptStartsLength = baseData->scriptStartsLength; 395| 0| } 396| | 397| 1| index = IX_COMPRESSIBLE_BYTES_OFFSET; 398| 1| offset = getIndex(inIndexes, indexesLength, index); 399| 1| length = getIndex(inIndexes, indexesLength, index + 1) - offset; 400| 1| if(length >= 256) { ------------------ | Branch (400:8): [True: 1, False: 0] ------------------ 401| 1| if(data == nullptr) { ------------------ | Branch (401:12): [True: 0, False: 1] ------------------ 402| 0| errorCode = U_INVALID_FORMAT_ERROR; 403| 0| return; 404| 0| } 405| 1| data->compressibleBytes = reinterpret_cast(inBytes + offset); 406| 1| } else if(data == nullptr) { ------------------ | Branch (406:15): [True: 0, False: 0] ------------------ 407| | // Nothing to do. 408| 0| } else if(baseData != nullptr) { ------------------ | Branch (408:15): [True: 0, False: 0] ------------------ 409| 0| data->compressibleBytes = baseData->compressibleBytes; 410| 0| } else { 411| 0| errorCode = U_INVALID_FORMAT_ERROR; // No compressibleBytes[]. 412| 0| return; 413| 0| } 414| | 415| 1| const CollationSettings &ts = *tailoring.settings; 416| 1| int32_t options = inIndexes[IX_OPTIONS] & 0xffff; 417| 1| uint16_t fastLatinPrimaries[CollationFastLatin::LATIN_LIMIT]; 418| 1| int32_t fastLatinOptions = CollationFastLatin::getOptions( 419| 1| tailoring.data, ts, fastLatinPrimaries, UPRV_LENGTHOF(fastLatinPrimaries)); ------------------ | | 99| 1|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 420| 1| if(options == ts.options && ts.variableTop != 0 && ------------------ | Branch (420:8): [True: 1, False: 0] | Branch (420:33): [True: 0, False: 1] ------------------ 421| 1| reorderCodesLength == ts.reorderCodesLength && ------------------ | Branch (421:13): [True: 0, False: 0] ------------------ 422| 1| (reorderCodesLength == 0 || ------------------ | Branch (422:14): [True: 0, False: 0] ------------------ 423| 0| uprv_memcmp(reorderCodes, ts.reorderCodes, reorderCodesLength * 4) == 0) && ------------------ | | 101| 0|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (423:17): [True: 0, False: 0] ------------------ 424| 1| fastLatinOptions == ts.fastLatinOptions && ------------------ | Branch (424:13): [True: 0, False: 0] ------------------ 425| 1| (fastLatinOptions < 0 || ------------------ | Branch (425:14): [True: 0, False: 0] ------------------ 426| 0| uprv_memcmp(fastLatinPrimaries, ts.fastLatinPrimaries, ------------------ | | 101| 0|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (426:17): [True: 0, False: 0] ------------------ 427| 0| sizeof(fastLatinPrimaries)) == 0)) { 428| 0| return; 429| 0| } 430| | 431| 1| CollationSettings *settings = SharedObject::copyOnWrite(tailoring.settings); 432| 1| if(settings == nullptr) { ------------------ | Branch (432:8): [True: 0, False: 1] ------------------ 433| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 434| 0| return; 435| 0| } 436| 1| settings->options = options; 437| | // Set variableTop from options and scripts data. 438| 1| settings->variableTop = tailoring.data->getLastPrimaryForGroup( 439| 1| UCOL_REORDER_CODE_FIRST + int32_t{settings->getMaxVariable()}); 440| 1| if(settings->variableTop == 0) { ------------------ | Branch (440:8): [True: 0, False: 1] ------------------ 441| 0| errorCode = U_INVALID_FORMAT_ERROR; 442| 0| return; 443| 0| } 444| | 445| 1| if(reorderCodesLength != 0) { ------------------ | Branch (445:8): [True: 0, False: 1] ------------------ 446| 0| settings->aliasReordering(*baseData, reorderCodes, reorderCodesLength, 447| 0| reorderRanges, reorderRangesLength, 448| 0| reorderTable, errorCode); 449| 0| } 450| | 451| 1| settings->fastLatinOptions = CollationFastLatin::getOptions( 452| 1| tailoring.data, *settings, 453| 1| settings->fastLatinPrimaries, UPRV_LENGTHOF(settings->fastLatinPrimaries)); ------------------ | | 99| 1|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 454| 1|} _ZN6icu_7819CollationDataReader12isAcceptableEPvPKcS3_PK9UDataInfo: 459| 1| const UDataInfo *pInfo) { 460| 1| if( 461| 1| pInfo->size >= 20 && ------------------ | Branch (461:9): [True: 1, False: 0] ------------------ 462| 1| pInfo->isBigEndian == U_IS_BIG_ENDIAN && ------------------ | | 353| 2|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (462:9): [True: 1, False: 0] ------------------ 463| 1| pInfo->charsetFamily == U_CHARSET_FAMILY && ------------------ | | 588| 1|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 2|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (463:9): [True: 1, False: 0] ------------------ 464| 1| pInfo->dataFormat[0] == 0x55 && // dataFormat="UCol" ------------------ | Branch (464:9): [True: 1, False: 0] ------------------ 465| 1| pInfo->dataFormat[1] == 0x43 && ------------------ | Branch (465:9): [True: 1, False: 0] ------------------ 466| 1| pInfo->dataFormat[2] == 0x6f && ------------------ | Branch (466:9): [True: 1, False: 0] ------------------ 467| 1| pInfo->dataFormat[3] == 0x6c && ------------------ | Branch (467:9): [True: 1, False: 0] ------------------ 468| 1| pInfo->formatVersion[0] == 5 ------------------ | Branch (468:9): [True: 1, False: 0] ------------------ 469| 1| ) { 470| 1| UVersionInfo *version = static_cast(context); 471| 1| if(version != nullptr) { ------------------ | Branch (471:12): [True: 1, False: 0] ------------------ 472| 1| uprv_memcpy(version, pInfo->dataVersion, 4); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 473| 1| } 474| 1| return true; 475| 1| } else { 476| 0| return false; 477| 0| } 478| 1|} collationdatareader.cpp:_ZN6icu_7812_GLOBAL__N_18getIndexEPKiii: 40| 23|int32_t getIndex(const int32_t *indexes, int32_t length, int32_t i) { 41| 23| return (i < length) ? indexes[i] : -1; ------------------ | Branch (41:12): [True: 23, False: 0] ------------------ 42| 23|} _ZN6icu_7818CollationFastLatin10getOptionsEPKNS_13CollationDataERKNS_17CollationSettingsEPti: 28| 4.09k| uint16_t *primaries, int32_t capacity) { 29| 4.09k| const uint16_t *table = data->fastLatinTable; 30| 4.09k| if(table == nullptr) { return -1; } ------------------ | Branch (30:8): [True: 161, False: 3.93k] ------------------ 31| 3.93k| U_ASSERT(capacity == LATIN_LIMIT); ------------------ | | 35| 3.93k|# define U_ASSERT(exp) (void)0 ------------------ 32| 3.93k| if(capacity != LATIN_LIMIT) { return -1; } ------------------ | Branch (32:8): [True: 0, False: 3.93k] ------------------ 33| | 34| 3.93k| uint32_t miniVarTop; 35| 3.93k| if((settings.options & CollationSettings::ALTERNATE_MASK) == 0) { ------------------ | Branch (35:8): [True: 3.59k, False: 341] ------------------ 36| | // No mini primaries are variable, set a variableTop just below the 37| | // lowest long mini primary. 38| 3.59k| miniVarTop = MIN_LONG - 1; 39| 3.59k| } else { 40| 341| int32_t headerLength = *table & 0xff; 41| 341| int32_t i = 1 + settings.getMaxVariable(); 42| 341| if(i >= headerLength) { ------------------ | Branch (42:12): [True: 0, False: 341] ------------------ 43| 0| return -1; // variableTop >= digits, should not occur 44| 0| } 45| 341| miniVarTop = table[i]; 46| 341| } 47| | 48| 3.93k| UBool digitsAreReordered = false; 49| 3.93k| if(settings.hasReordering()) { ------------------ | Branch (49:8): [True: 485, False: 3.45k] ------------------ 50| 485| uint32_t prevStart = 0; 51| 485| uint32_t beforeDigitStart = 0; 52| 485| uint32_t digitStart = 0; 53| 485| uint32_t afterDigitStart = 0; 54| 485| for(int32_t group = UCOL_REORDER_CODE_FIRST; 55| 4.36k| group < UCOL_REORDER_CODE_FIRST + CollationData::MAX_NUM_SPECIAL_REORDER_CODES; ------------------ | Branch (55:17): [True: 3.88k, False: 485] ------------------ 56| 3.88k| ++group) { 57| 3.88k| uint32_t start = data->getFirstPrimaryForGroup(group); 58| 3.88k| start = settings.reorder(start); 59| 3.88k| if(group == UCOL_REORDER_CODE_DIGIT) { ------------------ | Branch (59:16): [True: 485, False: 3.39k] ------------------ 60| 485| beforeDigitStart = prevStart; 61| 485| digitStart = start; 62| 3.39k| } else if(start != 0) { ------------------ | Branch (62:23): [True: 1.94k, False: 1.45k] ------------------ 63| 1.94k| if(start < prevStart) { ------------------ | Branch (63:20): [True: 0, False: 1.94k] ------------------ 64| | // The permutation affects the groups up to Latin. 65| 0| return -1; 66| 0| } 67| | // In the future, there might be a special group between digits & Latin. 68| 1.94k| if(digitStart != 0 && afterDigitStart == 0 && prevStart == beforeDigitStart) { ------------------ | Branch (68:20): [True: 0, False: 1.94k] | Branch (68:39): [True: 0, False: 0] | Branch (68:63): [True: 0, False: 0] ------------------ 69| 0| afterDigitStart = start; 70| 0| } 71| 1.94k| prevStart = start; 72| 1.94k| } 73| 3.88k| } 74| 485| uint32_t latinStart = data->getFirstPrimaryForGroup(USCRIPT_LATIN); 75| 485| latinStart = settings.reorder(latinStart); 76| 485| if(latinStart < prevStart) { ------------------ | Branch (76:12): [True: 0, False: 485] ------------------ 77| 0| return -1; 78| 0| } 79| 485| if(afterDigitStart == 0) { ------------------ | Branch (79:12): [True: 485, False: 0] ------------------ 80| 485| afterDigitStart = latinStart; 81| 485| } 82| 485| if(!(beforeDigitStart < digitStart && digitStart < afterDigitStart)) { ------------------ | Branch (82:14): [True: 485, False: 0] | Branch (82:47): [True: 485, False: 0] ------------------ 83| 0| digitsAreReordered = true; 84| 0| } 85| 485| } 86| | 87| 3.93k| table += (table[0] & 0xff); // skip the header 88| 1.51M| for(UChar32 c = 0; c < LATIN_LIMIT; ++c) { ------------------ | Branch (88:24): [True: 1.51M, False: 3.93k] ------------------ 89| 1.51M| uint32_t p = table[c]; 90| 1.51M| if(p >= MIN_SHORT) { ------------------ | Branch (90:12): [True: 914k, False: 596k] ------------------ 91| 914k| p &= SHORT_PRIMARY_MASK; 92| 914k| } else if(p > miniVarTop) { ------------------ | Branch (92:19): [True: 224k, False: 371k] ------------------ 93| 224k| p &= LONG_PRIMARY_MASK; 94| 371k| } else { 95| 371k| p = 0; 96| 371k| } 97| 1.51M| primaries[c] = static_cast(p); 98| 1.51M| } 99| 3.93k| if(digitsAreReordered || (settings.options & CollationSettings::NUMERIC) != 0) { ------------------ | Branch (99:8): [True: 0, False: 3.93k] | Branch (99:30): [True: 0, False: 3.93k] ------------------ 100| | // Bail out for digits. 101| 0| for(UChar32 c = 0x30; c <= 0x39; ++c) { primaries[c] = 0; } ------------------ | Branch (101:31): [True: 0, False: 0] ------------------ 102| 0| } 103| | 104| | // Shift the miniVarTop above other options. 105| 3.93k| return (static_cast(miniVarTop) << 16) | settings.options; 106| 3.93k|} _ZN6icu_7818CollationFastLatin12getCharIndexEDs: 191| 86.6k| static inline int32_t getCharIndex(char16_t c) { 192| 86.6k| if(c <= LATIN_MAX) { ------------------ | Branch (192:12): [True: 22.6k, False: 63.9k] ------------------ 193| 22.6k| return c; 194| 63.9k| } else if(PUNCT_START <= c && c < PUNCT_LIMIT) { ------------------ | Branch (194:19): [True: 13.2k, False: 50.6k] | Branch (194:39): [True: 1.18k, False: 12.1k] ------------------ 195| 1.18k| return c - (PUNCT_START - LATIN_LIMIT); 196| 62.7k| } else { 197| | // Not a fast Latin character. 198| | // Note: U+FFFE & U+FFFF are forbidden in tailorings 199| | // and thus do not occur in any contractions. 200| 62.7k| return -1; 201| 62.7k| } 202| 86.6k| } _ZN6icu_7825CollationFastLatinBuilderC2ER10UErrorCode: 90| 3.92k| : ce0(0), ce1(0), 91| 3.92k| contractionCEs(errorCode), uniqueCEs(errorCode), 92| 3.92k| miniCEs(nullptr), 93| 3.92k| firstDigitPrimary(0), firstLatinPrimary(0), lastLatinPrimary(0), 94| 3.92k| firstShortPrimary(0), shortPrimaryOverflow(false), 95| 3.92k| headerLength(0) { 96| 3.92k|} _ZN6icu_7825CollationFastLatinBuilderD2Ev: 98| 3.92k|CollationFastLatinBuilder::~CollationFastLatinBuilder() { 99| 3.92k| uprv_free(miniCEs); ------------------ | | 1503| 3.92k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 100| 3.92k|} _ZN6icu_7825CollationFastLatinBuilder7forDataERKNS_13CollationDataER10UErrorCode: 103| 3.92k|CollationFastLatinBuilder::forData(const CollationData &data, UErrorCode &errorCode) { 104| 3.92k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (104:8): [True: 0, False: 3.92k] ------------------ 105| 3.92k| if(!result.isEmpty()) { // This builder is not reusable. ------------------ | Branch (105:8): [True: 0, False: 3.92k] ------------------ 106| 0| errorCode = U_INVALID_STATE_ERROR; 107| 0| return false; 108| 0| } 109| 3.92k| if(!loadGroups(data, errorCode)) { return false; } ------------------ | Branch (109:8): [True: 0, False: 3.92k] ------------------ 110| | 111| | // Fast handling of digits. 112| 3.92k| firstShortPrimary = firstDigitPrimary; 113| 3.92k| getCEs(data, errorCode); 114| 3.92k| if(!encodeUniqueCEs(errorCode)) { return false; } ------------------ | Branch (114:8): [True: 0, False: 3.92k] ------------------ 115| 3.92k| if(shortPrimaryOverflow) { ------------------ | Branch (115:8): [True: 247, False: 3.68k] ------------------ 116| | // Give digits long mini primaries, 117| | // so that there are more short primaries for letters. 118| 247| firstShortPrimary = firstLatinPrimary; 119| 247| resetCEs(); 120| 247| getCEs(data, errorCode); 121| 247| if(!encodeUniqueCEs(errorCode)) { return false; } ------------------ | Branch (121:12): [True: 0, False: 247] ------------------ 122| 247| } 123| | // Note: If we still have a short-primary overflow but not a long-primary overflow, 124| | // then we could calculate how many more long primaries would fit, 125| | // and set the firstShortPrimary to that many after the current firstShortPrimary, 126| | // and try again. 127| | // However, this might only benefit the en_US_POSIX tailoring, 128| | // and it is simpler to suppress building fast Latin data for it in genrb, 129| | // or by returning false here if shortPrimaryOverflow. 130| | 131| 3.92k| UBool ok = !shortPrimaryOverflow && ------------------ | Branch (131:16): [True: 3.76k, False: 161] ------------------ 132| 3.92k| encodeCharCEs(errorCode) && encodeContractions(errorCode); ------------------ | Branch (132:13): [True: 3.76k, False: 0] | Branch (132:41): [True: 3.76k, False: 0] ------------------ 133| 3.92k| contractionCEs.removeAllElements(); // might reduce heap memory usage 134| 3.92k| uniqueCEs.removeAllElements(); 135| 3.92k| return ok; 136| 3.92k|} _ZN6icu_7825CollationFastLatinBuilder10loadGroupsERKNS_13CollationDataER10UErrorCode: 139| 3.92k|CollationFastLatinBuilder::loadGroups(const CollationData &data, UErrorCode &errorCode) { 140| 3.92k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (140:8): [True: 0, False: 3.92k] ------------------ 141| 3.92k| headerLength = 1 + NUM_SPECIAL_GROUPS; 142| 3.92k| uint32_t r0 = (CollationFastLatin::VERSION << 8) | headerLength; 143| 3.92k| result.append(static_cast(r0)); 144| | // The first few reordering groups should be special groups 145| | // (space, punct, ..., digit) followed by Latn, then Grek and other scripts. 146| 19.6k| for(int32_t i = 0; i < NUM_SPECIAL_GROUPS; ++i) { ------------------ | Branch (146:24): [True: 15.7k, False: 3.92k] ------------------ 147| 15.7k| lastSpecialPrimaries[i] = data.getLastPrimaryForGroup(UCOL_REORDER_CODE_FIRST + i); 148| 15.7k| if(lastSpecialPrimaries[i] == 0) { ------------------ | Branch (148:12): [True: 0, False: 15.7k] ------------------ 149| | // missing data 150| 0| return false; 151| 0| } 152| 15.7k| result.append(static_cast(0)); // reserve a slot for this group 153| 15.7k| } 154| | 155| 3.92k| firstDigitPrimary = data.getFirstPrimaryForGroup(UCOL_REORDER_CODE_DIGIT); 156| 3.92k| firstLatinPrimary = data.getFirstPrimaryForGroup(USCRIPT_LATIN); 157| 3.92k| lastLatinPrimary = data.getLastPrimaryForGroup(USCRIPT_LATIN); 158| 3.92k| if(firstDigitPrimary == 0 || firstLatinPrimary == 0) { ------------------ | Branch (158:8): [True: 0, False: 3.92k] | Branch (158:34): [True: 0, False: 3.92k] ------------------ 159| | // missing data 160| 0| return false; 161| 0| } 162| 3.92k| return true; 163| 3.92k|} _ZNK6icu_7825CollationFastLatinBuilder11inSameGroupEjj: 166| 80.8k|CollationFastLatinBuilder::inSameGroup(uint32_t p, uint32_t q) const { 167| | // Both or neither need to be encoded as short primaries, 168| | // so that we can test only one and use the same bit mask. 169| 80.8k| if(p >= firstShortPrimary) { ------------------ | Branch (169:8): [True: 58.7k, False: 22.0k] ------------------ 170| 58.7k| return q >= firstShortPrimary; 171| 58.7k| } else if(q >= firstShortPrimary) { ------------------ | Branch (171:15): [True: 2.34k, False: 19.7k] ------------------ 172| 2.34k| return false; 173| 2.34k| } 174| | // Both or neither must be potentially-variable, 175| | // so that we can test only one and determine if both are variable. 176| 19.7k| uint32_t lastVariablePrimary = lastSpecialPrimaries[NUM_SPECIAL_GROUPS - 1]; 177| 19.7k| if(p > lastVariablePrimary) { ------------------ | Branch (177:8): [True: 1.92k, False: 17.8k] ------------------ 178| 1.92k| return q > lastVariablePrimary; 179| 17.8k| } else if(q > lastVariablePrimary) { ------------------ | Branch (179:15): [True: 98, False: 17.7k] ------------------ 180| 98| return false; 181| 98| } 182| | // Both will be encoded with long mini primaries. 183| | // They must be in the same special reordering group, 184| | // so that we can test only one and determine if both are variable. 185| 17.7k| U_ASSERT(p != 0 && q != 0); ------------------ | | 35| 17.7k|# define U_ASSERT(exp) (void)0 ------------------ 186| 35.8k| for(int32_t i = 0;; ++i) { // will terminate 187| 35.8k| uint32_t lastPrimary = lastSpecialPrimaries[i]; 188| 35.8k| if(p <= lastPrimary) { ------------------ | Branch (188:12): [True: 17.3k, False: 18.4k] ------------------ 189| 17.3k| return q <= lastPrimary; 190| 18.4k| } else if(q <= lastPrimary) { ------------------ | Branch (190:19): [True: 325, False: 18.1k] ------------------ 191| 325| return false; 192| 325| } 193| 35.8k| } 194| 17.7k|} _ZN6icu_7825CollationFastLatinBuilder8resetCEsEv: 197| 247|CollationFastLatinBuilder::resetCEs() { 198| 247| contractionCEs.removeAllElements(); 199| 247| uniqueCEs.removeAllElements(); 200| 247| shortPrimaryOverflow = false; 201| 247| result.truncate(headerLength); 202| 247|} _ZN6icu_7825CollationFastLatinBuilder6getCEsERKNS_13CollationDataER10UErrorCode: 205| 4.17k|CollationFastLatinBuilder::getCEs(const CollationData &data, UErrorCode &errorCode) { 206| 4.17k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (206:8): [True: 0, False: 4.17k] ------------------ 207| 4.17k| int32_t i = 0; 208| 1.87M| for(char16_t c = 0;; ++i, ++c) { 209| 1.87M| if(c == CollationFastLatin::LATIN_LIMIT) { ------------------ | Branch (209:12): [True: 4.17k, False: 1.86M] ------------------ 210| 4.17k| c = CollationFastLatin::PUNCT_START; 211| 1.86M| } else if(c == CollationFastLatin::PUNCT_LIMIT) { ------------------ | Branch (211:19): [True: 4.17k, False: 1.86M] ------------------ 212| 4.17k| break; 213| 4.17k| } 214| 1.86M| const CollationData *d; 215| 1.86M| uint32_t ce32 = data.getCE32(c); 216| 1.86M| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (216:12): [True: 980k, False: 889k] ------------------ 217| 980k| d = data.base; 218| 980k| ce32 = d->getCE32(c); 219| 980k| } else { 220| 889k| d = &data; 221| 889k| } 222| 1.86M| if(getCEsFromCE32(*d, c, ce32, errorCode)) { ------------------ | Branch (222:12): [True: 1.73M, False: 132k] ------------------ 223| 1.73M| charCEs[i][0] = ce0; 224| 1.73M| charCEs[i][1] = ce1; 225| 1.73M| addUniqueCE(ce0, errorCode); 226| 1.73M| addUniqueCE(ce1, errorCode); 227| 1.73M| } else { 228| | // bail out for c 229| 132k| charCEs[i][0] = ce0 = Collation::NO_CE; 230| 132k| charCEs[i][1] = ce1 = 0; 231| 132k| } 232| 1.86M| if(c == 0 && !isContractionCharCE(ce0)) { ------------------ | Branch (232:12): [True: 4.17k, False: 1.86M] | Branch (232:22): [True: 3.82k, False: 349] ------------------ 233| | // Always map U+0000 to a contraction. 234| | // Write a contraction list with only a default value if there is no real contraction. 235| 3.82k| U_ASSERT(contractionCEs.isEmpty()); ------------------ | | 35| 3.82k|# define U_ASSERT(exp) (void)0 ------------------ 236| 3.82k| addContractionEntry(CollationFastLatin::CONTR_CHAR_MASK, ce0, ce1, errorCode); 237| 3.82k| charCEs[0][0] = (static_cast(Collation::NO_CE_PRIMARY) << 32) | CONTRACTION_FLAG; 238| 3.82k| charCEs[0][1] = 0; 239| 3.82k| } 240| 1.86M| } 241| | // Terminate the last contraction list. 242| 4.17k| contractionCEs.addElement(CollationFastLatin::CONTR_CHAR_MASK, errorCode); 243| 4.17k|} _ZN6icu_7825CollationFastLatinBuilder14getCEsFromCE32ERKNS_13CollationDataEijR10UErrorCode: 247| 1.88M| UErrorCode &errorCode) { 248| 1.88M| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (248:8): [True: 0, False: 1.88M] ------------------ 249| 1.88M| ce32 = data.getFinalCE32(ce32); 250| 1.88M| ce1 = 0; 251| 1.88M| if(Collation::isSimpleOrLongCE32(ce32)) { ------------------ | Branch (251:8): [True: 1.03M, False: 856k] ------------------ 252| 1.03M| ce0 = Collation::ceFromCE32(ce32); 253| 1.03M| } else { 254| 856k| switch(Collation::tagFromCE32(ce32)) { 255| 604k| case Collation::LATIN_EXPANSION_TAG: ------------------ | Branch (255:9): [True: 604k, False: 252k] ------------------ 256| 604k| ce0 = Collation::latinCE0FromCE32(ce32); 257| 604k| ce1 = Collation::latinCE1FromCE32(ce32); 258| 604k| break; 259| 159k| case Collation::EXPANSION32_TAG: { ------------------ | Branch (259:9): [True: 159k, False: 697k] ------------------ 260| 159k| const uint32_t *ce32s = data.ce32s + Collation::indexFromCE32(ce32); 261| 159k| int32_t length = Collation::lengthFromCE32(ce32); 262| 159k| if(length <= 2) { ------------------ | Branch (262:16): [True: 110k, False: 48.3k] ------------------ 263| 110k| ce0 = Collation::ceFromCE32(ce32s[0]); 264| 110k| if(length == 2) { ------------------ | Branch (264:20): [True: 110k, False: 0] ------------------ 265| 110k| ce1 = Collation::ceFromCE32(ce32s[1]); 266| 110k| } 267| 110k| break; 268| 110k| } else { 269| 48.3k| return false; 270| 48.3k| } 271| 159k| } 272| 81.4k| case Collation::EXPANSION_TAG: { ------------------ | Branch (272:9): [True: 81.4k, False: 774k] ------------------ 273| 81.4k| const int64_t *ces = data.ces + Collation::indexFromCE32(ce32); 274| 81.4k| int32_t length = Collation::lengthFromCE32(ce32); 275| 81.4k| if(length <= 2) { ------------------ | Branch (275:16): [True: 65.3k, False: 16.1k] ------------------ 276| 65.3k| ce0 = ces[0]; 277| 65.3k| if(length == 2) { ------------------ | Branch (277:20): [True: 45.5k, False: 19.8k] ------------------ 278| 45.5k| ce1 = ces[1]; 279| 45.5k| } 280| 65.3k| break; 281| 65.3k| } else { 282| 16.1k| return false; 283| 16.1k| } 284| 81.4k| } 285| | // Note: We could support PREFIX_TAG (assert c>=0) 286| | // by recursing on its default CE32 and checking that none of the prefixes starts 287| | // with a fast Latin character. 288| | // However, currently (2013) there are only the L-before-middle-dot 289| | // prefix mappings in the Latin range, and those would be rejected anyway. 290| 6.95k| case Collation::CONTRACTION_TAG: ------------------ | Branch (290:9): [True: 6.95k, False: 849k] ------------------ 291| 6.95k| U_ASSERT(c >= 0); ------------------ | | 35| 6.95k|# define U_ASSERT(exp) (void)0 ------------------ 292| 6.95k| return getCEsFromContractionCE32(data, ce32, errorCode); 293| 0| case Collation::OFFSET_TAG: ------------------ | Branch (293:9): [True: 0, False: 856k] ------------------ 294| 0| U_ASSERT(c >= 0); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 295| 0| ce0 = data.getCEFromOffsetCE32(c, ce32); 296| 0| break; 297| 4.75k| default: ------------------ | Branch (297:9): [True: 4.75k, False: 851k] ------------------ 298| 4.75k| return false; 299| 856k| } 300| 856k| } 301| | // A mapping can be completely ignorable. 302| 1.81M| if(ce0 == 0) { return ce1 == 0; } ------------------ | Branch (302:8): [True: 274k, False: 1.53M] ------------------ 303| | // We do not support an ignorable ce0 unless it is completely ignorable. 304| 1.53M| uint32_t p0 = static_cast(ce0 >> 32); 305| 1.53M| if(p0 == 0) { return false; } ------------------ | Branch (305:8): [True: 5.85k, False: 1.53M] ------------------ 306| | // We only support primaries up to the Latin script. 307| 1.53M| if(p0 > lastLatinPrimary) { return false; } ------------------ | Branch (307:8): [True: 11.6k, False: 1.51M] ------------------ 308| | // We support non-common secondary and case weights only together with short primaries. 309| 1.51M| uint32_t lower32_0 = static_cast(ce0); 310| 1.51M| if(p0 < firstShortPrimary) { ------------------ | Branch (310:8): [True: 468k, False: 1.05M] ------------------ 311| 468k| uint32_t sc0 = lower32_0 & Collation::SECONDARY_AND_CASE_MASK; 312| 468k| if(sc0 != Collation::COMMON_SECONDARY_CE) { return false; } ------------------ | Branch (312:12): [True: 40.9k, False: 427k] ------------------ 313| 468k| } 314| | // No below-common tertiary weights. 315| 1.47M| if((lower32_0 & Collation::ONLY_TERTIARY_MASK) < Collation::COMMON_WEIGHT16) { return false; } ------------------ | Branch (315:8): [True: 0, False: 1.47M] ------------------ 316| 1.47M| if(ce1 != 0) { ------------------ | Branch (316:8): [True: 749k, False: 729k] ------------------ 317| | // Both primaries must be in the same group, 318| | // or both must get short mini primaries, 319| | // or a short-primary CE is followed by a secondary CE. 320| | // This is so that we can test the first primary and use the same mask for both, 321| | // and determine for both whether they are variable. 322| 749k| uint32_t p1 = static_cast(ce1 >> 32); 323| 749k| if(p1 == 0 ? p0 < firstShortPrimary : !inSameGroup(p0, p1)) { return false; } ------------------ | Branch (323:12): [True: 668k, False: 80.8k] | Branch (323:12): [True: 7.46k, False: 742k] ------------------ 324| 742k| uint32_t lower32_1 = static_cast(ce1); 325| | // No tertiary CEs. 326| 742k| if((lower32_1 >> 16) == 0) { return false; } ------------------ | Branch (326:12): [True: 259, False: 742k] ------------------ 327| | // We support non-common secondary and case weights 328| | // only for secondary CEs or together with short primaries. 329| 742k| if(p1 != 0 && p1 < firstShortPrimary) { ------------------ | Branch (329:12): [True: 77.0k, False: 664k] | Branch (329:23): [True: 19.2k, False: 57.7k] ------------------ 330| 19.2k| uint32_t sc1 = lower32_1 & Collation::SECONDARY_AND_CASE_MASK; 331| 19.2k| if(sc1 != Collation::COMMON_SECONDARY_CE) { return false; } ------------------ | Branch (331:16): [True: 343, False: 18.9k] ------------------ 332| 19.2k| } 333| | // No below-common tertiary weights. 334| 741k| if((lower32_1 & Collation::ONLY_TERTIARY_MASK) < Collation::COMMON_WEIGHT16) { return false; } ------------------ | Branch (334:12): [True: 162, False: 741k] ------------------ 335| 741k| } 336| | // No quaternary weights. 337| 1.47M| if(((ce0 | ce1) & Collation::QUATERNARY_MASK) != 0) { return false; } ------------------ | Branch (337:8): [True: 36, False: 1.47M] ------------------ 338| 1.47M| return true; 339| 1.47M|} _ZN6icu_7825CollationFastLatinBuilder25getCEsFromContractionCE32ERKNS_13CollationDataEjR10UErrorCode: 343| 6.95k| UErrorCode &errorCode) { 344| 6.95k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (344:8): [True: 0, False: 6.95k] ------------------ 345| 6.95k| const char16_t *p = data.contexts + Collation::indexFromCE32(ce32); 346| 6.95k| ce32 = CollationData::readCE32(p); // Default if no suffix match. 347| | // Since the original ce32 is not a prefix mapping, 348| | // the default ce32 must not be another contraction. 349| 6.95k| U_ASSERT(!Collation::isContractionCE32(ce32)); ------------------ | | 35| 6.95k|# define U_ASSERT(exp) (void)0 ------------------ 350| 6.95k| int32_t contractionIndex = contractionCEs.size(); 351| 6.95k| if(getCEsFromCE32(data, U_SENTINEL, ce32, errorCode)) { ------------------ | | 469| 6.95k|#define U_SENTINEL (-1) ------------------ | Branch (351:8): [True: 6.17k, False: 781] ------------------ 352| 6.17k| addContractionEntry(CollationFastLatin::CONTR_CHAR_MASK, ce0, ce1, errorCode); 353| 6.17k| } else { 354| | // Bail out for c-without-contraction. 355| 781| addContractionEntry(CollationFastLatin::CONTR_CHAR_MASK, Collation::NO_CE, 0, errorCode); 356| 781| } 357| | // Handle an encodable contraction unless the next contraction is too long 358| | // and starts with the same character. 359| 6.95k| int32_t prevX = -1; 360| 6.95k| UBool addContraction = false; 361| 6.95k| UCharsTrie::Iterator suffixes(p + 2, 0, errorCode); 362| 93.5k| while(suffixes.next(errorCode)) { ------------------ | Branch (362:11): [True: 86.6k, False: 6.95k] ------------------ 363| 86.6k| const UnicodeString &suffix = suffixes.getString(); 364| 86.6k| int32_t x = CollationFastLatin::getCharIndex(suffix.charAt(0)); 365| 86.6k| if(x < 0) { continue; } // ignore anything but fast Latin text ------------------ | Branch (365:12): [True: 62.7k, False: 23.8k] ------------------ 366| 23.8k| if(x == prevX) { ------------------ | Branch (366:12): [True: 11.5k, False: 12.3k] ------------------ 367| 11.5k| if(addContraction) { ------------------ | Branch (367:16): [True: 49, False: 11.4k] ------------------ 368| | // Bail out for all contractions starting with this character. 369| 49| addContractionEntry(x, Collation::NO_CE, 0, errorCode); 370| 49| addContraction = false; 371| 49| } 372| 11.5k| continue; 373| 11.5k| } 374| 12.3k| if(addContraction) { ------------------ | Branch (374:12): [True: 6.81k, False: 5.48k] ------------------ 375| 6.81k| addContractionEntry(prevX, ce0, ce1, errorCode); 376| 6.81k| } 377| 12.3k| ce32 = static_cast(suffixes.getValue()); 378| 12.3k| if(suffix.length() == 1 && getCEsFromCE32(data, U_SENTINEL, ce32, errorCode)) { ------------------ | | 469| 11.2k|#define U_SENTINEL (-1) ------------------ | Branch (378:12): [True: 11.2k, False: 1.09k] | Branch (378:36): [True: 8.42k, False: 2.78k] ------------------ 379| 8.42k| addContraction = true; 380| 8.42k| } else { 381| 3.88k| addContractionEntry(x, Collation::NO_CE, 0, errorCode); 382| 3.88k| addContraction = false; 383| 3.88k| } 384| 12.3k| prevX = x; 385| 12.3k| } 386| 6.95k| if(addContraction) { ------------------ | Branch (386:8): [True: 1.55k, False: 5.39k] ------------------ 387| 1.55k| addContractionEntry(prevX, ce0, ce1, errorCode); 388| 1.55k| } 389| 6.95k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (389:8): [True: 0, False: 6.95k] ------------------ 390| | // Note: There might not be any fast Latin contractions, but 391| | // we need to enter contraction handling anyway so that we can bail out 392| | // when there is a non-fast-Latin character following. 393| | // For example: Danish &Y<(Collation::NO_CE_PRIMARY) << 32) | CONTRACTION_FLAG | contractionIndex; 396| 6.95k| ce1 = 0; 397| 6.95k| return true; 398| 6.95k|} _ZN6icu_7825CollationFastLatinBuilder19addContractionEntryEillR10UErrorCode: 402| 23.0k| UErrorCode &errorCode) { 403| 23.0k| contractionCEs.addElement(x, errorCode); 404| 23.0k| contractionCEs.addElement(cce0, errorCode); 405| 23.0k| contractionCEs.addElement(cce1, errorCode); 406| 23.0k| addUniqueCE(cce0, errorCode); 407| 23.0k| addUniqueCE(cce1, errorCode); 408| 23.0k|} _ZN6icu_7825CollationFastLatinBuilder11addUniqueCEElR10UErrorCode: 411| 3.52M|CollationFastLatinBuilder::addUniqueCE(int64_t ce, UErrorCode &errorCode) { 412| 3.52M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (412:8): [True: 0, False: 3.52M] ------------------ 413| 3.52M| if (ce == 0 || static_cast(ce >> 32) == Collation::NO_CE_PRIMARY) { return; } ------------------ | Branch (413:9): [True: 1.29M, False: 2.22M] | Branch (413:20): [True: 12.0k, False: 2.21M] ------------------ 414| 2.21M| ce &= ~static_cast(Collation::CASE_MASK); // blank out case bits 415| 2.21M| int32_t i = binarySearch(uniqueCEs.getBuffer(), uniqueCEs.size(), ce); 416| 2.21M| if(i < 0) { ------------------ | Branch (416:8): [True: 836k, False: 1.37M] ------------------ 417| 836k| uniqueCEs.insertElementAt(ce, ~i, errorCode); 418| 836k| } 419| 2.21M|} _ZNK6icu_7825CollationFastLatinBuilder9getMiniCEEl: 422| 1.98M|CollationFastLatinBuilder::getMiniCE(int64_t ce) const { 423| 1.98M| ce &= ~static_cast(Collation::CASE_MASK); // blank out case bits 424| 1.98M| int32_t index = binarySearch(uniqueCEs.getBuffer(), uniqueCEs.size(), ce); 425| 1.98M| U_ASSERT(index >= 0); ------------------ | | 35| 1.98M|# define U_ASSERT(exp) (void)0 ------------------ 426| 1.98M| return miniCEs[index]; 427| 1.98M|} _ZN6icu_7825CollationFastLatinBuilder15encodeUniqueCEsER10UErrorCode: 430| 4.17k|CollationFastLatinBuilder::encodeUniqueCEs(UErrorCode &errorCode) { 431| 4.17k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (431:8): [True: 0, False: 4.17k] ------------------ 432| 4.17k| uprv_free(miniCEs); ------------------ | | 1503| 4.17k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 4.17k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.17k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.17k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 433| 4.17k| miniCEs = static_cast(uprv_malloc(uniqueCEs.size() * 2)); ------------------ | | 1524| 4.17k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4.17k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.17k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.17k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 434| 4.17k| if(miniCEs == nullptr) { ------------------ | Branch (434:8): [True: 0, False: 4.17k] ------------------ 435| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 436| 0| return false; 437| 0| } 438| 4.17k| int32_t group = 0; 439| 4.17k| uint32_t lastGroupPrimary = lastSpecialPrimaries[group]; 440| | // The lowest unique CE must be at least a secondary CE. 441| 4.17k| U_ASSERT(((uint32_t)uniqueCEs.elementAti(0) >> 16) != 0); ------------------ | | 35| 4.17k|# define U_ASSERT(exp) (void)0 ------------------ 442| 4.17k| uint32_t prevPrimary = 0; 443| 4.17k| uint32_t prevSecondary = 0; 444| 4.17k| uint32_t pri = 0; 445| 4.17k| uint32_t sec = 0; 446| 4.17k| uint32_t ter = CollationFastLatin::COMMON_TER; 447| 840k| for(int32_t i = 0; i < uniqueCEs.size(); ++i) { ------------------ | Branch (447:24): [True: 836k, False: 4.17k] ------------------ 448| 836k| int64_t ce = uniqueCEs.elementAti(i); 449| | // Note: At least one of the p/s/t weights changes from one unique CE to the next. 450| | // (uniqueCEs does not store case bits.) 451| 836k| uint32_t p = static_cast(ce >> 32); 452| 836k| if(p != prevPrimary) { ------------------ | Branch (452:12): [True: 549k, False: 286k] ------------------ 453| 562k| while(p > lastGroupPrimary) { ------------------ | Branch (453:19): [True: 16.6k, False: 545k] ------------------ 454| 16.6k| U_ASSERT(pri <= CollationFastLatin::MAX_LONG); ------------------ | | 35| 16.6k|# define U_ASSERT(exp) (void)0 ------------------ 455| | // Set the group's header entry to the 456| | // last "long primary" in or before the group. 457| 16.6k| result.setCharAt(1 + group, static_cast(pri)); 458| 16.6k| if(++group < NUM_SPECIAL_GROUPS) { ------------------ | Branch (458:20): [True: 12.5k, False: 4.17k] ------------------ 459| 12.5k| lastGroupPrimary = lastSpecialPrimaries[group]; 460| 12.5k| } else { 461| 4.17k| lastGroupPrimary = 0xffffffff; 462| 4.17k| break; 463| 4.17k| } 464| 16.6k| } 465| 549k| if(p < firstShortPrimary) { ------------------ | Branch (465:16): [True: 341k, False: 208k] ------------------ 466| 341k| if(pri == 0) { ------------------ | Branch (466:20): [True: 4.17k, False: 337k] ------------------ 467| 4.17k| pri = CollationFastLatin::MIN_LONG; 468| 337k| } else if(pri < CollationFastLatin::MAX_LONG) { ------------------ | Branch (468:27): [True: 335k, False: 1.89k] ------------------ 469| 335k| pri += CollationFastLatin::LONG_INC; 470| 335k| } else { 471| |#if DEBUG_COLLATION_FAST_LATIN_BUILDER 472| | printf("long-primary overflow for %08x\n", p); 473| |#endif 474| 1.89k| miniCEs[i] = CollationFastLatin::BAIL_OUT; 475| 1.89k| continue; 476| 1.89k| } 477| 341k| } else { 478| 208k| if(pri < CollationFastLatin::MIN_SHORT) { ------------------ | Branch (478:20): [True: 4.17k, False: 204k] ------------------ 479| 4.17k| pri = CollationFastLatin::MIN_SHORT; 480| 204k| } else if(pri < (CollationFastLatin::MAX_SHORT - CollationFastLatin::SHORT_INC)) { ------------------ | Branch (480:27): [True: 173k, False: 30.1k] ------------------ 481| | // Reserve the highest primary weight for U+FFFF. 482| 173k| pri += CollationFastLatin::SHORT_INC; 483| 173k| } else { 484| |#if DEBUG_COLLATION_FAST_LATIN_BUILDER 485| | printf("short-primary overflow for %08x\n", p); 486| |#endif 487| 30.1k| shortPrimaryOverflow = true; 488| 30.1k| miniCEs[i] = CollationFastLatin::BAIL_OUT; 489| 30.1k| continue; 490| 30.1k| } 491| 208k| } 492| 517k| prevPrimary = p; 493| 517k| prevSecondary = Collation::COMMON_WEIGHT16; 494| 517k| sec = CollationFastLatin::COMMON_SEC; 495| 517k| ter = CollationFastLatin::COMMON_TER; 496| 517k| } 497| 804k| uint32_t lower32 = static_cast(ce); 498| 804k| uint32_t s = lower32 >> 16; 499| 804k| if(s != prevSecondary) { ------------------ | Branch (499:12): [True: 90.0k, False: 714k] ------------------ 500| 90.0k| if(pri == 0) { ------------------ | Branch (500:16): [True: 64.8k, False: 25.1k] ------------------ 501| 64.8k| if(sec == 0) { ------------------ | Branch (501:20): [True: 4.17k, False: 60.6k] ------------------ 502| 4.17k| sec = CollationFastLatin::MIN_SEC_HIGH; 503| 60.6k| } else if(sec < CollationFastLatin::MAX_SEC_HIGH) { ------------------ | Branch (503:27): [True: 59.6k, False: 1.04k] ------------------ 504| 59.6k| sec += CollationFastLatin::SEC_INC; 505| 59.6k| } else { 506| 1.04k| miniCEs[i] = CollationFastLatin::BAIL_OUT; 507| 1.04k| continue; 508| 1.04k| } 509| 63.8k| prevSecondary = s; 510| 63.8k| ter = CollationFastLatin::COMMON_TER; 511| 63.8k| } else if(s < Collation::COMMON_WEIGHT16) { ------------------ | Branch (511:23): [True: 0, False: 25.1k] ------------------ 512| 0| if(sec == CollationFastLatin::COMMON_SEC) { ------------------ | Branch (512:20): [True: 0, False: 0] ------------------ 513| 0| sec = CollationFastLatin::MIN_SEC_BEFORE; 514| 0| } else if(sec < CollationFastLatin::MAX_SEC_BEFORE) { ------------------ | Branch (514:27): [True: 0, False: 0] ------------------ 515| 0| sec += CollationFastLatin::SEC_INC; 516| 0| } else { 517| 0| miniCEs[i] = CollationFastLatin::BAIL_OUT; 518| 0| continue; 519| 0| } 520| 25.1k| } else if(s == Collation::COMMON_WEIGHT16) { ------------------ | Branch (520:23): [True: 0, False: 25.1k] ------------------ 521| 0| sec = CollationFastLatin::COMMON_SEC; 522| 25.1k| } else { 523| 25.1k| if(sec < CollationFastLatin::MIN_SEC_AFTER) { ------------------ | Branch (523:20): [True: 16.2k, False: 8.94k] ------------------ 524| 16.2k| sec = CollationFastLatin::MIN_SEC_AFTER; 525| 16.2k| } else if(sec < CollationFastLatin::MAX_SEC_AFTER) { ------------------ | Branch (525:27): [True: 4.60k, False: 4.34k] ------------------ 526| 4.60k| sec += CollationFastLatin::SEC_INC; 527| 4.60k| } else { 528| 4.34k| miniCEs[i] = CollationFastLatin::BAIL_OUT; 529| 4.34k| continue; 530| 4.34k| } 531| 25.1k| } 532| 84.6k| prevSecondary = s; 533| 84.6k| ter = CollationFastLatin::COMMON_TER; 534| 84.6k| } 535| 798k| U_ASSERT((lower32 & Collation::CASE_MASK) == 0); // blanked out in uniqueCEs ------------------ | | 35| 798k|# define U_ASSERT(exp) (void)0 ------------------ 536| 798k| uint32_t t = lower32 & Collation::ONLY_TERTIARY_MASK; 537| 798k| if(t > Collation::COMMON_WEIGHT16) { ------------------ | Branch (537:12): [True: 206k, False: 592k] ------------------ 538| 206k| if(ter < CollationFastLatin::MAX_TER_AFTER) { ------------------ | Branch (538:16): [True: 204k, False: 1.79k] ------------------ 539| 204k| ++ter; 540| 204k| } else { 541| 1.79k| miniCEs[i] = CollationFastLatin::BAIL_OUT; 542| 1.79k| continue; 543| 1.79k| } 544| 206k| } 545| 796k| if(CollationFastLatin::MIN_LONG <= pri && pri <= CollationFastLatin::MAX_LONG) { ------------------ | Branch (545:12): [True: 733k, False: 63.8k] | Branch (545:51): [True: 366k, False: 366k] ------------------ 546| 366k| U_ASSERT(sec == CollationFastLatin::COMMON_SEC); ------------------ | | 35| 366k|# define U_ASSERT(exp) (void)0 ------------------ 547| 366k| miniCEs[i] = static_cast(pri | ter); 548| 429k| } else { 549| 429k| miniCEs[i] = static_cast(pri | sec | ter); 550| 429k| } 551| 796k| } 552| |#if DEBUG_COLLATION_FAST_LATIN_BUILDER 553| | printf("last mini primary: %04x\n", pri); 554| |#endif 555| |#if DEBUG_COLLATION_FAST_LATIN_BUILDER >= 2 556| | for(int32_t i = 0; i < uniqueCEs.size(); ++i) { 557| | int64_t ce = uniqueCEs.elementAti(i); 558| | printf("unique CE 0x%016lx -> 0x%04x\n", ce, miniCEs[i]); 559| | } 560| |#endif 561| 4.17k| return U_SUCCESS(errorCode); 562| 4.17k|} _ZN6icu_7825CollationFastLatinBuilder13encodeCharCEsER10UErrorCode: 565| 3.76k|CollationFastLatinBuilder::encodeCharCEs(UErrorCode &errorCode) { 566| 3.76k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (566:8): [True: 0, False: 3.76k] ------------------ 567| 3.76k| int32_t miniCEsStart = result.length(); 568| 1.69M| for(int32_t i = 0; i < CollationFastLatin::NUM_FAST_CHARS; ++i) { ------------------ | Branch (568:24): [True: 1.68M, False: 3.76k] ------------------ 569| 1.68M| result.append(static_cast(0)); // initialize to completely ignorable 570| 1.68M| } 571| 3.76k| int32_t indexBase = result.length(); 572| 1.69M| for(int32_t i = 0; i < CollationFastLatin::NUM_FAST_CHARS; ++i) { ------------------ | Branch (572:24): [True: 1.68M, False: 3.76k] ------------------ 573| 1.68M| int64_t ce = charCEs[i][0]; 574| 1.68M| if(isContractionCharCE(ce)) { continue; } // defer contraction ------------------ | Branch (574:12): [True: 9.08k, False: 1.67M] ------------------ 575| 1.67M| uint32_t miniCE = encodeTwoCEs(ce, charCEs[i][1]); 576| 1.67M| if(miniCE > 0xffff) { ------------------ | Branch (576:12): [True: 58.7k, False: 1.61M] ------------------ 577| | // Note: There is a chance that this new expansion is the same as a previous one, 578| | // and if so, then we could reuse the other expansion. 579| | // However, that seems unlikely. 580| 58.7k| int32_t expansionIndex = result.length() - indexBase; 581| 58.7k| if (expansionIndex > static_cast(CollationFastLatin::INDEX_MASK)) { ------------------ | Branch (581:17): [True: 0, False: 58.7k] ------------------ 582| 0| miniCE = CollationFastLatin::BAIL_OUT; 583| 58.7k| } else { 584| 58.7k| result.append(static_cast(miniCE >> 16)).append(static_cast(miniCE)); 585| 58.7k| miniCE = CollationFastLatin::EXPANSION | expansionIndex; 586| 58.7k| } 587| 58.7k| } 588| 1.67M| result.setCharAt(miniCEsStart + i, static_cast(miniCE)); 589| 1.67M| } 590| 3.76k| return U_SUCCESS(errorCode); 591| 3.76k|} _ZN6icu_7825CollationFastLatinBuilder18encodeContractionsER10UErrorCode: 594| 3.76k|CollationFastLatinBuilder::encodeContractions(UErrorCode &errorCode) { 595| | // We encode all contraction lists so that the first word of a list 596| | // terminates the previous list, and we only need one additional terminator at the end. 597| 3.76k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (597:8): [True: 0, False: 3.76k] ------------------ 598| 3.76k| int32_t indexBase = headerLength + CollationFastLatin::NUM_FAST_CHARS; 599| 3.76k| int32_t firstContractionIndex = result.length(); 600| 1.69M| for(int32_t i = 0; i < CollationFastLatin::NUM_FAST_CHARS; ++i) { ------------------ | Branch (600:24): [True: 1.68M, False: 3.76k] ------------------ 601| 1.68M| int64_t ce = charCEs[i][0]; 602| 1.68M| if(!isContractionCharCE(ce)) { continue; } ------------------ | Branch (602:12): [True: 1.67M, False: 9.08k] ------------------ 603| 9.08k| int32_t contractionIndex = result.length() - indexBase; 604| 9.08k| if (contractionIndex > static_cast(CollationFastLatin::INDEX_MASK)) { ------------------ | Branch (604:13): [True: 0, False: 9.08k] ------------------ 605| 0| result.setCharAt(headerLength + i, CollationFastLatin::BAIL_OUT); 606| 0| continue; 607| 0| } 608| 9.08k| UBool firstTriple = true; 609| 28.2k| for (int32_t index = static_cast(ce) & 0x7fffffff;; index += 3) { 610| 28.2k| int32_t x = static_cast(contractionCEs.elementAti(index)); 611| 28.2k| if (static_cast(x) == CollationFastLatin::CONTR_CHAR_MASK && !firstTriple) { break; } ------------------ | Branch (611:17): [True: 18.1k, False: 10.0k] | Branch (611:84): [True: 9.08k, False: 9.08k] ------------------ 612| 19.1k| int64_t cce0 = contractionCEs.elementAti(index + 1); 613| 19.1k| int64_t cce1 = contractionCEs.elementAti(index + 2); 614| 19.1k| uint32_t miniCE = encodeTwoCEs(cce0, cce1); 615| 19.1k| if(miniCE == CollationFastLatin::BAIL_OUT) { ------------------ | Branch (615:16): [True: 4.74k, False: 14.3k] ------------------ 616| 4.74k| result.append(static_cast(x | (1 << CollationFastLatin::CONTR_LENGTH_SHIFT))); 617| 14.3k| } else if(miniCE <= 0xffff) { ------------------ | Branch (617:23): [True: 13.2k, False: 1.10k] ------------------ 618| 13.2k| result.append(static_cast(x | (2 << CollationFastLatin::CONTR_LENGTH_SHIFT))); 619| 13.2k| result.append(static_cast(miniCE)); 620| 13.2k| } else { 621| 1.10k| result.append(static_cast(x | (3 << CollationFastLatin::CONTR_LENGTH_SHIFT))); 622| 1.10k| result.append(static_cast(miniCE >> 16)).append(static_cast(miniCE)); 623| 1.10k| } 624| 19.1k| firstTriple = false; 625| 19.1k| } 626| | // Note: There is a chance that this new contraction list is the same as a previous one, 627| | // and if so, then we could truncate the result and reuse the other list. 628| | // However, that seems unlikely. 629| 9.08k| result.setCharAt(headerLength + i, 630| 9.08k| static_cast(CollationFastLatin::CONTRACTION | contractionIndex)); 631| 9.08k| } 632| 3.76k| if(result.length() > firstContractionIndex) { ------------------ | Branch (632:8): [True: 3.76k, False: 0] ------------------ 633| | // Terminate the last contraction list. 634| 3.76k| result.append(static_cast(CollationFastLatin::CONTR_CHAR_MASK)); 635| 3.76k| } 636| 3.76k| if(result.isBogus()) { ------------------ | Branch (636:8): [True: 0, False: 3.76k] ------------------ 637| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 638| 0| return false; 639| 0| } 640| |#if DEBUG_COLLATION_FAST_LATIN_BUILDER 641| | printf("** fast Latin %d * 2 = %d bytes\n", result.length(), result.length() * 2); 642| | puts(" header & below-digit groups map"); 643| | int32_t i = 0; 644| | for(; i < headerLength; ++i) { 645| | printf(" %04x", result[i]); 646| | } 647| | printf("\n char mini CEs"); 648| | U_ASSERT(CollationFastLatin::NUM_FAST_CHARS % 16 == 0); 649| | for(; i < indexBase; i += 16) { 650| | UChar32 c = i - headerLength; 651| | if(c >= CollationFastLatin::LATIN_LIMIT) { 652| | c = CollationFastLatin::PUNCT_START + c - CollationFastLatin::LATIN_LIMIT; 653| | } 654| | printf("\n %04x:", c); 655| | for(int32_t j = 0; j < 16; ++j) { 656| | printf(" %04x", result[i + j]); 657| | } 658| | } 659| | printf("\n expansions & contractions"); 660| | for(; i < result.length(); ++i) { 661| | if((i - indexBase) % 16 == 0) { puts(""); } 662| | printf(" %04x", result[i]); 663| | } 664| | puts(""); 665| |#endif 666| 3.76k| return true; 667| 3.76k|} _ZNK6icu_7825CollationFastLatinBuilder12encodeTwoCEsEll: 670| 1.69M|CollationFastLatinBuilder::encodeTwoCEs(int64_t first, int64_t second) const { 671| 1.69M| if(first == 0) { ------------------ | Branch (671:8): [True: 252k, False: 1.44M] ------------------ 672| 252k| return 0; // completely ignorable 673| 252k| } 674| 1.44M| if(first == Collation::NO_CE) { ------------------ | Branch (674:8): [True: 119k, False: 1.32M] ------------------ 675| 119k| return CollationFastLatin::BAIL_OUT; 676| 119k| } 677| 1.32M| U_ASSERT((uint32_t)(first >> 32) != Collation::NO_CE_PRIMARY); ------------------ | | 35| 1.32M|# define U_ASSERT(exp) (void)0 ------------------ 678| | 679| 1.32M| uint32_t miniCE = getMiniCE(first); 680| 1.32M| if(miniCE == CollationFastLatin::BAIL_OUT) { return miniCE; } ------------------ | Branch (680:8): [True: 9.50k, False: 1.31M] ------------------ 681| 1.31M| if(miniCE >= CollationFastLatin::MIN_SHORT) { ------------------ | Branch (681:8): [True: 927k, False: 388k] ------------------ 682| | // Extract & copy the case bits. 683| | // Shift them from normal CE bits 15..14 to mini CE bits 4..3. 684| 927k| uint32_t c = ((static_cast(first) & Collation::CASE_MASK) >> (14 - 3)); 685| | // Only in mini CEs: Ignorable case bits = 0, lowercase = 1. 686| 927k| c += CollationFastLatin::LOWER_CASE; 687| 927k| miniCE |= c; 688| 927k| } 689| 1.31M| if(second == 0) { return miniCE; } ------------------ | Branch (689:8): [True: 653k, False: 661k] ------------------ 690| | 691| 661k| uint32_t miniCE1 = getMiniCE(second); 692| 661k| if(miniCE1 == CollationFastLatin::BAIL_OUT) { return miniCE1; } ------------------ | Branch (692:8): [True: 2.86k, False: 658k] ------------------ 693| | 694| 658k| uint32_t case1 = static_cast(second) & Collation::CASE_MASK; 695| 658k| if(miniCE >= CollationFastLatin::MIN_SHORT && ------------------ | Branch (695:8): [True: 642k, False: 16.6k] ------------------ 696| 658k| (miniCE & CollationFastLatin::SECONDARY_MASK) == CollationFastLatin::COMMON_SEC) { ------------------ | Branch (696:13): [True: 622k, False: 19.6k] ------------------ 697| | // Try to combine the two mini CEs into one. 698| 622k| uint32_t sec1 = miniCE1 & CollationFastLatin::SECONDARY_MASK; 699| 622k| uint32_t ter1 = miniCE1 & CollationFastLatin::TERTIARY_MASK; 700| 622k| if(sec1 >= CollationFastLatin::MIN_SEC_HIGH && case1 == 0 && ------------------ | Branch (700:12): [True: 599k, False: 23.1k] | Branch (700:56): [True: 599k, False: 0] ------------------ 701| 622k| ter1 == CollationFastLatin::COMMON_TER) { ------------------ | Branch (701:17): [True: 599k, False: 438] ------------------ 702| | // sec1>=sec_high implies pri1==0. 703| 599k| return (miniCE & ~CollationFastLatin::SECONDARY_MASK) | sec1; 704| 599k| } 705| 622k| } 706| | 707| 59.8k| if(miniCE1 <= CollationFastLatin::SECONDARY_MASK || CollationFastLatin::MIN_SHORT <= miniCE1) { ------------------ | Branch (707:8): [True: 1.48k, False: 58.3k] | Branch (707:57): [True: 41.6k, False: 16.6k] ------------------ 708| | // Secondary CE, or a CE with a short primary, copy the case bits. 709| 43.1k| case1 = (case1 >> (14 - 3)) + CollationFastLatin::LOWER_CASE; 710| 43.1k| miniCE1 |= case1; 711| 43.1k| } 712| 59.8k| return (miniCE << 16) | miniCE1; 713| 658k|} collationfastlatinbuilder.cpp:_ZN6icu_7812_GLOBAL__N_112binarySearchEPKlil: 65| 4.19M|binarySearch(const int64_t list[], int32_t limit, int64_t ce) { 66| 4.19M| if (limit == 0) { return ~0; } ------------------ | Branch (66:9): [True: 4.17k, False: 4.19M] ------------------ 67| 4.19M| int32_t start = 0; 68| 28.5M| for (;;) { 69| 28.5M| int32_t i = (start + limit) / 2; 70| 28.5M| int32_t cmp = compareInt64AsUnsigned(ce, list[i]); 71| 28.5M| if (cmp == 0) { ------------------ | Branch (71:13): [True: 3.36M, False: 25.1M] ------------------ 72| 3.36M| return i; 73| 25.1M| } else if (cmp < 0) { ------------------ | Branch (73:20): [True: 12.7M, False: 12.4M] ------------------ 74| 12.7M| if (i == start) { ------------------ | Branch (74:17): [True: 9.37k, False: 12.7M] ------------------ 75| 9.37k| return ~start; // insert ce before i 76| 9.37k| } 77| 12.7M| limit = i; 78| 12.7M| } else { 79| 12.4M| if (i == start) { ------------------ | Branch (79:17): [True: 822k, False: 11.6M] ------------------ 80| 822k| return ~(start + 1); // insert ce after i 81| 822k| } 82| 11.6M| start = i; 83| 11.6M| } 84| 28.5M| } 85| 4.19M|} collationfastlatinbuilder.cpp:_ZN6icu_7812_GLOBAL__N_122compareInt64AsUnsignedEll: 47| 28.5M|compareInt64AsUnsigned(int64_t a, int64_t b) { 48| 28.5M| if (static_cast(a) < static_cast(b)) { ------------------ | Branch (48:9): [True: 12.7M, False: 15.7M] ------------------ 49| 12.7M| return -1; 50| 15.7M| } else if (static_cast(a) > static_cast(b)) { ------------------ | Branch (50:16): [True: 12.4M, False: 3.36M] ------------------ 51| 12.4M| return 1; 52| 12.4M| } else { 53| 3.36M| return 0; 54| 3.36M| } 55| 28.5M|} _ZNK6icu_7825CollationFastLatinBuilder8getTableEv: 39| 3.76k| const uint16_t *getTable() const { 40| 3.76k| return reinterpret_cast(result.getBuffer()); 41| 3.76k| } _ZNK6icu_7825CollationFastLatinBuilder13lengthOfTableEv: 42| 3.76k| int32_t lengthOfTable() const { return result.length(); } _ZN6icu_7825CollationFastLatinBuilder19isContractionCharCEEl: 65| 3.37M| static UBool isContractionCharCE(int64_t ce) { 66| 3.37M| return static_cast(ce >> 32) == Collation::NO_CE_PRIMARY && ce != Collation::NO_CE; ------------------ | Branch (66:16): [True: 248k, False: 3.13M] | Branch (66:79): [True: 18.5k, False: 229k] ------------------ 67| 3.37M| } _ZN6icu_7812CollationFCD11mayHaveLcccEi: 83| 680k| static inline UBool mayHaveLccc(UChar32 c) { 84| | // Handles all of Unicode 0..10FFFF. 85| | // c can be negative, e.g., U_SENTINEL. 86| | // U+0300 is the first character with lccc!=0. 87| 680k| if(c < 0x300) { return false; } ------------------ | Branch (87:12): [True: 9.03k, False: 671k] ------------------ 88| 671k| if(c > 0xffff) { c = U16_LEAD(c); } ------------------ | | 123| 3.37k|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ | Branch (88:12): [True: 3.37k, False: 667k] ------------------ 89| 671k| int32_t i; 90| 671k| return 91| 671k| (i = lcccIndex[c >> 5]) != 0 && ------------------ | Branch (91:13): [True: 643k, False: 27.3k] ------------------ 92| 671k| (lcccBits[i] & (static_cast(1) << (c & 0x1f))) != 0; ------------------ | Branch (92:13): [True: 629k, False: 14.6k] ------------------ 93| 680k| } _ZN6icu_7812CollationFCD7hasLcccEi: 59| 36.2k| static inline UBool hasLccc(UChar32 c) { 60| | // assert c <= 0xffff 61| | // c can be negative, e.g., U_SENTINEL from UCharIterator; 62| | // that is handled in the first test. 63| 36.2k| int32_t i; 64| 36.2k| return 65| | // U+0300 is the first character with lccc!=0. 66| 36.2k| c >= 0x300 && ------------------ | Branch (66:13): [True: 28.8k, False: 7.43k] ------------------ 67| 36.2k| (i = lcccIndex[c >> 5]) != 0 && ------------------ | Branch (67:13): [True: 16.2k, False: 12.5k] ------------------ 68| 36.2k| (lcccBits[i] & (static_cast(1) << (c & 0x1f))) != 0; ------------------ | Branch (68:13): [True: 15.1k, False: 1.12k] ------------------ 69| 36.2k| } _ZN6icu_7812CollationFCD7hasTcccEi: 71| 272k| static inline UBool hasTccc(UChar32 c) { 72| | // assert c <= 0xffff 73| | // c can be negative, e.g., U_SENTINEL from UCharIterator; 74| | // that is handled in the first test. 75| 272k| int32_t i; 76| 272k| return 77| | // U+00C0 is the first character with tccc!=0. 78| 272k| c >= 0xc0 && ------------------ | Branch (78:13): [True: 179k, False: 93.3k] ------------------ 79| 272k| (i = tcccIndex[c >> 5]) != 0 && ------------------ | Branch (79:13): [True: 43.5k, False: 135k] ------------------ 80| 272k| (tcccBits[i] & (static_cast(1) << (c & 0x1f))) != 0; ------------------ | Branch (80:13): [True: 31.5k, False: 12.0k] ------------------ 81| 272k| } _ZN6icu_7812CollationFCD26maybeTibetanCompositeVowelEi: 106| 40.6k| static inline UBool maybeTibetanCompositeVowel(UChar32 c) { 107| 40.6k| return (c & 0x1fff01) == 0xf01; 108| 40.6k| } _ZN6icu_7812CollationFCD30isFCD16OfTibetanCompositeVowelEt: 121| 24.5k| static inline UBool isFCD16OfTibetanCompositeVowel(uint16_t fcd16) { 122| 24.5k| return fcd16 == 0x8182 || fcd16 == 0x8184; ------------------ | Branch (122:16): [True: 7.67k, False: 16.8k] | Branch (122:35): [True: 9.61k, False: 7.21k] ------------------ 123| 24.5k| } _ZN6icu_7817CollationIterator8CEBufferD2Ev: 34| 5.84M|CollationIterator::CEBuffer::~CEBuffer() {} _ZN6icu_7817CollationIterator8CEBuffer20ensureAppendCapacityEiR10UErrorCode: 37| 8.52M|CollationIterator::CEBuffer::ensureAppendCapacity(int32_t appCap, UErrorCode &errorCode) { 38| 8.52M| int32_t capacity = buffer.getCapacity(); 39| 8.52M| if((length + appCap) <= capacity) { return true; } ------------------ | Branch (39:8): [True: 8.52M, False: 1.73k] ------------------ 40| 1.73k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (40:8): [True: 0, False: 1.73k] ------------------ 41| 1.73k| do { 42| 1.73k| if(capacity < 1000) { ------------------ | Branch (42:12): [True: 1.69k, False: 42] ------------------ 43| 1.69k| capacity *= 4; 44| 1.69k| } else { 45| 42| capacity *= 2; 46| 42| } 47| 1.73k| } while(capacity < (length + appCap)); ------------------ | Branch (47:13): [True: 0, False: 1.73k] ------------------ 48| 1.73k| int64_t *p = buffer.resize(capacity, length); 49| 1.73k| if(p == nullptr) { ------------------ | Branch (49:8): [True: 0, False: 1.73k] ------------------ 50| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 51| 0| return false; 52| 0| } 53| 1.73k| return true; 54| 1.73k|} _ZN6icu_7817CollationIteratorD2Ev: 167| 5.84M|CollationIterator::~CollationIterator() { 168| 5.84M| delete skipped; 169| 5.84M|} _ZN6icu_7817CollationIterator5resetEv: 192| 26.5M|CollationIterator::reset() { 193| 26.5M| cesIndex = ceBuffer.length = 0; 194| 26.5M| if(skipped != nullptr) { skipped->clear(); } ------------------ | Branch (194:8): [True: 6.65M, False: 19.8M] ------------------ 195| 26.5M|} _ZN6icu_7817CollationIterator8fetchCEsER10UErrorCode: 198| 5.82M|CollationIterator::fetchCEs(UErrorCode &errorCode) { 199| 11.8M| while(U_SUCCESS(errorCode) && nextCE(errorCode) != Collation::NO_CE) { ------------------ | Branch (199:11): [True: 11.8M, False: 0] | Branch (199:35): [True: 6.06M, False: 5.82M] ------------------ 200| | // No need to loop for each expansion CE. 201| 6.06M| cesIndex = ceBuffer.length; 202| 6.06M| } 203| 5.82M| return ceBuffer.length; 204| 5.82M|} _ZN6icu_7817CollationIterator18foundNULTerminatorEv: 218| 291k|CollationIterator::foundNULTerminator() { 219| 291k| return false; 220| 291k|} _ZNK6icu_7817CollationIterator25forbidSurrogateCodePointsEv: 223| 5.80k|CollationIterator::forbidSurrogateCodePoints() const { 224| 5.80k| return false; 225| 5.80k|} _ZNK6icu_7817CollationIterator11getDataCE32Ei: 228| 60.0k|CollationIterator::getDataCE32(UChar32 c) const { 229| 60.0k| return data->getCE32(c); 230| 60.0k|} _ZN6icu_7817CollationIterator14nextCEFromCE32EPKNS_13CollationDataEijR10UErrorCode: 240| 3.29M| UErrorCode &errorCode) { 241| 3.29M| --ceBuffer.length; // Undo ceBuffer.incLength(). 242| 3.29M| appendCEsFromCE32(d, c, ce32, true, errorCode); 243| 3.29M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (243:8): [True: 3.29M, False: 0] ------------------ 244| 3.29M| return ceBuffer.get(cesIndex++); 245| 3.29M| } else { 246| 0| return Collation::NO_CE_PRIMARY; 247| 0| } 248| 3.29M|} _ZN6icu_7817CollationIterator17appendCEsFromCE32EPKNS_13CollationDataEijaR10UErrorCode: 252| 48.8M| UBool forward, UErrorCode &errorCode) { 253| 55.9M| while(Collation::isSpecialCE32(ce32)) { ------------------ | Branch (253:11): [True: 35.0M, False: 20.9M] ------------------ 254| 35.0M| switch(Collation::tagFromCE32(ce32)) { ------------------ | Branch (254:16): [True: 0, False: 35.0M] ------------------ 255| 0| case Collation::FALLBACK_TAG: ------------------ | Branch (255:9): [True: 0, False: 35.0M] ------------------ 256| 0| case Collation::RESERVED_TAG_3: ------------------ | Branch (256:9): [True: 0, False: 35.0M] ------------------ 257| 0| if(U_SUCCESS(errorCode)) { errorCode = U_INTERNAL_PROGRAM_ERROR; } ------------------ | Branch (257:16): [True: 0, False: 0] ------------------ 258| 0| return; 259| 11.2M| case Collation::LONG_PRIMARY_TAG: ------------------ | Branch (259:9): [True: 11.2M, False: 23.7M] ------------------ 260| 11.2M| ceBuffer.append(Collation::ceFromLongPrimaryCE32(ce32), errorCode); 261| 11.2M| return; 262| 378k| case Collation::LONG_SECONDARY_TAG: ------------------ | Branch (262:9): [True: 378k, False: 34.6M] ------------------ 263| 378k| ceBuffer.append(Collation::ceFromLongSecondaryCE32(ce32), errorCode); 264| 378k| return; 265| 1.84M| case Collation::LATIN_EXPANSION_TAG: ------------------ | Branch (265:9): [True: 1.84M, False: 33.1M] ------------------ 266| 1.84M| if(ceBuffer.ensureAppendCapacity(2, errorCode)) { ------------------ | Branch (266:16): [True: 1.84M, False: 0] ------------------ 267| 1.84M| ceBuffer.set(ceBuffer.length, Collation::latinCE0FromCE32(ce32)); 268| 1.84M| ceBuffer.set(ceBuffer.length + 1, Collation::latinCE1FromCE32(ce32)); 269| 1.84M| ceBuffer.length += 2; 270| 1.84M| } 271| 1.84M| return; 272| 5.72M| case Collation::EXPANSION32_TAG: { ------------------ | Branch (272:9): [True: 5.72M, False: 29.3M] ------------------ 273| 5.72M| const uint32_t *ce32s = d->ce32s + Collation::indexFromCE32(ce32); 274| 5.72M| int32_t length = Collation::lengthFromCE32(ce32); 275| 5.72M| if(ceBuffer.ensureAppendCapacity(length, errorCode)) { ------------------ | Branch (275:16): [True: 5.72M, False: 0] ------------------ 276| 17.1M| do { 277| 17.1M| ceBuffer.appendUnsafe(Collation::ceFromCE32(*ce32s++)); 278| 17.1M| } while(--length > 0); ------------------ | Branch (278:25): [True: 11.4M, False: 5.72M] ------------------ 279| 5.72M| } 280| 5.72M| return; 281| 0| } 282| 706k| case Collation::EXPANSION_TAG: { ------------------ | Branch (282:9): [True: 706k, False: 34.3M] ------------------ 283| 706k| const int64_t *ces = d->ces + Collation::indexFromCE32(ce32); 284| 706k| int32_t length = Collation::lengthFromCE32(ce32); 285| 706k| if(ceBuffer.ensureAppendCapacity(length, errorCode)) { ------------------ | Branch (285:16): [True: 706k, False: 0] ------------------ 286| 11.2M| do { 287| 11.2M| ceBuffer.appendUnsafe(*ces++); 288| 11.2M| } while(--length > 0); ------------------ | Branch (288:25): [True: 10.5M, False: 706k] ------------------ 289| 706k| } 290| 706k| return; 291| 0| } 292| 2.65M| case Collation::BUILDER_DATA_TAG: ------------------ | Branch (292:9): [True: 2.65M, False: 32.3M] ------------------ 293| 2.65M| ce32 = getCE32FromBuilderData(ce32, errorCode); 294| 2.65M| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (294:16): [True: 0, False: 2.65M] ------------------ 295| 2.65M| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (295:16): [True: 723k, False: 1.93M] ------------------ 296| 723k| d = data->base; 297| 723k| ce32 = d->getCE32(c); 298| 723k| } 299| 2.65M| break; 300| 687k| case Collation::PREFIX_TAG: ------------------ | Branch (300:9): [True: 687k, False: 34.3M] ------------------ 301| 687k| if(forward) { backwardNumCodePoints(1, errorCode); } ------------------ | Branch (301:16): [True: 687k, False: 0] ------------------ 302| 687k| ce32 = getCE32FromPrefix(d, ce32, errorCode); 303| 687k| if(forward) { forwardNumCodePoints(1, errorCode); } ------------------ | Branch (303:16): [True: 687k, False: 0] ------------------ 304| 687k| break; 305| 2.39M| case Collation::CONTRACTION_TAG: { ------------------ | Branch (305:9): [True: 2.39M, False: 32.6M] ------------------ 306| 2.39M| const char16_t *p = d->contexts + Collation::indexFromCE32(ce32); 307| 2.39M| uint32_t defaultCE32 = CollationData::readCE32(p); // Default if no suffix match. 308| 2.39M| if(!forward) { ------------------ | Branch (308:16): [True: 0, False: 2.39M] ------------------ 309| | // Backward contractions are handled by previousCEUnsafe(). 310| | // c has contractions but they were not found. 311| 0| ce32 = defaultCE32; 312| 0| break; 313| 0| } 314| 2.39M| UChar32 nextCp; 315| 2.39M| if(skipped == nullptr && numCpFwd < 0) { ------------------ | Branch (315:16): [True: 1.45M, False: 938k] | Branch (315:38): [True: 1.45M, False: 0] ------------------ 316| | // Some portion of nextCE32FromContraction() pulled out here as an ASCII fast path, 317| | // avoiding the function call and the nextSkippedCodePoint() overhead. 318| 1.45M| nextCp = nextCodePoint(errorCode); 319| 1.45M| if(nextCp < 0) { ------------------ | Branch (319:20): [True: 115k, False: 1.34M] ------------------ 320| | // No more text. 321| 115k| ce32 = defaultCE32; 322| 115k| break; 323| 1.34M| } else if((ce32 & Collation::CONTRACT_NEXT_CCC) != 0 && ------------------ | Branch (323:27): [True: 275k, False: 1.06M] ------------------ 324| 1.34M| !CollationFCD::mayHaveLccc(nextCp)) { ------------------ | Branch (324:25): [True: 23.3k, False: 252k] ------------------ 325| | // All contraction suffixes start with characters with lccc!=0 326| | // but the next code point has lccc==0. 327| 23.3k| backwardNumCodePoints(1, errorCode); 328| 23.3k| ce32 = defaultCE32; 329| 23.3k| break; 330| 23.3k| } 331| 1.45M| } else { 332| 938k| nextCp = nextSkippedCodePoint(errorCode); 333| 938k| if(nextCp < 0) { ------------------ | Branch (333:20): [True: 62.2k, False: 876k] ------------------ 334| | // No more text. 335| 62.2k| ce32 = defaultCE32; 336| 62.2k| break; 337| 876k| } else if((ce32 & Collation::CONTRACT_NEXT_CCC) != 0 && ------------------ | Branch (337:27): [True: 404k, False: 472k] ------------------ 338| 876k| !CollationFCD::mayHaveLccc(nextCp)) { ------------------ | Branch (338:25): [True: 27.7k, False: 376k] ------------------ 339| | // All contraction suffixes start with characters with lccc!=0 340| | // but the next code point has lccc==0. 341| 27.7k| backwardNumSkipped(1, errorCode); 342| 27.7k| ce32 = defaultCE32; 343| 27.7k| break; 344| 27.7k| } 345| 938k| } 346| 2.16M| ce32 = nextCE32FromContraction(d, ce32, p + 2, defaultCE32, nextCp, errorCode); 347| 2.16M| if(ce32 == Collation::NO_CE32) { ------------------ | Branch (347:16): [True: 39.9k, False: 2.12M] ------------------ 348| | // CEs from a discontiguous contraction plus the skipped combining marks 349| | // have been appended already. 350| 39.9k| return; 351| 39.9k| } 352| 2.12M| break; 353| 2.16M| } 354| 2.12M| case Collation::DIGIT_TAG: ------------------ | Branch (354:9): [True: 83.8k, False: 34.9M] ------------------ 355| 83.8k| if(isNumeric) { ------------------ | Branch (355:16): [True: 0, False: 83.8k] ------------------ 356| 0| appendNumericCEs(ce32, forward, errorCode); 357| 0| return; 358| 83.8k| } else { 359| | // Fetch the non-numeric-collation CE32 and continue. 360| 83.8k| ce32 = d->ce32s[Collation::indexFromCE32(ce32)]; 361| 83.8k| break; 362| 83.8k| } 363| 353k| case Collation::U0000_TAG: ------------------ | Branch (363:9): [True: 353k, False: 34.6M] ------------------ 364| 353k| U_ASSERT(c == 0); ------------------ | | 35| 353k|# define U_ASSERT(exp) (void)0 ------------------ 365| 353k| if(forward && foundNULTerminator()) { ------------------ | Branch (365:16): [True: 353k, False: 0] | Branch (365:27): [True: 0, False: 353k] ------------------ 366| | // Handle NUL-termination. (Not needed in Java.) 367| 0| ceBuffer.append(Collation::NO_CE, errorCode); 368| 0| return; 369| 353k| } else { 370| | // Fetch the normal ce32 for U+0000 and continue. 371| 353k| ce32 = d->ce32s[0]; 372| 353k| break; 373| 353k| } 374| 299k| case Collation::HANGUL_TAG: { ------------------ | Branch (374:9): [True: 299k, False: 34.7M] ------------------ 375| 299k| const uint32_t *jamoCE32s = d->jamoCE32s; 376| 299k| c -= Hangul::HANGUL_BASE; 377| 299k| UChar32 t = c % Hangul::JAMO_T_COUNT; 378| 299k| c /= Hangul::JAMO_T_COUNT; 379| 299k| UChar32 v = c % Hangul::JAMO_V_COUNT; 380| 299k| c /= Hangul::JAMO_V_COUNT; 381| 299k| if((ce32 & Collation::HANGUL_NO_SPECIAL_JAMO) != 0) { ------------------ | Branch (381:16): [True: 11.2k, False: 288k] ------------------ 382| | // None of the Jamo CE32s are isSpecialCE32(). 383| | // Avoid recursive function calls and per-Jamo tests. 384| 11.2k| if(ceBuffer.ensureAppendCapacity(t == 0 ? 2 : 3, errorCode)) { ------------------ | Branch (384:20): [True: 11.2k, False: 0] | Branch (384:50): [True: 966, False: 10.3k] ------------------ 385| 11.2k| ceBuffer.set(ceBuffer.length, Collation::ceFromCE32(jamoCE32s[c])); 386| 11.2k| ceBuffer.set(ceBuffer.length + 1, Collation::ceFromCE32(jamoCE32s[19 + v])); 387| 11.2k| ceBuffer.length += 2; 388| 11.2k| if(t != 0) { ------------------ | Branch (388:24): [True: 10.3k, False: 966] ------------------ 389| 10.3k| ceBuffer.appendUnsafe(Collation::ceFromCE32(jamoCE32s[39 + t])); 390| 10.3k| } 391| 11.2k| } 392| 11.2k| return; 393| 288k| } else { 394| | // We should not need to compute each Jamo code point. 395| | // In particular, there should be no offset or implicit ce32. 396| 288k| appendCEsFromCE32(d, U_SENTINEL, jamoCE32s[c], forward, errorCode); ------------------ | | 469| 288k|#define U_SENTINEL (-1) ------------------ 397| 288k| appendCEsFromCE32(d, U_SENTINEL, jamoCE32s[19 + v], forward, errorCode); ------------------ | | 469| 288k|#define U_SENTINEL (-1) ------------------ 398| 288k| if(t == 0) { return; } ------------------ | Branch (398:20): [True: 121k, False: 167k] ------------------ 399| | // offset 39 = 19 + 21 - 1: 400| | // 19 = JAMO_L_COUNT 401| | // 21 = JAMO_T_COUNT 402| | // -1 = omit t==0 403| 167k| ce32 = jamoCE32s[39 + t]; 404| 167k| c = U_SENTINEL; ------------------ | | 469| 167k|#define U_SENTINEL (-1) ------------------ 405| 167k| break; 406| 288k| } 407| 299k| } 408| 735k| case Collation::LEAD_SURROGATE_TAG: { ------------------ | Branch (408:9): [True: 735k, False: 34.2M] ------------------ 409| 735k| U_ASSERT(forward); // Backward iteration should never see lead surrogate code _unit_ data. ------------------ | | 35| 735k|# define U_ASSERT(exp) (void)0 ------------------ 410| 735k| U_ASSERT(U16_IS_LEAD(c)); ------------------ | | 35| 735k|# define U_ASSERT(exp) (void)0 ------------------ 411| 735k| char16_t trail; 412| 735k| if(U16_IS_TRAIL(trail = handleGetTrailSurrogate())) { ------------------ | | 67| 735k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 732k, False: 3.64k] | | ------------------ ------------------ 413| 732k| c = U16_GET_SUPPLEMENTARY(c, trail); ------------------ | | 113| 732k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 732k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 414| 732k| ce32 &= Collation::LEAD_TYPE_MASK; 415| 732k| if(ce32 == Collation::LEAD_ALL_UNASSIGNED) { ------------------ | Branch (415:20): [True: 437k, False: 294k] ------------------ 416| 437k| ce32 = Collation::UNASSIGNED_CE32; // unassigned-implicit 417| 437k| } else if(ce32 == Collation::LEAD_ALL_FALLBACK || ------------------ | Branch (417:27): [True: 2.46k, False: 291k] ------------------ 418| 294k| (ce32 = d->getCE32FromSupplementary(c)) == Collation::FALLBACK_CE32) { ------------------ | Branch (418:25): [True: 552, False: 291k] ------------------ 419| | // fall back to the base data 420| 3.01k| d = d->base; 421| 3.01k| ce32 = d->getCE32FromSupplementary(c); 422| 3.01k| } 423| 732k| } else { 424| | // c is an unpaired surrogate. 425| 3.64k| ce32 = Collation::UNASSIGNED_CE32; 426| 3.64k| } 427| 735k| break; 428| 299k| } 429| 6.49M| case Collation::OFFSET_TAG: ------------------ | Branch (429:9): [True: 6.49M, False: 28.5M] ------------------ 430| 6.49M| U_ASSERT(c >= 0); ------------------ | | 35| 6.49M|# define U_ASSERT(exp) (void)0 ------------------ 431| 6.49M| ceBuffer.append(d->getCEFromOffsetCE32(c, ce32), errorCode); 432| 6.49M| return; 433| 1.42M| case Collation::IMPLICIT_TAG: ------------------ | Branch (433:9): [True: 1.42M, False: 33.6M] ------------------ 434| 1.42M| U_ASSERT(c >= 0); ------------------ | | 35| 1.42M|# define U_ASSERT(exp) (void)0 ------------------ 435| 1.42M| if(U_IS_SURROGATE(c) && forbidSurrogateCodePoints()) { ------------------ | | 193| 2.84M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ | | | Branch (193:27): [True: 5.80k, False: 1.41M] | | ------------------ ------------------ | Branch (435:37): [True: 0, False: 5.80k] ------------------ 436| 0| ce32 = Collation::FFFD_CE32; 437| 0| break; 438| 1.42M| } else { 439| 1.42M| ceBuffer.append(Collation::unassignedCEFromCodePoint(c), errorCode); 440| 1.42M| return; 441| 1.42M| } 442| 35.0M| } 443| 35.0M| } 444| 20.9M| ceBuffer.append(Collation::ceFromSimpleCE32(ce32), errorCode); 445| 20.9M|} _ZN6icu_7817CollationIterator17getCE32FromPrefixEPKNS_13CollationDataEjR10UErrorCode: 449| 687k| UErrorCode &errorCode) { 450| 687k| const char16_t *p = d->contexts + Collation::indexFromCE32(ce32); 451| 687k| ce32 = CollationData::readCE32(p); // Default if no prefix match. 452| 687k| p += 2; 453| | // Number of code points read before the original code point. 454| 687k| int32_t lookBehind = 0; 455| 687k| UCharsTrie prefixes(p); 456| 3.29M| for(;;) { 457| 3.29M| UChar32 c = previousCodePoint(errorCode); 458| 3.29M| if(c < 0) { break; } ------------------ | Branch (458:12): [True: 41.5k, False: 3.24M] ------------------ 459| 3.24M| ++lookBehind; 460| 3.24M| UStringTrieResult match = prefixes.nextForCodePoint(c); 461| 3.24M| if(USTRINGTRIE_HAS_VALUE(match)) { ------------------ | | 86| 3.24M|#define USTRINGTRIE_HAS_VALUE(result) ((result)>=USTRINGTRIE_FINAL_VALUE) | | ------------------ | | | Branch (86:39): [True: 444k, False: 2.80M] | | ------------------ ------------------ 462| 444k| ce32 = static_cast(prefixes.getValue()); 463| 444k| } 464| 3.24M| if(!USTRINGTRIE_HAS_NEXT(match)) { break; } ------------------ | | 95| 3.24M|#define USTRINGTRIE_HAS_NEXT(result) ((result)&1) ------------------ | Branch (464:12): [True: 645k, False: 2.60M] ------------------ 465| 3.24M| } 466| 687k| forwardNumCodePoints(lookBehind, errorCode); 467| 687k| return ce32; 468| 687k|} _ZN6icu_7817CollationIterator20nextSkippedCodePointER10UErrorCode: 471| 39.4M|CollationIterator::nextSkippedCodePoint(UErrorCode &errorCode) { 472| 39.4M| if(skipped != nullptr && skipped->hasNext()) { return skipped->next(); } ------------------ | Branch (472:8): [True: 30.0M, False: 9.33M] | Branch (472:30): [True: 24.5M, False: 5.51M] ------------------ 473| 14.8M| if(numCpFwd == 0) { return U_SENTINEL; } ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ | Branch (473:8): [True: 0, False: 14.8M] ------------------ 474| 14.8M| UChar32 c = nextCodePoint(errorCode); 475| 14.8M| if(skipped != nullptr && !skipped->isEmpty() && c >= 0) { skipped->incBeyond(); } ------------------ | Branch (475:8): [True: 5.51M, False: 9.33M] | Branch (475:30): [True: 497k, False: 5.01M] | Branch (475:53): [True: 487k, False: 9.99k] ------------------ 476| 14.8M| if(numCpFwd > 0 && c >= 0) { --numCpFwd; } ------------------ | Branch (476:8): [True: 0, False: 14.8M] | Branch (476:24): [True: 0, False: 0] ------------------ 477| 14.8M| return c; 478| 14.8M|} _ZN6icu_7817CollationIterator18backwardNumSkippedEiR10UErrorCode: 481| 1.51M|CollationIterator::backwardNumSkipped(int32_t n, UErrorCode &errorCode) { 482| 1.51M| if(skipped != nullptr && !skipped->isEmpty()) { ------------------ | Branch (482:8): [True: 619k, False: 899k] | Branch (482:30): [True: 96.4k, False: 523k] ------------------ 483| 96.4k| n = skipped->backwardNumCodePoints(n); 484| 96.4k| } 485| 1.51M| backwardNumCodePoints(n, errorCode); 486| 1.51M| if(numCpFwd >= 0) { numCpFwd += n; } ------------------ | Branch (486:8): [True: 0, False: 1.51M] ------------------ 487| 1.51M|} _ZN6icu_7817CollationIterator23nextCE32FromContractionEPKNS_13CollationDataEjPKDsjiR10UErrorCode: 492| 2.16M| UErrorCode &errorCode) { 493| | // c: next code point after the original one 494| | 495| | // Number of code points read beyond the original code point. 496| | // Needed for discontiguous contraction matching. 497| 2.16M| int32_t lookAhead = 1; 498| | // Number of code points read since the last match (initially only c). 499| 2.16M| int32_t sinceMatch = 1; 500| | // Normally we only need a contiguous match, 501| | // and therefore need not remember the suffixes state from before a mismatch for retrying. 502| | // If we are already processing skipped combining marks, then we do track the state. 503| 2.16M| UCharsTrie suffixes(p); 504| 2.16M| if(skipped != nullptr && !skipped->isEmpty()) { skipped->saveTrieState(suffixes); } ------------------ | Branch (504:8): [True: 848k, False: 1.31M] | Branch (504:30): [True: 80.3k, False: 768k] ------------------ 505| 2.16M| UStringTrieResult match = suffixes.firstForCodePoint(c); 506| 15.1M| for(;;) { 507| 15.1M| UChar32 nextCp; 508| 15.1M| if(USTRINGTRIE_HAS_VALUE(match)) { ------------------ | | 86| 15.1M|#define USTRINGTRIE_HAS_VALUE(result) ((result)>=USTRINGTRIE_FINAL_VALUE) | | ------------------ | | | Branch (86:39): [True: 901k, False: 14.2M] | | ------------------ ------------------ 509| 901k| ce32 = static_cast(suffixes.getValue()); 510| 901k| if(!USTRINGTRIE_HAS_NEXT(match) || (c = nextSkippedCodePoint(errorCode)) < 0) { ------------------ | | 95| 1.80M|#define USTRINGTRIE_HAS_NEXT(result) ((result)&1) ------------------ | Branch (510:16): [True: 794k, False: 106k] | Branch (510:48): [True: 28.0k, False: 78.5k] ------------------ 511| 822k| return ce32; 512| 822k| } 513| 78.5k| if(skipped != nullptr && !skipped->isEmpty()) { skipped->saveTrieState(suffixes); } ------------------ | Branch (513:16): [True: 41.0k, False: 37.4k] | Branch (513:38): [True: 2.22k, False: 38.8k] ------------------ 514| 78.5k| sinceMatch = 1; 515| 14.2M| } else if(match == USTRINGTRIE_NO_MATCH || (nextCp = nextSkippedCodePoint(errorCode)) < 0) { ------------------ | Branch (515:19): [True: 1.33M, False: 12.8M] | Branch (515:52): [True: 11.7k, False: 12.8M] ------------------ 516| | // No match for c, or partial match (USTRINGTRIE_NO_VALUE) and no further text. 517| | // Back up if necessary, and try a discontiguous contraction. 518| 1.34M| if((contractionCE32 & Collation::CONTRACT_TRAILING_CCC) != 0 && ------------------ | Branch (518:16): [True: 487k, False: 857k] ------------------ 519| | // Discontiguous contraction matching extends an existing match. 520| | // If there is no match yet, then there is nothing to do. 521| 1.34M| ((contractionCE32 & Collation::CONTRACT_SINGLE_CP_NO_MATCH) == 0 || ------------------ | Branch (521:22): [True: 445k, False: 42.2k] ------------------ 522| 487k| sinceMatch < lookAhead)) { ------------------ | Branch (522:25): [True: 287, False: 41.9k] ------------------ 523| | // The last character of at least one suffix has lccc!=0, 524| | // allowing for discontiguous contractions. 525| | // UCA S2.1.1 only processes non-starters immediately following 526| | // "a match in the table" (sinceMatch=1). 527| 445k| if(sinceMatch > 1) { ------------------ | Branch (527:20): [True: 146k, False: 299k] ------------------ 528| | // Return to the state after the last match. 529| | // (Return to sinceMatch=0 and re-fetch the first partially-matched character.) 530| 146k| backwardNumSkipped(sinceMatch, errorCode); 531| 146k| c = nextSkippedCodePoint(errorCode); 532| 146k| lookAhead -= sinceMatch - 1; 533| 146k| sinceMatch = 1; 534| 146k| } 535| 445k| if(d->getFCD16(c) > 0xff) { ------------------ | Branch (535:20): [True: 284k, False: 161k] ------------------ 536| 284k| return nextCE32FromDiscontiguousContraction( 537| 284k| d, suffixes, ce32, lookAhead, c, errorCode); 538| 284k| } 539| 445k| } 540| 1.06M| break; 541| 12.8M| } else { 542| | // Continue after partial match (USTRINGTRIE_NO_VALUE) for c. 543| | // It does not have a result value, therefore it is not itself "a match in the table". 544| | // If a partially-matched c has ccc!=0 then 545| | // it might be skipped in discontiguous contraction. 546| 12.8M| c = nextCp; 547| 12.8M| ++sinceMatch; 548| 12.8M| } 549| 12.9M| ++lookAhead; 550| 12.9M| match = suffixes.nextForCodePoint(c); 551| 12.9M| } 552| 1.06M| backwardNumSkipped(sinceMatch, errorCode); 553| 1.06M| return ce32; 554| 2.16M|} _ZN6icu_7817CollationIterator36nextCE32FromDiscontiguousContractionEPKNS_13CollationDataERNS_10UCharsTrieEjiiR10UErrorCode: 560| 284k| UErrorCode &errorCode) { 561| 284k| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (561:8): [True: 0, False: 284k] ------------------ 562| | 563| | // UCA section 3.3.2 Contractions: 564| | // Contractions that end with non-starter characters 565| | // are known as discontiguous contractions. 566| | // ... discontiguous contractions must be detected in input text 567| | // whenever the final sequence of non-starter characters could be rearranged 568| | // so as to make a contiguous matching sequence that is canonically equivalent. 569| | 570| | // UCA: http://www.unicode.org/reports/tr10/#S2.1 571| | // S2.1 Find the longest initial substring S at each point that has a match in the table. 572| | // S2.1.1 If there are any non-starters following S, process each non-starter C. 573| | // S2.1.2 If C is not blocked from S, find if S + C has a match in the table. 574| | // Note: A non-starter in a string is called blocked 575| | // if there is another non-starter of the same canonical combining class or zero 576| | // between it and the last character of canonical combining class 0. 577| | // S2.1.3 If there is a match, replace S by S + C, and remove C. 578| | 579| | // First: Is a discontiguous contraction even possible? 580| 284k| uint16_t fcd16 = d->getFCD16(c); 581| 284k| U_ASSERT(fcd16 > 0xff); // The caller checked this already, as a shortcut. ------------------ | | 35| 284k|# define U_ASSERT(exp) (void)0 ------------------ 582| 284k| UChar32 nextCp = nextSkippedCodePoint(errorCode); 583| 284k| if(nextCp < 0) { ------------------ | Branch (583:8): [True: 87.3k, False: 197k] ------------------ 584| | // No further text. 585| 87.3k| backwardNumSkipped(1, errorCode); 586| 87.3k| return ce32; 587| 87.3k| } 588| 197k| ++lookAhead; 589| 197k| uint8_t prevCC = static_cast(fcd16); 590| 197k| fcd16 = d->getFCD16(nextCp); 591| 197k| if(fcd16 <= 0xff) { ------------------ | Branch (591:8): [True: 26.9k, False: 170k] ------------------ 592| | // The next code point after c is a starter (S2.1.1 "process each non-starter"). 593| 26.9k| backwardNumSkipped(2, errorCode); 594| 26.9k| return ce32; 595| 26.9k| } 596| | 597| | // We have read and matched (lookAhead-2) code points, 598| | // read non-matching c and peeked ahead at nextCp. 599| | // Return to the state before the mismatch and continue matching with nextCp. 600| 170k| if(skipped == nullptr || skipped->isEmpty()) { ------------------ | Branch (600:8): [True: 3.12k, False: 167k] | Branch (600:30): [True: 95.9k, False: 71.3k] ------------------ 601| 99.0k| if(skipped == nullptr) { ------------------ | Branch (601:12): [True: 3.12k, False: 95.9k] ------------------ 602| 3.12k| skipped = new SkippedState(); 603| 3.12k| if(skipped == nullptr) { ------------------ | Branch (603:16): [True: 0, False: 3.12k] ------------------ 604| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 605| 0| return 0; 606| 0| } 607| 3.12k| } 608| 99.0k| suffixes.reset(); 609| 99.0k| if(lookAhead > 2) { ------------------ | Branch (609:12): [True: 4.22k, False: 94.8k] ------------------ 610| | // Replay the partial match so far. 611| 4.22k| backwardNumCodePoints(lookAhead, errorCode); 612| 4.22k| suffixes.firstForCodePoint(nextCodePoint(errorCode)); 613| 10.6k| for(int32_t i = 3; i < lookAhead; ++i) { ------------------ | Branch (613:32): [True: 6.39k, False: 4.22k] ------------------ 614| 6.39k| suffixes.nextForCodePoint(nextCodePoint(errorCode)); 615| 6.39k| } 616| | // Skip c (which did not match) and nextCp (which we will try now). 617| 4.22k| forwardNumCodePoints(2, errorCode); 618| 4.22k| } 619| 99.0k| skipped->saveTrieState(suffixes); 620| 99.0k| } else { 621| | // Reset to the trie state before the failed match of c. 622| 71.3k| skipped->resetToTrieState(suffixes); 623| 71.3k| } 624| | 625| 170k| skipped->setFirstSkipped(c); 626| | // Number of code points read since the last match (at this point: c and nextCp). 627| 170k| int32_t sinceMatch = 2; 628| 170k| c = nextCp; 629| 25.1M| for(;;) { 630| 25.1M| UStringTrieResult match; 631| | // "If C is not blocked from S, find if S + C has a match in the table." (S2.1.2) 632| 25.1M| if(prevCC < (fcd16 >> 8) && USTRINGTRIE_HAS_VALUE(match = suffixes.nextForCodePoint(c))) { ------------------ | | 86| 156k|#define USTRINGTRIE_HAS_VALUE(result) ((result)>=USTRINGTRIE_FINAL_VALUE) | | ------------------ | | | Branch (86:39): [True: 73.4k, False: 83.3k] | | ------------------ ------------------ | Branch (632:12): [True: 156k, False: 24.9M] ------------------ 633| | // "If there is a match, replace S by S + C, and remove C." (S2.1.3) 634| | // Keep prevCC unchanged. 635| 73.4k| ce32 = static_cast(suffixes.getValue()); 636| 73.4k| sinceMatch = 0; 637| 73.4k| skipped->recordMatch(); 638| 73.4k| if(!USTRINGTRIE_HAS_NEXT(match)) { break; } ------------------ | | 95| 73.4k|#define USTRINGTRIE_HAS_NEXT(result) ((result)&1) ------------------ | Branch (638:16): [True: 65.6k, False: 7.71k] ------------------ 639| 7.71k| skipped->saveTrieState(suffixes); 640| 25.0M| } else { 641| | // No match for "S + C", skip C. 642| 25.0M| skipped->skip(c); 643| 25.0M| skipped->resetToTrieState(suffixes); 644| 25.0M| prevCC = static_cast(fcd16); 645| 25.0M| } 646| 25.0M| if((c = nextSkippedCodePoint(errorCode)) < 0) { break; } ------------------ | Branch (646:12): [True: 47.3k, False: 25.0M] ------------------ 647| 25.0M| ++sinceMatch; 648| 25.0M| fcd16 = d->getFCD16(c); 649| 25.0M| if(fcd16 <= 0xff) { ------------------ | Branch (649:12): [True: 57.3k, False: 24.9M] ------------------ 650| | // The next code point after c is a starter (S2.1.1 "process each non-starter"). 651| 57.3k| break; 652| 57.3k| } 653| 25.0M| } 654| 170k| backwardNumSkipped(sinceMatch, errorCode); 655| 170k| UBool isTopDiscontiguous = skipped->isEmpty(); 656| 170k| skipped->replaceMatch(); 657| 170k| if(isTopDiscontiguous && !skipped->isEmpty()) { ------------------ | Branch (657:8): [True: 99.0k, False: 71.3k] | Branch (657:30): [True: 39.9k, False: 59.0k] ------------------ 658| | // We did get a match after skipping one or more combining marks, 659| | // and we are not in a recursive discontiguous contraction. 660| | // Append CEs from the contraction ce32 661| | // and then from the combining marks that we skipped before the match. 662| 39.9k| c = U_SENTINEL; ------------------ | | 469| 39.9k|#define U_SENTINEL (-1) ------------------ 663| 192k| for(;;) { 664| 192k| appendCEsFromCE32(d, c, ce32, true, errorCode); 665| | // Fetch CE32s for skipped combining marks from the normal data, with fallback, 666| | // rather than from the CollationData where we found the contraction. 667| 192k| if(!skipped->hasNext()) { break; } ------------------ | Branch (667:16): [True: 39.9k, False: 153k] ------------------ 668| 153k| c = skipped->next(); 669| 153k| ce32 = getDataCE32(c); 670| 153k| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (670:16): [True: 99.1k, False: 53.9k] ------------------ 671| 99.1k| d = data->base; 672| 99.1k| ce32 = d->getCE32(c); 673| 99.1k| } else { 674| 53.9k| d = data; 675| 53.9k| } 676| | // Note: A nested discontiguous-contraction match 677| | // replaces consumed combining marks with newly skipped ones 678| | // and resets the reading position to the beginning. 679| 153k| } 680| 39.9k| skipped->clear(); 681| 39.9k| ce32 = Collation::NO_CE32; // Signal to the caller that the result is in the ceBuffer. 682| 39.9k| } 683| 170k| return ce32; 684| 170k|} _ZN6icu_7812SkippedState5clearEv: 62| 6.69M| void clear() { 63| 6.69M| oldBuffer.remove(); 64| 6.69M| pos = 0; 65| | // The newBuffer is reset by setFirstSkipped(). 66| 6.69M| } _ZNK6icu_7812SkippedState7hasNextEv: 70| 30.2M| UBool hasNext() const { return pos < oldBuffer.length(); } _ZN6icu_7812SkippedState4nextEv: 73| 24.7M| UChar32 next() { 74| 24.7M| UChar32 c = oldBuffer.char32At(pos); 75| 24.7M| pos += U16_LENGTH(c); ------------------ | | 141| 24.7M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 24.7M, False: 2.61k] | | ------------------ ------------------ 76| 24.7M| return c; 77| 24.7M| } _ZNK6icu_7812SkippedState7isEmptyEv: 68| 7.46M| UBool isEmpty() const { return oldBuffer.isEmpty(); } _ZN6icu_7812SkippedState9incBeyondEv: 80| 487k| void incBeyond() { 81| 487k| U_ASSERT(!hasNext()); ------------------ | | 35| 487k|# define U_ASSERT(exp) (void)0 ------------------ 82| 487k| ++pos; 83| 487k| } _ZN6icu_7812SkippedState21backwardNumCodePointsEi: 88| 96.4k| int32_t backwardNumCodePoints(int32_t n) { 89| 96.4k| int32_t length = oldBuffer.length(); 90| 96.4k| int32_t beyond = pos - length; 91| 96.4k| if(beyond > 0) { ------------------ | Branch (91:12): [True: 76.1k, False: 20.2k] ------------------ 92| 76.1k| if(beyond >= n) { ------------------ | Branch (92:16): [True: 39.4k, False: 36.7k] ------------------ 93| | // Not back far enough to re-enter the oldBuffer. 94| 39.4k| pos -= n; 95| 39.4k| return n; 96| 39.4k| } else { 97| | // Back out all beyond-oldBuffer code points and re-enter the buffer. 98| 36.7k| pos = oldBuffer.moveIndex32(length, beyond - n); 99| 36.7k| return beyond; 100| 36.7k| } 101| 76.1k| } else { 102| | // Go backwards from inside the oldBuffer. 103| 20.2k| pos = oldBuffer.moveIndex32(pos, -n); 104| 20.2k| return 0; 105| 20.2k| } 106| 96.4k| } _ZN6icu_7812SkippedState13saveTrieStateERKNS_10UCharsTrieE: 126| 189k| void saveTrieState(const UCharsTrie &trie) { trie.saveState(state); } _ZN6icu_7812SkippedStateC2Ev: 61| 3.12k| SkippedState() : pos(0), skipLengthAtMatch(0) {} _ZNK6icu_7812SkippedState16resetToTrieStateERNS_10UCharsTrieE: 127| 25.1M| void resetToTrieState(UCharsTrie &trie) const { trie.resetToState(state); } _ZN6icu_7812SkippedState15setFirstSkippedEi: 108| 170k| void setFirstSkipped(UChar32 c) { 109| 170k| skipLengthAtMatch = 0; 110| 170k| newBuffer.setTo(c); 111| 170k| } _ZN6icu_7812SkippedState11recordMatchEv: 117| 73.4k| void recordMatch() { skipLengthAtMatch = newBuffer.length(); } _ZN6icu_7812SkippedState4skipEi: 113| 25.0M| void skip(UChar32 c) { 114| 25.0M| newBuffer.append(c); 115| 25.0M| } _ZN6icu_7812SkippedState12replaceMatchEv: 120| 170k| void replaceMatch() { 121| | // Note: UnicodeString.replace() pins pos to at most length(). 122| 170k| oldBuffer.replace(0, pos, newBuffer, 0, skipLengthAtMatch); 123| 170k| pos = 0; 124| 170k| } _ZN6icu_7817CollationIteratorC2EPKNS_13CollationDataEa: 103| 5.84M| : trie(d->trie), 104| 5.84M| data(d), 105| 5.84M| cesIndex(0), 106| 5.84M| skipped(nullptr), 107| 5.84M| numCpFwd(-1), 108| 5.84M| isNumeric(numeric) {} _ZN6icu_7817CollationIterator8CEBufferC2Ev: 59| 5.84M| CEBuffer() : length(0) {} _ZNK6icu_7817CollationIterator5getCEEi: 196| 73.1M| inline int64_t getCE(int32_t i) const { 197| 73.1M| return ceBuffer.get(i); 198| 73.1M| } _ZNK6icu_7817CollationIterator8CEBuffer3getEi: 88| 78.5M| inline int64_t get(int32_t i) const { return buffer[i]; } _ZN6icu_7817CollationIterator8CEBuffer6appendElR10UErrorCode: 62| 40.4M| inline void append(int64_t ce, UErrorCode &errorCode) { 63| 40.4M| if(length < INITIAL_CAPACITY || ensureAppendCapacity(1, errorCode)) { ------------------ | Branch (63:16): [True: 40.3M, False: 117k] | Branch (63:45): [True: 117k, False: 0] ------------------ 64| 40.4M| buffer[length++] = ce; 65| 40.4M| } 66| 40.4M| } _ZN6icu_7817CollationIterator8CEBuffer12appendUnsafeEl: 68| 28.4M| inline void appendUnsafe(int64_t ce) { 69| 28.4M| buffer[length++] = ce; 70| 28.4M| } _ZN6icu_7817CollationIterator8CEBuffer9incLengthER10UErrorCode: 74| 12.4M| inline UBool incLength(UErrorCode &errorCode) { 75| | // Use INITIAL_CAPACITY for a very simple fastpath. 76| | // (Rather than buffer.getCapacity().) 77| 12.4M| if(length < INITIAL_CAPACITY || ensureAppendCapacity(1, errorCode)) { ------------------ | Branch (77:16): [True: 12.3M, False: 115k] | Branch (77:45): [True: 115k, False: 0] ------------------ 78| 12.4M| ++length; 79| 12.4M| return true; 80| 12.4M| } else { 81| 0| return false; 82| 0| } 83| 12.4M| } _ZN6icu_7817CollationIterator8CEBuffer3setEil: 85| 12.8M| inline int64_t set(int32_t i, int64_t ce) { 86| 12.8M| return buffer[i] = ce; 87| 12.8M| } _ZN6icu_7817CollationIterator6nextCEER10UErrorCode: 129| 14.5M| inline int64_t nextCE(UErrorCode &errorCode) { 130| 14.5M| if(cesIndex < ceBuffer.length) { ------------------ | Branch (130:12): [True: 2.10M, False: 12.4M] ------------------ 131| | // Return the next buffered CE. 132| 2.10M| return ceBuffer.get(cesIndex++); 133| 2.10M| } 134| | // assert cesIndex == ceBuffer.length; 135| 12.4M| if(!ceBuffer.incLength(errorCode)) { ------------------ | Branch (135:12): [True: 0, False: 12.4M] ------------------ 136| 0| return Collation::NO_CE; 137| 0| } 138| 12.4M| UChar32 c; 139| 12.4M| uint32_t ce32 = handleNextCE32(c, errorCode); 140| 12.4M| uint32_t t = ce32 & 0xff; 141| 12.4M| if(t < Collation::SPECIAL_CE32_LOW_BYTE) { // Forced-inline of isSpecialCE32(ce32). ------------------ | Branch (141:12): [True: 688k, False: 11.7M] ------------------ 142| | // Normal CE from the main data. 143| | // Forced-inline of ceFromSimpleCE32(ce32). 144| 688k| return ceBuffer.set(cesIndex++, 145| 688k| (static_cast(ce32 & 0xffff0000) << 32) | ((ce32 & 0xff00) << 16) | (t << 8)); 146| 688k| } 147| 11.7M| const CollationData *d; 148| | // The compiler should be able to optimize the previous and the following 149| | // comparisons of t with the same constant. 150| 11.7M| if(t == Collation::SPECIAL_CE32_LOW_BYTE) { ------------------ | Branch (150:12): [True: 5.98M, False: 5.77M] ------------------ 151| 5.98M| if(c < 0) { ------------------ | Branch (151:16): [True: 5.83M, False: 153k] ------------------ 152| 5.83M| return ceBuffer.set(cesIndex++, Collation::NO_CE); 153| 5.83M| } 154| 153k| d = data->base; 155| 153k| ce32 = d->getCE32(c); 156| 153k| t = ce32 & 0xff; 157| 153k| if(t < Collation::SPECIAL_CE32_LOW_BYTE) { ------------------ | Branch (157:16): [True: 33.9k, False: 119k] ------------------ 158| | // Normal CE from the base data. 159| 33.9k| return ceBuffer.set(cesIndex++, 160| 33.9k| (static_cast(ce32 & 0xffff0000) << 32) | ((ce32 & 0xff00) << 16) | (t << 8)); 161| 33.9k| } 162| 5.77M| } else { 163| 5.77M| d = data; 164| 5.77M| } 165| 5.89M| if(t == Collation::LONG_PRIMARY_CE32_LOW_BYTE) { ------------------ | Branch (165:12): [True: 2.60M, False: 3.29M] ------------------ 166| | // Forced-inline of ceFromLongPrimaryCE32(ce32). 167| 2.60M| return ceBuffer.set(cesIndex++, 168| 2.60M| (static_cast(ce32 - t) << 32) | Collation::COMMON_SEC_AND_TER_CE); 169| 2.60M| } 170| 3.29M| return nextCEFromCE32(d, c, ce32, errorCode); 171| 5.89M| } _ZNK6icu_7817CollationIterator12getCEsLengthEv: 192| 111M| inline int32_t getCEsLength() const { 193| 111M| return ceBuffer.length; 194| 111M| } _ZN6icu_7817CollationIterator8clearCEsEv: 204| 45.3M| void clearCEs() { 205| 45.3M| cesIndex = ceBuffer.length = 0; 206| 45.3M| } _ZN6icu_7817CollationIterator23clearCEsIfNoneRemainingEv: 208| 2.61M| void clearCEsIfNoneRemaining() { 209| 2.61M| if(cesIndex == ceBuffer.length) { clearCEs(); } ------------------ | Branch (209:12): [True: 530k, False: 2.08M] ------------------ 210| 2.61M| } _ZN6icu_7815SortKeyByteSinkD2Ev: 27| 8.19k|SortKeyByteSink::~SortKeyByteSink() {} _ZN6icu_7815SortKeyByteSink6AppendEPKci: 30| 1.80M|SortKeyByteSink::Append(const char *bytes, int32_t n) { 31| 1.80M| if (n <= 0 || bytes == nullptr) { ------------------ | Branch (31:9): [True: 212, False: 1.80M] | Branch (31:19): [True: 0, False: 1.80M] ------------------ 32| 212| return; 33| 212| } 34| 1.80M| if (ignore_ > 0) { ------------------ | Branch (34:9): [True: 0, False: 1.80M] ------------------ 35| 0| int32_t ignoreRest = ignore_ - n; 36| 0| if (ignoreRest >= 0) { ------------------ | Branch (36:13): [True: 0, False: 0] ------------------ 37| 0| ignore_ = ignoreRest; 38| 0| return; 39| 0| } else { 40| 0| bytes += ignore_; 41| 0| n = -ignoreRest; 42| 0| ignore_ = 0; 43| 0| } 44| 0| } 45| 1.80M| int32_t length = appended_; 46| 1.80M| appended_ += n; 47| 1.80M| if ((buffer_ + length) == bytes) { ------------------ | Branch (47:9): [True: 397, False: 1.80M] ------------------ 48| 397| return; // the caller used GetAppendBuffer() and wrote the bytes already 49| 397| } 50| 1.80M| int32_t available = capacity_ - length; 51| 1.80M| if (n <= available) { ------------------ | Branch (51:9): [True: 899k, False: 907k] ------------------ 52| 899k| uprv_memcpy(buffer_ + length, bytes, n); ------------------ | | 42| 899k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 899k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 899k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 899k| _Pragma("clang diagnostic push") \ | | 45| 899k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 899k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 899k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 899k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 899k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 899k| _Pragma("clang diagnostic pop") \ | | 49| 899k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 899k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 899k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 899k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 53| 907k| } else { 54| 907k| AppendBeyondCapacity(bytes, n, length); 55| 907k| } 56| 1.80M|} _ZN6icu_7815SortKeyByteSink15GetAppendBufferEiiPciPi: 63| 2.48k| int32_t *result_capacity) { 64| 2.48k| if (min_capacity < 1 || scratch_capacity < min_capacity) { ------------------ | Branch (64:9): [True: 0, False: 2.48k] | Branch (64:29): [True: 0, False: 2.48k] ------------------ 65| 0| *result_capacity = 0; 66| 0| return nullptr; 67| 0| } 68| 2.48k| if (ignore_ > 0) { ------------------ | Branch (68:9): [True: 0, False: 2.48k] ------------------ 69| | // Do not write ignored bytes right at the end of the buffer. 70| 0| *result_capacity = scratch_capacity; 71| 0| return scratch; 72| 0| } 73| 2.48k| int32_t available = capacity_ - appended_; 74| 2.48k| if (available >= min_capacity) { ------------------ | Branch (74:9): [True: 506, False: 1.98k] ------------------ 75| 506| *result_capacity = available; 76| 506| return buffer_ + appended_; 77| 1.98k| } else if (Resize(desired_capacity_hint, appended_)) { ------------------ | Branch (77:16): [True: 1, False: 1.98k] ------------------ 78| 1| *result_capacity = capacity_ - appended_; 79| 1| return buffer_ + appended_; 80| 1.98k| } else { 81| 1.98k| *result_capacity = scratch_capacity; 82| 1.98k| return scratch; 83| 1.98k| } 84| 2.48k|} _ZN6icu_7813CollationKeys13LevelCallbackD2Ev: 208| 8.19k|CollationKeys::LevelCallback::~LevelCallback() {} _ZN6icu_7813CollationKeys13LevelCallback11needToWriteENS_9Collation5LevelE: 211| 16.6k|CollationKeys::LevelCallback::needToWrite(Collation::Level /*level*/) { return true; } _ZN6icu_7813CollationKeys26writeSortKeyUpToQuaternaryERNS_17CollationIteratorEPKaRKNS_17CollationSettingsERNS_15SortKeyByteSinkENS_9Collation5LevelERNS0_13LevelCallbackEaR10UErrorCode: 236| 8.19k| UBool preflight, UErrorCode &errorCode) { 237| 8.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (237:8): [True: 0, False: 8.19k] ------------------ 238| | 239| 8.19k| int32_t options = settings.options; 240| | // Set of levels to process and write. 241| 8.19k| uint32_t levels = levelMasks[CollationSettings::getStrength(options)]; 242| 8.19k| if((options & CollationSettings::CASE_LEVEL) != 0) { ------------------ | Branch (242:8): [True: 0, False: 8.19k] ------------------ 243| 0| levels |= Collation::CASE_LEVEL_FLAG; 244| 0| } 245| | // Minus the levels below minLevel. 246| 8.19k| levels &= ~((static_cast(1) << minLevel) - 1); 247| 8.19k| if(levels == 0) { return; } ------------------ | Branch (247:8): [True: 0, False: 8.19k] ------------------ 248| | 249| 8.19k| uint32_t variableTop; 250| 8.19k| if((options & CollationSettings::ALTERNATE_MASK) == 0) { ------------------ | Branch (250:8): [True: 7.49k, False: 698] ------------------ 251| 7.49k| variableTop = 0; 252| 7.49k| } else { 253| | // +1 so that we can use "<" and primary ignorables test out early. 254| 698| variableTop = settings.variableTop + 1; 255| 698| } 256| | 257| 8.19k| uint32_t tertiaryMask = CollationSettings::getTertiaryMask(options); 258| | 259| 8.19k| SortKeyLevel cases; 260| 8.19k| SortKeyLevel secondaries; 261| 8.19k| SortKeyLevel tertiaries; 262| 8.19k| SortKeyLevel quaternaries; 263| | 264| 8.19k| uint32_t prevReorderedPrimary = 0; // 0==no compression 265| 8.19k| int32_t commonCases = 0; 266| 8.19k| int32_t commonSecondaries = 0; 267| 8.19k| int32_t commonTertiaries = 0; 268| 8.19k| int32_t commonQuaternaries = 0; 269| | 270| 8.19k| uint32_t prevSecondary = 0; 271| 8.19k| int32_t secSegmentStart = 0; 272| | 273| 2.61M| for(;;) { 274| | // No need to keep all CEs in the buffer when we write a sort key. 275| 2.61M| iter.clearCEsIfNoneRemaining(); 276| 2.61M| int64_t ce = iter.nextCE(errorCode); 277| 2.61M| uint32_t p = static_cast(ce >> 32); 278| 2.61M| if(p < variableTop && p > Collation::MERGE_SEPARATOR_PRIMARY) { ------------------ | Branch (278:12): [True: 93.9k, False: 2.52M] | Branch (278:31): [True: 36.4k, False: 57.4k] ------------------ 279| | // Variable CE, shift it to quaternary level. 280| | // Ignore all following primary ignorables, and shift further variable CEs. 281| 36.4k| if(commonQuaternaries != 0) { ------------------ | Branch (281:16): [True: 9.02k, False: 27.4k] ------------------ 282| 9.02k| --commonQuaternaries; 283| 9.51k| while(commonQuaternaries >= QUAT_COMMON_MAX_COUNT) { ------------------ | Branch (283:23): [True: 492, False: 9.02k] ------------------ 284| 492| quaternaries.appendByte(QUAT_COMMON_MIDDLE); 285| 492| commonQuaternaries -= QUAT_COMMON_MAX_COUNT; 286| 492| } 287| | // Shifted primary weights are lower than the common weight. 288| 9.02k| quaternaries.appendByte(QUAT_COMMON_LOW + commonQuaternaries); 289| 9.02k| commonQuaternaries = 0; 290| 9.02k| } 291| 52.1k| do { 292| 52.1k| if((levels & Collation::QUATERNARY_LEVEL_FLAG) != 0) { ------------------ | Branch (292:20): [True: 17.6k, False: 34.5k] ------------------ 293| 17.6k| if(settings.hasReordering()) { ------------------ | Branch (293:24): [True: 17.6k, False: 0] ------------------ 294| 17.6k| p = settings.reorder(p); 295| 17.6k| } 296| 17.6k| if((p >> 24) >= QUAT_SHIFTED_LIMIT_BYTE) { ------------------ | Branch (296:24): [True: 0, False: 17.6k] ------------------ 297| | // Prevent shifted primary lead bytes from 298| | // overlapping with the common compression range. 299| 0| quaternaries.appendByte(QUAT_SHIFTED_LIMIT_BYTE); 300| 0| } 301| 17.6k| quaternaries.appendWeight32(p); 302| 17.6k| } 303| 56.0k| do { 304| 56.0k| ce = iter.nextCE(errorCode); 305| 56.0k| p = static_cast(ce >> 32); 306| 56.0k| } while(p == 0); ------------------ | Branch (306:25): [True: 3.95k, False: 52.1k] ------------------ 307| 52.1k| } while(p < variableTop && p > Collation::MERGE_SEPARATOR_PRIMARY); ------------------ | Branch (307:21): [True: 15.8k, False: 36.3k] | Branch (307:40): [True: 15.7k, False: 118] ------------------ 308| 36.4k| } 309| | // ce could be primary ignorable, or NO_CE, or the merge separator, 310| | // or a regular primary CE, but it is not variable. 311| | // If ce==NO_CE, then write nothing for the primary level but 312| | // terminate compression on all levels and then exit the loop. 313| 2.61M| if(p > Collation::NO_CE_PRIMARY && (levels & Collation::PRIMARY_LEVEL_FLAG) != 0) { ------------------ | Branch (313:12): [True: 2.19M, False: 422k] | Branch (313:44): [True: 2.19M, False: 0] ------------------ 314| | // Test the un-reordered primary for compressibility. 315| 2.19M| UBool isCompressible = compressibleBytes[p >> 24]; 316| 2.19M| if(settings.hasReordering()) { ------------------ | Branch (316:16): [True: 645k, False: 1.54M] ------------------ 317| 645k| p = settings.reorder(p); 318| 645k| } 319| 2.19M| uint32_t p1 = p >> 24; 320| 2.19M| if(!isCompressible || p1 != (prevReorderedPrimary >> 24)) { ------------------ | Branch (320:16): [True: 1.36M, False: 824k] | Branch (320:35): [True: 445k, False: 378k] ------------------ 321| 1.81M| if(prevReorderedPrimary != 0) { ------------------ | Branch (321:20): [True: 443k, False: 1.37M] ------------------ 322| 443k| if(p < prevReorderedPrimary) { ------------------ | Branch (322:24): [True: 318k, False: 124k] ------------------ 323| | // No primary compression terminator 324| | // at the end of the level or merged segment. 325| 318k| if(p1 > Collation::MERGE_SEPARATOR_BYTE) { ------------------ | Branch (325:28): [True: 318k, False: 124] ------------------ 326| 318k| sink.Append(Collation::PRIMARY_COMPRESSION_LOW_BYTE); 327| 318k| } 328| 318k| } else { 329| 124k| sink.Append(Collation::PRIMARY_COMPRESSION_HIGH_BYTE); 330| 124k| } 331| 443k| } 332| 1.81M| sink.Append(p1); 333| 1.81M| if(isCompressible) { ------------------ | Branch (333:20): [True: 445k, False: 1.36M] ------------------ 334| 445k| prevReorderedPrimary = p; 335| 1.36M| } else { 336| 1.36M| prevReorderedPrimary = 0; 337| 1.36M| } 338| 1.81M| } 339| 2.19M| char p2 = static_cast(p >> 16); 340| 2.19M| if(p2 != 0) { ------------------ | Branch (340:16): [True: 1.78M, False: 411k] ------------------ 341| 1.78M| char buffer[3] = {p2, static_cast(p >> 8), static_cast(p)}; 342| 1.78M| sink.Append(buffer, (buffer[1] == 0) ? 1 : (buffer[2] == 0) ? 2 : 3); ------------------ | Branch (342:37): [True: 830k, False: 950k] | Branch (342:60): [True: 740k, False: 209k] ------------------ 343| 1.78M| } 344| | // Optimization for internalNextSortKeyPart(): 345| | // When the primary level overflows we can stop because we need not 346| | // calculate (preflight) the whole sort key length. 347| 2.19M| if(!preflight && sink.Overflowed()) { ------------------ | Branch (347:16): [True: 0, False: 2.19M] | Branch (347:30): [True: 0, False: 0] ------------------ 348| 0| if(U_SUCCESS(errorCode) && !sink.IsOk()) { ------------------ | Branch (348:20): [True: 0, False: 0] | Branch (348:44): [True: 0, False: 0] ------------------ 349| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 350| 0| } 351| 0| return; 352| 0| } 353| 2.19M| } 354| | 355| 2.61M| uint32_t lower32 = static_cast(ce); 356| 2.61M| if(lower32 == 0) { continue; } // completely ignorable, no secondary/case/tertiary/quaternary ------------------ | Branch (356:12): [True: 30.5k, False: 2.58M] ------------------ 357| | 358| 2.58M| if((levels & Collation::SECONDARY_LEVEL_FLAG) != 0) { ------------------ | Branch (358:12): [True: 2.58M, False: 1.44k] ------------------ 359| 2.58M| uint32_t s = lower32 >> 16; 360| 2.58M| if(s == 0) { ------------------ | Branch (360:16): [True: 5.09k, False: 2.57M] ------------------ 361| | // secondary ignorable 362| 2.57M| } else if(s == Collation::COMMON_WEIGHT16 && ------------------ | Branch (362:23): [True: 2.07M, False: 502k] ------------------ 363| 2.57M| ((options & CollationSettings::BACKWARD_SECONDARY) == 0 || ------------------ | Branch (363:22): [True: 1.73M, False: 344k] ------------------ 364| 2.07M| p != Collation::MERGE_SEPARATOR_PRIMARY)) { ------------------ | Branch (364:25): [True: 344k, False: 258] ------------------ 365| | // s is a common secondary weight, and 366| | // backwards-secondary is off or the ce is not the merge separator. 367| 2.07M| ++commonSecondaries; 368| 2.07M| } else if((options & CollationSettings::BACKWARD_SECONDARY) == 0) { ------------------ | Branch (368:23): [True: 378k, False: 124k] ------------------ 369| 378k| if(commonSecondaries != 0) { ------------------ | Branch (369:20): [True: 344k, False: 34.1k] ------------------ 370| 344k| --commonSecondaries; 371| 365k| while(commonSecondaries >= SEC_COMMON_MAX_COUNT) { ------------------ | Branch (371:27): [True: 20.7k, False: 344k] ------------------ 372| 20.7k| secondaries.appendByte(SEC_COMMON_MIDDLE); 373| 20.7k| commonSecondaries -= SEC_COMMON_MAX_COUNT; 374| 20.7k| } 375| 344k| uint32_t b; 376| 344k| if(s < Collation::COMMON_WEIGHT16) { ------------------ | Branch (376:24): [True: 7.09k, False: 337k] ------------------ 377| 7.09k| b = SEC_COMMON_LOW + commonSecondaries; 378| 337k| } else { 379| 337k| b = SEC_COMMON_HIGH - commonSecondaries; 380| 337k| } 381| 344k| secondaries.appendByte(b); 382| 344k| commonSecondaries = 0; 383| 344k| } 384| 378k| secondaries.appendWeight16(s); 385| 378k| } else { 386| 124k| if(commonSecondaries != 0) { ------------------ | Branch (386:20): [True: 121k, False: 2.69k] ------------------ 387| 121k| --commonSecondaries; 388| | // Append reverse weights. The level will be re-reversed later. 389| 121k| int32_t remainder = commonSecondaries % SEC_COMMON_MAX_COUNT; 390| 121k| uint32_t b; 391| 121k| if(prevSecondary < Collation::COMMON_WEIGHT16) { ------------------ | Branch (391:24): [True: 738, False: 120k] ------------------ 392| 738| b = SEC_COMMON_LOW + remainder; 393| 120k| } else { 394| 120k| b = SEC_COMMON_HIGH - remainder; 395| 120k| } 396| 121k| secondaries.appendByte(b); 397| 121k| commonSecondaries -= remainder; 398| | // commonSecondaries is now a multiple of SEC_COMMON_MAX_COUNT. 399| 125k| while(commonSecondaries > 0) { // same as >= SEC_COMMON_MAX_COUNT ------------------ | Branch (399:27): [True: 4.47k, False: 121k] ------------------ 400| 4.47k| secondaries.appendByte(SEC_COMMON_MIDDLE); 401| 4.47k| commonSecondaries -= SEC_COMMON_MAX_COUNT; 402| 4.47k| } 403| | // commonSecondaries == 0 404| 121k| } 405| 124k| if(0 < p && p <= Collation::MERGE_SEPARATOR_PRIMARY) { ------------------ | Branch (405:20): [True: 5.43k, False: 118k] | Branch (405:29): [True: 506, False: 4.92k] ------------------ 406| | // The backwards secondary level compares secondary weights backwards 407| | // within segments separated by the merge separator (U+FFFE). 408| 506| uint8_t *secs = secondaries.data(); 409| 506| int32_t last = secondaries.length() - 1; 410| 506| if(secSegmentStart < last) { ------------------ | Branch (410:24): [True: 352, False: 154] ------------------ 411| 352| uint8_t *q = secs + secSegmentStart; 412| 352| uint8_t *r = secs + last; 413| 126k| do { 414| 126k| uint8_t b = *q; 415| 126k| *q++ = *r; 416| 126k| *r-- = b; 417| 126k| } while(q < r); ------------------ | Branch (417:33): [True: 126k, False: 352] ------------------ 418| 352| } 419| 506| secondaries.appendByte(p == Collation::NO_CE_PRIMARY ? ------------------ | Branch (419:44): [True: 248, False: 258] ------------------ 420| 258| Collation::LEVEL_SEPARATOR_BYTE : Collation::MERGE_SEPARATOR_BYTE); 421| 506| prevSecondary = 0; 422| 506| secSegmentStart = secondaries.length(); 423| 123k| } else { 424| 123k| secondaries.appendReverseWeight16(s); 425| 123k| prevSecondary = s; 426| 123k| } 427| 124k| } 428| 2.58M| } 429| | 430| 2.58M| if((levels & Collation::CASE_LEVEL_FLAG) != 0) { ------------------ | Branch (430:12): [True: 0, False: 2.58M] ------------------ 431| 0| if((CollationSettings::getStrength(options) == UCOL_PRIMARY) ? ------------------ | Branch (431:16): [True: 0, False: 0] | Branch (431:16): [True: 0, False: 0] ------------------ 432| 0| p == 0 : lower32 <= 0xffff) { 433| | // Primary+caseLevel: Ignore case level weights of primary ignorables. 434| | // Otherwise: Ignore case level weights of secondary ignorables. 435| | // For details see the comments in the CollationCompare class. 436| 0| } else { 437| 0| uint32_t c = (lower32 >> 8) & 0xff; // case bits & tertiary lead byte 438| 0| U_ASSERT((c & 0xc0) != 0xc0); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 439| 0| if((c & 0xc0) == 0 && c > Collation::LEVEL_SEPARATOR_BYTE) { ------------------ | Branch (439:20): [True: 0, False: 0] | Branch (439:39): [True: 0, False: 0] ------------------ 440| 0| ++commonCases; 441| 0| } else { 442| 0| if((options & CollationSettings::UPPER_FIRST) == 0) { ------------------ | Branch (442:24): [True: 0, False: 0] ------------------ 443| | // lowerFirst: Compress common weights to nibbles 1..7..13, mixed=14, upper=15. 444| | // If there are only common (=lowest) weights in the whole level, 445| | // then we need not write anything. 446| | // Level length differences are handled already on the next-higher level. 447| 0| if(commonCases != 0 && ------------------ | Branch (447:28): [True: 0, False: 0] ------------------ 448| 0| (c > Collation::LEVEL_SEPARATOR_BYTE || !cases.isEmpty())) { ------------------ | Branch (448:34): [True: 0, False: 0] | Branch (448:73): [True: 0, False: 0] ------------------ 449| 0| --commonCases; 450| 0| while(commonCases >= CASE_LOWER_FIRST_COMMON_MAX_COUNT) { ------------------ | Branch (450:35): [True: 0, False: 0] ------------------ 451| 0| cases.appendByte(CASE_LOWER_FIRST_COMMON_MIDDLE << 4); 452| 0| commonCases -= CASE_LOWER_FIRST_COMMON_MAX_COUNT; 453| 0| } 454| 0| uint32_t b; 455| 0| if(c <= Collation::LEVEL_SEPARATOR_BYTE) { ------------------ | Branch (455:32): [True: 0, False: 0] ------------------ 456| 0| b = CASE_LOWER_FIRST_COMMON_LOW + commonCases; 457| 0| } else { 458| 0| b = CASE_LOWER_FIRST_COMMON_HIGH - commonCases; 459| 0| } 460| 0| cases.appendByte(b << 4); 461| 0| commonCases = 0; 462| 0| } 463| 0| if(c > Collation::LEVEL_SEPARATOR_BYTE) { ------------------ | Branch (463:28): [True: 0, False: 0] ------------------ 464| 0| c = (CASE_LOWER_FIRST_COMMON_HIGH + (c >> 6)) << 4; // 14 or 15 465| 0| } 466| 0| } else { 467| | // upperFirst: Compress common weights to nibbles 3..15, mixed=2, upper=1. 468| | // The compressed common case weights only go up from the "low" value 469| | // because with upperFirst the common weight is the highest one. 470| 0| if(commonCases != 0) { ------------------ | Branch (470:28): [True: 0, False: 0] ------------------ 471| 0| --commonCases; 472| 0| while(commonCases >= CASE_UPPER_FIRST_COMMON_MAX_COUNT) { ------------------ | Branch (472:35): [True: 0, False: 0] ------------------ 473| 0| cases.appendByte(CASE_UPPER_FIRST_COMMON_LOW << 4); 474| 0| commonCases -= CASE_UPPER_FIRST_COMMON_MAX_COUNT; 475| 0| } 476| 0| cases.appendByte((CASE_UPPER_FIRST_COMMON_LOW + commonCases) << 4); 477| 0| commonCases = 0; 478| 0| } 479| 0| if(c > Collation::LEVEL_SEPARATOR_BYTE) { ------------------ | Branch (479:28): [True: 0, False: 0] ------------------ 480| 0| c = (CASE_UPPER_FIRST_COMMON_LOW - (c >> 6)) << 4; // 2 or 1 481| 0| } 482| 0| } 483| | // c is a separator byte 01, 484| | // or a left-shifted nibble 0x10, 0x20, ... 0xf0. 485| 0| cases.appendByte(c); 486| 0| } 487| 0| } 488| 0| } 489| | 490| 2.58M| if((levels & Collation::TERTIARY_LEVEL_FLAG) != 0) { ------------------ | Branch (490:12): [True: 2.58M, False: 1.48k] ------------------ 491| 2.58M| uint32_t t = lower32 & tertiaryMask; 492| 2.58M| U_ASSERT((lower32 & 0xc000) != 0xc000); ------------------ | | 35| 2.58M|# define U_ASSERT(exp) (void)0 ------------------ 493| 2.58M| if(t == Collation::COMMON_WEIGHT16) { ------------------ | Branch (493:16): [True: 1.73M, False: 846k] ------------------ 494| 1.73M| ++commonTertiaries; 495| 1.73M| } else if((tertiaryMask & 0x8000) == 0) { ------------------ | Branch (495:23): [True: 718k, False: 127k] ------------------ 496| | // Tertiary weights without case bits. 497| | // Move lead bytes 06..3F to C6..FF for a large common-weight range. 498| 718k| if(commonTertiaries != 0) { ------------------ | Branch (498:20): [True: 292k, False: 425k] ------------------ 499| 292k| --commonTertiaries; 500| 299k| while(commonTertiaries >= TER_ONLY_COMMON_MAX_COUNT) { ------------------ | Branch (500:27): [True: 6.97k, False: 292k] ------------------ 501| 6.97k| tertiaries.appendByte(TER_ONLY_COMMON_MIDDLE); 502| 6.97k| commonTertiaries -= TER_ONLY_COMMON_MAX_COUNT; 503| 6.97k| } 504| 292k| uint32_t b; 505| 292k| if(t < Collation::COMMON_WEIGHT16) { ------------------ | Branch (505:24): [True: 7.58k, False: 284k] ------------------ 506| 7.58k| b = TER_ONLY_COMMON_LOW + commonTertiaries; 507| 284k| } else { 508| 284k| b = TER_ONLY_COMMON_HIGH - commonTertiaries; 509| 284k| } 510| 292k| tertiaries.appendByte(b); 511| 292k| commonTertiaries = 0; 512| 292k| } 513| 718k| if(t > Collation::COMMON_WEIGHT16) { t += 0xc000; } ------------------ | Branch (513:20): [True: 709k, False: 9.42k] ------------------ 514| 718k| tertiaries.appendWeight16(t); 515| 718k| } else if((options & CollationSettings::UPPER_FIRST) == 0) { ------------------ | Branch (515:23): [True: 0, False: 127k] ------------------ 516| | // Tertiary weights with caseFirst=lowerFirst. 517| | // Move lead bytes 06..BF to 46..FF for the common-weight range. 518| 0| if(commonTertiaries != 0) { ------------------ | Branch (518:20): [True: 0, False: 0] ------------------ 519| 0| --commonTertiaries; 520| 0| while(commonTertiaries >= TER_LOWER_FIRST_COMMON_MAX_COUNT) { ------------------ | Branch (520:27): [True: 0, False: 0] ------------------ 521| 0| tertiaries.appendByte(TER_LOWER_FIRST_COMMON_MIDDLE); 522| 0| commonTertiaries -= TER_LOWER_FIRST_COMMON_MAX_COUNT; 523| 0| } 524| 0| uint32_t b; 525| 0| if(t < Collation::COMMON_WEIGHT16) { ------------------ | Branch (525:24): [True: 0, False: 0] ------------------ 526| 0| b = TER_LOWER_FIRST_COMMON_LOW + commonTertiaries; 527| 0| } else { 528| 0| b = TER_LOWER_FIRST_COMMON_HIGH - commonTertiaries; 529| 0| } 530| 0| tertiaries.appendByte(b); 531| 0| commonTertiaries = 0; 532| 0| } 533| 0| if(t > Collation::COMMON_WEIGHT16) { t += 0x4000; } ------------------ | Branch (533:20): [True: 0, False: 0] ------------------ 534| 0| tertiaries.appendWeight16(t); 535| 127k| } else { 536| | // Tertiary weights with caseFirst=upperFirst. 537| | // Do not change the artificial uppercase weight of a tertiary CE (0.0.ut), 538| | // to keep tertiary CEs well-formed. 539| | // Their case+tertiary weights must be greater than those of 540| | // primary and secondary CEs. 541| | // 542| | // Separator 01 -> 01 (unchanged) 543| | // Lowercase 02..04 -> 82..84 (includes uncased) 544| | // Common weight 05 -> 85..C5 (common-weight compression range) 545| | // Lowercase 06..3F -> C6..FF 546| | // Mixed case 42..7F -> 42..7F 547| | // Uppercase 82..BF -> 02..3F 548| | // Tertiary CE 86..BF -> C6..FF 549| 127k| if(t <= Collation::NO_CE_WEIGHT16) { ------------------ | Branch (549:20): [True: 182, False: 127k] ------------------ 550| | // Keep separators unchanged. 551| 127k| } else if(lower32 > 0xffff) { ------------------ | Branch (551:27): [True: 123k, False: 3.96k] ------------------ 552| | // Invert case bits of primary & secondary CEs. 553| 123k| t ^= 0xc000; 554| 123k| if(t < (TER_UPPER_FIRST_COMMON_HIGH << 8)) { ------------------ | Branch (554:24): [True: 3.59k, False: 120k] ------------------ 555| 3.59k| t -= 0x4000; 556| 3.59k| } 557| 123k| } else { 558| | // Keep uppercase bits of tertiary CEs. 559| 3.96k| U_ASSERT(0x8600 <= t && t <= 0xbfff); ------------------ | | 35| 3.96k|# define U_ASSERT(exp) (void)0 ------------------ 560| 3.96k| t += 0x4000; 561| 3.96k| } 562| 127k| if(commonTertiaries != 0) { ------------------ | Branch (562:20): [True: 118k, False: 9.23k] ------------------ 563| 118k| --commonTertiaries; 564| 121k| while(commonTertiaries >= TER_UPPER_FIRST_COMMON_MAX_COUNT) { ------------------ | Branch (564:27): [True: 2.86k, False: 118k] ------------------ 565| 2.86k| tertiaries.appendByte(TER_UPPER_FIRST_COMMON_MIDDLE); 566| 2.86k| commonTertiaries -= TER_UPPER_FIRST_COMMON_MAX_COUNT; 567| 2.86k| } 568| 118k| uint32_t b; 569| 118k| if(t < (TER_UPPER_FIRST_COMMON_LOW << 8)) { ------------------ | Branch (569:24): [True: 3.08k, False: 115k] ------------------ 570| 3.08k| b = TER_UPPER_FIRST_COMMON_LOW + commonTertiaries; 571| 115k| } else { 572| 115k| b = TER_UPPER_FIRST_COMMON_HIGH - commonTertiaries; 573| 115k| } 574| 118k| tertiaries.appendByte(b); 575| 118k| commonTertiaries = 0; 576| 118k| } 577| 127k| tertiaries.appendWeight16(t); 578| 127k| } 579| 2.58M| } 580| | 581| 2.58M| if((levels & Collation::QUATERNARY_LEVEL_FLAG) != 0) { ------------------ | Branch (581:12): [True: 461k, False: 2.12M] ------------------ 582| 461k| uint32_t q = lower32 & 0xffff; 583| 461k| if((q & 0xc0) == 0 && q > Collation::NO_CE_WEIGHT16) { ------------------ | Branch (583:16): [True: 448k, False: 13.1k] | Branch (583:35): [True: 447k, False: 346] ------------------ 584| 447k| ++commonQuaternaries; 585| 447k| } else if(q == Collation::NO_CE_WEIGHT16 && ------------------ | Branch (585:23): [True: 346, False: 13.1k] ------------------ 586| 13.5k| (options & CollationSettings::ALTERNATE_MASK) == 0 && ------------------ | Branch (586:21): [True: 202, False: 144] ------------------ 587| 13.5k| quaternaries.isEmpty()) { ------------------ | Branch (587:21): [True: 152, False: 50] ------------------ 588| | // If alternate=non-ignorable and there are only common quaternary weights, 589| | // then we need not write anything. 590| | // The only weights greater than the merge separator and less than the common weight 591| | // are shifted primary weights, which are not generated for alternate=non-ignorable. 592| | // There are also exactly as many quaternary weights as tertiary weights, 593| | // so level length differences are handled already on tertiary level. 594| | // Any above-common quaternary weight will compare greater regardless. 595| 152| quaternaries.appendByte(Collation::LEVEL_SEPARATOR_BYTE); 596| 13.3k| } else { 597| 13.3k| if(q == Collation::NO_CE_WEIGHT16) { ------------------ | Branch (597:20): [True: 194, False: 13.1k] ------------------ 598| 194| q = Collation::LEVEL_SEPARATOR_BYTE; 599| 13.1k| } else { 600| 13.1k| q = 0xfc + ((q >> 6) & 3); 601| 13.1k| } 602| 13.3k| if(commonQuaternaries != 0) { ------------------ | Branch (602:20): [True: 12.1k, False: 1.24k] ------------------ 603| 12.1k| --commonQuaternaries; 604| 14.2k| while(commonQuaternaries >= QUAT_COMMON_MAX_COUNT) { ------------------ | Branch (604:27): [True: 2.06k, False: 12.1k] ------------------ 605| 2.06k| quaternaries.appendByte(QUAT_COMMON_MIDDLE); 606| 2.06k| commonQuaternaries -= QUAT_COMMON_MAX_COUNT; 607| 2.06k| } 608| 12.1k| uint32_t b; 609| 12.1k| if(q < QUAT_COMMON_LOW) { ------------------ | Branch (609:24): [True: 174, False: 11.9k] ------------------ 610| 174| b = QUAT_COMMON_LOW + commonQuaternaries; 611| 11.9k| } else { 612| 11.9k| b = QUAT_COMMON_HIGH - commonQuaternaries; 613| 11.9k| } 614| 12.1k| quaternaries.appendByte(b); 615| 12.1k| commonQuaternaries = 0; 616| 12.1k| } 617| 13.3k| quaternaries.appendByte(q); 618| 13.3k| } 619| 461k| } 620| | 621| 2.58M| if((lower32 >> 24) == Collation::LEVEL_SEPARATOR_BYTE) { break; } // ce == NO_CE ------------------ | Branch (621:12): [True: 8.19k, False: 2.57M] ------------------ 622| 2.58M| } 623| | 624| 8.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (624:8): [True: 0, False: 8.19k] ------------------ 625| | 626| | // Append the beyond-primary levels. 627| 8.19k| UBool ok = true; 628| 8.19k| if((levels & Collation::SECONDARY_LEVEL_FLAG) != 0) { ------------------ | Branch (628:8): [True: 8.17k, False: 16] ------------------ 629| 8.17k| if(!callback.needToWrite(Collation::SECONDARY_LEVEL)) { return; } ------------------ | Branch (629:12): [True: 0, False: 8.17k] ------------------ 630| 8.17k| ok &= secondaries.isOk(); 631| 8.17k| sink.Append(Collation::LEVEL_SEPARATOR_BYTE); 632| 8.17k| secondaries.appendTo(sink); 633| 8.17k| } 634| | 635| 8.19k| if((levels & Collation::CASE_LEVEL_FLAG) != 0) { ------------------ | Branch (635:8): [True: 0, False: 8.19k] ------------------ 636| 0| if(!callback.needToWrite(Collation::CASE_LEVEL)) { return; } ------------------ | Branch (636:12): [True: 0, False: 0] ------------------ 637| 0| ok &= cases.isOk(); 638| 0| sink.Append(Collation::LEVEL_SEPARATOR_BYTE); 639| | // Write pairs of nibbles as bytes, except separator bytes as themselves. 640| 0| int32_t length = cases.length() - 1; // Ignore the trailing NO_CE. 641| 0| uint8_t b = 0; 642| 0| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (642:28): [True: 0, False: 0] ------------------ 643| 0| uint8_t c = cases[i]; 644| 0| U_ASSERT((c & 0xf) == 0 && c != 0); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 645| 0| if(b == 0) { ------------------ | Branch (645:16): [True: 0, False: 0] ------------------ 646| 0| b = c; 647| 0| } else { 648| 0| sink.Append(b | (c >> 4)); 649| 0| b = 0; 650| 0| } 651| 0| } 652| 0| if(b != 0) { ------------------ | Branch (652:12): [True: 0, False: 0] ------------------ 653| 0| sink.Append(b); 654| 0| } 655| 0| } 656| | 657| 8.19k| if((levels & Collation::TERTIARY_LEVEL_FLAG) != 0) { ------------------ | Branch (657:8): [True: 8.17k, False: 18] ------------------ 658| 8.17k| if(!callback.needToWrite(Collation::TERTIARY_LEVEL)) { return; } ------------------ | Branch (658:12): [True: 0, False: 8.17k] ------------------ 659| 8.17k| ok &= tertiaries.isOk(); 660| 8.17k| sink.Append(Collation::LEVEL_SEPARATOR_BYTE); 661| 8.17k| tertiaries.appendTo(sink); 662| 8.17k| } 663| | 664| 8.19k| if((levels & Collation::QUATERNARY_LEVEL_FLAG) != 0) { ------------------ | Branch (664:8): [True: 346, False: 7.84k] ------------------ 665| 346| if(!callback.needToWrite(Collation::QUATERNARY_LEVEL)) { return; } ------------------ | Branch (665:12): [True: 0, False: 346] ------------------ 666| 346| ok &= quaternaries.isOk(); 667| 346| sink.Append(Collation::LEVEL_SEPARATOR_BYTE); 668| 346| quaternaries.appendTo(sink); 669| 346| } 670| | 671| 8.19k| if(!ok || !sink.IsOk()) { ------------------ | Branch (671:8): [True: 0, False: 8.19k] | Branch (671:15): [True: 0, False: 8.19k] ------------------ 672| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 673| 0| } 674| 8.19k|} collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevelC2Ev: 93| 32.7k| SortKeyLevel() : len(0), ok(true) {} collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevel10appendByteEj: 127| 950k|void SortKeyLevel::appendByte(uint32_t b) { 128| 950k| if(len < buffer.getCapacity() || ensureCapacity(1)) { ------------------ | Branch (128:8): [True: 947k, False: 2.12k] | Branch (128:38): [True: 2.12k, False: 0] ------------------ 129| 950k| buffer[len++] = static_cast(b); 130| 950k| } 131| 950k|} collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevel14ensureCapacityEi: 188| 4.84k|UBool SortKeyLevel::ensureCapacity(int32_t appendCapacity) { 189| 4.84k| if(!ok) { ------------------ | Branch (189:8): [True: 0, False: 4.84k] ------------------ 190| 0| return false; 191| 0| } 192| 4.84k| int32_t newCapacity = 2 * buffer.getCapacity(); 193| 4.84k| int32_t altCapacity = len + 2 * appendCapacity; 194| 4.84k| if (newCapacity < altCapacity) { ------------------ | Branch (194:9): [True: 0, False: 4.84k] ------------------ 195| 0| newCapacity = altCapacity; 196| 0| } 197| 4.84k| if (newCapacity < 200) { ------------------ | Branch (197:9): [True: 2.55k, False: 2.28k] ------------------ 198| 2.55k| newCapacity = 200; 199| 2.55k| } 200| 4.84k| if(buffer.resize(newCapacity, len)==nullptr) { ------------------ | Branch (200:8): [True: 0, False: 4.84k] ------------------ 201| 0| return ok = false; 202| 0| } 203| 4.84k| return true; 204| 4.84k|} collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevel14appendWeight32Ej: 148| 17.6k|SortKeyLevel::appendWeight32(uint32_t w) { 149| 17.6k| U_ASSERT(w != 0); ------------------ | | 35| 17.6k|# define U_ASSERT(exp) (void)0 ------------------ 150| 17.6k| uint8_t bytes[4] = { 151| 17.6k| static_cast(w >> 24), 152| 17.6k| static_cast(w >> 16), 153| 17.6k| static_cast(w >> 8), 154| 17.6k| static_cast(w) 155| 17.6k| }; 156| 17.6k| int32_t appendLength = (bytes[1] == 0) ? 1 : (bytes[2] == 0) ? 2 : (bytes[3] == 0) ? 3 : 4; ------------------ | Branch (156:28): [True: 2.68k, False: 14.9k] | Branch (156:50): [True: 9.73k, False: 5.19k] | Branch (156:72): [True: 1.70k, False: 3.48k] ------------------ 157| 17.6k| if((len + appendLength) <= buffer.getCapacity() || ensureCapacity(appendLength)) { ------------------ | Branch (157:8): [True: 17.4k, False: 156] | Branch (157:56): [True: 156, False: 0] ------------------ 158| 17.6k| buffer[len++] = bytes[0]; 159| 17.6k| if(bytes[1] != 0) { ------------------ | Branch (159:12): [True: 14.9k, False: 2.68k] ------------------ 160| 14.9k| buffer[len++] = bytes[1]; 161| 14.9k| if(bytes[2] != 0) { ------------------ | Branch (161:16): [True: 5.19k, False: 9.73k] ------------------ 162| 5.19k| buffer[len++] = bytes[2]; 163| 5.19k| if(bytes[3] != 0) { ------------------ | Branch (163:20): [True: 3.48k, False: 1.70k] ------------------ 164| 3.48k| buffer[len++] = bytes[3]; 165| 3.48k| } 166| 5.19k| } 167| 14.9k| } 168| 17.6k| } 169| 17.6k|} collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevel14appendWeight16Ej: 134| 1.22M|SortKeyLevel::appendWeight16(uint32_t w) { 135| 1.22M| U_ASSERT((w & 0xffff) != 0); ------------------ | | 35| 1.22M|# define U_ASSERT(exp) (void)0 ------------------ 136| 1.22M| uint8_t b0 = static_cast(w >> 8); 137| 1.22M| uint8_t b1 = static_cast(w); 138| 1.22M| int32_t appendLength = (b1 == 0) ? 1 : 2; ------------------ | Branch (138:28): [True: 1.16M, False: 59.7k] ------------------ 139| 1.22M| if((len + appendLength) <= buffer.getCapacity() || ensureCapacity(appendLength)) { ------------------ | Branch (139:8): [True: 1.22M, False: 2.38k] | Branch (139:56): [True: 2.38k, False: 0] ------------------ 140| 1.22M| buffer[len++] = b0; 141| 1.22M| if(b1 != 0) { ------------------ | Branch (141:12): [True: 59.7k, False: 1.16M] ------------------ 142| 59.7k| buffer[len++] = b1; 143| 59.7k| } 144| 1.22M| } 145| 1.22M|} collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevel4dataEv: 103| 506| uint8_t *data() { return buffer.getAlias(); } collationkeys.cpp:_ZNK6icu_7812_GLOBAL__N_112SortKeyLevel6lengthEv: 99| 1.01k| int32_t length() const { return len; } collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevel21appendReverseWeight16Ej: 172| 123k|SortKeyLevel::appendReverseWeight16(uint32_t w) { 173| 123k| U_ASSERT((w & 0xffff) != 0); ------------------ | | 35| 123k|# define U_ASSERT(exp) (void)0 ------------------ 174| 123k| uint8_t b0 = static_cast(w >> 8); 175| 123k| uint8_t b1 = static_cast(w); 176| 123k| int32_t appendLength = (b1 == 0) ? 1 : 2; ------------------ | Branch (176:28): [True: 120k, False: 3.53k] ------------------ 177| 123k| if((len + appendLength) <= buffer.getCapacity() || ensureCapacity(appendLength)) { ------------------ | Branch (177:8): [True: 123k, False: 182] | Branch (177:56): [True: 182, False: 0] ------------------ 178| 123k| if(b1 == 0) { ------------------ | Branch (178:12): [True: 120k, False: 3.53k] ------------------ 179| 120k| buffer[len++] = b0; 180| 120k| } else { 181| 3.53k| buffer[len] = b1; 182| 3.53k| buffer[len + 1] = b0; 183| 3.53k| len += 2; 184| 3.53k| } 185| 123k| } 186| 123k|} collationkeys.cpp:_ZNK6icu_7812_GLOBAL__N_112SortKeyLevel7isEmptyEv: 98| 202| UBool isEmpty() const { return len == 0; } collationkeys.cpp:_ZNK6icu_7812_GLOBAL__N_112SortKeyLevel4isOkEv: 97| 16.6k| UBool isOk() const { return ok; } collationkeys.cpp:_ZNK6icu_7812_GLOBAL__N_112SortKeyLevel8appendToERNS_8ByteSinkE: 111| 16.6k| void appendTo(ByteSink &sink) const { 112| 16.6k| U_ASSERT(len > 0 && buffer[len - 1] == 1); ------------------ | | 35| 16.6k|# define U_ASSERT(exp) (void)0 ------------------ 113| 16.6k| sink.Append(reinterpret_cast(buffer.getAlias()), len - 1); 114| 16.6k| } collationkeys.cpp:_ZN6icu_7812_GLOBAL__N_112SortKeyLevelD2Ev: 94| 32.7k| ~SortKeyLevel() {} _ZN6icu_7815SortKeyByteSinkC2EPci: 35| 8.19k| : buffer_(dest), capacity_(destCapacity), 36| 8.19k| appended_(0), ignore_(0) {} _ZNK6icu_7815SortKeyByteSink21NumberOfBytesAppendedEv: 56| 8.19k| int32_t NumberOfBytesAppended() const { return appended_; } _ZN6icu_7815SortKeyByteSink6AppendEj: 42| 2.27M| void Append(uint32_t b) { 43| 2.27M| if (ignore_ > 0) { ------------------ | Branch (43:13): [True: 0, False: 2.27M] ------------------ 44| 0| --ignore_; 45| 2.27M| } else { 46| 2.27M| if (appended_ < capacity_ || Resize(1, appended_)) { ------------------ | Branch (46:17): [True: 1.13M, False: 1.13M] | Branch (46:42): [True: 1.89k, False: 1.13M] ------------------ 47| 1.13M| buffer_[appended_] = static_cast(b); 48| 1.13M| } 49| 2.27M| ++appended_; 50| 2.27M| } 51| 2.27M| } _ZNK6icu_7815SortKeyByteSink4IsOkEv: 69| 8.19k| UBool IsOk() const { return buffer_ != nullptr; } _ZN6icu_7813CollationRoot4loadEPKcR10UErrorCode: 79| 1|CollationRoot::load(const char* ucadataPath, UErrorCode &errorCode) { 80| 1| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (80:8): [True: 0, False: 1] ------------------ 81| 1| LocalPointer t(new CollationTailoring(nullptr)); 82| 1| if(t.isNull() || t->isBogus()) { ------------------ | Branch (82:8): [True: 0, False: 1] | Branch (82:22): [True: 0, False: 1] ------------------ 83| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 84| 0| return; 85| 0| } 86| 1| t->memory = ucadataPath ? CollationRoot::loadFromFile(ucadataPath, errorCode) : ------------------ | Branch (86:17): [True: 0, False: 1] ------------------ 87| 1| udata_openChoice(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll", ------------------ | | 894| 1|#define udata_openChoice U_ICU_ENTRY_POINT_RENAME(udata_openChoice) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ udata_openChoice(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll", ------------------ | | 154| 1|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER ------------------ 88| 1| "icu", "ucadata", 89| 1| CollationDataReader::isAcceptable, 90| 1| t->version, &errorCode); 91| 1| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (91:8): [True: 0, False: 1] ------------------ 92| 1| const uint8_t *inBytes = static_cast(udata_getMemory(t->memory)); ------------------ | | 891| 1|#define udata_getMemory U_ICU_ENTRY_POINT_RENAME(udata_getMemory) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 93| 1| CollationDataReader::read(nullptr, inBytes, udata_getLength(t->memory), *t, errorCode); ------------------ | | 890| 1|#define udata_getLength U_ICU_ENTRY_POINT_RENAME(udata_getLength) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 94| 1| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (94:8): [True: 0, False: 1] ------------------ 95| 1| ucln_i18n_registerCleanup(UCLN_I18N_COLLATION_ROOT, uprv_collation_root_cleanup); ------------------ | | 618| 1|#define ucln_i18n_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_i18n_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 96| 1| CollationCacheEntry *entry = new CollationCacheEntry(Locale::getRoot(), t.getAlias()); 97| 1| if(entry != nullptr) { ------------------ | Branch (97:8): [True: 1, False: 0] ------------------ 98| 1| t.orphan(); // The rootSingleton took ownership of the tailoring. 99| 1| entry->addRef(); 100| 1| rootSingleton = entry; 101| 1| } 102| 1|} _ZN6icu_7813CollationRoot7getRootER10UErrorCode: 112| 7.71k|CollationRoot::getRoot(UErrorCode &errorCode) { 113| 7.71k| umtx_initOnce(initOnce, CollationRoot::load, static_cast(nullptr), errorCode); 114| 7.71k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (114:8): [True: 0, False: 7.71k] ------------------ 115| 7.71k| return rootSingleton->tailoring; 116| 7.71k|} _ZNK6icu_7821CollationRootElements25firstCEWithPrimaryAtLeastEj: 71| 4|CollationRootElements::firstCEWithPrimaryAtLeast(uint32_t p) const { 72| 4| if(p == 0) { return 0; } ------------------ | Branch (72:8): [True: 0, False: 4] ------------------ 73| 4| int32_t index = findP(p); 74| 4| if(p != (elements[index] & 0xffffff00)) { ------------------ | Branch (74:8): [True: 4, False: 0] ------------------ 75| 4| for(;;) { 76| 4| p = elements[++index]; 77| 4| if((p & SEC_TER_DELTA_FLAG) == 0) { ------------------ | Branch (77:16): [True: 4, False: 0] ------------------ 78| | // First primary after p. We must not be in a primary range. 79| 4| U_ASSERT((p & PRIMARY_STEP_MASK) == 0); ------------------ | | 35| 4|# define U_ASSERT(exp) (void)0 ------------------ 80| 4| break; 81| 4| } 82| 4| } 83| 4| } 84| | // The code above guarantees that p has at most 3 bytes: (p & 0xff) == 0. 85| 4| return (static_cast(p) << 32) | Collation::COMMON_SEC_AND_TER_CE; 86| 4|} _ZNK6icu_7821CollationRootElements16getPrimaryBeforeEja: 89| 4.65k|CollationRootElements::getPrimaryBefore(uint32_t p, UBool isCompressible) const { 90| 4.65k| int32_t index = findPrimary(p); 91| 4.65k| int32_t step; 92| 4.65k| uint32_t q = elements[index]; 93| 4.65k| if(p == (q & 0xffffff00)) { ------------------ | Branch (93:8): [True: 2.44k, False: 2.20k] ------------------ 94| | // Found p itself. Return the previous primary. 95| | // See if p is at the end of a previous range. 96| 2.44k| step = static_cast(q) & PRIMARY_STEP_MASK; 97| 2.44k| if(step == 0) { ------------------ | Branch (97:12): [True: 2.01k, False: 431] ------------------ 98| | // p is not at the end of a range. Look for the previous primary. 99| 3.96k| do { 100| 3.96k| p = elements[--index]; 101| 3.96k| } while((p & SEC_TER_DELTA_FLAG) != 0); ------------------ | Branch (101:21): [True: 1.95k, False: 2.01k] ------------------ 102| 2.01k| return p & 0xffffff00; 103| 2.01k| } 104| 2.44k| } else { 105| | // p is in a range, and not at the start. 106| 2.20k| uint32_t nextElement = elements[index + 1]; 107| 2.20k| U_ASSERT(isEndOfPrimaryRange(nextElement)); ------------------ | | 35| 2.20k|# define U_ASSERT(exp) (void)0 ------------------ 108| 2.20k| step = static_cast(nextElement) & PRIMARY_STEP_MASK; 109| 2.20k| } 110| | // Return the previous range primary. 111| 2.64k| if((p & 0xffff) == 0) { ------------------ | Branch (111:8): [True: 2.26k, False: 377] ------------------ 112| 2.26k| return Collation::decTwoBytePrimaryByOneStep(p, isCompressible, step); 113| 2.26k| } else { 114| 377| return Collation::decThreeBytePrimaryByOneStep(p, isCompressible, step); 115| 377| } 116| 2.64k|} _ZNK6icu_7821CollationRootElements18getSecondaryBeforeEjj: 119| 783|CollationRootElements::getSecondaryBefore(uint32_t p, uint32_t s) const { 120| 783| int32_t index; 121| 783| uint32_t previousSec, sec; 122| 783| if(p == 0) { ------------------ | Branch (122:8): [True: 0, False: 783] ------------------ 123| 0| index = static_cast(elements[IX_FIRST_SECONDARY_INDEX]); 124| | // Gap at the beginning of the secondary CE range. 125| 0| previousSec = 0; 126| 0| sec = elements[index] >> 16; 127| 783| } else { 128| 783| index = findPrimary(p) + 1; 129| 783| previousSec = Collation::BEFORE_WEIGHT16; 130| 783| sec = getFirstSecTerForPrimary(index) >> 16; 131| 783| } 132| 783| U_ASSERT(s >= sec); ------------------ | | 35| 783|# define U_ASSERT(exp) (void)0 ------------------ 133| 783| while(s > sec) { ------------------ | Branch (133:11): [True: 0, False: 783] ------------------ 134| 0| previousSec = sec; 135| 0| U_ASSERT((elements[index] & SEC_TER_DELTA_FLAG) != 0); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 136| 0| sec = elements[index++] >> 16; 137| 0| } 138| 783| U_ASSERT(sec == s); ------------------ | | 35| 783|# define U_ASSERT(exp) (void)0 ------------------ 139| 783| return previousSec; 140| 783|} _ZNK6icu_7821CollationRootElements17getTertiaryBeforeEjjj: 143| 220|CollationRootElements::getTertiaryBefore(uint32_t p, uint32_t s, uint32_t t) const { 144| 220| U_ASSERT((t & ~Collation::ONLY_TERTIARY_MASK) == 0); ------------------ | | 35| 220|# define U_ASSERT(exp) (void)0 ------------------ 145| 220| int32_t index; 146| 220| uint32_t previousTer, secTer; 147| 220| if(p == 0) { ------------------ | Branch (147:8): [True: 8, False: 212] ------------------ 148| 8| if(s == 0) { ------------------ | Branch (148:12): [True: 0, False: 8] ------------------ 149| 0| index = static_cast(elements[IX_FIRST_TERTIARY_INDEX]); 150| | // Gap at the beginning of the tertiary CE range. 151| 0| previousTer = 0; 152| 8| } else { 153| 8| index = static_cast(elements[IX_FIRST_SECONDARY_INDEX]); 154| 8| previousTer = Collation::BEFORE_WEIGHT16; 155| 8| } 156| 8| secTer = elements[index] & ~SEC_TER_DELTA_FLAG; 157| 212| } else { 158| 212| index = findPrimary(p) + 1; 159| 212| previousTer = Collation::BEFORE_WEIGHT16; 160| 212| secTer = getFirstSecTerForPrimary(index); 161| 212| } 162| 220| uint32_t st = (s << 16) | t; 163| 620| while(st > secTer) { ------------------ | Branch (163:11): [True: 400, False: 220] ------------------ 164| 400| if((secTer >> 16) == s) { previousTer = secTer; } ------------------ | Branch (164:12): [True: 160, False: 240] ------------------ 165| 400| U_ASSERT((elements[index] & SEC_TER_DELTA_FLAG) != 0); ------------------ | | 35| 400|# define U_ASSERT(exp) (void)0 ------------------ 166| 400| secTer = elements[index++] & ~SEC_TER_DELTA_FLAG; 167| 400| } 168| 220| U_ASSERT(secTer == st); ------------------ | | 35| 220|# define U_ASSERT(exp) (void)0 ------------------ 169| 220| return previousTer & 0xffff; 170| 220|} _ZNK6icu_7821CollationRootElements15getPrimaryAfterEjia: 173| 7.57k|CollationRootElements::getPrimaryAfter(uint32_t p, int32_t index, UBool isCompressible) const { 174| 7.57k| U_ASSERT(p == (elements[index] & 0xffffff00) || isEndOfPrimaryRange(elements[index + 1])); ------------------ | | 35| 7.57k|# define U_ASSERT(exp) (void)0 ------------------ 175| 7.57k| uint32_t q = elements[++index]; 176| 7.57k| int32_t step; 177| 7.57k| if ((q & SEC_TER_DELTA_FLAG) == 0 && (step = static_cast(q) & PRIMARY_STEP_MASK) != 0) { ------------------ | Branch (177:9): [True: 4.90k, False: 2.66k] | Branch (177:42): [True: 4.01k, False: 894] ------------------ 178| | // Return the next primary in this range. 179| 4.01k| if((p & 0xffff) == 0) { ------------------ | Branch (179:12): [True: 2.31k, False: 1.69k] ------------------ 180| 2.31k| return Collation::incTwoBytePrimaryByOffset(p, isCompressible, step); 181| 2.31k| } else { 182| 1.69k| return Collation::incThreeBytePrimaryByOffset(p, isCompressible, step); 183| 1.69k| } 184| 4.01k| } else { 185| | // Return the next primary in the list. 186| 19.8k| while((q & SEC_TER_DELTA_FLAG) != 0) { ------------------ | Branch (186:15): [True: 16.3k, False: 3.56k] ------------------ 187| 16.3k| q = elements[++index]; 188| 16.3k| } 189| 3.56k| U_ASSERT((q & PRIMARY_STEP_MASK) == 0); ------------------ | | 35| 3.56k|# define U_ASSERT(exp) (void)0 ------------------ 190| 3.56k| return q; 191| 3.56k| } 192| 7.57k|} _ZNK6icu_7821CollationRootElements17getSecondaryAfterEij: 195| 3.86k|CollationRootElements::getSecondaryAfter(int32_t index, uint32_t s) const { 196| 3.86k| uint32_t secTer; 197| 3.86k| uint32_t secLimit; 198| 3.86k| if(index == 0) { ------------------ | Branch (198:8): [True: 949, False: 2.91k] ------------------ 199| | // primary = 0 200| 949| U_ASSERT(s != 0); ------------------ | | 35| 949|# define U_ASSERT(exp) (void)0 ------------------ 201| 949| index = static_cast(elements[IX_FIRST_SECONDARY_INDEX]); 202| 949| secTer = elements[index]; 203| | // Gap at the end of the secondary CE range. 204| 949| secLimit = 0x10000; 205| 2.91k| } else { 206| 2.91k| U_ASSERT(index >= (int32_t)elements[IX_FIRST_PRIMARY_INDEX]); ------------------ | | 35| 2.91k|# define U_ASSERT(exp) (void)0 ------------------ 207| 2.91k| secTer = getFirstSecTerForPrimary(index + 1); 208| | // If this is an explicit sec/ter unit, then it will be read once more. 209| | // Gap for secondaries of primary CEs. 210| 2.91k| secLimit = getSecondaryBoundary(); 211| 2.91k| } 212| 126k| for(;;) { 213| 126k| uint32_t sec = secTer >> 16; 214| 126k| if(sec > s) { return sec; } ------------------ | Branch (214:12): [True: 1.23k, False: 124k] ------------------ 215| 124k| secTer = elements[++index]; 216| 124k| if((secTer & SEC_TER_DELTA_FLAG) == 0) { return secLimit; } ------------------ | Branch (216:12): [True: 2.62k, False: 122k] ------------------ 217| 124k| } 218| 3.86k|} _ZNK6icu_7821CollationRootElements16getTertiaryAfterEijj: 221| 2.05k|CollationRootElements::getTertiaryAfter(int32_t index, uint32_t s, uint32_t t) const { 222| 2.05k| uint32_t secTer; 223| 2.05k| uint32_t terLimit; 224| 2.05k| if(index == 0) { ------------------ | Branch (224:8): [True: 346, False: 1.70k] ------------------ 225| | // primary = 0 226| 346| if(s == 0) { ------------------ | Branch (226:12): [True: 73, False: 273] ------------------ 227| 73| U_ASSERT(t != 0); ------------------ | | 35| 73|# define U_ASSERT(exp) (void)0 ------------------ 228| 73| index = static_cast(elements[IX_FIRST_TERTIARY_INDEX]); 229| | // Gap at the end of the tertiary CE range. 230| 73| terLimit = 0x4000; 231| 273| } else { 232| 273| index = static_cast(elements[IX_FIRST_SECONDARY_INDEX]); 233| | // Gap for tertiaries of primary/secondary CEs. 234| 273| terLimit = getTertiaryBoundary(); 235| 273| } 236| 346| secTer = elements[index] & ~SEC_TER_DELTA_FLAG; 237| 1.70k| } else { 238| 1.70k| U_ASSERT(index >= (int32_t)elements[IX_FIRST_PRIMARY_INDEX]); ------------------ | | 35| 1.70k|# define U_ASSERT(exp) (void)0 ------------------ 239| 1.70k| secTer = getFirstSecTerForPrimary(index + 1); 240| | // If this is an explicit sec/ter unit, then it will be read once more. 241| 1.70k| terLimit = getTertiaryBoundary(); 242| 1.70k| } 243| 2.05k| uint32_t st = (s << 16) | t; 244| 19.8k| for(;;) { 245| 19.8k| if(secTer > st) { ------------------ | Branch (245:12): [True: 995, False: 18.8k] ------------------ 246| 995| U_ASSERT((secTer >> 16) == s); ------------------ | | 35| 995|# define U_ASSERT(exp) (void)0 ------------------ 247| 995| return secTer & 0xffff; 248| 995| } 249| 18.8k| secTer = elements[++index]; 250| | // No tertiary greater than t for this primary+secondary. 251| 18.8k| if((secTer & SEC_TER_DELTA_FLAG) == 0 || (secTer >> 16) > s) { return terLimit; } ------------------ | Branch (251:12): [True: 752, False: 18.1k] | Branch (251:50): [True: 305, False: 17.8k] ------------------ 252| 17.8k| secTer &= ~SEC_TER_DELTA_FLAG; 253| 17.8k| } 254| 2.05k|} _ZNK6icu_7821CollationRootElements24getFirstSecTerForPrimaryEi: 257| 5.61k|CollationRootElements::getFirstSecTerForPrimary(int32_t index) const { 258| 5.61k| uint32_t secTer = elements[index]; 259| 5.61k| if((secTer & SEC_TER_DELTA_FLAG) == 0) { ------------------ | Branch (259:8): [True: 2.59k, False: 3.01k] ------------------ 260| | // No sec/ter delta. 261| 2.59k| return Collation::COMMON_SEC_AND_TER_CE; 262| 2.59k| } 263| 3.01k| secTer &= ~SEC_TER_DELTA_FLAG; 264| 3.01k| if(secTer > Collation::COMMON_SEC_AND_TER_CE) { ------------------ | Branch (264:8): [True: 2.76k, False: 254] ------------------ 265| | // Implied sec/ter. 266| 2.76k| return Collation::COMMON_SEC_AND_TER_CE; 267| 2.76k| } 268| | // Explicit sec/ter below common/common. 269| 254| return secTer; 270| 3.01k|} _ZNK6icu_7821CollationRootElements11findPrimaryEj: 273| 18.9k|CollationRootElements::findPrimary(uint32_t p) const { 274| | // Requirement: p must occur as a root primary. 275| 18.9k| U_ASSERT((p & 0xff) == 0); // at most a 3-byte primary ------------------ | | 35| 18.9k|# define U_ASSERT(exp) (void)0 ------------------ 276| 18.9k| int32_t index = findP(p); 277| | // If p is in a range, then we just assume that p is an actual primary in this range. 278| | // (Too cumbersome/expensive to check.) 279| | // Otherwise, it must be an exact match. 280| 18.9k| U_ASSERT(isEndOfPrimaryRange(elements[index + 1]) || p == (elements[index] & 0xffffff00)); ------------------ | | 35| 18.9k|# define U_ASSERT(exp) (void)0 ------------------ 281| 18.9k| return index; 282| 18.9k|} _ZNK6icu_7821CollationRootElements5findPEj: 285| 18.9k|CollationRootElements::findP(uint32_t p) const { 286| | // p need not occur as a root primary. 287| | // For example, it might be a reordering group boundary. 288| 18.9k| U_ASSERT((p >> 24) != Collation::UNASSIGNED_IMPLICIT_BYTE); ------------------ | | 35| 18.9k|# define U_ASSERT(exp) (void)0 ------------------ 289| | // modified binary search 290| 18.9k| int32_t start = static_cast(elements[IX_FIRST_PRIMARY_INDEX]); 291| 18.9k| U_ASSERT(p >= elements[start]); ------------------ | | 35| 18.9k|# define U_ASSERT(exp) (void)0 ------------------ 292| 18.9k| int32_t limit = length - 1; 293| 18.9k| U_ASSERT(elements[limit] >= PRIMARY_SENTINEL); ------------------ | | 35| 18.9k|# define U_ASSERT(exp) (void)0 ------------------ 294| 18.9k| U_ASSERT(p < elements[limit]); ------------------ | | 35| 18.9k|# define U_ASSERT(exp) (void)0 ------------------ 295| 239k| while((start + 1) < limit) { ------------------ | Branch (295:11): [True: 228k, False: 10.1k] ------------------ 296| | // Invariant: elements[start] and elements[limit] are primaries, 297| | // and elements[start]<=p<=elements[limit]. 298| 228k| int32_t i = (start + limit) / 2; 299| 228k| uint32_t q = elements[i]; 300| 228k| if((q & SEC_TER_DELTA_FLAG) != 0) { ------------------ | Branch (300:12): [True: 91.2k, False: 137k] ------------------ 301| | // Find the next primary. 302| 91.2k| int32_t j = i + 1; 303| 295k| for(;;) { 304| 295k| if(j == limit) { break; } ------------------ | Branch (304:20): [True: 13.3k, False: 282k] ------------------ 305| 282k| q = elements[j]; 306| 282k| if((q & SEC_TER_DELTA_FLAG) == 0) { ------------------ | Branch (306:20): [True: 77.9k, False: 204k] ------------------ 307| 77.9k| i = j; 308| 77.9k| break; 309| 77.9k| } 310| 204k| ++j; 311| 204k| } 312| 91.2k| if((q & SEC_TER_DELTA_FLAG) != 0) { ------------------ | Branch (312:16): [True: 13.3k, False: 77.9k] ------------------ 313| | // Find the preceding primary. 314| 13.3k| j = i - 1; 315| 50.1k| for(;;) { 316| 50.1k| if(j == start) { break; } ------------------ | Branch (316:24): [True: 8.80k, False: 41.3k] ------------------ 317| 41.3k| q = elements[j]; 318| 41.3k| if((q & SEC_TER_DELTA_FLAG) == 0) { ------------------ | Branch (318:24): [True: 4.51k, False: 36.8k] ------------------ 319| 4.51k| i = j; 320| 4.51k| break; 321| 4.51k| } 322| 36.8k| --j; 323| 36.8k| } 324| 13.3k| if((q & SEC_TER_DELTA_FLAG) != 0) { ------------------ | Branch (324:20): [True: 8.80k, False: 4.51k] ------------------ 325| | // No primary between start and limit. 326| 8.80k| break; 327| 8.80k| } 328| 13.3k| } 329| 91.2k| } 330| 220k| if(p < (q & 0xffffff00)) { // Reset the "step" bits of a range end primary. ------------------ | Branch (330:12): [True: 116k, False: 103k] ------------------ 331| 116k| limit = i; 332| 116k| } else { 333| 103k| start = i; 334| 103k| } 335| 220k| } 336| 18.9k| return start; 337| 18.9k|} _ZN6icu_7821CollationRootElementsC2EPKji: 36| 7.71k| : elements(rootElements), length(rootElementsLength) {} _ZNK6icu_7821CollationRootElements15getFirstPrimaryEv: 145| 4.65k| uint32_t getFirstPrimary() const { 146| 4.65k| return elements[elements[IX_FIRST_PRIMARY_INDEX]]; // step=0: cannot be a range end 147| 4.65k| } _ZNK6icu_7821CollationRootElements18getFirstTertiaryCEEv: 99| 165| uint32_t getFirstTertiaryCE() const { 100| 165| return elements[elements[IX_FIRST_TERTIARY_INDEX]] & ~SEC_TER_DELTA_FLAG; 101| 165| } _ZNK6icu_7821CollationRootElements17getLastTertiaryCEEv: 106| 736| uint32_t getLastTertiaryCE() const { 107| 736| return elements[elements[IX_FIRST_SECONDARY_INDEX] - 1] & ~SEC_TER_DELTA_FLAG; 108| 736| } _ZNK6icu_7821CollationRootElements19getFirstSecondaryCEEv: 131| 67| uint32_t getFirstSecondaryCE() const { 132| 67| return elements[elements[IX_FIRST_SECONDARY_INDEX]] & ~SEC_TER_DELTA_FLAG; 133| 67| } _ZNK6icu_7821CollationRootElements17getFirstPrimaryCEEv: 152| 1| int64_t getFirstPrimaryCE() const { 153| 1| return Collation::makeCE(getFirstPrimary()); 154| 1| } _ZNK6icu_7821CollationRootElements19getTertiaryBoundaryEv: 92| 7.15k| uint32_t getTertiaryBoundary() const { 93| 7.15k| return (elements[IX_SEC_TER_BOUNDARIES] << 8) & 0xff00; 94| 7.15k| } _ZNK6icu_7821CollationRootElements20getSecondaryBoundaryEv: 124| 4.63k| uint32_t getSecondaryBoundary() const { 125| 4.63k| return (elements[IX_SEC_TER_BOUNDARIES] >> 8) & 0xff00; 126| 4.63k| } _ZNK6icu_7821CollationRootElements22getLastCommonSecondaryEv: 114| 4.32k| uint32_t getLastCommonSecondary() const { 115| 4.32k| return (elements[IX_SEC_TER_BOUNDARIES] >> 16) & 0xff00; 116| 4.32k| } _ZN6icu_7819CollationRuleParser4SinkD2Ev: 49| 7.71k|CollationRuleParser::Sink::~Sink() {} _ZN6icu_7819CollationRuleParser8ImporterD2Ev: 57| 7.71k|CollationRuleParser::Importer::~Importer() {} _ZN6icu_7819CollationRuleParserC2EPKNS_13CollationDataER10UErrorCode: 60| 7.71k| : nfd(*Normalizer2::getNFDInstance(errorCode)), 61| 7.71k| nfc(*Normalizer2::getNFCInstance(errorCode)), 62| 7.71k| rules(nullptr), baseData(base), settings(nullptr), 63| 7.71k| parseError(nullptr), errorReason(nullptr), 64| 7.71k| sink(nullptr), importer(nullptr), 65| 7.71k| ruleIndex(0) { 66| 7.71k|} _ZN6icu_7819CollationRuleParserD2Ev: 68| 7.71k|CollationRuleParser::~CollationRuleParser() { 69| 7.71k|} _ZN6icu_7819CollationRuleParser5parseERKNS_13UnicodeStringERNS_17CollationSettingsEP11UParseErrorR10UErrorCode: 75| 7.71k| UErrorCode &errorCode) { 76| 7.71k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (76:8): [True: 0, False: 7.71k] ------------------ 77| 7.71k| settings = &outSettings; 78| 7.71k| parseError = outParseError; 79| 7.71k| if(parseError != nullptr) { ------------------ | Branch (79:8): [True: 0, False: 7.71k] ------------------ 80| 0| parseError->line = 0; 81| 0| parseError->offset = -1; 82| 0| parseError->preContext[0] = 0; 83| 0| parseError->postContext[0] = 0; 84| 0| } 85| 7.71k| errorReason = nullptr; 86| 7.71k| parse(ruleString, errorCode); 87| 7.71k|} _ZN6icu_7819CollationRuleParser5parseERKNS_13UnicodeStringER10UErrorCode: 90| 12.5k|CollationRuleParser::parse(const UnicodeString &ruleString, UErrorCode &errorCode) { 91| 12.5k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (91:8): [True: 0, False: 12.5k] ------------------ 92| 12.5k| rules = &ruleString; 93| 12.5k| ruleIndex = 0; 94| | 95| 341k| while(ruleIndex < rules->length()) { ------------------ | Branch (95:11): [True: 332k, False: 8.93k] ------------------ 96| 332k| char16_t c = rules->charAt(ruleIndex); 97| 332k| if(PatternProps::isWhiteSpace(c)) { ------------------ | Branch (97:12): [True: 383, False: 332k] ------------------ 98| 383| ++ruleIndex; 99| 383| continue; 100| 383| } 101| 332k| switch(c) { 102| 317k| case 0x26: // '&' ------------------ | Branch (102:9): [True: 317k, False: 14.9k] ------------------ 103| 317k| parseRuleChain(errorCode); 104| 317k| break; 105| 12.5k| case 0x5b: // '[' ------------------ | Branch (105:9): [True: 12.5k, False: 319k] ------------------ 106| 12.5k| parseSetting(errorCode); 107| 12.5k| break; 108| 1.13k| case 0x23: // '#' starts a comment, until the end of the line ------------------ | Branch (108:9): [True: 1.13k, False: 331k] ------------------ 109| 1.13k| ruleIndex = skipComment(ruleIndex + 1); 110| 1.13k| break; 111| 591| case 0x40: // '@' is equivalent to [backwards 2] ------------------ | Branch (111:9): [True: 591, False: 331k] ------------------ 112| 591| settings->setFlag(CollationSettings::BACKWARD_SECONDARY, 113| 591| UCOL_ON, 0, errorCode); 114| 591| ++ruleIndex; 115| 591| break; 116| 347| case 0x21: // '!' used to turn on Thai/Lao character reversal ------------------ | Branch (116:9): [True: 347, False: 332k] ------------------ 117| | // Accept but ignore. The root collator has contractions 118| | // that are equivalent to the character reversal, where appropriate. 119| 347| ++ruleIndex; 120| 347| break; 121| 259| default: ------------------ | Branch (121:9): [True: 259, False: 332k] ------------------ 122| 259| setParseError("expected a reset or setting or comment", errorCode); 123| 259| break; 124| 332k| } 125| 332k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (125:12): [True: 3.59k, False: 328k] ------------------ 126| 332k| } 127| 12.5k|} _ZN6icu_7819CollationRuleParser14parseRuleChainER10UErrorCode: 130| 317k|CollationRuleParser::parseRuleChain(UErrorCode &errorCode) { 131| 317k| int32_t resetStrength = parseResetAndPosition(errorCode); 132| 317k| UBool isFirstRelation = true; 133| 982k| for(;;) { 134| 982k| int32_t result = parseRelationOperator(errorCode); 135| 982k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (135:12): [True: 195, False: 982k] ------------------ 136| 982k| if(result < 0) { ------------------ | Branch (136:12): [True: 318k, False: 664k] ------------------ 137| 318k| if(ruleIndex < rules->length() && rules->charAt(ruleIndex) == 0x23) { ------------------ | Branch (137:16): [True: 310k, False: 8.23k] | Branch (137:47): [True: 1.61k, False: 308k] ------------------ 138| | // '#' starts a comment, until the end of the line 139| 1.61k| ruleIndex = skipComment(ruleIndex + 1); 140| 1.61k| continue; 141| 1.61k| } 142| 316k| if(isFirstRelation) { ------------------ | Branch (142:16): [True: 452, False: 316k] ------------------ 143| 452| setParseError("reset not followed by a relation", errorCode); 144| 452| } 145| 316k| return; 146| 318k| } 147| 664k| int32_t strength = result & STRENGTH_MASK; 148| 664k| if(resetStrength < UCOL_IDENTICAL) { ------------------ | Branch (148:12): [True: 16.5k, False: 647k] ------------------ 149| | // reset-before rule chain 150| 16.5k| if(isFirstRelation) { ------------------ | Branch (150:16): [True: 6.61k, False: 9.92k] ------------------ 151| 6.61k| if(strength != resetStrength) { ------------------ | Branch (151:20): [True: 0, False: 6.61k] ------------------ 152| 0| setParseError("reset-before strength differs from its first relation", errorCode); 153| 0| return; 154| 0| } 155| 9.92k| } else { 156| 9.92k| if(strength < resetStrength) { ------------------ | Branch (156:20): [True: 0, False: 9.92k] ------------------ 157| 0| setParseError("reset-before strength followed by a stronger relation", errorCode); 158| 0| return; 159| 0| } 160| 9.92k| } 161| 16.5k| } 162| 664k| int32_t i = ruleIndex + (result >> OFFSET_SHIFT); // skip over the relation operator 163| 664k| if((result & STARRED_FLAG) == 0) { ------------------ | Branch (163:12): [True: 652k, False: 11.2k] ------------------ 164| 652k| parseRelationStrings(strength, i, errorCode); 165| 652k| } else { 166| 11.2k| parseStarredCharacters(strength, i, errorCode); 167| 11.2k| } 168| 664k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (168:12): [True: 554, False: 663k] ------------------ 169| 663k| isFirstRelation = false; 170| 663k| } 171| 317k|} _ZN6icu_7819CollationRuleParser21parseResetAndPositionER10UErrorCode: 174| 317k|CollationRuleParser::parseResetAndPosition(UErrorCode &errorCode) { 175| 317k| if(U_FAILURE(errorCode)) { return UCOL_DEFAULT; } ------------------ | Branch (175:8): [True: 0, False: 317k] ------------------ 176| 317k| int32_t i = skipWhiteSpace(ruleIndex + 1); 177| 317k| int32_t j; 178| 317k| char16_t c; 179| 317k| int32_t resetStrength; 180| 317k| if(rules->compare(i, BEFORE_LENGTH, BEFORE, 0, BEFORE_LENGTH) == 0 && ------------------ | Branch (180:8): [True: 6.61k, False: 310k] ------------------ 181| 317k| (j = i + BEFORE_LENGTH) < rules->length() && ------------------ | Branch (181:13): [True: 6.61k, False: 0] ------------------ 182| 317k| PatternProps::isWhiteSpace(rules->charAt(j)) && ------------------ | Branch (182:13): [True: 6.61k, False: 0] ------------------ 183| 317k| ((j = skipWhiteSpace(j + 1)) + 1) < rules->length() && ------------------ | Branch (183:13): [True: 6.61k, False: 0] ------------------ 184| 317k| 0x31 <= (c = rules->charAt(j)) && c <= 0x33 && ------------------ | Branch (184:13): [True: 6.61k, False: 0] | Branch (184:47): [True: 6.61k, False: 0] ------------------ 185| 317k| rules->charAt(j + 1) == 0x5d) { ------------------ | Branch (185:13): [True: 6.61k, False: 0] ------------------ 186| | // &[before n] with n=1 or 2 or 3 187| 6.61k| resetStrength = UCOL_PRIMARY + (c - 0x31); 188| 6.61k| i = skipWhiteSpace(j + 2); 189| 310k| } else { 190| 310k| resetStrength = UCOL_IDENTICAL; 191| 310k| } 192| 317k| if(i >= rules->length()) { ------------------ | Branch (192:8): [True: 47, False: 317k] ------------------ 193| 47| setParseError("reset without position", errorCode); 194| 47| return UCOL_DEFAULT; 195| 47| } 196| 317k| UnicodeString str; 197| 317k| if(rules->charAt(i) == 0x5b) { // '[' ------------------ | Branch (197:8): [True: 928, False: 316k] ------------------ 198| 928| i = parseSpecialPosition(i, str, errorCode); 199| 316k| } else { 200| 316k| i = parseTailoringString(i, str, errorCode); 201| 316k| } 202| 317k| sink->addReset(resetStrength, str, errorReason, errorCode); 203| 317k| if(U_FAILURE(errorCode)) { setErrorContext(); } ------------------ | Branch (203:8): [True: 148, False: 317k] ------------------ 204| 317k| ruleIndex = i; 205| 317k| return resetStrength; 206| 317k|} _ZN6icu_7819CollationRuleParser21parseRelationOperatorER10UErrorCode: 209| 982k|CollationRuleParser::parseRelationOperator(UErrorCode &errorCode) { 210| 982k| if(U_FAILURE(errorCode)) { return UCOL_DEFAULT; } ------------------ | Branch (210:8): [True: 195, False: 982k] ------------------ 211| 982k| ruleIndex = skipWhiteSpace(ruleIndex); 212| 982k| if(ruleIndex >= rules->length()) { return UCOL_DEFAULT; } ------------------ | Branch (212:8): [True: 8.23k, False: 974k] ------------------ 213| 974k| int32_t strength; 214| 974k| int32_t i = ruleIndex; 215| 974k| char16_t c = rules->charAt(i++); 216| 974k| switch(c) { 217| 118k| case 0x3c: // '<' ------------------ | Branch (217:5): [True: 118k, False: 855k] ------------------ 218| 118k| if(i < rules->length() && rules->charAt(i) == 0x3c) { // << ------------------ | Branch (218:12): [True: 118k, False: 33] | Branch (218:35): [True: 77.7k, False: 40.8k] ------------------ 219| 77.7k| ++i; 220| 77.7k| if(i < rules->length() && rules->charAt(i) == 0x3c) { // <<< ------------------ | Branch (220:16): [True: 77.7k, False: 1] | Branch (220:39): [True: 54.3k, False: 23.3k] ------------------ 221| 54.3k| ++i; 222| 54.3k| if(i < rules->length() && rules->charAt(i) == 0x3c) { // <<<< ------------------ | Branch (222:20): [True: 54.3k, False: 2] | Branch (222:43): [True: 615, False: 53.6k] ------------------ 223| 615| ++i; 224| 615| strength = UCOL_QUATERNARY; 225| 53.6k| } else { 226| 53.6k| strength = UCOL_TERTIARY; 227| 53.6k| } 228| 54.3k| } else { 229| 23.3k| strength = UCOL_SECONDARY; 230| 23.3k| } 231| 77.7k| } else { 232| 40.9k| strength = UCOL_PRIMARY; 233| 40.9k| } 234| 118k| if(i < rules->length() && rules->charAt(i) == 0x2a) { // '*' ------------------ | Branch (234:12): [True: 118k, False: 40] | Branch (234:35): [True: 10.5k, False: 107k] ------------------ 235| 10.5k| ++i; 236| 10.5k| strength |= STARRED_FLAG; 237| 10.5k| } 238| 118k| break; 239| 5.41k| case 0x3b: // ';' same as << ------------------ | Branch (239:5): [True: 5.41k, False: 968k] ------------------ 240| 5.41k| strength = UCOL_SECONDARY; 241| 5.41k| break; 242| 3.60k| case 0x2c: // ',' same as <<< ------------------ | Branch (242:5): [True: 3.60k, False: 970k] ------------------ 243| 3.60k| strength = UCOL_TERTIARY; 244| 3.60k| break; 245| 536k| case 0x3d: // '=' ------------------ | Branch (245:5): [True: 536k, False: 437k] ------------------ 246| 536k| strength = UCOL_IDENTICAL; 247| 536k| if(i < rules->length() && rules->charAt(i) == 0x2a) { // '*' ------------------ | Branch (247:12): [True: 536k, False: 41] | Branch (247:35): [True: 686, False: 535k] ------------------ 248| 686| ++i; 249| 686| strength |= STARRED_FLAG; 250| 686| } 251| 536k| break; 252| 310k| default: ------------------ | Branch (252:5): [True: 310k, False: 664k] ------------------ 253| 310k| return UCOL_DEFAULT; 254| 974k| } 255| 664k| return ((i - ruleIndex) << OFFSET_SHIFT) | strength; 256| 974k|} _ZN6icu_7819CollationRuleParser20parseRelationStringsEiiR10UErrorCode: 259| 652k|CollationRuleParser::parseRelationStrings(int32_t strength, int32_t i, UErrorCode &errorCode) { 260| | // Parse 261| | // prefix | str / extension 262| | // where prefix and extension are optional. 263| 652k| UnicodeString prefix, str, extension; 264| 652k| i = parseTailoringString(i, str, errorCode); 265| 652k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (265:8): [True: 143, False: 652k] ------------------ 266| 652k| char16_t next = (i < rules->length()) ? rules->charAt(i) : 0; ------------------ | Branch (266:21): [True: 647k, False: 5.61k] ------------------ 267| 652k| if(next == 0x7c) { // '|' separates the context prefix from the string. ------------------ | Branch (267:8): [True: 4.29k, False: 648k] ------------------ 268| 4.29k| prefix = str; 269| 4.29k| i = parseTailoringString(i + 1, str, errorCode); 270| 4.29k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (270:12): [True: 7, False: 4.28k] ------------------ 271| 4.28k| next = (i < rules->length()) ? rules->charAt(i) : 0; ------------------ | Branch (271:16): [True: 3.94k, False: 340] ------------------ 272| 4.28k| } 273| 652k| if(next == 0x2f) { // '/' separates the string from the extension. ------------------ | Branch (273:8): [True: 984, False: 651k] ------------------ 274| 984| i = parseTailoringString(i + 1, extension, errorCode); 275| 984| } 276| 652k| if(!prefix.isEmpty()) { ------------------ | Branch (276:8): [True: 4.28k, False: 648k] ------------------ 277| 4.28k| UChar32 prefix0 = prefix.char32At(0); 278| 4.28k| UChar32 c = str.char32At(0); 279| 4.28k| if(!nfc.hasBoundaryBefore(prefix0) || !nfc.hasBoundaryBefore(c)) { ------------------ | Branch (279:12): [True: 3, False: 4.28k] | Branch (279:47): [True: 3, False: 4.28k] ------------------ 280| 6| setParseError("in 'prefix|str', prefix and str must each start with an NFC boundary", 281| 6| errorCode); 282| 6| return; 283| 6| } 284| 4.28k| } 285| 652k| sink->addRelation(strength, prefix, str, extension, errorReason, errorCode); 286| 652k| if(U_FAILURE(errorCode)) { setErrorContext(); } ------------------ | Branch (286:8): [True: 321, False: 652k] ------------------ 287| 652k| ruleIndex = i; 288| 652k|} _ZN6icu_7819CollationRuleParser22parseStarredCharactersEiiR10UErrorCode: 291| 11.2k|CollationRuleParser::parseStarredCharacters(int32_t strength, int32_t i, UErrorCode &errorCode) { 292| 11.2k| UnicodeString empty, raw; 293| 11.2k| i = parseString(skipWhiteSpace(i), raw, errorCode); 294| 11.2k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (294:8): [True: 1, False: 11.2k] ------------------ 295| 11.2k| if(raw.isEmpty()) { ------------------ | Branch (295:8): [True: 16, False: 11.2k] ------------------ 296| 16| setParseError("missing starred-relation string", errorCode); 297| 16| return; 298| 16| } 299| 11.2k| UChar32 prev = -1; 300| 11.2k| int32_t j = 0; 301| 17.1k| for(;;) { 302| 198k| while(j < raw.length()) { ------------------ | Branch (302:15): [True: 181k, False: 17.0k] ------------------ 303| 181k| UChar32 c = raw.char32At(j); 304| 181k| if(!nfd.isInert(c)) { ------------------ | Branch (304:16): [True: 18, False: 181k] ------------------ 305| 18| setParseError("starred-relation string is not all NFD-inert", errorCode); 306| 18| return; 307| 18| } 308| 181k| sink->addRelation(strength, empty, UnicodeString(c), empty, errorReason, errorCode); 309| 181k| if(U_FAILURE(errorCode)) { ------------------ | Branch (309:16): [True: 2, False: 181k] ------------------ 310| 2| setErrorContext(); 311| 2| return; 312| 2| } 313| 181k| j += U16_LENGTH(c); ------------------ | | 141| 181k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 181k, False: 146] | | ------------------ ------------------ 314| 181k| prev = c; 315| 181k| } 316| 17.0k| if(i >= rules->length() || rules->charAt(i) != 0x2d) { // '-' ------------------ | Branch (316:12): [True: 1.78k, False: 15.2k] | Branch (316:36): [True: 9.40k, False: 5.89k] ------------------ 317| 11.1k| break; 318| 11.1k| } 319| 5.89k| if(prev < 0) { ------------------ | Branch (319:12): [True: 2, False: 5.88k] ------------------ 320| 2| setParseError("range without start in starred-relation string", errorCode); 321| 2| return; 322| 2| } 323| 5.88k| i = parseString(i + 1, raw, errorCode); 324| 5.88k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (324:12): [True: 1, False: 5.88k] ------------------ 325| 5.88k| if(raw.isEmpty()) { ------------------ | Branch (325:12): [True: 3, False: 5.88k] ------------------ 326| 3| setParseError("range without end in starred-relation string", errorCode); 327| 3| return; 328| 3| } 329| 5.88k| UChar32 c = raw.char32At(0); 330| 5.88k| if(c < prev) { ------------------ | Branch (330:12): [True: 3, False: 5.88k] ------------------ 331| 3| setParseError("range start greater than end in starred-relation string", errorCode); 332| 3| return; 333| 3| } 334| | // range prev-c 335| 5.88k| UnicodeString s; 336| 5.16M| while(++prev <= c) { ------------------ | Branch (336:15): [True: 5.15M, False: 5.85k] ------------------ 337| 5.15M| if(!nfd.isInert(prev)) { ------------------ | Branch (337:16): [True: 29, False: 5.15M] ------------------ 338| 29| setParseError("starred-relation string range is not all NFD-inert", errorCode); 339| 29| return; 340| 29| } 341| 5.15M| if(U_IS_SURROGATE(prev)) { ------------------ | | 193| 5.15M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ | | | Branch (193:27): [True: 1, False: 5.15M] | | ------------------ ------------------ 342| 1| setParseError("starred-relation string range contains a surrogate", errorCode); 343| 1| return; 344| 1| } 345| 5.15M| if(0xfffd <= prev && prev <= 0xffff) { ------------------ | Branch (345:16): [True: 724k, False: 4.43M] | Branch (345:34): [True: 1, False: 724k] ------------------ 346| 1| setParseError("starred-relation string range contains U+FFFD, U+FFFE or U+FFFF", errorCode); 347| 1| return; 348| 1| } 349| 5.15M| s.setTo(prev); 350| 5.15M| sink->addRelation(strength, empty, s, empty, errorReason, errorCode); 351| 5.15M| if(U_FAILURE(errorCode)) { ------------------ | Branch (351:16): [True: 0, False: 5.15M] ------------------ 352| 0| setErrorContext(); 353| 0| return; 354| 0| } 355| 5.15M| } 356| 5.85k| prev = -1; 357| 5.85k| j = U16_LENGTH(c); ------------------ | | 141| 5.85k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 5.83k, False: 14] | | ------------------ ------------------ 358| 5.85k| } 359| 11.1k| ruleIndex = skipWhiteSpace(i); 360| 11.1k|} _ZN6icu_7819CollationRuleParser20parseTailoringStringEiRNS_13UnicodeStringER10UErrorCode: 363| 974k|CollationRuleParser::parseTailoringString(int32_t i, UnicodeString &raw, UErrorCode &errorCode) { 364| 974k| i = parseString(skipWhiteSpace(i), raw, errorCode); 365| 974k| if(U_SUCCESS(errorCode) && raw.isEmpty()) { ------------------ | Branch (365:8): [True: 974k, False: 82] | Branch (365:32): [True: 136, False: 974k] ------------------ 366| 136| setParseError("missing relation string", errorCode); 367| 136| } 368| 974k| return skipWhiteSpace(i); 369| 974k|} _ZN6icu_7819CollationRuleParser11parseStringEiRNS_13UnicodeStringER10UErrorCode: 372| 991k|CollationRuleParser::parseString(int32_t i, UnicodeString &raw, UErrorCode &errorCode) { 373| 991k| if(U_FAILURE(errorCode)) { return i; } ------------------ | Branch (373:8): [True: 0, False: 991k] ------------------ 374| 991k| raw.remove(); 375| 2.76M| while(i < rules->length()) { ------------------ | Branch (375:11): [True: 2.75M, False: 8.38k] ------------------ 376| 2.75M| UChar32 c = rules->charAt(i++); 377| 2.75M| if(isSyntaxChar(c)) { ------------------ | Branch (377:12): [True: 180k, False: 2.57M] ------------------ 378| 180k| if(c == 0x27) { // apostrophe ------------------ | Branch (378:16): [True: 9.63k, False: 170k] ------------------ 379| 9.63k| if(i < rules->length() && rules->charAt(i) == 0x27) { ------------------ | Branch (379:20): [True: 9.62k, False: 6] | Branch (379:43): [True: 268, False: 9.35k] ------------------ 380| | // Double apostrophe, encodes a single one. 381| 268| raw.append(static_cast(0x27)); 382| 268| ++i; 383| 268| continue; 384| 268| } 385| | // Quote literal text until the next single apostrophe. 386| 52.2k| for(;;) { 387| 52.2k| if(i == rules->length()) { ------------------ | Branch (387:24): [True: 34, False: 52.1k] ------------------ 388| 34| setParseError("quoted literal text missing terminating apostrophe", errorCode); 389| 34| return i; 390| 34| } 391| 52.1k| c = rules->charAt(i++); 392| 52.1k| if(c == 0x27) { ------------------ | Branch (392:24): [True: 9.54k, False: 42.6k] ------------------ 393| 9.54k| if(i < rules->length() && rules->charAt(i) == 0x27) { ------------------ | Branch (393:28): [True: 8.55k, False: 995] | Branch (393:51): [True: 216, False: 8.33k] ------------------ 394| | // Double apostrophe inside quoted literal text, 395| | // still encodes a single apostrophe. 396| 216| ++i; 397| 9.33k| } else { 398| 9.33k| break; 399| 9.33k| } 400| 9.54k| } 401| 42.8k| raw.append(static_cast(c)); 402| 42.8k| } 403| 170k| } else if(c == 0x5c) { // backslash ------------------ | Branch (403:23): [True: 640, False: 169k] ------------------ 404| 640| if(i == rules->length()) { ------------------ | Branch (404:20): [True: 3, False: 637] ------------------ 405| 3| setParseError("backslash escape at the end of the rule string", errorCode); 406| 3| return i; 407| 3| } 408| 637| c = rules->char32At(i); 409| 637| raw.append(c); 410| 637| i += U16_LENGTH(c); ------------------ | | 141| 637|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 438, False: 199] | | ------------------ ------------------ 411| 169k| } else { 412| | // Any other syntax character terminates a string. 413| 169k| --i; 414| 169k| break; 415| 169k| } 416| 2.57M| } else if(PatternProps::isWhiteSpace(c)) { ------------------ | Branch (416:19): [True: 813k, False: 1.75M] ------------------ 417| | // Unquoted white space terminates a string. 418| 813k| --i; 419| 813k| break; 420| 1.75M| } else { 421| 1.75M| raw.append(static_cast(c)); 422| 1.75M| } 423| 2.75M| } 424| 2.78M| for(int32_t j = 0; j < raw.length();) { ------------------ | Branch (424:24): [True: 1.79M, False: 991k] ------------------ 425| 1.79M| UChar32 c = raw.char32At(j); 426| 1.79M| if(U_IS_SURROGATE(c)) { ------------------ | | 193| 1.79M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ | | | Branch (193:27): [True: 30, False: 1.79M] | | ------------------ ------------------ 427| 30| setParseError("string contains an unpaired surrogate", errorCode); 428| 30| return i; 429| 30| } 430| 1.79M| if(0xfffd <= c && c <= 0xffff) { ------------------ | Branch (430:12): [True: 3.44k, False: 1.79M] | Branch (430:27): [True: 17, False: 3.43k] ------------------ 431| 17| setParseError("string contains U+FFFD, U+FFFE or U+FFFF", errorCode); 432| 17| return i; 433| 17| } 434| 1.79M| j += U16_LENGTH(c); ------------------ | | 141| 1.79M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 1.79M, False: 3.43k] | | ------------------ ------------------ 435| 1.79M| } 436| 991k| return i; 437| 991k|} _ZN6icu_7819CollationRuleParser20parseSpecialPositionEiRNS_13UnicodeStringER10UErrorCode: 461| 928|CollationRuleParser::parseSpecialPosition(int32_t i, UnicodeString &str, UErrorCode &errorCode) { 462| 928| if(U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (462:8): [True: 0, False: 928] ------------------ 463| 928| UnicodeString raw; 464| 928| int32_t j = readWords(i + 1, raw); 465| 928| if(j > i && rules->charAt(j) == 0x5d && !raw.isEmpty()) { // words end with ] ------------------ | Branch (465:8): [True: 927, False: 1] | Branch (465:17): [True: 919, False: 8] | Branch (465:45): [True: 918, False: 1] ------------------ 466| 918| ++j; 467| 3.46k| for(int32_t pos = 0; pos < UPRV_LENGTHOF(positions); ++pos) { ------------------ | | 99| 3.46k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (467:30): [True: 3.45k, False: 8] ------------------ 468| 3.45k| if(raw == UnicodeString(positions[pos], -1, US_INV)) { ------------------ | | 98| 3.45k|#define US_INV icu::UnicodeString::kInvariant ------------------ | Branch (468:16): [True: 910, False: 2.54k] ------------------ 469| 910| str.setTo(POS_LEAD).append(static_cast(POS_BASE + pos)); 470| 910| return j; 471| 910| } 472| 3.45k| } 473| 8| if(raw == UNICODE_STRING_SIMPLE("top")) { ------------------ | | 135| 8|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 8|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (473:12): [True: 0, False: 8] ------------------ 474| 0| str.setTo(POS_LEAD).append(static_cast(POS_BASE + LAST_REGULAR)); 475| 0| return j; 476| 0| } 477| 8| if(raw == UNICODE_STRING_SIMPLE("variable top")) { ------------------ | | 135| 8|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 8|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (477:12): [True: 0, False: 8] ------------------ 478| 0| str.setTo(POS_LEAD).append(static_cast(POS_BASE + LAST_VARIABLE)); 479| 0| return j; 480| 0| } 481| 8| } 482| 18| setParseError("not a valid special reset position", errorCode); 483| 18| return i; 484| 928|} _ZN6icu_7819CollationRuleParser12parseSettingER10UErrorCode: 487| 12.5k|CollationRuleParser::parseSetting(UErrorCode &errorCode) { 488| 12.5k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (488:8): [True: 0, False: 12.5k] ------------------ 489| 12.5k| UnicodeString raw; 490| 12.5k| int32_t i = ruleIndex + 1; 491| 12.5k| int32_t j = readWords(i, raw); 492| 12.5k| if(j <= i || raw.isEmpty()) { ------------------ | Branch (492:8): [True: 243, False: 12.3k] | Branch (492:18): [True: 1, False: 12.3k] ------------------ 493| 244| setParseError("expected a setting/option at '['", errorCode); 494| 244| } 495| 12.5k| if(rules->charAt(j) == 0x5d) { // words end with ] ------------------ | Branch (495:8): [True: 10.3k, False: 2.22k] ------------------ 496| 10.3k| ++j; 497| 10.3k| if(raw.startsWith(UNICODE_STRING_SIMPLE("reorder")) && ------------------ | | 135| 10.3k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 10.3k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (497:12): [True: 3.19k, False: 7.17k] | Branch (497:12): [True: 3.19k, False: 7.17k] ------------------ 498| 10.3k| (raw.length() == 7 || raw.charAt(7) == 0x20)) { ------------------ | Branch (498:18): [True: 0, False: 3.19k] | Branch (498:39): [True: 3.19k, False: 0] ------------------ 499| 3.19k| parseReordering(raw, errorCode); 500| 3.19k| ruleIndex = j; 501| 3.19k| return; 502| 3.19k| } 503| 7.17k| if(raw == UNICODE_STRING_SIMPLE("backwards 2")) { ------------------ | | 135| 7.17k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 7.17k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (503:12): [True: 1, False: 7.17k] ------------------ 504| 1| settings->setFlag(CollationSettings::BACKWARD_SECONDARY, 505| 1| UCOL_ON, 0, errorCode); 506| 1| ruleIndex = j; 507| 1| return; 508| 1| } 509| 7.17k| UnicodeString v; 510| 7.17k| int32_t valueIndex = raw.lastIndexOf(static_cast(0x20)); 511| 7.17k| if(valueIndex >= 0) { ------------------ | Branch (511:12): [True: 7.07k, False: 100] ------------------ 512| 7.07k| v.setTo(raw, valueIndex + 1); 513| 7.07k| raw.truncate(valueIndex); 514| 7.07k| } 515| 7.17k| if(raw == UNICODE_STRING_SIMPLE("strength") && v.length() == 1) { ------------------ | | 135| 7.17k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 14.3k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (515:12): [True: 226, False: 6.95k] | Branch (515:12): [True: 225, False: 6.95k] | Branch (515:56): [True: 225, False: 1] ------------------ 516| 225| int32_t value = UCOL_DEFAULT; 517| 225| char16_t c = v.charAt(0); 518| 225| if(0x31 <= c && c <= 0x34) { // 1..4 ------------------ | Branch (518:16): [True: 223, False: 2] | Branch (518:29): [True: 33, False: 190] ------------------ 519| 33| value = UCOL_PRIMARY + (c - 0x31); 520| 192| } else if(c == 0x49) { // 'I' ------------------ | Branch (520:23): [True: 188, False: 4] ------------------ 521| 188| value = UCOL_IDENTICAL; 522| 188| } 523| 225| if(value != UCOL_DEFAULT) { ------------------ | Branch (523:16): [True: 221, False: 4] ------------------ 524| 221| settings->setStrength(value, 0, errorCode); 525| 221| ruleIndex = j; 526| 221| return; 527| 221| } 528| 6.95k| } else if(raw == UNICODE_STRING_SIMPLE("alternate")) { ------------------ | | 135| 6.95k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 6.95k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (528:19): [True: 453, False: 6.49k] ------------------ 529| 453| UColAttributeValue value = UCOL_DEFAULT; 530| 453| if(v == UNICODE_STRING_SIMPLE("non-ignorable")) { ------------------ | | 135| 453|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 453|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (530:16): [True: 0, False: 453] ------------------ 531| 0| value = UCOL_NON_IGNORABLE; 532| 453| } else if(v == UNICODE_STRING_SIMPLE("shifted")) { ------------------ | | 135| 453|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 453|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (532:23): [True: 453, False: 0] ------------------ 533| 453| value = UCOL_SHIFTED; 534| 453| } 535| 453| if(value != UCOL_DEFAULT) { ------------------ | Branch (535:16): [True: 453, False: 0] ------------------ 536| 453| settings->setAlternateHandling(value, 0, errorCode); 537| 453| ruleIndex = j; 538| 453| return; 539| 453| } 540| 6.49k| } else if(raw == UNICODE_STRING_SIMPLE("maxVariable")) { ------------------ | | 135| 6.49k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 6.49k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (540:19): [True: 0, False: 6.49k] ------------------ 541| 0| int32_t value = UCOL_DEFAULT; 542| 0| if(v == UNICODE_STRING_SIMPLE("space")) { ------------------ | | 135| 0|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 0|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (542:16): [True: 0, False: 0] ------------------ 543| 0| value = CollationSettings::MAX_VAR_SPACE; 544| 0| } else if(v == UNICODE_STRING_SIMPLE("punct")) { ------------------ | | 135| 0|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 0|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (544:23): [True: 0, False: 0] ------------------ 545| 0| value = CollationSettings::MAX_VAR_PUNCT; 546| 0| } else if(v == UNICODE_STRING_SIMPLE("symbol")) { ------------------ | | 135| 0|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 0|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (546:23): [True: 0, False: 0] ------------------ 547| 0| value = CollationSettings::MAX_VAR_SYMBOL; 548| 0| } else if(v == UNICODE_STRING_SIMPLE("currency")) { ------------------ | | 135| 0|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 0|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (548:23): [True: 0, False: 0] ------------------ 549| 0| value = CollationSettings::MAX_VAR_CURRENCY; 550| 0| } 551| 0| if(value != UCOL_DEFAULT) { ------------------ | Branch (551:16): [True: 0, False: 0] ------------------ 552| 0| settings->setMaxVariable(value, 0, errorCode); 553| 0| settings->variableTop = baseData->getLastPrimaryForGroup( 554| 0| UCOL_REORDER_CODE_FIRST + value); 555| 0| U_ASSERT(settings->variableTop != 0); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 556| 0| ruleIndex = j; 557| 0| return; 558| 0| } 559| 6.49k| } else if(raw == UNICODE_STRING_SIMPLE("caseFirst")) { ------------------ | | 135| 6.49k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 6.49k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (559:19): [True: 112, False: 6.38k] ------------------ 560| 112| UColAttributeValue value = UCOL_DEFAULT; 561| 112| if(v == UNICODE_STRING_SIMPLE("off")) { ------------------ | | 135| 112|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 112|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (561:16): [True: 0, False: 112] ------------------ 562| 0| value = UCOL_OFF; 563| 112| } else if(v == UNICODE_STRING_SIMPLE("lower")) { ------------------ | | 135| 112|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 112|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (563:23): [True: 0, False: 112] ------------------ 564| 0| value = UCOL_LOWER_FIRST; 565| 112| } else if(v == UNICODE_STRING_SIMPLE("upper")) { ------------------ | | 135| 112|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 112|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (565:23): [True: 111, False: 1] ------------------ 566| 111| value = UCOL_UPPER_FIRST; 567| 111| } 568| 112| if(value != UCOL_DEFAULT) { ------------------ | Branch (568:16): [True: 111, False: 1] ------------------ 569| 111| settings->setCaseFirst(value, 0, errorCode); 570| 111| ruleIndex = j; 571| 111| return; 572| 111| } 573| 6.38k| } else if(raw == UNICODE_STRING_SIMPLE("caseLevel")) { ------------------ | | 135| 6.38k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 6.38k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (573:19): [True: 1, False: 6.38k] ------------------ 574| 1| UColAttributeValue value = getOnOffValue(v); 575| 1| if(value != UCOL_DEFAULT) { ------------------ | Branch (575:16): [True: 0, False: 1] ------------------ 576| 0| settings->setFlag(CollationSettings::CASE_LEVEL, value, 0, errorCode); 577| 0| ruleIndex = j; 578| 0| return; 579| 0| } 580| 6.38k| } else if(raw == UNICODE_STRING_SIMPLE("normalization")) { ------------------ | | 135| 6.38k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 6.38k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (580:19): [True: 1.30k, False: 5.08k] ------------------ 581| 1.30k| UColAttributeValue value = getOnOffValue(v); 582| 1.30k| if(value != UCOL_DEFAULT) { ------------------ | Branch (582:16): [True: 1.29k, False: 2] ------------------ 583| 1.29k| settings->setFlag(CollationSettings::CHECK_FCD, value, 0, errorCode); 584| 1.29k| ruleIndex = j; 585| 1.29k| return; 586| 1.29k| } 587| 5.08k| } else if(raw == UNICODE_STRING_SIMPLE("numericOrdering")) { ------------------ | | 135| 5.08k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 5.08k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (587:19): [True: 0, False: 5.08k] ------------------ 588| 0| UColAttributeValue value = getOnOffValue(v); 589| 0| if(value != UCOL_DEFAULT) { ------------------ | Branch (589:16): [True: 0, False: 0] ------------------ 590| 0| settings->setFlag(CollationSettings::NUMERIC, value, 0, errorCode); 591| 0| ruleIndex = j; 592| 0| return; 593| 0| } 594| 5.08k| } else if(raw == UNICODE_STRING_SIMPLE("hiraganaQ")) { ------------------ | | 135| 5.08k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 5.08k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (594:19): [True: 1, False: 5.08k] ------------------ 595| 1| UColAttributeValue value = getOnOffValue(v); 596| 1| if(value != UCOL_DEFAULT) { ------------------ | Branch (596:16): [True: 0, False: 1] ------------------ 597| 0| if(value == UCOL_ON) { ------------------ | Branch (597:20): [True: 0, False: 0] ------------------ 598| 0| setParseError("[hiraganaQ on] is not supported", errorCode); 599| 0| } 600| 0| ruleIndex = j; 601| 0| return; 602| 0| } 603| 5.08k| } else if(raw == UNICODE_STRING_SIMPLE("import")) { ------------------ | | 135| 5.08k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 5.08k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (603:19): [True: 5.04k, False: 45] ------------------ 604| 5.04k| CharString lang; 605| 5.04k| lang.appendInvariantChars(v, errorCode); 606| 5.04k| if(errorCode == U_MEMORY_ALLOCATION_ERROR) { return; } ------------------ | Branch (606:16): [True: 0, False: 5.04k] ------------------ 607| | // BCP 47 language tag -> ICU locale ID 608| 5.04k| int32_t parsedLength; 609| 5.04k| CharString localeID = ulocimp_forLanguageTag(lang.data(), -1, &parsedLength, errorCode); ------------------ | | 1198| 5.04k|#define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag) | | ------------------ | | | | 123| 5.04k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.04k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.04k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 610| 5.04k| if(U_FAILURE(errorCode) || parsedLength != lang.length()) { ------------------ | Branch (610:16): [True: 13, False: 5.02k] | Branch (610:40): [True: 152, False: 4.87k] ------------------ 611| 165| errorCode = U_ZERO_ERROR; 612| 165| setParseError("expected language tag in [import langTag]", errorCode); 613| 165| return; 614| 165| } 615| | // localeID minus all keywords 616| 4.87k| CharString baseID = ulocimp_getBaseName(localeID.toStringPiece(), errorCode); ------------------ | | 1199| 4.87k|#define ulocimp_getBaseName U_ICU_ENTRY_POINT_RENAME(ulocimp_getBaseName) | | ------------------ | | | | 123| 4.87k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.87k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.87k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 617| 4.87k| if (U_FAILURE(errorCode)) { ------------------ | Branch (617:17): [True: 0, False: 4.87k] ------------------ 618| 0| errorCode = U_ZERO_ERROR; 619| 0| setParseError("expected language tag in [import langTag]", errorCode); 620| 0| return; 621| 0| } 622| 4.87k| if (baseID.isEmpty()) { ------------------ | Branch (622:17): [True: 119, False: 4.75k] ------------------ 623| 119| baseID.copyFrom("root", errorCode); 624| 4.75k| } else if (baseID[0] == '_') { ------------------ | Branch (624:24): [True: 5, False: 4.75k] ------------------ 625| | // CharString doesn't have any insert() method, only append(). 626| 5| constexpr char und[] = "und"; 627| 5| constexpr int32_t length = sizeof und - 1; 628| 5| int32_t dummy; 629| 5| char* tail = baseID.getAppendBuffer(length, length, dummy, errorCode); 630| 5| char* head = baseID.data(); 631| 5| uprv_memmove(head + length, head, baseID.length()); ------------------ | | 51| 5|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 5| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 5| _Pragma("clang diagnostic push") \ | | 54| 5| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 5| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 5| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 5| _Pragma("clang diagnostic pop") \ | | 58| 5| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 5|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 5|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 632| 5| uprv_memcpy(head, und, length); ------------------ | | 42| 5|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 5| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 5| _Pragma("clang diagnostic push") \ | | 45| 5| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 5| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 5| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 5| _Pragma("clang diagnostic pop") \ | | 49| 5| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 5|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 5|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 633| 5| baseID.append(tail, length, errorCode); 634| 5| } 635| | // @collation=type, or length=0 if not specified 636| 4.87k| CharString collationType = ulocimp_getKeywordValue(localeID.data(), "collation", errorCode); ------------------ | | 1200| 4.87k|#define ulocimp_getKeywordValue U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywordValue) | | ------------------ | | | | 123| 4.87k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.87k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.87k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 637| 4.87k| if(U_FAILURE(errorCode)) { ------------------ | Branch (637:16): [True: 0, False: 4.87k] ------------------ 638| 0| errorCode = U_ZERO_ERROR; 639| 0| setParseError("expected language tag in [import langTag]", errorCode); 640| 0| return; 641| 0| } 642| 4.87k| if(importer == nullptr) { ------------------ | Branch (642:16): [True: 0, False: 4.87k] ------------------ 643| 0| setParseError("[import langTag] is not supported", errorCode); 644| 4.87k| } else { 645| 4.87k| UnicodeString importedRules; 646| 4.87k| importer->getRules(baseID.data(), 647| 4.87k| !collationType.isEmpty() ? collationType.data() : "standard", ------------------ | Branch (647:36): [True: 62, False: 4.81k] ------------------ 648| 4.87k| importedRules, errorReason, errorCode); 649| 4.87k| if(U_FAILURE(errorCode)) { ------------------ | Branch (649:20): [True: 58, False: 4.81k] ------------------ 650| 58| if(errorReason == nullptr) { ------------------ | Branch (650:24): [True: 58, False: 0] ------------------ 651| 58| errorReason = "[import langTag] failed"; 652| 58| } 653| 58| setErrorContext(); 654| 58| return; 655| 58| } 656| 4.81k| const UnicodeString *outerRules = rules; 657| 4.81k| int32_t outerRuleIndex = ruleIndex; 658| 4.81k| parse(importedRules, errorCode); 659| 4.81k| if(U_FAILURE(errorCode)) { ------------------ | Branch (659:20): [True: 16, False: 4.80k] ------------------ 660| 16| if(parseError != nullptr) { ------------------ | Branch (660:24): [True: 0, False: 16] ------------------ 661| 0| parseError->offset = outerRuleIndex; 662| 0| } 663| 16| } 664| 4.81k| rules = outerRules; 665| 4.81k| ruleIndex = j; 666| 4.81k| } 667| 4.81k| return; 668| 4.87k| } 669| 7.17k| } else if(rules->charAt(j) == 0x5b) { // words end with [ ------------------ | Branch (669:15): [True: 2.14k, False: 86] ------------------ 670| 2.14k| UnicodeSet set; 671| 2.14k| j = parseUnicodeSet(j, set, errorCode); 672| 2.14k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (672:12): [True: 1.71k, False: 429] ------------------ 673| 429| if(raw == UNICODE_STRING_SIMPLE("optimize")) { ------------------ | | 135| 429|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 429|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (673:12): [True: 90, False: 339] ------------------ 674| 90| sink->optimize(set, errorReason, errorCode); 675| 90| if(U_FAILURE(errorCode)) { setErrorContext(); } ------------------ | Branch (675:16): [True: 0, False: 90] ------------------ 676| 90| ruleIndex = j; 677| 90| return; 678| 339| } else if(raw == UNICODE_STRING_SIMPLE("suppressContractions")) { ------------------ | | 135| 339|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 339|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (678:19): [True: 296, False: 43] ------------------ 679| 296| sink->suppressContractions(set, errorReason, errorCode); 680| 296| if(U_FAILURE(errorCode)) { setErrorContext(); } ------------------ | Branch (680:16): [True: 0, False: 296] ------------------ 681| 296| ruleIndex = j; 682| 296| return; 683| 296| } 684| 429| } 685| 183| setParseError("not a valid setting/option", errorCode); 686| 183|} _ZN6icu_7819CollationRuleParser15parseReorderingERKNS_13UnicodeStringER10UErrorCode: 689| 3.19k|CollationRuleParser::parseReordering(const UnicodeString &raw, UErrorCode &errorCode) { 690| 3.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (690:8): [True: 0, False: 3.19k] ------------------ 691| 3.19k| int32_t i = 7; // after "reorder" 692| 3.19k| if(i == raw.length()) { ------------------ | Branch (692:8): [True: 0, False: 3.19k] ------------------ 693| | // empty [reorder] with no codes 694| 0| settings->resetReordering(); 695| 0| return; 696| 0| } 697| | // Parse the codes in [reorder aa bb cc]. 698| 3.19k| UVector32 reorderCodes(errorCode); 699| 3.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (699:8): [True: 0, False: 3.19k] ------------------ 700| 3.19k| CharString word; 701| 11.8k| while(i < raw.length()) { ------------------ | Branch (701:11): [True: 8.65k, False: 3.19k] ------------------ 702| 8.65k| ++i; // skip the word-separating space 703| 8.65k| int32_t limit = raw.indexOf(static_cast(0x20), i); 704| 8.65k| if(limit < 0) { limit = raw.length(); } ------------------ | Branch (704:12): [True: 3.19k, False: 5.46k] ------------------ 705| 8.65k| word.clear().appendInvariantChars(raw.tempSubStringBetween(i, limit), errorCode); 706| 8.65k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (706:12): [True: 0, False: 8.65k] ------------------ 707| 8.65k| int32_t code = getReorderCode(word.data()); 708| 8.65k| if(code < 0) { ------------------ | Branch (708:12): [True: 0, False: 8.65k] ------------------ 709| 0| setParseError("unknown script or reorder code", errorCode); 710| 0| return; 711| 0| } 712| 8.65k| reorderCodes.addElement(code, errorCode); 713| 8.65k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (713:12): [True: 0, False: 8.65k] ------------------ 714| 8.65k| i = limit; 715| 8.65k| } 716| 3.19k| settings->setReordering(*baseData, reorderCodes.getBuffer(), reorderCodes.size(), errorCode); 717| 3.19k|} _ZN6icu_7819CollationRuleParser14getReorderCodeEPKc: 724| 8.65k|CollationRuleParser::getReorderCode(const char *word) { 725| 51.9k| for(int32_t i = 0; i < UPRV_LENGTHOF(gSpecialReorderCodes); ++i) { ------------------ | | 99| 51.9k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (725:24): [True: 43.2k, False: 8.65k] ------------------ 726| 43.2k| if(uprv_stricmp(word, gSpecialReorderCodes[i]) == 0) { ------------------ | | 1542| 43.2k|#define uprv_stricmp U_ICU_ENTRY_POINT_RENAME(uprv_stricmp) | | ------------------ | | | | 123| 43.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 43.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 43.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (726:12): [True: 0, False: 43.2k] ------------------ 727| 0| return UCOL_REORDER_CODE_FIRST + i; 728| 0| } 729| 43.2k| } 730| 8.65k| int32_t script = u_getPropertyValueEnum(UCHAR_SCRIPT, word); ------------------ | | 285| 8.65k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 8.65k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.65k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.65k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 731| 8.65k| if(script >= 0) { ------------------ | Branch (731:8): [True: 8.65k, False: 0] ------------------ 732| 8.65k| return script; 733| 8.65k| } 734| 0| if(uprv_stricmp(word, "others") == 0) { ------------------ | | 1542| 0|#define uprv_stricmp U_ICU_ENTRY_POINT_RENAME(uprv_stricmp) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (734:8): [True: 0, False: 0] ------------------ 735| 0| return UCOL_REORDER_CODE_OTHERS; // same as Zzzz = USCRIPT_UNKNOWN 736| 0| } 737| 0| return -1; 738| 0|} _ZN6icu_7819CollationRuleParser13getOnOffValueERKNS_13UnicodeStringE: 741| 1.30k|CollationRuleParser::getOnOffValue(const UnicodeString &s) { 742| 1.30k| if(s == UNICODE_STRING_SIMPLE("on")) { ------------------ | | 135| 1.30k|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 1.30k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (742:8): [True: 1.29k, False: 4] ------------------ 743| 1.29k| return UCOL_ON; 744| 1.29k| } else if(s == UNICODE_STRING_SIMPLE("off")) { ------------------ | | 135| 4|#define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1) | | ------------------ | | | | 121| 4|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) | | ------------------ ------------------ | Branch (744:15): [True: 0, False: 4] ------------------ 745| 0| return UCOL_OFF; 746| 4| } else { 747| 4| return UCOL_DEFAULT; 748| 4| } 749| 1.30k|} _ZN6icu_7819CollationRuleParser15parseUnicodeSetEiRNS_10UnicodeSetER10UErrorCode: 752| 2.14k|CollationRuleParser::parseUnicodeSet(int32_t i, UnicodeSet &set, UErrorCode &errorCode) { 753| | // Collect a UnicodeSet pattern between a balanced pair of [brackets]. 754| 2.14k| int32_t level = 0; 755| 2.14k| int32_t j = i; 756| 259k| for(;;) { 757| 259k| if(j == rules->length()) { ------------------ | Branch (757:12): [True: 107, False: 259k] ------------------ 758| 107| setParseError("unbalanced UnicodeSet pattern brackets", errorCode); 759| 107| return j; 760| 107| } 761| 259k| char16_t c = rules->charAt(j++); 762| 259k| if(c == 0x5b) { // '[' ------------------ | Branch (762:12): [True: 9.70k, False: 250k] ------------------ 763| 9.70k| ++level; 764| 250k| } else if(c == 0x5d) { // ']' ------------------ | Branch (764:19): [True: 9.40k, False: 240k] ------------------ 765| 9.40k| if(--level == 0) { break; } ------------------ | Branch (765:16): [True: 2.03k, False: 7.37k] ------------------ 766| 9.40k| } 767| 259k| } 768| 2.03k| set.applyPattern(rules->tempSubStringBetween(i, j), errorCode); 769| 2.03k| if(U_FAILURE(errorCode)) { ------------------ | Branch (769:8): [True: 740, False: 1.29k] ------------------ 770| 740| errorCode = U_ZERO_ERROR; 771| 740| setParseError("not a valid UnicodeSet pattern", errorCode); 772| 740| return j; 773| 740| } 774| 1.29k| j = skipWhiteSpace(j); 775| 1.29k| if(j == rules->length() || rules->charAt(j) != 0x5d) { ------------------ | Branch (775:8): [True: 575, False: 719] | Branch (775:32): [True: 290, False: 429] ------------------ 776| 865| setParseError("missing option-terminating ']' after UnicodeSet pattern", errorCode); 777| 865| return j; 778| 865| } 779| 429| return ++j; 780| 1.29k|} _ZNK6icu_7819CollationRuleParser9readWordsEiRNS_13UnicodeStringE: 783| 13.5k|CollationRuleParser::readWords(int32_t i, UnicodeString &raw) const { 784| 13.5k| static const char16_t sp = 0x20; 785| 13.5k| raw.remove(); 786| 13.5k| i = skipWhiteSpace(i); 787| 235k| for(;;) { 788| 235k| if(i >= rules->length()) { return 0; } ------------------ | Branch (788:12): [True: 224, False: 235k] ------------------ 789| 235k| char16_t c = rules->charAt(i); 790| 235k| if(isSyntaxChar(c) && c != 0x2d && c != 0x5f) { // syntax except -_ ------------------ | Branch (790:12): [True: 23.3k, False: 212k] | Branch (790:31): [True: 13.5k, False: 9.82k] | Branch (790:44): [True: 13.3k, False: 217] ------------------ 791| 13.3k| if(raw.isEmpty()) { return i; } ------------------ | Branch (791:16): [True: 23, False: 13.2k] ------------------ 792| 13.2k| if(raw.endsWith(&sp, 1)) { // remove trailing space ------------------ | Branch (792:16): [True: 1.19k, False: 12.0k] ------------------ 793| 1.19k| raw.truncate(raw.length() - 1); 794| 1.19k| } 795| 13.2k| return i; 796| 13.3k| } 797| 222k| if(PatternProps::isWhiteSpace(c)) { ------------------ | Branch (797:12): [True: 19.1k, False: 203k] ------------------ 798| 19.1k| raw.append(sp); 799| 19.1k| i = skipWhiteSpace(i + 1); 800| 203k| } else { 801| 203k| raw.append(c); 802| 203k| ++i; 803| 203k| } 804| 222k| } 805| 13.5k|} _ZNK6icu_7819CollationRuleParser11skipCommentEi: 808| 2.74k|CollationRuleParser::skipComment(int32_t i) const { 809| | // skip to past the newline 810| 105k| while(i < rules->length()) { ------------------ | Branch (810:11): [True: 105k, False: 453] ------------------ 811| 105k| char16_t c = rules->charAt(i++); 812| | // LF or FF or CR or NEL or LS or PS 813| 105k| if(c == 0xa || c == 0xc || c == 0xd || c == 0x85 || c == 0x2028 || c == 0x2029) { ------------------ | Branch (813:12): [True: 612, False: 104k] | Branch (813:24): [True: 169, False: 104k] | Branch (813:36): [True: 729, False: 103k] | Branch (813:48): [True: 435, False: 103k] | Branch (813:61): [True: 60, False: 103k] | Branch (813:76): [True: 285, False: 103k] ------------------ 814| | // Unicode Newline Guidelines: "A readline function should stop at NLF, LS, FF, or PS." 815| | // NLF (new line function) = CR or LF or CR+LF or NEL. 816| | // No need to collect all of CR+LF because a following LF will be ignored anyway. 817| 2.29k| break; 818| 2.29k| } 819| 105k| } 820| 2.74k| return i; 821| 2.74k|} _ZN6icu_7819CollationRuleParser13setParseErrorEPKcR10UErrorCode: 824| 3.37k|CollationRuleParser::setParseError(const char *reason, UErrorCode &errorCode) { 825| 3.37k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (825:8): [True: 152, False: 3.22k] ------------------ 826| | // Error code consistent with the old parser (from ca. 2001), 827| | // rather than U_PARSE_ERROR; 828| 3.22k| errorCode = U_INVALID_FORMAT_ERROR; 829| 3.22k| errorReason = reason; 830| 3.22k| if(parseError != nullptr) { setErrorContext(); } ------------------ | Branch (830:8): [True: 0, False: 3.22k] ------------------ 831| 3.22k|} _ZN6icu_7819CollationRuleParser15setErrorContextEv: 834| 529|CollationRuleParser::setErrorContext() { 835| 529| if(parseError == nullptr) { return; } ------------------ | Branch (835:8): [True: 529, False: 0] ------------------ 836| | 837| | // Note: This relies on the calling code maintaining the ruleIndex 838| | // at a position that is useful for debugging. 839| | // For example, at the beginning of a reset or relation etc. 840| 0| parseError->offset = ruleIndex; 841| 0| parseError->line = 0; // We are not counting line numbers. 842| | 843| | // before ruleIndex 844| 0| int32_t start = ruleIndex - (U_PARSE_CONTEXT_LEN - 1); 845| 0| if(start < 0) { ------------------ | Branch (845:8): [True: 0, False: 0] ------------------ 846| 0| start = 0; 847| 0| } else if(start > 0 && U16_IS_TRAIL(rules->charAt(start))) { ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ | Branch (847:15): [True: 0, False: 0] ------------------ 848| 0| ++start; 849| 0| } 850| 0| int32_t length = ruleIndex - start; 851| 0| rules->extract(start, length, parseError->preContext); 852| 0| parseError->preContext[length] = 0; 853| | 854| | // starting from ruleIndex 855| 0| length = rules->length() - ruleIndex; 856| 0| if(length >= U_PARSE_CONTEXT_LEN) { ------------------ | Branch (856:8): [True: 0, False: 0] ------------------ 857| 0| length = U_PARSE_CONTEXT_LEN - 1; 858| 0| if(U16_IS_LEAD(rules->charAt(ruleIndex + length - 1))) { ------------------ | | 59| 0|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 0, False: 0] | | ------------------ ------------------ 859| 0| --length; 860| 0| } 861| 0| } 862| 0| rules->extract(ruleIndex, length, parseError->postContext); 863| 0| parseError->postContext[length] = 0; 864| 0|} _ZN6icu_7819CollationRuleParser12isSyntaxCharEi: 867| 2.98M|CollationRuleParser::isSyntaxChar(UChar32 c) { 868| 2.98M| return 0x21 <= c && c <= 0x7e && ------------------ | Branch (868:12): [True: 2.92M, False: 58.6k] | Branch (868:25): [True: 467k, False: 2.46M] ------------------ 869| 2.98M| (c <= 0x2f || (0x3a <= c && c <= 0x40) || ------------------ | Branch (869:14): [True: 61.1k, False: 405k] | Branch (869:28): [True: 399k, False: 6.74k] | Branch (869:41): [True: 120k, False: 278k] ------------------ 870| 467k| (0x5b <= c && c <= 0x60) || (0x7b <= c)); ------------------ | Branch (870:14): [True: 216k, False: 68.9k] | Branch (870:27): [True: 17.3k, False: 198k] | Branch (870:41): [True: 4.31k, False: 263k] ------------------ 871| 2.98M|} _ZNK6icu_7819CollationRuleParser14skipWhiteSpaceEi: 874| 3.31M|CollationRuleParser::skipWhiteSpace(int32_t i) const { 875| 4.14M| while(i < rules->length() && PatternProps::isWhiteSpace(rules->charAt(i))) { ------------------ | Branch (875:11): [True: 4.12M, False: 17.4k] | Branch (875:34): [True: 825k, False: 3.30M] ------------------ 876| 825k| ++i; 877| 825k| } 878| 3.31M| return i; 879| 3.31M|} _ZN6icu_7819CollationRuleParser7setSinkEPNS0_4SinkE: 116| 7.71k| void setSink(Sink *sinkAlias) { 117| 7.71k| sink = sinkAlias; 118| 7.71k| } _ZN6icu_7819CollationRuleParser11setImporterEPNS0_8ImporterE: 124| 7.71k| void setImporter(Importer *importerAlias) { 125| 7.71k| importer = importerAlias; 126| 7.71k| } _ZNK6icu_7819CollationRuleParser14getErrorReasonEv: 133| 7.71k| const char *getErrorReason() const { return errorReason; } _ZN6icu_7811TailoredSet7forDataEPKNS_13CollationDataER10UErrorCode: 46| 3.92k|TailoredSet::forData(const CollationData *d, UErrorCode &ec) { 47| 3.92k| if(U_FAILURE(ec)) { return; } ------------------ | Branch (47:8): [True: 0, False: 3.92k] ------------------ 48| 3.92k| errorCode = ec; // Preserve info & warning codes. 49| 3.92k| data = d; 50| 3.92k| baseData = d->base; 51| 3.92k| U_ASSERT(baseData != nullptr); ------------------ | | 35| 3.92k|# define U_ASSERT(exp) (void)0 ------------------ 52| 3.92k| utrie2_enum(data->trie, nullptr, enumTailoredRange, this); ------------------ | | 1962| 3.92k|#define utrie2_enum U_ICU_ENTRY_POINT_RENAME(utrie2_enum) | | ------------------ | | | | 123| 3.92k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.92k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.92k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 53| 3.92k| ec = errorCode; 54| 3.92k|} _ZN6icu_7811TailoredSet10handleCE32Eiij: 57| 3.86M|TailoredSet::handleCE32(UChar32 start, UChar32 end, uint32_t ce32) { 58| 3.86M| U_ASSERT(ce32 != Collation::FALLBACK_CE32); ------------------ | | 35| 3.86M|# define U_ASSERT(exp) (void)0 ------------------ 59| 3.86M| if(Collation::isSpecialCE32(ce32)) { ------------------ | Branch (59:8): [True: 3.34M, False: 525k] ------------------ 60| 3.34M| ce32 = data->getIndirectCE32(ce32); 61| 3.34M| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (61:12): [True: 0, False: 3.34M] ------------------ 62| 0| return U_SUCCESS(errorCode); 63| 0| } 64| 3.34M| } 65| 48.7M| do { 66| 48.7M| uint32_t baseCE32 = baseData->getFinalCE32(baseData->getCE32(start)); 67| | // Do not just continue if ce32 == baseCE32 because 68| | // contractions and expansions in different data objects 69| | // normally differ even if they have the same data offsets. 70| 48.7M| if(Collation::isSelfContainedCE32(ce32) && Collation::isSelfContainedCE32(baseCE32)) { ------------------ | Branch (70:12): [True: 3.17M, False: 45.6M] | Branch (70:52): [True: 2.20M, False: 971k] ------------------ 71| | // fastpath 72| 2.20M| if(ce32 != baseCE32) { ------------------ | Branch (72:16): [True: 601k, False: 1.60M] ------------------ 73| 601k| tailored->add(start); 74| 601k| } 75| 46.5M| } else { 76| 46.5M| compare(start, ce32, baseCE32); 77| 46.5M| } 78| 48.7M| } while(++start <= end); ------------------ | Branch (78:13): [True: 44.9M, False: 3.86M] ------------------ 79| 3.86M| return U_SUCCESS(errorCode); 80| 3.86M|} _ZN6icu_7811TailoredSet7compareEijj: 83| 46.6M|TailoredSet::compare(UChar32 c, uint32_t ce32, uint32_t baseCE32) { 84| 46.6M| if(Collation::isPrefixCE32(ce32)) { ------------------ | Branch (84:8): [True: 1.82k, False: 46.6M] ------------------ 85| 1.82k| const char16_t *p = data->contexts + Collation::indexFromCE32(ce32); 86| 1.82k| ce32 = data->getFinalCE32(CollationData::readCE32(p)); 87| 1.82k| if(Collation::isPrefixCE32(baseCE32)) { ------------------ | Branch (87:12): [True: 355, False: 1.47k] ------------------ 88| 355| const char16_t *q = baseData->contexts + Collation::indexFromCE32(baseCE32); 89| 355| baseCE32 = baseData->getFinalCE32(CollationData::readCE32(q)); 90| 355| comparePrefixes(c, p + 2, q + 2); 91| 1.47k| } else { 92| 1.47k| addPrefixes(data, c, p + 2); 93| 1.47k| } 94| 46.6M| } else if(Collation::isPrefixCE32(baseCE32)) { ------------------ | Branch (94:15): [True: 0, False: 46.6M] ------------------ 95| 0| const char16_t *q = baseData->contexts + Collation::indexFromCE32(baseCE32); 96| 0| baseCE32 = baseData->getFinalCE32(CollationData::readCE32(q)); 97| 0| addPrefixes(baseData, c, q + 2); 98| 0| } 99| | 100| 46.6M| if(Collation::isContractionCE32(ce32)) { ------------------ | Branch (100:8): [True: 23.3k, False: 46.6M] ------------------ 101| 23.3k| const char16_t *p = data->contexts + Collation::indexFromCE32(ce32); 102| 23.3k| if((ce32 & Collation::CONTRACT_SINGLE_CP_NO_MATCH) != 0) { ------------------ | Branch (102:12): [True: 0, False: 23.3k] ------------------ 103| 0| ce32 = Collation::NO_CE32; 104| 23.3k| } else { 105| 23.3k| ce32 = data->getFinalCE32(CollationData::readCE32(p)); 106| 23.3k| } 107| 23.3k| if(Collation::isContractionCE32(baseCE32)) { ------------------ | Branch (107:12): [True: 2.77k, False: 20.6k] ------------------ 108| 2.77k| const char16_t *q = baseData->contexts + Collation::indexFromCE32(baseCE32); 109| 2.77k| if((baseCE32 & Collation::CONTRACT_SINGLE_CP_NO_MATCH) != 0) { ------------------ | Branch (109:16): [True: 0, False: 2.77k] ------------------ 110| 0| baseCE32 = Collation::NO_CE32; 111| 2.77k| } else { 112| 2.77k| baseCE32 = baseData->getFinalCE32(CollationData::readCE32(q)); 113| 2.77k| } 114| 2.77k| compareContractions(c, p + 2, q + 2); 115| 20.6k| } else { 116| 20.6k| addContractions(c, p + 2); 117| 20.6k| } 118| 46.6M| } else if(Collation::isContractionCE32(baseCE32)) { ------------------ | Branch (118:15): [True: 37, False: 46.6M] ------------------ 119| 37| const char16_t *q = baseData->contexts + Collation::indexFromCE32(baseCE32); 120| 37| baseCE32 = baseData->getFinalCE32(CollationData::readCE32(q)); 121| 37| addContractions(c, q + 2); 122| 37| } 123| | 124| 46.6M| int32_t tag; 125| 46.6M| if(Collation::isSpecialCE32(ce32)) { ------------------ | Branch (125:8): [True: 46.5M, False: 67.8k] ------------------ 126| 46.5M| tag = Collation::tagFromCE32(ce32); 127| 46.5M| U_ASSERT(tag != Collation::PREFIX_TAG); ------------------ | | 35| 46.5M|# define U_ASSERT(exp) (void)0 ------------------ 128| 46.5M| U_ASSERT(tag != Collation::CONTRACTION_TAG); ------------------ | | 35| 46.5M|# define U_ASSERT(exp) (void)0 ------------------ 129| | // Currently, the tailoring data builder does not write offset tags. 130| | // They might be useful for saving space, 131| | // but they would complicate the builder, 132| | // and in tailorings we assume that performance of tailored characters is more important. 133| 46.5M| U_ASSERT(tag != Collation::OFFSET_TAG); ------------------ | | 35| 46.5M|# define U_ASSERT(exp) (void)0 ------------------ 134| 46.5M| } else { 135| 67.8k| tag = -1; 136| 67.8k| } 137| 46.6M| int32_t baseTag; 138| 46.6M| if(Collation::isSpecialCE32(baseCE32)) { ------------------ | Branch (138:8): [True: 46.5M, False: 66.3k] ------------------ 139| 46.5M| baseTag = Collation::tagFromCE32(baseCE32); 140| 46.5M| U_ASSERT(baseTag != Collation::PREFIX_TAG); ------------------ | | 35| 46.5M|# define U_ASSERT(exp) (void)0 ------------------ 141| 46.5M| U_ASSERT(baseTag != Collation::CONTRACTION_TAG); ------------------ | | 35| 46.5M|# define U_ASSERT(exp) (void)0 ------------------ 142| 46.5M| } else { 143| 66.3k| baseTag = -1; 144| 66.3k| } 145| | 146| | // Non-contextual mappings, expansions, etc. 147| 46.6M| if(baseTag == Collation::OFFSET_TAG) { ------------------ | Branch (147:8): [True: 1.26M, False: 45.3M] ------------------ 148| | // We might be comparing a tailoring CE which is a copy of 149| | // a base offset-tag CE, via the [optimize [set]] syntax 150| | // or when a single-character mapping was copied for tailored contractions. 151| | // Offset tags always result in long-primary CEs, 152| | // with common secondary/tertiary weights. 153| 1.26M| if(!Collation::isLongPrimaryCE32(ce32)) { ------------------ | Branch (153:12): [True: 419k, False: 848k] ------------------ 154| 419k| add(c); 155| 419k| return; 156| 419k| } 157| 848k| int64_t dataCE = baseData->ces[Collation::indexFromCE32(baseCE32)]; 158| 848k| uint32_t p = Collation::getThreeBytePrimaryForOffsetData(c, dataCE); 159| 848k| if(Collation::primaryFromLongPrimaryCE32(ce32) != p) { ------------------ | Branch (159:12): [True: 275k, False: 572k] ------------------ 160| 275k| add(c); 161| 275k| return; 162| 275k| } 163| 848k| } 164| | 165| 45.9M| if(tag != baseTag) { ------------------ | Branch (165:8): [True: 1.85M, False: 44.0M] ------------------ 166| 1.85M| add(c); 167| 1.85M| return; 168| 1.85M| } 169| | 170| 44.0M| if(tag == Collation::EXPANSION32_TAG) { ------------------ | Branch (170:8): [True: 152k, False: 43.9M] ------------------ 171| 152k| const uint32_t *ce32s = data->ce32s + Collation::indexFromCE32(ce32); 172| 152k| int32_t length = Collation::lengthFromCE32(ce32); 173| | 174| 152k| const uint32_t *baseCE32s = baseData->ce32s + Collation::indexFromCE32(baseCE32); 175| 152k| int32_t baseLength = Collation::lengthFromCE32(baseCE32); 176| | 177| 152k| if(length != baseLength) { ------------------ | Branch (177:12): [True: 19.4k, False: 133k] ------------------ 178| 19.4k| add(c); 179| 19.4k| return; 180| 19.4k| } 181| 343k| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (181:28): [True: 270k, False: 73.5k] ------------------ 182| 270k| if(ce32s[i] != baseCE32s[i]) { ------------------ | Branch (182:16): [True: 59.5k, False: 210k] ------------------ 183| 59.5k| add(c); 184| 59.5k| break; 185| 59.5k| } 186| 270k| } 187| 43.9M| } else if(tag == Collation::EXPANSION_TAG) { ------------------ | Branch (187:15): [True: 21.6k, False: 43.9M] ------------------ 188| 21.6k| const int64_t *ces = data->ces + Collation::indexFromCE32(ce32); 189| 21.6k| int32_t length = Collation::lengthFromCE32(ce32); 190| | 191| 21.6k| const int64_t *baseCEs = baseData->ces + Collation::indexFromCE32(baseCE32); 192| 21.6k| int32_t baseLength = Collation::lengthFromCE32(baseCE32); 193| | 194| 21.6k| if(length != baseLength) { ------------------ | Branch (194:12): [True: 1.77k, False: 19.8k] ------------------ 195| 1.77k| add(c); 196| 1.77k| return; 197| 1.77k| } 198| 44.6k| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (198:28): [True: 25.9k, False: 18.7k] ------------------ 199| 25.9k| if(ces[i] != baseCEs[i]) { ------------------ | Branch (199:16): [True: 1.05k, False: 24.8k] ------------------ 200| 1.05k| add(c); 201| 1.05k| break; 202| 1.05k| } 203| 25.9k| } 204| 43.9M| } else if(tag == Collation::HANGUL_TAG) { ------------------ | Branch (204:15): [True: 43.8M, False: 31.9k] ------------------ 205| 43.8M| char16_t jamos[3]; 206| 43.8M| int32_t length = Hangul::decompose(c, jamos); 207| 43.8M| if(tailored->contains(jamos[0]) || tailored->contains(jamos[1]) || ------------------ | Branch (207:12): [True: 335k, False: 43.5M] | Branch (207:44): [True: 147k, False: 43.3M] ------------------ 208| 43.8M| (length == 3 && tailored->contains(jamos[2]))) { ------------------ | Branch (208:18): [True: 41.8M, False: 1.54M] | Branch (208:33): [True: 37.7k, False: 41.8M] ------------------ 209| 521k| add(c); 210| 521k| } 211| 43.8M| } else if(ce32 != baseCE32) { ------------------ | Branch (211:15): [True: 867, False: 31.0k] ------------------ 212| 867| add(c); 213| 867| } 214| 44.0M|} _ZN6icu_7811TailoredSet15comparePrefixesEiPKDsS2_: 217| 355|TailoredSet::comparePrefixes(UChar32 c, const char16_t *p, const char16_t *q) { 218| | // Parallel iteration over prefixes of both tables. 219| 355| UCharsTrie::Iterator prefixes(p, 0, errorCode); 220| 355| UCharsTrie::Iterator basePrefixes(q, 0, errorCode); 221| 355| const UnicodeString *tp = nullptr; // Tailoring prefix. 222| 355| const UnicodeString *bp = nullptr; // Base prefix. 223| | // Use a string with a U+FFFF as the limit sentinel. 224| | // U+FFFF is untailorable and will not occur in prefixes. 225| 355| UnicodeString none(static_cast(0xffff)); 226| 1.84k| for(;;) { 227| 1.84k| if(tp == nullptr) { ------------------ | Branch (227:12): [True: 1.84k, False: 0] ------------------ 228| 1.84k| if(prefixes.next(errorCode)) { ------------------ | Branch (228:16): [True: 1.49k, False: 355] ------------------ 229| 1.49k| tp = &prefixes.getString(); 230| 1.49k| } else { 231| 355| tp = &none; 232| 355| } 233| 1.84k| } 234| 1.84k| if(bp == nullptr) { ------------------ | Branch (234:12): [True: 1.06k, False: 780] ------------------ 235| 1.06k| if(basePrefixes.next(errorCode)) { ------------------ | Branch (235:16): [True: 710, False: 355] ------------------ 236| 710| bp = &basePrefixes.getString(); 237| 710| } else { 238| 355| bp = &none; 239| 355| } 240| 1.06k| } 241| 1.84k| if(tp == &none && bp == &none) { break; } ------------------ | Branch (241:12): [True: 355, False: 1.49k] | Branch (241:27): [True: 355, False: 0] ------------------ 242| 1.49k| int32_t cmp = tp->compare(*bp); 243| 1.49k| if(cmp < 0) { ------------------ | Branch (243:12): [True: 780, False: 710] ------------------ 244| | // tp occurs in the tailoring but not in the base. 245| 780| addPrefix(data, *tp, c, static_cast(prefixes.getValue())); 246| 780| tp = nullptr; 247| 780| } else if(cmp > 0) { ------------------ | Branch (247:19): [True: 0, False: 710] ------------------ 248| | // bp occurs in the base but not in the tailoring. 249| 0| addPrefix(baseData, *bp, c, static_cast(basePrefixes.getValue())); 250| 0| bp = nullptr; 251| 710| } else { 252| 710| setPrefix(*tp); 253| 710| compare(c, static_cast(prefixes.getValue()), static_cast(basePrefixes.getValue())); 254| 710| resetPrefix(); 255| 710| tp = nullptr; 256| 710| bp = nullptr; 257| 710| } 258| 1.49k| } 259| 355|} _ZN6icu_7811TailoredSet19compareContractionsEiPKDsS2_: 262| 2.77k|TailoredSet::compareContractions(UChar32 c, const char16_t *p, const char16_t *q) { 263| | // Parallel iteration over suffixes of both tables. 264| 2.77k| UCharsTrie::Iterator suffixes(p, 0, errorCode); 265| 2.77k| UCharsTrie::Iterator baseSuffixes(q, 0, errorCode); 266| 2.77k| const UnicodeString *ts = nullptr; // Tailoring suffix. 267| 2.77k| const UnicodeString *bs = nullptr; // Base suffix. 268| | // Use a string with two U+FFFF as the limit sentinel. 269| | // U+FFFF is untailorable and will not occur in contractions except maybe 270| | // as a single suffix character for a root-collator boundary contraction. 271| 2.77k| UnicodeString none(static_cast(0xffff)); 272| 2.77k| none.append(static_cast(0xffff)); 273| 58.4k| for(;;) { 274| 58.4k| if(ts == nullptr) { ------------------ | Branch (274:12): [True: 58.4k, False: 3] ------------------ 275| 58.4k| if(suffixes.next(errorCode)) { ------------------ | Branch (275:16): [True: 55.6k, False: 2.77k] ------------------ 276| 55.6k| ts = &suffixes.getString(); 277| 55.6k| } else { 278| 2.77k| ts = &none; 279| 2.77k| } 280| 58.4k| } 281| 58.4k| if(bs == nullptr) { ------------------ | Branch (281:12): [True: 42.1k, False: 16.2k] ------------------ 282| 42.1k| if(baseSuffixes.next(errorCode)) { ------------------ | Branch (282:16): [True: 39.3k, False: 2.77k] ------------------ 283| 39.3k| bs = &baseSuffixes.getString(); 284| 39.3k| } else { 285| 2.77k| bs = &none; 286| 2.77k| } 287| 42.1k| } 288| 58.4k| if(ts == &none && bs == &none) { break; } ------------------ | Branch (288:12): [True: 2.77k, False: 55.6k] | Branch (288:27): [True: 2.77k, False: 0] ------------------ 289| 55.6k| int32_t cmp = ts->compare(*bs); 290| 55.6k| if(cmp < 0) { ------------------ | Branch (290:12): [True: 16.2k, False: 39.3k] ------------------ 291| | // ts occurs in the tailoring but not in the base. 292| 16.2k| addSuffix(c, *ts); 293| 16.2k| ts = nullptr; 294| 39.3k| } else if(cmp > 0) { ------------------ | Branch (294:19): [True: 3, False: 39.3k] ------------------ 295| | // bs occurs in the base but not in the tailoring. 296| 3| addSuffix(c, *bs); 297| 3| bs = nullptr; 298| 39.3k| } else { 299| 39.3k| suffix = ts; 300| 39.3k| compare(c, static_cast(suffixes.getValue()), static_cast(baseSuffixes.getValue())); 301| 39.3k| suffix = nullptr; 302| 39.3k| ts = nullptr; 303| 39.3k| bs = nullptr; 304| 39.3k| } 305| 55.6k| } 306| 2.77k|} _ZN6icu_7811TailoredSet11addPrefixesEPKNS_13CollationDataEiPKDs: 309| 1.47k|TailoredSet::addPrefixes(const CollationData *d, UChar32 c, const char16_t *p) { 310| 1.47k| UCharsTrie::Iterator prefixes(p, 0, errorCode); 311| 26.3k| while(prefixes.next(errorCode)) { ------------------ | Branch (311:11): [True: 24.9k, False: 1.47k] ------------------ 312| 24.9k| addPrefix(d, prefixes.getString(), c, static_cast(prefixes.getValue())); 313| 24.9k| } 314| 1.47k|} _ZN6icu_7811TailoredSet9addPrefixEPKNS_13CollationDataERKNS_13UnicodeStringEij: 317| 25.6k|TailoredSet::addPrefix(const CollationData *d, const UnicodeString &pfx, UChar32 c, uint32_t ce32) { 318| 25.6k| setPrefix(pfx); 319| 25.6k| ce32 = d->getFinalCE32(ce32); 320| 25.6k| if(Collation::isContractionCE32(ce32)) { ------------------ | Branch (320:8): [True: 5.50k, False: 20.1k] ------------------ 321| 5.50k| const char16_t *p = d->contexts + Collation::indexFromCE32(ce32); 322| 5.50k| addContractions(c, p + 2); 323| 5.50k| } 324| 25.6k| tailored->add(UnicodeString(unreversedPrefix).append(c)); 325| 25.6k| resetPrefix(); 326| 25.6k|} _ZN6icu_7811TailoredSet15addContractionsEiPKDs: 329| 26.1k|TailoredSet::addContractions(UChar32 c, const char16_t *p) { 330| 26.1k| UCharsTrie::Iterator suffixes(p, 0, errorCode); 331| 247k| while(suffixes.next(errorCode)) { ------------------ | Branch (331:11): [True: 220k, False: 26.1k] ------------------ 332| 220k| addSuffix(c, suffixes.getString()); 333| 220k| } 334| 26.1k|} _ZN6icu_7811TailoredSet9addSuffixEiRKNS_13UnicodeStringE: 337| 237k|TailoredSet::addSuffix(UChar32 c, const UnicodeString &sfx) { 338| 237k| tailored->add(UnicodeString(unreversedPrefix).append(c).append(sfx)); 339| 237k|} _ZN6icu_7811TailoredSet3addEi: 342| 3.15M|TailoredSet::add(UChar32 c) { 343| 3.15M| if(unreversedPrefix.isEmpty() && suffix == nullptr) { ------------------ | Branch (343:8): [True: 3.15M, False: 0] | Branch (343:38): [True: 3.15M, False: 737] ------------------ 344| 3.15M| tailored->add(c); 345| 3.15M| } else { 346| 737| UnicodeString s(unreversedPrefix); 347| 737| s.append(c); 348| 737| if(suffix != nullptr) { ------------------ | Branch (348:12): [True: 737, False: 0] ------------------ 349| 737| s.append(*suffix); 350| 737| } 351| 737| tailored->add(s); 352| 737| } 353| 3.15M|} collationsets.cpp:_ZN6icu_78L17enumTailoredRangeEPKviij: 35| 3.99M|enumTailoredRange(const void *context, UChar32 start, UChar32 end, uint32_t ce32) { 36| 3.99M| if(ce32 == Collation::FALLBACK_CE32) { ------------------ | Branch (36:8): [True: 128k, False: 3.86M] ------------------ 37| 128k| return true; // fallback to base, not tailored 38| 128k| } 39| 3.86M| TailoredSet *ts = (TailoredSet *)context; 40| 3.86M| return ts->handleCE32(start, end, ce32); 41| 3.99M|} _ZN6icu_7811TailoredSetC2EPNS_10UnicodeSetE: 46| 3.92k| : data(nullptr), baseData(nullptr), 47| 3.92k| tailored(t), 48| 3.92k| suffix(nullptr), 49| 3.92k| errorCode(U_ZERO_ERROR) {} _ZN6icu_7811TailoredSet9setPrefixERKNS_13UnicodeStringE: 71| 26.4k| void setPrefix(const UnicodeString &pfx) { 72| 26.4k| unreversedPrefix = pfx; 73| 26.4k| unreversedPrefix.reverse(); 74| 26.4k| } _ZN6icu_7811TailoredSet11resetPrefixEv: 75| 26.4k| void resetPrefix() { 76| 26.4k| unreversedPrefix.remove(); 77| 26.4k| } _ZN6icu_7817CollationSettingsC2ERKS0_: 31| 7.71k| : SharedObject(other), 32| 7.71k| options(other.options), variableTop(other.variableTop), 33| 7.71k| reorderTable(nullptr), 34| 7.71k| minHighNoReorder(other.minHighNoReorder), 35| 7.71k| reorderRanges(nullptr), reorderRangesLength(0), 36| 7.71k| reorderCodes(nullptr), reorderCodesLength(0), reorderCodesCapacity(0), 37| 7.71k| fastLatinOptions(other.fastLatinOptions) { 38| 7.71k| UErrorCode errorCode = U_ZERO_ERROR; 39| 7.71k| copyReorderingFrom(other, errorCode); 40| 7.71k| if(fastLatinOptions >= 0) { ------------------ | Branch (40:8): [True: 7.71k, False: 0] ------------------ 41| 7.71k| uprv_memcpy(fastLatinPrimaries, other.fastLatinPrimaries, sizeof(fastLatinPrimaries)); ------------------ | | 42| 7.71k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 7.71k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 7.71k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 7.71k| _Pragma("clang diagnostic push") \ | | 45| 7.71k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 7.71k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 7.71k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 7.71k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 7.71k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 7.71k| _Pragma("clang diagnostic pop") \ | | 49| 7.71k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 7.71k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 7.71k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7.71k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 42| 7.71k| } 43| 7.71k|} _ZN6icu_7817CollationSettingsD2Ev: 45| 7.71k|CollationSettings::~CollationSettings() { 46| 7.71k| if(reorderCodesCapacity != 0) { ------------------ | Branch (46:8): [True: 762, False: 6.95k] ------------------ 47| 762| uprv_free(const_cast(reorderCodes)); ------------------ | | 1503| 762|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 762|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 762|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 762|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 48| 762| } 49| 7.71k|} _ZN6icu_7817CollationSettings15resetReorderingEv: 74| 7.71k|CollationSettings::resetReordering() { 75| | // When we turn off reordering, we want to set a nullptr permutation 76| | // rather than a no-op permutation. 77| | // Keep the memory via reorderCodes and its capacity. 78| 7.71k| reorderTable = nullptr; 79| 7.71k| minHighNoReorder = 0; 80| 7.71k| reorderRangesLength = 0; 81| 7.71k| reorderCodesLength = 0; 82| 7.71k|} _ZN6icu_7817CollationSettings13setReorderingERKNS_13CollationDataEPKiiR10UErrorCode: 131| 3.19k| UErrorCode &errorCode) { 132| 3.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (132:8): [True: 0, False: 3.19k] ------------------ 133| 3.19k| if(codesLength == 0 || (codesLength == 1 && codes[0] == UCOL_REORDER_CODE_NONE)) { ------------------ | Branch (133:8): [True: 0, False: 3.19k] | Branch (133:29): [True: 2.56k, False: 626] | Branch (133:49): [True: 0, False: 2.56k] ------------------ 134| 0| resetReordering(); 135| 0| return; 136| 0| } 137| 3.19k| UVector32 rangesList(errorCode); 138| 3.19k| data.makeReorderRanges(codes, codesLength, rangesList, errorCode); 139| 3.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (139:8): [True: 0, False: 3.19k] ------------------ 140| 3.19k| int32_t rangesLength = rangesList.size(); 141| 3.19k| if(rangesLength == 0) { ------------------ | Branch (141:8): [True: 0, False: 3.19k] ------------------ 142| 0| resetReordering(); 143| 0| return; 144| 0| } 145| 3.19k| const uint32_t *ranges = reinterpret_cast(rangesList.getBuffer()); 146| | // ranges[] contains at least two (limit, offset) pairs. 147| | // The first offset must be 0. The last offset must not be 0. 148| | // Separators (at the low end) and trailing weights (at the high end) 149| | // are never reordered. 150| 3.19k| U_ASSERT(rangesLength >= 2); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 151| 3.19k| U_ASSERT((ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 152| 3.19k| minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000; 153| | 154| | // Write the lead byte permutation table. 155| | // Set a 0 for each lead byte that has a range boundary in the middle. 156| 3.19k| uint8_t table[256]; 157| 3.19k| int32_t b = 0; 158| 3.19k| int32_t firstSplitByteRangeIndex = -1; 159| 12.2k| for(int32_t i = 0; i < rangesLength; ++i) { ------------------ | Branch (159:24): [True: 9.06k, False: 3.19k] ------------------ 160| 9.06k| uint32_t pair = ranges[i]; 161| 9.06k| int32_t limit1 = static_cast(pair >> 24); 162| 358k| while(b < limit1) { ------------------ | Branch (162:15): [True: 349k, False: 9.06k] ------------------ 163| 349k| table[b] = static_cast(b + pair); 164| 349k| ++b; 165| 349k| } 166| | // Check the second byte of the limit. 167| 9.06k| if((pair & 0xff0000) != 0) { ------------------ | Branch (167:12): [True: 1.15k, False: 7.91k] ------------------ 168| 1.15k| table[limit1] = 0; 169| 1.15k| b = limit1 + 1; 170| 1.15k| if(firstSplitByteRangeIndex < 0) { ------------------ | Branch (170:16): [True: 1.15k, False: 2] ------------------ 171| 1.15k| firstSplitByteRangeIndex = i; 172| 1.15k| } 173| 1.15k| } 174| 9.06k| } 175| 469k| while(b <= 0xff) { ------------------ | Branch (175:11): [True: 466k, False: 3.19k] ------------------ 176| 466k| table[b] = static_cast(b); 177| 466k| ++b; 178| 466k| } 179| 3.19k| if(firstSplitByteRangeIndex < 0) { ------------------ | Branch (179:8): [True: 2.03k, False: 1.15k] ------------------ 180| | // The lead byte permutation table alone suffices for reordering. 181| 2.03k| rangesLength = 0; 182| 2.03k| } else { 183| | // Remove the ranges below the first split byte. 184| 1.15k| ranges += firstSplitByteRangeIndex; 185| 1.15k| rangesLength -= firstSplitByteRangeIndex; 186| 1.15k| } 187| 3.19k| setReorderArrays(codes, codesLength, ranges, rangesLength, table, errorCode); 188| 3.19k|} _ZN6icu_7817CollationSettings16setReorderArraysEPKiiPKjiPKhR10UErrorCode: 193| 3.19k| const uint8_t *table, UErrorCode &errorCode) { 194| 3.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (194:8): [True: 0, False: 3.19k] ------------------ 195| 3.19k| int32_t *ownedCodes; 196| 3.19k| int32_t totalLength = codesLength + rangesLength; 197| 3.19k| U_ASSERT(totalLength > 0); ------------------ | | 35| 3.19k|# define U_ASSERT(exp) (void)0 ------------------ 198| 3.19k| if(totalLength <= reorderCodesCapacity) { ------------------ | Branch (198:8): [True: 2.34k, False: 843] ------------------ 199| 2.34k| ownedCodes = const_cast(reorderCodes); 200| 2.34k| } else { 201| | // Allocate one memory block for the codes, the ranges, and the 16-aligned table. 202| 843| int32_t capacity = (totalLength + 3) & ~3; // round up to a multiple of 4 ints 203| 843| ownedCodes = static_cast(uprv_malloc(capacity * 4 + 256)); ------------------ | | 1524| 843|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 843|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 843|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 843|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 204| 843| if(ownedCodes == nullptr) { ------------------ | Branch (204:12): [True: 0, False: 843] ------------------ 205| 0| resetReordering(); 206| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 207| 0| return; 208| 0| } 209| 843| if(reorderCodesCapacity != 0) { ------------------ | Branch (209:12): [True: 81, False: 762] ------------------ 210| 81| uprv_free(const_cast(reorderCodes)); ------------------ | | 1503| 81|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 81|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 81|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 81|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 211| 81| } 212| 843| reorderCodes = ownedCodes; 213| 843| reorderCodesCapacity = capacity; 214| 843| } 215| 3.19k| uprv_memcpy(ownedCodes + reorderCodesCapacity, table, 256); ------------------ | | 42| 3.19k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.19k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.19k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.19k| _Pragma("clang diagnostic push") \ | | 45| 3.19k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.19k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.19k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.19k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.19k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.19k| _Pragma("clang diagnostic pop") \ | | 49| 3.19k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.19k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.19k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.19k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 216| 3.19k| uprv_memcpy(ownedCodes, codes, codesLength * 4); ------------------ | | 42| 3.19k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.19k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.19k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.19k| _Pragma("clang diagnostic push") \ | | 45| 3.19k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.19k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.19k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.19k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.19k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.19k| _Pragma("clang diagnostic pop") \ | | 49| 3.19k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.19k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.19k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.19k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 217| 3.19k| uprv_memcpy(ownedCodes + codesLength, ranges, rangesLength * 4); ------------------ | | 42| 3.19k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.19k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.19k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.19k| _Pragma("clang diagnostic push") \ | | 45| 3.19k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.19k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.19k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.19k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.19k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.19k| _Pragma("clang diagnostic pop") \ | | 49| 3.19k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.19k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.19k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.19k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 218| 3.19k| reorderTable = reinterpret_cast(reorderCodes + reorderCodesCapacity); 219| 3.19k| reorderCodesLength = codesLength; 220| 3.19k| reorderRanges = reinterpret_cast(ownedCodes) + codesLength; 221| 3.19k| reorderRangesLength = rangesLength; 222| 3.19k|} _ZN6icu_7817CollationSettings18copyReorderingFromERKS0_R10UErrorCode: 225| 7.71k|CollationSettings::copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode) { 226| 7.71k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (226:8): [True: 0, False: 7.71k] ------------------ 227| 7.71k| if(!other.hasReordering()) { ------------------ | Branch (227:8): [True: 7.71k, False: 0] ------------------ 228| 7.71k| resetReordering(); 229| 7.71k| return; 230| 7.71k| } 231| 0| minHighNoReorder = other.minHighNoReorder; 232| 0| if(other.reorderCodesCapacity == 0) { ------------------ | Branch (232:8): [True: 0, False: 0] ------------------ 233| | // The reorder arrays are aliased to memory-mapped data. 234| 0| reorderTable = other.reorderTable; 235| 0| reorderRanges = other.reorderRanges; 236| 0| reorderRangesLength = other.reorderRangesLength; 237| 0| reorderCodes = other.reorderCodes; 238| 0| reorderCodesLength = other.reorderCodesLength; 239| 0| } else { 240| 0| setReorderArrays(other.reorderCodes, other.reorderCodesLength, 241| 0| other.reorderRanges, other.reorderRangesLength, 242| 0| other.reorderTable, errorCode); 243| 0| } 244| 0|} _ZNK6icu_7817CollationSettings9reorderExEj: 258| 1.24k|CollationSettings::reorderEx(uint32_t p) const { 259| 1.24k| if(p >= minHighNoReorder) { return p; } ------------------ | Branch (259:8): [True: 608, False: 634] ------------------ 260| | // Round up p so that its lower 16 bits are >= any offset bits. 261| | // Then compare q directly with (limit, offset) pairs. 262| 634| uint32_t q = p | 0xffff; 263| 634| uint32_t r; 264| 634| const uint32_t *ranges = reorderRanges; 265| 1.02k| while(q >= (r = *ranges)) { ++ranges; } ------------------ | Branch (265:11): [True: 390, False: 634] ------------------ 266| 634| return p + (r << 24); 267| 1.24k|} _ZN6icu_7817CollationSettings11setStrengthEiiR10UErrorCode: 270| 221|CollationSettings::setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) { 271| 221| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (271:8): [True: 0, False: 221] ------------------ 272| 221| int32_t noStrength = options & ~STRENGTH_MASK; 273| 221| switch(value) { 274| 17| case UCOL_PRIMARY: ------------------ | Branch (274:5): [True: 17, False: 204] ------------------ 275| 20| case UCOL_SECONDARY: ------------------ | Branch (275:5): [True: 3, False: 218] ------------------ 276| 30| case UCOL_TERTIARY: ------------------ | Branch (276:5): [True: 10, False: 211] ------------------ 277| 33| case UCOL_QUATERNARY: ------------------ | Branch (277:5): [True: 3, False: 218] ------------------ 278| 221| case UCOL_IDENTICAL: ------------------ | Branch (278:5): [True: 188, False: 33] ------------------ 279| 221| options = noStrength | (value << STRENGTH_SHIFT); 280| 221| break; 281| 0| case UCOL_DEFAULT: ------------------ | Branch (281:5): [True: 0, False: 221] ------------------ 282| 0| options = noStrength | (defaultOptions & STRENGTH_MASK); 283| 0| break; 284| 0| default: ------------------ | Branch (284:5): [True: 0, False: 221] ------------------ 285| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 286| 0| break; 287| 221| } 288| 221|} _ZN6icu_7817CollationSettings7setFlagEi18UColAttributeValueiR10UErrorCode: 292| 1.89k| int32_t defaultOptions, UErrorCode &errorCode) { 293| 1.89k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (293:8): [True: 0, False: 1.89k] ------------------ 294| 1.89k| switch(value) { 295| 1.89k| case UCOL_ON: ------------------ | Branch (295:5): [True: 1.89k, False: 0] ------------------ 296| 1.89k| options |= bit; 297| 1.89k| break; 298| 0| case UCOL_OFF: ------------------ | Branch (298:5): [True: 0, False: 1.89k] ------------------ 299| 0| options &= ~bit; 300| 0| break; 301| 0| case UCOL_DEFAULT: ------------------ | Branch (301:5): [True: 0, False: 1.89k] ------------------ 302| 0| options = (options & ~bit) | (defaultOptions & bit); 303| 0| break; 304| 0| default: ------------------ | Branch (304:5): [True: 0, False: 1.89k] ------------------ 305| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 306| 0| break; 307| 1.89k| } 308| 1.89k|} _ZN6icu_7817CollationSettings12setCaseFirstE18UColAttributeValueiR10UErrorCode: 312| 111| int32_t defaultOptions, UErrorCode &errorCode) { 313| 111| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (313:8): [True: 0, False: 111] ------------------ 314| 111| int32_t noCaseFirst = options & ~CASE_FIRST_AND_UPPER_MASK; 315| 111| switch(value) { 316| 0| case UCOL_OFF: ------------------ | Branch (316:5): [True: 0, False: 111] ------------------ 317| 0| options = noCaseFirst; 318| 0| break; 319| 0| case UCOL_LOWER_FIRST: ------------------ | Branch (319:5): [True: 0, False: 111] ------------------ 320| 0| options = noCaseFirst | CASE_FIRST; 321| 0| break; 322| 111| case UCOL_UPPER_FIRST: ------------------ | Branch (322:5): [True: 111, False: 0] ------------------ 323| 111| options = noCaseFirst | CASE_FIRST_AND_UPPER_MASK; 324| 111| break; 325| 0| case UCOL_DEFAULT: ------------------ | Branch (325:5): [True: 0, False: 111] ------------------ 326| 0| options = noCaseFirst | (defaultOptions & CASE_FIRST_AND_UPPER_MASK); 327| 0| break; 328| 0| default: ------------------ | Branch (328:5): [True: 0, False: 111] ------------------ 329| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 330| 0| break; 331| 111| } 332| 111|} _ZN6icu_7817CollationSettings20setAlternateHandlingE18UColAttributeValueiR10UErrorCode: 336| 453| int32_t defaultOptions, UErrorCode &errorCode) { 337| 453| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (337:8): [True: 0, False: 453] ------------------ 338| 453| int32_t noAlternate = options & ~ALTERNATE_MASK; 339| 453| switch(value) { 340| 0| case UCOL_NON_IGNORABLE: ------------------ | Branch (340:5): [True: 0, False: 453] ------------------ 341| 0| options = noAlternate; 342| 0| break; 343| 453| case UCOL_SHIFTED: ------------------ | Branch (343:5): [True: 453, False: 0] ------------------ 344| 453| options = noAlternate | SHIFTED; 345| 453| break; 346| 0| case UCOL_DEFAULT: ------------------ | Branch (346:5): [True: 0, False: 453] ------------------ 347| 0| options = noAlternate | (defaultOptions & ALTERNATE_MASK); 348| 0| break; 349| 0| default: ------------------ | Branch (349:5): [True: 0, False: 453] ------------------ 350| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 351| 0| break; 352| 453| } 353| 453|} _ZN6icu_7817CollationSettingsC2Ev: 106| 1| : options((UCOL_DEFAULT_STRENGTH << STRENGTH_SHIFT) | 107| 1| (MAX_VAR_PUNCT << MAX_VARIABLE_SHIFT)), 108| 1| variableTop(0), 109| 1| reorderTable(nullptr), 110| 1| minHighNoReorder(0), 111| 1| reorderRanges(nullptr), reorderRangesLength(0), 112| 1| reorderCodes(nullptr), reorderCodesLength(0), reorderCodesCapacity(0), 113| 1| fastLatinOptions(-1) {} _ZNK6icu_7817CollationSettings13hasReorderingEv: 134| 2.22M| inline UBool hasReordering() const { return reorderTable != nullptr; } _ZNK6icu_7817CollationSettings7reorderEj: 136| 667k| inline uint32_t reorder(uint32_t p) const { 137| 667k| uint8_t b = reorderTable[p >> 24]; 138| 667k| if(b != 0 || p <= Collation::NO_CE_PRIMARY) { ------------------ | Branch (138:12): [True: 665k, False: 2.69k] | Branch (138:22): [True: 1.45k, False: 1.24k] ------------------ 139| 666k| return (static_cast(b) << 24) | (p & 0xffffff); 140| 666k| } else { 141| 1.24k| return reorderEx(p); 142| 1.24k| } 143| 667k| } _ZN6icu_7817CollationSettings11getStrengthEi: 147| 20.4k| static int32_t getStrength(int32_t options) { 148| 20.4k| return options >> STRENGTH_SHIFT; 149| 20.4k| } _ZNK6icu_7817CollationSettings11getStrengthEv: 151| 12.2k| int32_t getStrength() const { 152| 12.2k| return getStrength(options); 153| 12.2k| } _ZNK6icu_7817CollationSettings14getMaxVariableEv: 180| 4.43k| MaxVariable getMaxVariable() const { 181| 4.43k| return static_cast((options & MAX_VARIABLE_MASK) >> MAX_VARIABLE_SHIFT); 182| 4.43k| } _ZN6icu_7817CollationSettings22isTertiaryWithCaseBitsEi: 187| 8.19k| static inline UBool isTertiaryWithCaseBits(int32_t options) { 188| 8.19k| return (options & (CASE_LEVEL | CASE_FIRST)) == CASE_FIRST; 189| 8.19k| } _ZN6icu_7817CollationSettings15getTertiaryMaskEi: 190| 8.19k| static uint32_t getTertiaryMask(int32_t options) { 191| | // Remove the case bits from the tertiary weight when caseLevel is on or caseFirst is off. 192| 8.19k| return isTertiaryWithCaseBits(options) ? ------------------ | Branch (192:16): [True: 182, False: 8.00k] ------------------ 193| 8.00k| Collation::CASE_AND_TERTIARY_MASK : Collation::ONLY_TERTIARY_MASK; 194| 8.19k| } _ZNK6icu_7817CollationSettings12dontCheckFCDEv: 202| 8.19k| inline UBool dontCheckFCD() const { 203| 8.19k| return (options & CHECK_FCD) == 0; 204| 8.19k| } _ZNK6icu_7817CollationSettings9isNumericEv: 210| 8.19k| inline UBool isNumeric() const { 211| 8.19k| return (options & NUMERIC) != 0; 212| 8.19k| } _ZN6icu_7818CollationTailoringC2EPKNS_17CollationSettingsE: 36| 7.71k| : data(nullptr), settings(baseSettings), 37| 7.71k| actualLocale(""), 38| 7.71k| ownedData(nullptr), 39| 7.71k| builder(nullptr), memory(nullptr), bundle(nullptr), 40| 7.71k| trie(nullptr), unsafeBackwardSet(nullptr), 41| 7.71k| maxExpansions(nullptr) { 42| 7.71k| if(baseSettings != nullptr) { ------------------ | Branch (42:8): [True: 7.71k, False: 1] ------------------ 43| 7.71k| U_ASSERT(baseSettings->reorderCodesLength == 0); ------------------ | | 35| 7.71k|# define U_ASSERT(exp) (void)0 ------------------ 44| 7.71k| U_ASSERT(baseSettings->reorderTable == nullptr); ------------------ | | 35| 7.71k|# define U_ASSERT(exp) (void)0 ------------------ 45| 7.71k| U_ASSERT(baseSettings->minHighNoReorder == 0); ------------------ | | 35| 7.71k|# define U_ASSERT(exp) (void)0 ------------------ 46| 7.71k| } else { 47| 1| settings = new CollationSettings(); 48| 1| } 49| 7.71k| if(settings != nullptr) { ------------------ | Branch (49:8): [True: 7.71k, False: 0] ------------------ 50| 7.71k| settings->addRef(); 51| 7.71k| } 52| 7.71k| rules.getTerminatedBuffer(); // ensure NUL-termination 53| 7.71k| version[0] = version[1] = version[2] = version[3] = 0; 54| 7.71k| maxExpansionsInitOnce.reset(); 55| 7.71k|} _ZN6icu_7818CollationTailoringD2Ev: 57| 7.71k|CollationTailoring::~CollationTailoring() { 58| 7.71k| SharedObject::clearPtr(settings); 59| 7.71k| delete ownedData; 60| 7.71k| delete builder; 61| 7.71k| udata_close(memory); ------------------ | | 885| 7.71k|#define udata_close U_ICU_ENTRY_POINT_RENAME(udata_close) | | ------------------ | | | | 123| 7.71k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.71k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.71k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 62| 7.71k| ures_close(bundle); ------------------ | | 1652| 7.71k|#define ures_close U_ICU_ENTRY_POINT_RENAME(ures_close) | | ------------------ | | | | 123| 7.71k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.71k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.71k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 7.71k| utrie2_close(trie); ------------------ | | 1961| 7.71k|#define utrie2_close U_ICU_ENTRY_POINT_RENAME(utrie2_close) | | ------------------ | | | | 123| 7.71k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.71k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.71k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 7.71k| delete unsafeBackwardSet; 65| 7.71k| uhash_close(maxExpansions); ------------------ | | 991| 7.71k|#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close) | | ------------------ | | | | 123| 7.71k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.71k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.71k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 66| 7.71k| maxExpansionsInitOnce.reset(); 67| 7.71k|} _ZN6icu_7818CollationTailoring15ensureOwnedDataER10UErrorCode: 70| 3.96k|CollationTailoring::ensureOwnedData(UErrorCode &errorCode) { 71| 3.96k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (71:8): [True: 41, False: 3.92k] ------------------ 72| 3.92k| if(ownedData == nullptr) { ------------------ | Branch (72:8): [True: 3.92k, False: 0] ------------------ 73| 3.92k| const Normalizer2Impl *nfcImpl = Normalizer2Factory::getNFCImpl(errorCode); 74| 3.92k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (74:12): [True: 0, False: 3.92k] ------------------ 75| 3.92k| ownedData = new CollationData(*nfcImpl); 76| 3.92k| if(ownedData == nullptr) { ------------------ | Branch (76:12): [True: 0, False: 3.92k] ------------------ 77| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 78| 0| return false; 79| 0| } 80| 3.92k| } 81| 3.92k| data = ownedData; 82| 3.92k| return true; 83| 3.92k|} _ZN6icu_7818CollationTailoring10setVersionEPKhS2_: 94| 4.09k|CollationTailoring::setVersion(const UVersionInfo baseVersion, const UVersionInfo rulesVersion) { 95| 4.09k| version[0] = UCOL_BUILDER_VERSION; ------------------ | | 179| 4.09k|#define UCOL_BUILDER_VERSION 9 ------------------ 96| 4.09k| version[1] = baseVersion[1]; 97| 4.09k| version[2] = (baseVersion[2] & 0xc0) + ((rulesVersion[0] + (rulesVersion[0] >> 6)) & 0x3f); 98| 4.09k| version[3] = (rulesVersion[1] << 3) + (rulesVersion[1] >> 5) + rulesVersion[2] + 99| 4.09k| (rulesVersion[3] << 4) + (rulesVersion[3] >> 4); 100| 4.09k|} _ZN6icu_7819CollationCacheEntryD2Ev: 107| 4.09k|CollationCacheEntry::~CollationCacheEntry() { 108| 4.09k| SharedObject::clearPtr(tailoring); 109| 4.09k|} _ZN6icu_7818CollationTailoring7isBogusEv: 57| 7.71k| UBool isBogus() { return settings == nullptr; } _ZN6icu_7819CollationCacheEntryC2ERKNS_6LocaleEPKNS_18CollationTailoringE: 99| 4.09k| : validLocale(loc), tailoring(t) { 100| 4.09k| if(t != nullptr) { ------------------ | Branch (100:12): [True: 4.09k, False: 0] ------------------ 101| 4.09k| t->addRef(); 102| 4.09k| } 103| 4.09k| } _ZN6icu_7816CollationWeightsC2Ev: 99| 11.9k| : middleLength(0), rangeIndex(0), rangeCount(0) { 100| 71.4k| for(int32_t i = 0; i < 5; ++i) { ------------------ | Branch (100:24): [True: 59.5k, False: 11.9k] ------------------ 101| 59.5k| minBytes[i] = maxBytes[i] = 0; 102| 59.5k| } 103| 11.9k|} _ZN6icu_7816CollationWeights14initForPrimaryEa: 106| 7.57k|CollationWeights::initForPrimary(UBool compressible) { 107| 7.57k| middleLength=1; 108| 7.57k| minBytes[1] = Collation::MERGE_SEPARATOR_BYTE + 1; 109| 7.57k| maxBytes[1] = Collation::TRAIL_WEIGHT_BYTE; 110| 7.57k| if(compressible) { ------------------ | Branch (110:8): [True: 3.13k, False: 4.44k] ------------------ 111| 3.13k| minBytes[2] = Collation::PRIMARY_COMPRESSION_LOW_BYTE + 1; 112| 3.13k| maxBytes[2] = Collation::PRIMARY_COMPRESSION_HIGH_BYTE - 1; 113| 4.44k| } else { 114| 4.44k| minBytes[2] = 2; 115| 4.44k| maxBytes[2] = 0xff; 116| 4.44k| } 117| 7.57k| minBytes[3] = 2; 118| 7.57k| maxBytes[3] = 0xff; 119| 7.57k| minBytes[4] = 2; 120| 7.57k| maxBytes[4] = 0xff; 121| 7.57k|} _ZN6icu_7816CollationWeights16initForSecondaryEv: 124| 5.65k|CollationWeights::initForSecondary() { 125| | // We use only the lower 16 bits for secondary weights. 126| 5.65k| middleLength=3; 127| 5.65k| minBytes[1] = 0; 128| 5.65k| maxBytes[1] = 0; 129| 5.65k| minBytes[2] = 0; 130| 5.65k| maxBytes[2] = 0; 131| 5.65k| minBytes[3] = Collation::LEVEL_SEPARATOR_BYTE + 1; 132| 5.65k| maxBytes[3] = 0xff; 133| 5.65k| minBytes[4] = 2; 134| 5.65k| maxBytes[4] = 0xff; 135| 5.65k|} _ZN6icu_7816CollationWeights15initForTertiaryEv: 138| 7.22k|CollationWeights::initForTertiary() { 139| | // We use only the lower 16 bits for tertiary weights. 140| 7.22k| middleLength=3; 141| 7.22k| minBytes[1] = 0; 142| 7.22k| maxBytes[1] = 0; 143| 7.22k| minBytes[2] = 0; 144| 7.22k| maxBytes[2] = 0; 145| | // We use only 6 bits per byte. 146| | // The other bits are used for case & quaternary weights. 147| 7.22k| minBytes[3] = Collation::LEVEL_SEPARATOR_BYTE + 1; 148| 7.22k| maxBytes[3] = 0x3f; 149| 7.22k| minBytes[4] = 2; 150| 7.22k| maxBytes[4] = 0x3f; 151| 7.22k|} _ZNK6icu_7816CollationWeights9incWeightEji: 154| 3.14M|CollationWeights::incWeight(uint32_t weight, int32_t length) const { 155| 3.16M| for(;;) { 156| 3.16M| uint32_t byte=getWeightByte(weight, length); 157| 3.16M| if(byte 0); ------------------ | | 35| 12.3k|# define U_ASSERT(exp) (void)0 ------------------ 164| 12.3k| } 165| 3.16M| } 166| 3.14M|} _ZNK6icu_7816CollationWeights17incWeightByOffsetEjii: 169| 940|CollationWeights::incWeightByOffset(uint32_t weight, int32_t length, int32_t offset) const { 170| 979| for(;;) { 171| 979| offset += getWeightByte(weight, length); 172| 979| if (static_cast(offset) <= maxBytes[length]) { ------------------ | Branch (172:13): [True: 940, False: 39] ------------------ 173| 940| return setWeightByte(weight, length, offset); 174| 940| } else { 175| | // Split the offset between this byte and the previous one. 176| 39| offset -= minBytes[length]; 177| 39| weight = setWeightByte(weight, length, minBytes[length] + offset % countBytes(length)); 178| 39| offset /= countBytes(length); 179| 39| --length; 180| 39| U_ASSERT(length > 0); ------------------ | | 35| 39|# define U_ASSERT(exp) (void)0 ------------------ 181| 39| } 182| 979| } 183| 940|} _ZNK6icu_7816CollationWeights13lengthenRangeERNS0_11WeightRangeE: 186| 3.18k|CollationWeights::lengthenRange(WeightRange &range) const { 187| 3.18k| int32_t length=range.length+1; 188| 3.18k| range.start=setWeightTrail(range.start, length, minBytes[length]); 189| 3.18k| range.end=setWeightTrail(range.end, length, maxBytes[length]); 190| 3.18k| range.count*=countBytes(length); 191| 3.18k| range.length=length; 192| 3.18k|} _ZN6icu_7816CollationWeights15getWeightRangesEjj: 211| 20.4k|CollationWeights::getWeightRanges(uint32_t lowerLimit, uint32_t upperLimit) { 212| 20.4k| U_ASSERT(lowerLimit != 0); ------------------ | | 35| 20.4k|# define U_ASSERT(exp) (void)0 ------------------ 213| 20.4k| U_ASSERT(upperLimit != 0); ------------------ | | 35| 20.4k|# define U_ASSERT(exp) (void)0 ------------------ 214| | 215| | /* get the lengths of the limits */ 216| 20.4k| int32_t lowerLength=lengthOfWeight(lowerLimit); 217| 20.4k| int32_t upperLength=lengthOfWeight(upperLimit); 218| | 219| |#ifdef UCOL_DEBUG 220| | printf("length of lower limit 0x%08lx is %ld\n", lowerLimit, lowerLength); 221| | printf("length of upper limit 0x%08lx is %ld\n", upperLimit, upperLength); 222| |#endif 223| 20.4k| U_ASSERT(lowerLength>=middleLength); ------------------ | | 35| 20.4k|# define U_ASSERT(exp) (void)0 ------------------ 224| | // Permit upperLength=upperLimit) { ------------------ | Branch (226:8): [True: 0, False: 20.4k] ------------------ 227| |#ifdef UCOL_DEBUG 228| | printf("error: no space between lower & upper limits\n"); 229| |#endif 230| 0| return false; 231| 0| } 232| | 233| | /* check that neither is a prefix of the other */ 234| 20.4k| if(lowerLength=upperLimit has caught it */ 243| | 244| 20.4k| WeightRange lower[5], middle, upper[5]; /* [0] and [1] are not used - this simplifies indexing */ 245| 20.4k| uprv_memset(lower, 0, sizeof(lower)); ------------------ | | 100| 20.4k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 20.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 246| 20.4k| uprv_memset(&middle, 0, sizeof(middle)); ------------------ | | 100| 20.4k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 20.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 247| 20.4k| uprv_memset(upper, 0, sizeof(upper)); ------------------ | | 100| 20.4k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 20.4k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 248| | 249| | /* 250| | * With the limit lengths of 1..4, there are up to 7 ranges for allocation: 251| | * range minimum length 252| | * lower[4] 4 253| | * lower[3] 3 254| | * lower[2] 2 255| | * middle 1 256| | * upper[2] 2 257| | * upper[3] 3 258| | * upper[4] 4 259| | * 260| | * We are now going to calculate up to 7 ranges. 261| | * Some of them will typically overlap, so we will then have to merge and eliminate ranges. 262| | */ 263| 20.4k| uint32_t weight=lowerLimit; 264| 29.5k| for(int32_t length=lowerLength; length>middleLength; --length) { ------------------ | Branch (264:37): [True: 9.11k, False: 20.4k] ------------------ 265| 9.11k| uint32_t trail=getWeightTrail(weight, length); 266| 9.11k| if(trailmiddleLength; --length) { ------------------ | Branch (283:37): [True: 9.68k, False: 20.4k] ------------------ 284| 9.68k| uint32_t trail=getWeightTrail(weight, length); 285| 9.68k| if(trail>minBytes[length]) { ------------------ | Branch (285:12): [True: 8.96k, False: 722] ------------------ 286| 8.96k| upper[length].start=setWeightTrail(weight, length, minBytes[length]); 287| 8.96k| upper[length].end=decWeightTrail(weight, length); 288| 8.96k| upper[length].length=length; 289| 8.96k| upper[length].count=trail-minBytes[length]; 290| 8.96k| } 291| 9.68k| weight=truncateWeight(weight, length-1); 292| 9.68k| } 293| 20.4k| middle.end=decWeightTrail(weight, middleLength); 294| | 295| | /* set the middle range */ 296| 20.4k| middle.length=middleLength; 297| 20.4k| if(middle.end>=middle.start) { ------------------ | Branch (297:8): [True: 12.5k, False: 7.89k] ------------------ 298| 12.5k| middle.count = static_cast((middle.end - middle.start) >> (8 * (4 - middleLength))) + 1; 299| 12.5k| } else { 300| | /* no middle range, eliminate overlaps */ 301| 22.3k| for(int32_t length=4; length>middleLength; --length) { ------------------ | Branch (301:31): [True: 20.9k, False: 1.41k] ------------------ 302| 20.9k| if(lower[length].count>0 && upper[length].count>0) { ------------------ | Branch (302:16): [True: 7.23k, False: 13.6k] | Branch (302:41): [True: 6.48k, False: 747] ------------------ 303| | // Note: The lowerEnd and upperStart weights are versions of 304| | // lowerLimit and upperLimit (which are lowerLimitupperStart) { ------------------ | Branch (312:20): [True: 6.47k, False: 16] ------------------ 313| | // These two lower and upper ranges collide. 314| | // Since lowerLimitupperStart is only possible 318| | // if the leading bytes are equal 319| | // and lastByte(lowerEnd)>lastByte(upperStart). 320| 6.47k| U_ASSERT(truncateWeight(lowerEnd, length-1)== ------------------ | | 35| 6.47k|# define U_ASSERT(exp) (void)0 ------------------ 321| 6.47k| truncateWeight(upperStart, length-1)); 322| | // Intersect these two ranges. 323| 6.47k| lower[length].end=upper[length].end; 324| 6.47k| lower[length].count= 325| 6.47k| static_cast(getWeightTrail(lower[length].end, length)) - 326| 6.47k| static_cast(getWeightTrail(lower[length].start, length)) + 1; 327| | // count might be <=0 in which case there is no room, 328| | // and the range-collecting code below will ignore this range. 329| 6.47k| merged=true; 330| 6.47k| } else if(lowerEnd==upperStart) { ------------------ | Branch (330:27): [True: 0, False: 16] ------------------ 331| | // Not possible, unless minByte==maxByte which is not allowed. 332| 0| U_ASSERT(minBytes[length]countBytes 338| 16| merged=true; 339| 16| } 340| 16| } 341| 6.48k| if(merged) { ------------------ | Branch (341:20): [True: 6.48k, False: 0] ------------------ 342| | // Remove all shorter ranges. 343| | // There was no room available for them between the ranges we just merged. 344| 6.48k| upper[length].count=0; 345| 8.26k| while(--length>middleLength) { ------------------ | Branch (345:27): [True: 1.77k, False: 6.48k] ------------------ 346| 1.77k| lower[length].count=upper[length].count=0; 347| 1.77k| } 348| 6.48k| break; 349| 6.48k| } 350| 6.48k| } 351| 20.9k| } 352| 7.89k| } 353| | 354| |#ifdef UCOL_DEBUG 355| | /* print ranges */ 356| | for(int32_t length=4; length>=2; --length) { 357| | if(lower[length].count>0) { 358| | printf("lower[%ld] .start=0x%08lx .end=0x%08lx .count=%ld\n", length, lower[length].start, lower[length].end, lower[length].count); 359| | } 360| | } 361| | if(middle.count>0) { 362| | printf("middle .start=0x%08lx .end=0x%08lx .count=%ld\n", middle.start, middle.end, middle.count); 363| | } 364| | for(int32_t length=2; length<=4; ++length) { 365| | if(upper[length].count>0) { 366| | printf("upper[%ld] .start=0x%08lx .end=0x%08lx .count=%ld\n", length, upper[length].start, upper[length].end, upper[length].count); 367| | } 368| | } 369| |#endif 370| | 371| | /* copy the ranges, shortest first, into the result array */ 372| 20.4k| rangeCount=0; 373| 20.4k| if(middle.count>0) { ------------------ | Branch (373:8): [True: 12.5k, False: 7.89k] ------------------ 374| 12.5k| uprv_memcpy(ranges, &middle, sizeof(WeightRange)); ------------------ | | 42| 12.5k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 12.5k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 12.5k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 12.5k| _Pragma("clang diagnostic push") \ | | 45| 12.5k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 12.5k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 12.5k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 12.5k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 12.5k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 12.5k| _Pragma("clang diagnostic pop") \ | | 49| 12.5k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 12.5k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 12.5k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 12.5k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 375| 12.5k| rangeCount=1; 376| 12.5k| } 377| 56.0k| for(int32_t length=middleLength+1; length<=4; ++length) { ------------------ | Branch (377:40): [True: 35.6k, False: 20.4k] ------------------ 378| | /* copy upper first so that later the middle range is more likely the first one to use */ 379| 35.6k| if(upper[length].count>0) { ------------------ | Branch (379:12): [True: 756, False: 34.8k] ------------------ 380| 756| uprv_memcpy(ranges+rangeCount, upper+length, sizeof(WeightRange)); ------------------ | | 42| 756|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 756|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 756| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 756| _Pragma("clang diagnostic push") \ | | 45| 756| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 756| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 756|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 756| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 756|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 756| _Pragma("clang diagnostic pop") \ | | 49| 756| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 756|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 756|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 756|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 381| 756| ++rangeCount; 382| 756| } 383| 35.6k| if(lower[length].count>0) { ------------------ | Branch (383:12): [True: 7.29k, False: 28.3k] ------------------ 384| 7.29k| uprv_memcpy(ranges+rangeCount, lower+length, sizeof(WeightRange)); ------------------ | | 42| 7.29k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 7.29k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 7.29k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 7.29k| _Pragma("clang diagnostic push") \ | | 45| 7.29k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 7.29k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 7.29k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 7.29k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 7.29k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 7.29k| _Pragma("clang diagnostic pop") \ | | 49| 7.29k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 7.29k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 7.29k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7.29k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 385| 7.29k| ++rangeCount; 386| 7.29k| } 387| 35.6k| } 388| 20.4k| return rangeCount>0; 389| 20.4k|} _ZN6icu_7816CollationWeights25allocWeightsInShortRangesEii: 392| 20.7k|CollationWeights::allocWeightsInShortRanges(int32_t n, int32_t minLength) { 393| | // See if the first few minLength and minLength+1 ranges have enough weights. 394| 24.0k| for(int32_t i = 0; i < rangeCount && ranges[i].length <= (minLength + 1); ++i) { ------------------ | Branch (394:24): [True: 20.8k, False: 3.21k] | Branch (394:42): [True: 20.8k, False: 2] ------------------ 395| 20.8k| if(n <= ranges[i].count) { ------------------ | Branch (395:12): [True: 17.5k, False: 3.35k] ------------------ 396| | // Use the first few minLength and minLength+1 ranges. 397| 17.5k| if(ranges[i].length > minLength) { ------------------ | Branch (397:16): [True: 53, False: 17.4k] ------------------ 398| | // Reduce the number of weights from the last minLength+1 range 399| | // which might sort before some minLength ranges, 400| | // so that we use all weights in the minLength ranges. 401| 53| ranges[i].count = n; 402| 53| } 403| 17.5k| rangeCount = i + 1; 404| |#ifdef UCOL_DEBUG 405| | printf("take first %ld ranges\n", rangeCount); 406| |#endif 407| | 408| 17.5k| if(rangeCount>1) { ------------------ | Branch (408:16): [True: 70, False: 17.4k] ------------------ 409| | /* sort the ranges by weight values */ 410| 70| UErrorCode errorCode=U_ZERO_ERROR; 411| 70| uprv_sortArray(ranges, rangeCount, sizeof(WeightRange), ------------------ | | 1538| 70|#define uprv_sortArray U_ICU_ENTRY_POINT_RENAME(uprv_sortArray) | | ------------------ | | | | 123| 70|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 70|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 70|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 412| 70| compareRanges, nullptr, false, &errorCode); 413| | /* ignore error code: we know that the internal sort function will not fail here */ 414| 70| } 415| 17.5k| return true; 416| 17.5k| } 417| 3.35k| n -= ranges[i].count; // still >0 418| 3.35k| } 419| 3.21k| return false; 420| 20.7k|} _ZN6icu_7816CollationWeights29allocWeightsInMinLengthRangesEii: 423| 3.18k|CollationWeights::allocWeightsInMinLengthRanges(int32_t n, int32_t minLength) { 424| | // See if the minLength ranges have enough weights 425| | // when we split one and lengthen the following ones. 426| 3.18k| int32_t count = 0; 427| 3.18k| int32_t minLengthRangeCount; 428| 3.18k| for(minLengthRangeCount = 0; 429| 6.37k| minLengthRangeCount < rangeCount && ------------------ | Branch (429:13): [True: 3.25k, False: 3.12k] ------------------ 430| 6.37k| ranges[minLengthRangeCount].length == minLength; ------------------ | Branch (430:17): [True: 3.19k, False: 60] ------------------ 431| 3.19k| ++minLengthRangeCount) { 432| 3.19k| count += ranges[minLengthRangeCount].count; 433| 3.19k| } 434| | 435| 3.18k| int32_t nextCountBytes = countBytes(minLength + 1); 436| 3.18k| if(n > count * nextCountBytes) { return false; } ------------------ | Branch (436:8): [True: 282, False: 2.90k] ------------------ 437| | 438| | // Use the minLength ranges. Merge them, and then split again as necessary. 439| 2.90k| uint32_t start = ranges[0].start; 440| 2.90k| uint32_t end = ranges[0].end; 441| 2.91k| for(int32_t i = 1; i < minLengthRangeCount; ++i) { ------------------ | Branch (441:24): [True: 7, False: 2.90k] ------------------ 442| 7| if(ranges[i].start < start) { start = ranges[i].start; } ------------------ | Branch (442:12): [True: 7, False: 0] ------------------ 443| 7| if(ranges[i].end > end) { end = ranges[i].end; } ------------------ | Branch (443:12): [True: 0, False: 7] ------------------ 444| 7| } 445| | 446| | // Calculate how to split the range between minLength (count1) and minLength+1 (count2). 447| | // Goal: 448| | // count1 + count2 * nextCountBytes = n 449| | // count1 + count2 = count 450| | // These turn into 451| | // (count - count2) + count2 * nextCountBytes = n 452| | // and then into the following count1 & count2 computations. 453| 2.90k| int32_t count2 = (n - count) / (nextCountBytes - 1); // number of weights to be lengthened 454| 2.90k| int32_t count1 = count - count2; // number of minLength weights 455| 2.90k| if(count2 == 0 || (count1 + count2 * nextCountBytes) < n) { ------------------ | Branch (455:8): [True: 2.40k, False: 496] | Branch (455:23): [True: 465, False: 31] ------------------ 456| | // round up 457| 2.87k| ++count2; 458| 2.87k| --count1; 459| 2.87k| U_ASSERT((count1 + count2 * nextCountBytes) >= n); ------------------ | | 35| 2.87k|# define U_ASSERT(exp) (void)0 ------------------ 460| 2.87k| } 461| | 462| 2.90k| ranges[0].start = start; 463| | 464| 2.90k| if(count1 == 0) { ------------------ | Branch (464:8): [True: 1.96k, False: 940] ------------------ 465| | // Make one long range. 466| 1.96k| ranges[0].end = end; 467| 1.96k| ranges[0].count = count; 468| 1.96k| lengthenRange(ranges[0]); 469| 1.96k| rangeCount = 1; 470| 1.96k| } else { 471| | // Split the range, lengthen the second part. 472| |#ifdef UCOL_DEBUG 473| | printf("split the range number %ld (out of %ld minLength ranges) by %ld:%ld\n", 474| | splitRange, rangeCount, count1, count2); 475| |#endif 476| | 477| | // Next start = start + count1. First end = 1 before that. 478| 940| ranges[0].end = incWeightByOffset(start, minLength, count1 - 1); 479| 940| ranges[0].count = count1; 480| | 481| 940| ranges[1].start = incWeight(ranges[0].end, minLength); 482| 940| ranges[1].end = end; 483| 940| ranges[1].length = minLength; // +1 when lengthened 484| 940| ranges[1].count = count2; // *countBytes when lengthened 485| 940| lengthenRange(ranges[1]); 486| 940| rangeCount = 2; 487| 940| } 488| 2.90k| return true; 489| 3.18k|} _ZN6icu_7816CollationWeights12allocWeightsEjji: 497| 20.4k|CollationWeights::allocWeights(uint32_t lowerLimit, uint32_t upperLimit, int32_t n) { 498| |#ifdef UCOL_DEBUG 499| | puts(""); 500| |#endif 501| | 502| 20.4k| if(!getWeightRanges(lowerLimit, upperLimit)) { ------------------ | Branch (502:8): [True: 0, False: 20.4k] ------------------ 503| |#ifdef UCOL_DEBUG 504| | printf("error: unable to get Weight ranges\n"); 505| |#endif 506| 0| return false; 507| 0| } 508| | 509| | /* try until we find suitably large ranges */ 510| 20.7k| for(;;) { 511| | /* get the smallest number of bytes in a range */ 512| 20.7k| int32_t minLength=ranges[0].length; 513| | 514| 20.7k| if(allocWeightsInShortRanges(n, minLength)) { break; } ------------------ | Branch (514:12): [True: 17.5k, False: 3.21k] ------------------ 515| | 516| 3.21k| if(minLength == 4) { ------------------ | Branch (516:12): [True: 28, False: 3.18k] ------------------ 517| |#ifdef UCOL_DEBUG 518| | printf("error: the maximum number of %ld weights is insufficient for n=%ld\n", 519| | minLengthCount, n); 520| |#endif 521| 28| return false; 522| 28| } 523| | 524| 3.18k| if(allocWeightsInMinLengthRanges(n, minLength)) { break; } ------------------ | Branch (524:12): [True: 2.90k, False: 282] ------------------ 525| | 526| | /* no good match, lengthen all minLength ranges and iterate */ 527| |#ifdef UCOL_DEBUG 528| | printf("lengthen the short ranges from %ld bytes to %ld and iterate\n", minLength, minLength+1); 529| |#endif 530| 564| for(int32_t i=0; i= rangeCount) { ------------------ | Branch (549:8): [True: 0, False: 3.15M] ------------------ 550| 0| return 0xffffffff; 551| 3.15M| } else { 552| | /* get the next weight */ 553| 3.15M| WeightRange &range = ranges[rangeIndex]; 554| 3.15M| uint32_t weight = range.start; 555| 3.15M| if(--range.count == 0) { ------------------ | Branch (555:12): [True: 5.21k, False: 3.14M] ------------------ 556| | /* this range is finished */ 557| 5.21k| ++rangeIndex; 558| 3.14M| } else { 559| | /* increment the weight for the next value */ 560| 3.14M| range.start = incWeight(weight, range.length); 561| 3.14M| U_ASSERT(range.start <= range.end); ------------------ | | 35| 3.14M|# define U_ASSERT(exp) (void)0 ------------------ 562| 3.14M| } 563| | 564| 3.15M| return weight; 565| 3.15M| } 566| 3.15M|} collationweights.cpp:_ZN6icu_78L13getWeightByteEji: 55| 3.16M|getWeightByte(uint32_t weight, int32_t idx) { 56| 3.16M| return getWeightTrail(weight, idx); /* same calculation */ 57| 3.16M|} collationweights.cpp:_ZN6icu_78L13setWeightByteEjij: 60| 3.16M|setWeightByte(uint32_t weight, int32_t idx, uint32_t byte) { 61| 3.16M| uint32_t mask; /* 0xffffffff except a 00 "hole" for the index-th byte */ 62| | 63| 3.16M| idx*=8; 64| 3.16M| if(idx<32) { ------------------ | Branch (64:8): [True: 1.92M, False: 1.23M] ------------------ 65| 1.92M| mask = (static_cast(0xffffffff)) >> idx; 66| 1.92M| } else { 67| | // Do not use uint32_t>>32 because on some platforms that does not shift at all 68| | // while we need it to become 0. 69| | // PowerPC: 0xffffffff>>32 = 0 (wanted) 70| | // x86: 0xffffffff>>32 = 0xffffffff (not wanted) 71| | // 72| | // ANSI C99 6.5.7 Bitwise shift operators: 73| | // "If the value of the right operand is negative 74| | // or is greater than or equal to the width of the promoted left operand, 75| | // the behavior is undefined." 76| 1.23M| mask=0; 77| 1.23M| } 78| 3.16M| idx=32-idx; 79| 3.16M| mask|=0xffffff00<((weight & (0xffffff00 << length)) | (trail << length)); 52| 24.4k|} collationweights.cpp:_ZN6icu_78L14truncateWeightEji: 84| 20.1k|truncateWeight(uint32_t weight, int32_t length) { 85| 20.1k| return static_cast(weight & (0xffffffff << (8 * (4 - length)))); 86| 20.1k|} collationweights.cpp:_ZN6icu_78L14getWeightTrailEji: 44| 3.19M|getWeightTrail(uint32_t weight, int32_t length) { 45| 3.19M| return (weight >> (8 * (4 - length))) & 0xff; 46| 3.19M|} collationweights.cpp:_ZN6icu_78L14incWeightTrailEji: 89| 29.5k|incWeightTrail(uint32_t weight, int32_t length) { 90| 29.5k| return static_cast(weight + (1UL << (8 * (4 - length)))); 91| 29.5k|} collationweights.cpp:_ZN6icu_78L14decWeightTrailEji: 94| 29.4k|decWeightTrail(uint32_t weight, int32_t length) { 95| 29.4k| return static_cast(weight - (1UL << (8 * (4 - length)))); 96| 29.4k|} collationweights.cpp:_ZN6icu_78L13compareRangesEPKvS1_S1_: 196| 70|compareRanges(const void * /*context*/, const void *left, const void *right) { 197| 70| uint32_t l, r; 198| | 199| 70| l = static_cast(left)->start; 200| 70| r = static_cast(right)->start; 201| 70| if(lr) { ------------------ | Branch (203:15): [True: 0, False: 0] ------------------ 204| 0| return 1; 205| 0| } else { 206| 0| return 0; 207| 0| } 208| 70|} _ZN6icu_7816CollationWeights14lengthOfWeightEj: 38| 40.9k| static inline int32_t lengthOfWeight(uint32_t weight) { 39| 40.9k| if((weight&0xffffff)==0) { ------------------ | Branch (39:12): [True: 1.74k, False: 39.1k] ------------------ 40| 1.74k| return 1; 41| 39.1k| } else if((weight&0xffff)==0) { ------------------ | Branch (41:19): [True: 9.26k, False: 29.9k] ------------------ 42| 9.26k| return 2; 43| 29.9k| } else if((weight&0xff)==0) { ------------------ | Branch (43:19): [True: 28.6k, False: 1.24k] ------------------ 44| 28.6k| return 3; 45| 28.6k| } else { 46| 1.24k| return 4; 47| 1.24k| } 48| 40.9k| } _ZNK6icu_7816CollationWeights10countBytesEi: 86| 6.44k| inline int32_t countBytes(int32_t idx) const { 87| 6.44k| return static_cast(maxBytes[idx] - minBytes[idx] + 1); 88| 6.44k| } _ZN6icu_7820CollationKeyByteSinkD2Ev: 108| 4.09k|CollationKeyByteSink::~CollationKeyByteSink() {} _ZN6icu_7820CollationKeyByteSink20AppendBeyondCapacityEPKcii: 111| 3.20k|CollationKeyByteSink::AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) { 112| | // buffer_ != nullptr && bytes != nullptr && n > 0 && appended_ > capacity_ 113| 3.20k| if (Resize(n, length)) { ------------------ | Branch (113:9): [True: 3.20k, False: 0] ------------------ 114| 3.20k| uprv_memcpy(buffer_ + length, bytes, n); ------------------ | | 42| 3.20k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.20k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.20k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.20k| _Pragma("clang diagnostic push") \ | | 45| 3.20k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.20k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.20k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.20k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.20k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.20k| _Pragma("clang diagnostic pop") \ | | 49| 3.20k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.20k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.20k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.20k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 115| 3.20k| } 116| 3.20k|} _ZN6icu_7820CollationKeyByteSink6ResizeEii: 119| 5.10k|CollationKeyByteSink::Resize(int32_t appendCapacity, int32_t length) { 120| 5.10k| if (buffer_ == nullptr) { ------------------ | Branch (120:9): [True: 0, False: 5.10k] ------------------ 121| 0| return false; // allocation failed before already 122| 0| } 123| 5.10k| int32_t newCapacity = 2 * capacity_; 124| 5.10k| int32_t altCapacity = length + 2 * appendCapacity; 125| 5.10k| if (newCapacity < altCapacity) { ------------------ | Branch (125:9): [True: 94, False: 5.00k] ------------------ 126| 94| newCapacity = altCapacity; 127| 94| } 128| 5.10k| if (newCapacity < 200) { ------------------ | Branch (128:9): [True: 2.16k, False: 2.93k] ------------------ 129| 2.16k| newCapacity = 200; 130| 2.16k| } 131| 5.10k| uint8_t *newBuffer = key_.reallocate(newCapacity, length); 132| 5.10k| if (newBuffer == nullptr) { ------------------ | Branch (132:9): [True: 0, False: 5.10k] ------------------ 133| 0| SetNotOk(); 134| 0| return false; 135| 0| } 136| 5.10k| buffer_ = reinterpret_cast(newBuffer); 137| 5.10k| capacity_ = newCapacity; 138| 5.10k| return true; 139| 5.10k|} _ZN6icu_7817RuleBasedCollatorD2Ev: 197| 7.71k|RuleBasedCollator::~RuleBasedCollator() { 198| 7.71k| SharedObject::clearPtr(settings); 199| 7.71k| SharedObject::clearPtr(cacheEntry); 200| 7.71k|} _ZN6icu_7817RuleBasedCollator14adoptTailoringEPNS_18CollationTailoringER10UErrorCode: 203| 4.09k|RuleBasedCollator::adoptTailoring(CollationTailoring *t, UErrorCode &errorCode) { 204| 4.09k| if(U_FAILURE(errorCode)) { ------------------ | Branch (204:8): [True: 0, False: 4.09k] ------------------ 205| 0| t->deleteIfZeroRefCount(); 206| 0| return; 207| 0| } 208| 4.09k| U_ASSERT(settings == nullptr && data == nullptr && tailoring == nullptr && cacheEntry == nullptr); ------------------ | | 35| 4.09k|# define U_ASSERT(exp) (void)0 ------------------ 209| 4.09k| cacheEntry = new CollationCacheEntry(t->actualLocale, t); 210| 4.09k| if(cacheEntry == nullptr) { ------------------ | Branch (210:8): [True: 0, False: 4.09k] ------------------ 211| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 212| 0| t->deleteIfZeroRefCount(); 213| 0| return; 214| 0| } 215| 4.09k| data = t->data; 216| 4.09k| settings = t->settings; 217| 4.09k| settings->addRef(); 218| 4.09k| tailoring = t; 219| 4.09k| cacheEntry->addRef(); 220| 4.09k| validLocale = t->actualLocale; 221| 4.09k| actualLocaleIsSameAsValid = false; 222| 4.09k|} _ZNK6icu_7817RuleBasedCollator9getLocaleE18ULocDataLocaleTypeR10UErrorCode: 306| 8.19k|RuleBasedCollator::getLocale(ULocDataLocaleType type, UErrorCode& errorCode) const { 307| 8.19k| if(U_FAILURE(errorCode)) { ------------------ | Branch (307:8): [True: 0, False: 8.19k] ------------------ 308| 0| return Locale::getRoot(); 309| 0| } 310| 8.19k| switch(type) { 311| 4.09k| case ULOC_ACTUAL_LOCALE: ------------------ | Branch (311:5): [True: 4.09k, False: 4.09k] ------------------ 312| 4.09k| return actualLocaleIsSameAsValid ? validLocale : tailoring->actualLocale; ------------------ | Branch (312:16): [True: 0, False: 4.09k] ------------------ 313| 4.09k| case ULOC_VALID_LOCALE: ------------------ | Branch (313:5): [True: 4.09k, False: 4.09k] ------------------ 314| 4.09k| return validLocale; 315| 0| case ULOC_REQUESTED_LOCALE: ------------------ | Branch (315:5): [True: 0, False: 8.19k] ------------------ 316| 0| default: ------------------ | Branch (316:5): [True: 0, False: 8.19k] ------------------ 317| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 318| 0| return Locale::getRoot(); 319| 8.19k| } 320| 8.19k|} _ZNK6icu_7817RuleBasedCollator14getTailoredSetER10UErrorCode: 369| 4.09k|RuleBasedCollator::getTailoredSet(UErrorCode &errorCode) const { 370| 4.09k| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (370:8): [True: 0, False: 4.09k] ------------------ 371| 4.09k| UnicodeSet *tailored = new UnicodeSet(); 372| 4.09k| if(tailored == nullptr) { ------------------ | Branch (372:8): [True: 0, False: 4.09k] ------------------ 373| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 374| 0| return nullptr; 375| 0| } 376| 4.09k| if(data->base != nullptr) { ------------------ | Branch (376:8): [True: 3.92k, False: 168] ------------------ 377| 3.92k| TailoredSet(tailored).forData(data, errorCode); 378| 3.92k| if(U_FAILURE(errorCode)) { ------------------ | Branch (378:12): [True: 0, False: 3.92k] ------------------ 379| 0| delete tailored; 380| 0| return nullptr; 381| 0| } 382| 3.92k| } 383| 4.09k| return tailored; 384| 4.09k|} _ZNK6icu_7817RuleBasedCollator12getAttributeE13UColAttributeR10UErrorCode: 412| 4.09k|RuleBasedCollator::getAttribute(UColAttribute attr, UErrorCode &errorCode) const { 413| 4.09k| if(U_FAILURE(errorCode)) { return UCOL_DEFAULT; } ------------------ | Branch (413:8): [True: 0, False: 4.09k] ------------------ 414| 4.09k| int32_t option; 415| 4.09k| switch(attr) { 416| 0| case UCOL_FRENCH_COLLATION: ------------------ | Branch (416:5): [True: 0, False: 4.09k] ------------------ 417| 0| option = CollationSettings::BACKWARD_SECONDARY; 418| 0| break; 419| 0| case UCOL_ALTERNATE_HANDLING: ------------------ | Branch (419:5): [True: 0, False: 4.09k] ------------------ 420| 0| return settings->getAlternateHandling(); 421| 0| case UCOL_CASE_FIRST: ------------------ | Branch (421:5): [True: 0, False: 4.09k] ------------------ 422| 0| return settings->getCaseFirst(); 423| 0| case UCOL_CASE_LEVEL: ------------------ | Branch (423:5): [True: 0, False: 4.09k] ------------------ 424| 0| option = CollationSettings::CASE_LEVEL; 425| 0| break; 426| 0| case UCOL_NORMALIZATION_MODE: ------------------ | Branch (426:5): [True: 0, False: 4.09k] ------------------ 427| 0| option = CollationSettings::CHECK_FCD; 428| 0| break; 429| 4.09k| case UCOL_STRENGTH: ------------------ | Branch (429:5): [True: 4.09k, False: 0] ------------------ 430| 4.09k| return static_cast(settings->getStrength()); 431| 0| case UCOL_HIRAGANA_QUATERNARY_MODE: ------------------ | Branch (431:5): [True: 0, False: 4.09k] ------------------ 432| | // Deprecated attribute, unsettable. 433| 0| return UCOL_OFF; 434| 0| case UCOL_NUMERIC_COLLATION: ------------------ | Branch (434:5): [True: 0, False: 4.09k] ------------------ 435| 0| option = CollationSettings::NUMERIC; 436| 0| break; 437| 0| default: ------------------ | Branch (437:5): [True: 0, False: 4.09k] ------------------ 438| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 439| 0| return UCOL_DEFAULT; 440| 4.09k| } 441| 0| return ((settings->options & option) == 0) ? UCOL_OFF : UCOL_ON; ------------------ | Branch (441:12): [True: 0, False: 0] ------------------ 442| 4.09k|} _ZNK6icu_7817RuleBasedCollator14getMaxVariableEv: 560| 4.09k|RuleBasedCollator::getMaxVariable() const { 561| 4.09k| return static_cast(UCOL_REORDER_CODE_FIRST + int32_t{settings->getMaxVariable()}); 562| 4.09k|} _ZNK6icu_7817RuleBasedCollator14getVariableTopER10UErrorCode: 565| 4.09k|RuleBasedCollator::getVariableTop(UErrorCode & /*errorCode*/) const { 566| 4.09k| return settings->variableTop; 567| 4.09k|} _ZNK6icu_7817RuleBasedCollator15getCollationKeyERKNS_13UnicodeStringERNS_12CollationKeyER10UErrorCode: 1282| 4.09k| UErrorCode &errorCode) const { 1283| 4.09k| return getCollationKey(s.getBuffer(), s.length(), key, errorCode); 1284| 4.09k|} _ZNK6icu_7817RuleBasedCollator15getCollationKeyEPKDsiRNS_12CollationKeyER10UErrorCode: 1288| 4.09k| UErrorCode &errorCode) const { 1289| 4.09k| if(U_FAILURE(errorCode)) { ------------------ | Branch (1289:8): [True: 0, False: 4.09k] ------------------ 1290| 0| return key.setToBogus(); 1291| 0| } 1292| 4.09k| if(s == nullptr && length != 0) { ------------------ | Branch (1292:8): [True: 0, False: 4.09k] | Branch (1292:24): [True: 0, False: 0] ------------------ 1293| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 1294| 0| return key.setToBogus(); 1295| 0| } 1296| 4.09k| key.reset(); // resets the "bogus" state 1297| 4.09k| CollationKeyByteSink sink(key); 1298| 4.09k| writeSortKey(s, length, sink, errorCode); 1299| 4.09k| if(U_FAILURE(errorCode)) { ------------------ | Branch (1299:8): [True: 0, False: 4.09k] ------------------ 1300| 0| key.setToBogus(); 1301| 4.09k| } else if(key.isBogus()) { ------------------ | Branch (1301:15): [True: 0, False: 4.09k] ------------------ 1302| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1303| 4.09k| } else { 1304| 4.09k| key.setLength(sink.NumberOfBytesAppended()); 1305| 4.09k| } 1306| 4.09k| return key; 1307| 4.09k|} _ZNK6icu_7817RuleBasedCollator10getSortKeyERKNS_13UnicodeStringEPhi: 1311| 4.09k| uint8_t *dest, int32_t capacity) const { 1312| 4.09k| return getSortKey(s.getBuffer(), s.length(), dest, capacity); 1313| 4.09k|} _ZNK6icu_7817RuleBasedCollator10getSortKeyEPKDsiPhi: 1317| 4.09k| uint8_t *dest, int32_t capacity) const { 1318| 4.09k| if((s == nullptr && length != 0) || capacity < 0 || (dest == nullptr && capacity > 0)) { ------------------ | Branch (1318:9): [True: 0, False: 4.09k] | Branch (1318:25): [True: 0, False: 0] | Branch (1318:41): [True: 0, False: 4.09k] | Branch (1318:58): [True: 4.09k, False: 0] | Branch (1318:77): [True: 0, False: 4.09k] ------------------ 1319| 0| return 0; 1320| 0| } 1321| 4.09k| uint8_t noDest[1] = { 0 }; 1322| 4.09k| if(dest == nullptr) { ------------------ | Branch (1322:8): [True: 4.09k, False: 0] ------------------ 1323| | // Distinguish pure preflighting from an allocation error. 1324| 4.09k| dest = noDest; 1325| 4.09k| capacity = 0; 1326| 4.09k| } 1327| 4.09k| FixedSortKeyByteSink sink(reinterpret_cast(dest), capacity); 1328| 4.09k| UErrorCode errorCode = U_ZERO_ERROR; 1329| 4.09k| writeSortKey(s, length, sink, errorCode); 1330| 4.09k| return U_SUCCESS(errorCode) ? sink.NumberOfBytesAppended() : 0; ------------------ | Branch (1330:12): [True: 4.09k, False: 0] ------------------ 1331| 4.09k|} _ZNK6icu_7817RuleBasedCollator12writeSortKeyEPKDsiRNS_15SortKeyByteSinkER10UErrorCode: 1335| 8.19k| SortKeyByteSink &sink, UErrorCode &errorCode) const { 1336| 8.19k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1336:8): [True: 0, False: 8.19k] ------------------ 1337| 8.19k| const char16_t *limit = (length >= 0) ? s + length : nullptr; ------------------ | Branch (1337:29): [True: 8.19k, False: 0] ------------------ 1338| 8.19k| UBool numeric = settings->isNumeric(); 1339| 8.19k| CollationKeys::LevelCallback callback; 1340| 8.19k| if(settings->dontCheckFCD()) { ------------------ | Branch (1340:8): [True: 7.27k, False: 914] ------------------ 1341| 7.27k| UTF16CollationIterator iter(data, numeric, s, s, limit); 1342| 7.27k| CollationKeys::writeSortKeyUpToQuaternary(iter, data->compressibleBytes, *settings, 1343| 7.27k| sink, Collation::PRIMARY_LEVEL, 1344| 7.27k| callback, true, errorCode); 1345| 7.27k| } else { 1346| 914| FCDUTF16CollationIterator iter(data, numeric, s, s, limit); 1347| 914| CollationKeys::writeSortKeyUpToQuaternary(iter, data->compressibleBytes, *settings, 1348| 914| sink, Collation::PRIMARY_LEVEL, 1349| 914| callback, true, errorCode); 1350| 914| } 1351| 8.19k| if(settings->getStrength() == UCOL_IDENTICAL) { ------------------ | Branch (1351:8): [True: 346, False: 7.84k] ------------------ 1352| 346| writeIdenticalLevel(s, limit, sink, errorCode); 1353| 346| } 1354| 8.19k| static const char terminator = 0; // TERMINATOR_BYTE 1355| 8.19k| sink.Append(&terminator, 1); 1356| 8.19k|} _ZNK6icu_7817RuleBasedCollator19writeIdenticalLevelEPKDsS2_RNS_15SortKeyByteSinkER10UErrorCode: 1360| 346| SortKeyByteSink &sink, UErrorCode &errorCode) const { 1361| | // NFD quick check 1362| 346| const char16_t *nfdQCYesLimit = data->nfcImpl.decompose(s, limit, nullptr, errorCode); 1363| 346| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (1363:8): [True: 0, False: 346] ------------------ 1364| 346| sink.Append(Collation::LEVEL_SEPARATOR_BYTE); 1365| 346| UChar32 prev = 0; 1366| 346| if(nfdQCYesLimit != s) { ------------------ | Branch (1366:8): [True: 346, False: 0] ------------------ 1367| 346| prev = u_writeIdenticalLevelRun(prev, s, static_cast(nfdQCYesLimit - s), sink); ------------------ | | 434| 346|#define u_writeIdenticalLevelRun U_ICU_ENTRY_POINT_RENAME(u_writeIdenticalLevelRun) | | ------------------ | | | | 123| 346|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 346|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 346|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1368| 346| } 1369| | // Is there non-NFD text? 1370| 346| int32_t destLengthEstimate; 1371| 346| if(limit != nullptr) { ------------------ | Branch (1371:8): [True: 346, False: 0] ------------------ 1372| 346| if(nfdQCYesLimit == limit) { return; } ------------------ | Branch (1372:12): [True: 30, False: 316] ------------------ 1373| 316| destLengthEstimate = static_cast(limit - nfdQCYesLimit); 1374| 316| } else { 1375| | // s is NUL-terminated 1376| 0| if(*nfdQCYesLimit == 0) { return; } ------------------ | Branch (1376:12): [True: 0, False: 0] ------------------ 1377| 0| destLengthEstimate = -1; 1378| 0| } 1379| 316| UnicodeString nfd; 1380| 316| data->nfcImpl.decompose(nfdQCYesLimit, limit, nfd, destLengthEstimate, errorCode); 1381| 316| u_writeIdenticalLevelRun(prev, nfd.getBuffer(), nfd.length(), sink); ------------------ | | 434| 316|#define u_writeIdenticalLevelRun U_ICU_ENTRY_POINT_RENAME(u_writeIdenticalLevelRun) | | ------------------ | | | | 123| 316|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 316|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 316|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1382| 316|} _ZN6icu_7820CollationKeyByteSinkC2ERNS_12CollationKeyE: 97| 4.09k| : SortKeyByteSink(reinterpret_cast(key.getBytes()), key.getCapacity()), 98| 4.09k| key_(key) {} rulebasedcollator.cpp:_ZN6icu_7812_GLOBAL__N_120FixedSortKeyByteSinkC2EPci: 66| 4.09k| : SortKeyByteSink(dest, destCapacity) {} rulebasedcollator.cpp:_ZN6icu_7812_GLOBAL__N_120FixedSortKeyByteSink20AppendBeyondCapacityEPKcii: 77| 904k|FixedSortKeyByteSink::AppendBeyondCapacity(const char *bytes, int32_t /*n*/, int32_t length) { 78| | // buffer_ != nullptr && bytes != nullptr && n > 0 && appended_ > capacity_ 79| | // Fill the buffer completely. 80| 904k| int32_t available = capacity_ - length; 81| 904k| if (available > 0) { ------------------ | Branch (81:9): [True: 0, False: 904k] ------------------ 82| 0| uprv_memcpy(buffer_ + length, bytes, available); ------------------ | | 42| 0|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 0| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 0| _Pragma("clang diagnostic push") \ | | 45| 0| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 0| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 0| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 0|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 0| _Pragma("clang diagnostic pop") \ | | 49| 0| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 83| 0| } 84| 904k|} rulebasedcollator.cpp:_ZN6icu_7812_GLOBAL__N_120FixedSortKeyByteSink6ResizeEii: 87| 1.13M|FixedSortKeyByteSink::Resize(int32_t /*appendCapacity*/, int32_t /*length*/) { 88| 1.13M| return false; 89| 1.13M|} _ZN6icu_7812CollationKeyC2Ev: 54| 4.09k| : UObject(), fFlagAndLength(0), 55| 4.09k| fHashCode(kEmptyHashCode) 56| 4.09k|{ 57| 4.09k|} _ZN6icu_7812CollationKeyD2Ev: 97| 4.09k|{ 98| 4.09k| if(fFlagAndLength < 0) { uprv_free(fUnion.fFields.fBytes); } ------------------ | | 1503| 2.16k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (98:8): [True: 2.16k, False: 1.93k] ------------------ 99| 4.09k|} _ZN6icu_7812CollationKey10reallocateEii: 101| 5.10k|uint8_t *CollationKey::reallocate(int32_t newCapacity, int32_t length) { 102| 5.10k| uint8_t *newBytes = static_cast(uprv_malloc(newCapacity)); ------------------ | | 1524| 5.10k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 5.10k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.10k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.10k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 103| 5.10k| if(newBytes == nullptr) { return nullptr; } ------------------ | Branch (103:8): [True: 0, False: 5.10k] ------------------ 104| 5.10k| if(length > 0) { ------------------ | Branch (104:8): [True: 5.10k, False: 0] ------------------ 105| 5.10k| uprv_memcpy(newBytes, getBytes(), length); ------------------ | | 42| 5.10k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5.10k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 5.10k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 5.10k| _Pragma("clang diagnostic push") \ | | 45| 5.10k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 5.10k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 5.10k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 5.10k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 5.10k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 5.10k| _Pragma("clang diagnostic pop") \ | | 49| 5.10k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 5.10k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 5.10k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5.10k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 106| 5.10k| } 107| 5.10k| if(fFlagAndLength < 0) { uprv_free(fUnion.fFields.fBytes); } ------------------ | | 1503| 2.93k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.93k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.93k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.93k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (107:8): [True: 2.93k, False: 2.16k] ------------------ 108| 5.10k| fUnion.fFields.fBytes = newBytes; 109| 5.10k| fUnion.fFields.fCapacity = newCapacity; 110| 5.10k| fFlagAndLength |= 0x80000000; 111| 5.10k| return newBytes; 112| 5.10k|} _ZN6icu_7812CollationKey9setLengthEi: 114| 4.09k|void CollationKey::setLength(int32_t newLength) { 115| | // U_ASSERT(newLength >= 0 && newLength <= getCapacity()); 116| 4.09k| fFlagAndLength = (fFlagAndLength & 0x80000000) | newLength; 117| 4.09k| fHashCode = kInvalidHashCode; 118| 4.09k|} _ZN6icu_7812CollationKey5resetEv: 123| 4.09k|{ 124| 4.09k| fFlagAndLength &= 0x80000000; 125| 4.09k| fHashCode = kEmptyHashCode; 126| | 127| 4.09k| return *this; 128| 4.09k|} ucln_i18n_registerCleanup_78: 52| 1| cleanupFunc *func) { 53| 1| U_ASSERT(UCLN_I18N_START < type && type < UCLN_I18N_COUNT); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 54| 1| { 55| 1| icu::Mutex m; // See ticket 10295 for discussion. 56| 1| ucln_registerCleanup(UCLN_I18N, i18n_cleanup); ------------------ | | 621| 1|#define ucln_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 57| 1| if (UCLN_I18N_START < type && type < UCLN_I18N_COUNT) { ------------------ | Branch (57:13): [True: 1, False: 0] | Branch (57:39): [True: 1, False: 0] ------------------ 58| 1| gCleanupFunctions[type] = func; 59| 1| } 60| 1| } 61| |#if !UCLN_NO_AUTO_CLEANUP && (defined(UCLN_AUTO_ATEXIT) || defined(UCLN_AUTO_LOCAL)) 62| | ucln_registerAutomaticCleanup(); 63| |#endif 64| 1|} _ZN6icu_7815CollationLoader9loadRulesEPKcS2_RNS_13UnicodeStringER10UErrorCode: 108| 4.87k| UnicodeString &rules, UErrorCode &errorCode) { 109| 4.87k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (109:8): [True: 0, False: 4.87k] ------------------ 110| 4.87k| U_ASSERT(collationType != nullptr && *collationType != 0); ------------------ | | 35| 4.87k|# define U_ASSERT(exp) (void)0 ------------------ 111| | // Copy the type for lowercasing. 112| 4.87k| char type[16]; 113| 4.87k| int32_t typeLength = static_cast(uprv_strlen(collationType)); ------------------ | | 37| 4.87k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 4.87k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 114| 4.87k| if(typeLength >= UPRV_LENGTHOF(type)) { ------------------ | | 99| 4.87k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (114:8): [True: 21, False: 4.85k] ------------------ 115| 21| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 116| 21| return; 117| 21| } 118| 4.87k| uprv_memcpy(type, collationType, typeLength + 1); ------------------ | | 42| 4.85k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.85k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 4.85k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 4.85k| _Pragma("clang diagnostic push") \ | | 45| 4.85k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 4.85k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4.85k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 4.85k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4.85k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 4.85k| _Pragma("clang diagnostic pop") \ | | 49| 4.85k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 4.85k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 4.87k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.87k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 119| 4.85k| T_CString_toLowerCase(type); ------------------ | | 69| 4.85k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 120| | 121| 4.85k| LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, localeID, &errorCode)); ------------------ | | 1691| 4.85k|#define ures_open U_ICU_ENTRY_POINT_RENAME(ures_open) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, localeID, &errorCode)); ------------------ | | 53| 4.85k|#define U_ICUDATA_COLL U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll" | | ------------------ | | | | 154| 4.85k|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ ------------------ 122| 4.85k| LocalUResourceBundlePointer collations( 123| 4.85k| ures_getByKey(bundle.getAlias(), "collations", nullptr, &errorCode)); ------------------ | | 1661| 4.85k|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 124| 4.85k| LocalUResourceBundlePointer data( 125| 4.85k| ures_getByKeyWithFallback(collations.getAlias(), type, nullptr, &errorCode)); ------------------ | | 1662| 4.85k|#define ures_getByKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ures_getByKeyWithFallback) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 126| 4.85k| int32_t length; 127| 4.85k| const char16_t *s = ures_getStringByKey(data.getAlias(), "Sequence", &length, &errorCode); ------------------ | | 1677| 4.85k|#define ures_getStringByKey U_ICU_ENTRY_POINT_RENAME(ures_getStringByKey) | | ------------------ | | | | 123| 4.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 128| 4.85k| if(U_FAILURE(errorCode)) { return; } ------------------ | Branch (128:8): [True: 37, False: 4.81k] ------------------ 129| | 130| | // No string pointer aliasing so that we need not hold onto the resource bundle. 131| 4.81k| rules.setTo(s, length); 132| 4.81k| if(rules.isBogus()) { ------------------ | Branch (132:8): [True: 0, False: 4.81k] ------------------ 133| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 134| 0| } 135| 4.81k|} _ZN6icu_7812CollationKey8getBytesEv: 260| 9.19k| uint8_t *getBytes() { 261| 9.19k| return (fFlagAndLength >= 0) ? fUnion.fStackBuffer : fUnion.fFields.fBytes; ------------------ | Branch (261:16): [True: 6.25k, False: 2.93k] ------------------ 262| 9.19k| } _ZNK6icu_7812CollationKey11getCapacityEv: 266| 4.09k| int32_t getCapacity() const { 267| 4.09k| return fFlagAndLength >= 0 ? static_cast(sizeof(fUnion)) : fUnion.fFields.fCapacity; ------------------ | Branch (267:16): [True: 4.09k, False: 0] ------------------ 268| 4.09k| } _ZNK6icu_7812CollationKey7isBogusEv: 327| 4.09k|{ 328| 4.09k| return fHashCode == 2; // kBogusHashCode 329| 4.09k|} _ZN6icu_7822UTF16CollationIteratorD2Ev: 38| 5.83M|UTF16CollationIterator::~UTF16CollationIterator() {} _ZN6icu_7822UTF16CollationIterator14handleNextCE32ERiR10UErrorCode: 60| 12.2M|UTF16CollationIterator::handleNextCE32(UChar32 &c, UErrorCode & /*errorCode*/) { 61| 12.2M| if(pos == limit) { ------------------ | Branch (61:8): [True: 5.83M, False: 6.39M] ------------------ 62| 5.83M| c = U_SENTINEL; ------------------ | | 469| 5.83M|#define U_SENTINEL (-1) ------------------ 63| 5.83M| return Collation::FALLBACK_CE32; 64| 5.83M| } 65| 6.39M| c = *pos++; 66| 6.39M| return UTRIE2_GET32_FROM_U16_SINGLE_LEAD(trie, c); ------------------ | | 568| 6.39M|#define UTRIE2_GET32_FROM_U16_SINGLE_LEAD(trie, c) _UTRIE2_GET_FROM_U16_SINGLE_LEAD((trie), data32, c) | | ------------------ | | | | 859| 6.39M| (trie)->data[_UTRIE2_INDEX_FROM_U16_SINGLE_LEAD((trie)->index, c)] | | | | ------------------ | | | | | | 820| 6.39M|#define _UTRIE2_INDEX_FROM_U16_SINGLE_LEAD(trieIndex, c) _UTRIE2_INDEX_RAW(0, trieIndex, c) | | | | | | ------------------ | | | | | | | | 815| 6.39M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 6.39M| < 0 && pos != limit) { ------------------ | Branch (124:11): [True: 31.5k, False: 29.0k] | Branch (124:22): [True: 31.5k, False: 0] ------------------ 125| 31.5k| UChar32 c = *pos; 126| 31.5k| if(c == 0 && limit == nullptr) { ------------------ | Branch (126:12): [True: 14.2k, False: 17.2k] | Branch (126:22): [True: 0, False: 14.2k] ------------------ 127| 0| limit = pos; 128| 0| break; 129| 0| } 130| 31.5k| ++pos; 131| 31.5k| --num; 132| 31.5k| if(U16_IS_LEAD(c) && pos != limit && U16_IS_TRAIL(*pos)) { ------------------ | | 59| 63.0k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 268, False: 31.2k] | | ------------------ ------------------ if(U16_IS_LEAD(c) && pos != limit && U16_IS_TRAIL(*pos)) { ------------------ | | 67| 268|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 252, False: 16] | | ------------------ ------------------ | Branch (132:30): [True: 268, False: 0] ------------------ 133| 252| ++pos; 134| 252| } 135| 31.5k| } 136| 29.0k|} _ZN6icu_7822UTF16CollationIterator21backwardNumCodePointsEiR10UErrorCode: 139| 51.4k|UTF16CollationIterator::backwardNumCodePoints(int32_t num, UErrorCode & /*errorCode*/) { 140| 193k| while(num > 0 && pos != start) { ------------------ | Branch (140:11): [True: 141k, False: 51.4k] | Branch (140:22): [True: 141k, False: 0] ------------------ 141| 141k| UChar32 c = *--pos; 142| 141k| --num; 143| 141k| if(U16_IS_TRAIL(c) && pos != start && U16_IS_LEAD(*(pos-1))) { ------------------ | | 67| 283k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 1.23k, False: 140k] | | ------------------ ------------------ if(U16_IS_TRAIL(c) && pos != start && U16_IS_LEAD(*(pos-1))) { ------------------ | | 59| 1.23k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 1.12k, False: 108] | | ------------------ ------------------ | Branch (143:31): [True: 1.23k, False: 0] ------------------ 144| 1.12k| --pos; 145| 1.12k| } 146| 141k| } 147| 51.4k|} _ZN6icu_7825FCDUTF16CollationIteratorD2Ev: 172| 914|FCDUTF16CollationIterator::~FCDUTF16CollationIterator() {} _ZN6icu_7825FCDUTF16CollationIterator14handleNextCE32ERiR10UErrorCode: 210| 226k|FCDUTF16CollationIterator::handleNextCE32(UChar32 &c, UErrorCode &errorCode) { 211| 241k| for(;;) { 212| 241k| if(checkDir > 0) { ------------------ | Branch (212:12): [True: 203k, False: 38.1k] ------------------ 213| 203k| if(pos == limit) { ------------------ | Branch (213:16): [True: 914, False: 202k] ------------------ 214| 914| c = U_SENTINEL; ------------------ | | 469| 914|#define U_SENTINEL (-1) ------------------ 215| 914| return Collation::FALLBACK_CE32; 216| 914| } 217| 202k| c = *pos++; 218| 202k| if(CollationFCD::hasTccc(c)) { ------------------ | Branch (218:16): [True: 18.2k, False: 183k] ------------------ 219| 18.2k| if(CollationFCD::maybeTibetanCompositeVowel(c) || ------------------ | Branch (219:20): [True: 4.60k, False: 13.6k] ------------------ 220| 18.2k| (pos != limit && CollationFCD::hasLccc(*pos))) { ------------------ | Branch (220:26): [True: 13.5k, False: 68] | Branch (220:42): [True: 1.78k, False: 11.8k] ------------------ 221| 6.39k| --pos; 222| 6.39k| if(!nextSegment(errorCode)) { ------------------ | Branch (222:24): [True: 0, False: 6.39k] ------------------ 223| 0| c = U_SENTINEL; ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ 224| 0| return Collation::FALLBACK_CE32; 225| 0| } 226| 6.39k| c = *pos++; 227| 6.39k| } 228| 18.2k| } 229| 202k| break; 230| 202k| } else if(checkDir == 0 && pos != limit) { ------------------ | Branch (230:19): [True: 37.9k, False: 198] | Branch (230:36): [True: 23.2k, False: 14.7k] ------------------ 231| 23.2k| c = *pos++; 232| 23.2k| break; 233| 23.2k| } else { 234| 14.9k| switchToForward(); 235| 14.9k| } 236| 241k| } 237| 225k| return UTRIE2_GET32_FROM_U16_SINGLE_LEAD(trie, c); ------------------ | | 568| 225k|#define UTRIE2_GET32_FROM_U16_SINGLE_LEAD(trie, c) _UTRIE2_GET_FROM_U16_SINGLE_LEAD((trie), data32, c) | | ------------------ | | | | 859| 225k| (trie)->data[_UTRIE2_INDEX_FROM_U16_SINGLE_LEAD((trie)->index, c)] | | | | ------------------ | | | | | | 820| 225k|#define _UTRIE2_INDEX_FROM_U16_SINGLE_LEAD(trieIndex, c) _UTRIE2_INDEX_RAW(0, trieIndex, c) | | | | | | ------------------ | | | | | | | | 815| 225k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 225k| < 0) { ------------------ | Branch (254:12): [True: 69.5k, False: 291k] ------------------ 255| 69.5k| if(pos == limit) { ------------------ | Branch (255:16): [True: 832, False: 68.7k] ------------------ 256| 832| return U_SENTINEL; ------------------ | | 469| 832|#define U_SENTINEL (-1) ------------------ 257| 832| } 258| 68.7k| c = *pos++; 259| 68.7k| if(CollationFCD::hasTccc(c)) { ------------------ | Branch (259:16): [True: 12.0k, False: 56.7k] ------------------ 260| 12.0k| if(CollationFCD::maybeTibetanCompositeVowel(c) || ------------------ | Branch (260:20): [True: 4.35k, False: 7.65k] ------------------ 261| 12.0k| (pos != limit && CollationFCD::hasLccc(*pos))) { ------------------ | Branch (261:26): [True: 7.07k, False: 584] | Branch (261:42): [True: 3.02k, False: 4.05k] ------------------ 262| 7.37k| --pos; 263| 7.37k| if(!nextSegment(errorCode)) { ------------------ | Branch (263:24): [True: 0, False: 7.37k] ------------------ 264| 0| return U_SENTINEL; ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ 265| 0| } 266| 7.37k| c = *pos++; 267| 7.37k| } 268| 56.7k| } else if(c == 0 && limit == nullptr) { ------------------ | Branch (268:23): [True: 10.4k, False: 46.2k] | Branch (268:33): [True: 0, False: 10.4k] ------------------ 269| 0| limit = rawLimit = --pos; 270| 0| return U_SENTINEL; ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ 271| 0| } 272| 68.7k| break; 273| 291k| } else if(checkDir == 0 && pos != limit) { ------------------ | Branch (273:19): [True: 291k, False: 682] | Branch (273:36): [True: 272k, False: 18.5k] ------------------ 274| 272k| c = *pos++; 275| 272k| break; 276| 272k| } else { 277| 19.2k| switchToForward(); 278| 19.2k| } 279| 361k| } 280| 341k| char16_t trail; 281| 341k| if(U16_IS_LEAD(c) && pos != limit && U16_IS_TRAIL(trail = *pos)) { ------------------ | | 59| 682k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 2.60k, False: 338k] | | ------------------ ------------------ if(U16_IS_LEAD(c) && pos != limit && U16_IS_TRAIL(trail = *pos)) { ------------------ | | 67| 2.15k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 1.73k, False: 418] | | ------------------ ------------------ | Branch (281:26): [True: 2.15k, False: 448] ------------------ 282| 1.73k| ++pos; 283| 1.73k| return U16_GET_SUPPLEMENTARY(c, trail); ------------------ | | 113| 1.73k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 1.73k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 284| 339k| } else { 285| 339k| return c; 286| 339k| } 287| 341k|} _ZN6icu_7825FCDUTF16CollationIterator17previousCodePointER10UErrorCode: 290| 240k|FCDUTF16CollationIterator::previousCodePoint(UErrorCode &errorCode) { 291| 240k| UChar32 c; 292| 270k| for(;;) { 293| 270k| if(checkDir < 0) { ------------------ | Branch (293:12): [True: 15.5k, False: 254k] ------------------ 294| 15.5k| if(pos == start) { ------------------ | Branch (294:16): [True: 0, False: 15.5k] ------------------ 295| 0| return U_SENTINEL; ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ 296| 0| } 297| 15.5k| c = *--pos; 298| 15.5k| if(CollationFCD::hasLccc(c)) { ------------------ | Branch (298:16): [True: 10.3k, False: 5.24k] ------------------ 299| 10.3k| if(CollationFCD::maybeTibetanCompositeVowel(c) || ------------------ | Branch (299:20): [True: 8.72k, False: 1.63k] ------------------ 300| 10.3k| (pos != start && CollationFCD::hasTccc(*(pos - 1)))) { ------------------ | Branch (300:26): [True: 1.63k, False: 0] | Branch (300:42): [True: 1.31k, False: 320] ------------------ 301| 10.0k| ++pos; 302| 10.0k| if(!previousSegment(errorCode)) { ------------------ | Branch (302:24): [True: 0, False: 10.0k] ------------------ 303| 0| return U_SENTINEL; ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ 304| 0| } 305| 10.0k| c = *--pos; 306| 10.0k| } 307| 10.3k| } 308| 15.5k| break; 309| 254k| } else if(checkDir == 0 && pos != start) { ------------------ | Branch (309:19): [True: 234k, False: 19.5k] | Branch (309:36): [True: 224k, False: 10.2k] ------------------ 310| 224k| c = *--pos; 311| 224k| break; 312| 224k| } else { 313| 29.8k| switchToBackward(); 314| 29.8k| } 315| 270k| } 316| 240k| char16_t lead; 317| 240k| if(U16_IS_TRAIL(c) && pos != start && U16_IS_LEAD(lead = *(pos - 1))) { ------------------ | | 67| 480k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 1.81k, False: 238k] | | ------------------ ------------------ if(U16_IS_TRAIL(c) && pos != start && U16_IS_LEAD(lead = *(pos - 1))) { ------------------ | | 59| 1.52k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 1.38k, False: 136] | | ------------------ ------------------ | Branch (317:27): [True: 1.52k, False: 292] ------------------ 318| 1.38k| --pos; 319| 1.38k| return U16_GET_SUPPLEMENTARY(lead, c); ------------------ | | 113| 1.38k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 1.38k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 320| 238k| } else { 321| 238k| return c; 322| 238k| } 323| 240k|} _ZN6icu_7825FCDUTF16CollationIterator20forwardNumCodePointsEiR10UErrorCode: 326| 9.64k|FCDUTF16CollationIterator::forwardNumCodePoints(int32_t num, UErrorCode &errorCode) { 327| | // Specify the class to avoid a virtual-function indirection. 328| | // In Java, we would declare this class final. 329| 21.6k| while(num > 0 && FCDUTF16CollationIterator::nextCodePoint(errorCode) >= 0) { ------------------ | Branch (329:11): [True: 12.0k, False: 9.64k] | Branch (329:22): [True: 12.0k, False: 0] ------------------ 330| 12.0k| --num; 331| 12.0k| } 332| 9.64k|} _ZN6icu_7825FCDUTF16CollationIterator21backwardNumCodePointsEiR10UErrorCode: 335| 62.3k|FCDUTF16CollationIterator::backwardNumCodePoints(int32_t num, UErrorCode &errorCode) { 336| | // Specify the class to avoid a virtual-function indirection. 337| | // In Java, we would declare this class final. 338| 295k| while(num > 0 && FCDUTF16CollationIterator::previousCodePoint(errorCode) >= 0) { ------------------ | Branch (338:11): [True: 233k, False: 62.3k] | Branch (338:22): [True: 233k, False: 0] ------------------ 339| 233k| --num; 340| 233k| } 341| 62.3k|} _ZN6icu_7825FCDUTF16CollationIterator15switchToForwardEv: 344| 34.1k|FCDUTF16CollationIterator::switchToForward() { 345| 34.1k| U_ASSERT(checkDir < 0 || (checkDir == 0 && pos == limit)); ------------------ | | 35| 34.1k|# define U_ASSERT(exp) (void)0 ------------------ 346| 34.1k| if(checkDir < 0) { ------------------ | Branch (346:8): [True: 880, False: 33.3k] ------------------ 347| | // Turn around from backward checking. 348| 880| start = segmentStart = pos; 349| 880| if(pos == segmentLimit) { ------------------ | Branch (349:12): [True: 0, False: 880] ------------------ 350| 0| limit = rawLimit; 351| 0| checkDir = 1; // Check forward. 352| 880| } else { // pos < segmentLimit 353| 880| checkDir = 0; // Stay in FCD segment. 354| 880| } 355| 33.3k| } else { 356| | // Reached the end of the FCD segment. 357| 33.3k| if(start == segmentStart) { ------------------ | Branch (357:12): [True: 16.4k, False: 16.8k] ------------------ 358| | // The input text segment is FCD, extend it forward. 359| 16.8k| } else { 360| | // The input text segment needed to be normalized. 361| | // Switch to checking forward from it. 362| 16.8k| pos = start = segmentStart = segmentLimit; 363| | // Note: If this segment is at the end of the input text, 364| | // then it might help to return false to indicate that, so that 365| | // we do not have to re-check and normalize when we turn around and go backwards. 366| | // However, that would complicate the call sites for an optimization of an unusual case. 367| 16.8k| } 368| 33.3k| limit = rawLimit; 369| 33.3k| checkDir = 1; 370| 33.3k| } 371| 34.1k|} _ZN6icu_7825FCDUTF16CollationIterator11nextSegmentER10UErrorCode: 374| 13.7k|FCDUTF16CollationIterator::nextSegment(UErrorCode &errorCode) { 375| 13.7k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (375:8): [True: 0, False: 13.7k] ------------------ 376| 13.7k| U_ASSERT(checkDir > 0 && pos != limit); ------------------ | | 35| 13.7k|# define U_ASSERT(exp) (void)0 ------------------ 377| | // The input text [segmentStart..pos[ passes the FCD check. 378| 13.7k| const char16_t *p = pos; 379| 13.7k| uint8_t prevCC = 0; 380| 19.2k| for(;;) { 381| | // Fetch the next character's fcd16 value. 382| 19.2k| const char16_t *q = p; 383| 19.2k| uint16_t fcd16 = nfcImpl.nextFCD16(p, rawLimit); 384| 19.2k| uint8_t leadCC = static_cast(fcd16 >> 8); 385| 19.2k| if(leadCC == 0 && q != pos) { ------------------ | Branch (385:12): [True: 5.72k, False: 13.4k] | Branch (385:27): [True: 1.36k, False: 4.36k] ------------------ 386| | // FCD boundary before the [q, p[ character. 387| 1.36k| limit = segmentLimit = q; 388| 1.36k| break; 389| 1.36k| } 390| 17.8k| if(leadCC != 0 && (prevCC > leadCC || CollationFCD::isFCD16OfTibetanCompositeVowel(fcd16))) { ------------------ | Branch (390:12): [True: 13.4k, False: 4.36k] | Branch (390:28): [True: 2.56k, False: 10.9k] | Branch (390:47): [True: 8.36k, False: 2.55k] ------------------ 391| | // Fails FCD check. Find the next FCD boundary and normalize. 392| 60.0k| do { 393| 60.0k| q = p; 394| 60.0k| } while(p != rawLimit && nfcImpl.nextFCD16(p, rawLimit) > 0xff); ------------------ | Branch (394:21): [True: 59.7k, False: 330] | Branch (394:38): [True: 49.0k, False: 10.6k] ------------------ 395| 10.9k| if(!normalize(pos, q, errorCode)) { return false; } ------------------ | Branch (395:16): [True: 0, False: 10.9k] ------------------ 396| 10.9k| pos = start; 397| 10.9k| break; 398| 10.9k| } 399| 6.91k| prevCC = static_cast(fcd16); 400| 6.91k| if(p == rawLimit || prevCC == 0) { ------------------ | Branch (400:12): [True: 28, False: 6.88k] | Branch (400:29): [True: 1.44k, False: 5.44k] ------------------ 401| | // FCD boundary after the last character. 402| 1.46k| limit = segmentLimit = p; 403| 1.46k| break; 404| 1.46k| } 405| 6.91k| } 406| 13.7k| U_ASSERT(pos != limit); ------------------ | | 35| 13.7k|# define U_ASSERT(exp) (void)0 ------------------ 407| 13.7k| checkDir = 0; 408| 13.7k| return true; 409| 13.7k|} _ZN6icu_7825FCDUTF16CollationIterator16switchToBackwardEv: 412| 29.8k|FCDUTF16CollationIterator::switchToBackward() { 413| 29.8k| U_ASSERT(checkDir > 0 || (checkDir == 0 && pos == start)); ------------------ | | 35| 29.8k|# define U_ASSERT(exp) (void)0 ------------------ 414| 29.8k| if(checkDir > 0) { ------------------ | Branch (414:8): [True: 19.5k, False: 10.2k] ------------------ 415| | // Turn around from forward checking. 416| 19.5k| limit = segmentLimit = pos; 417| 19.5k| if(pos == segmentStart) { ------------------ | Branch (417:12): [True: 624, False: 18.9k] ------------------ 418| 624| start = rawStart; 419| 624| checkDir = -1; // Check backward. 420| 18.9k| } else { // pos > segmentStart 421| 18.9k| checkDir = 0; // Stay in FCD segment. 422| 18.9k| } 423| 19.5k| } else { 424| | // Reached the start of the FCD segment. 425| 10.2k| if(start == segmentStart) { ------------------ | Branch (425:12): [True: 6.41k, False: 3.87k] ------------------ 426| | // The input text segment is FCD, extend it backward. 427| 6.41k| } else { 428| | // The input text segment needed to be normalized. 429| | // Switch to checking backward from it. 430| 3.87k| pos = limit = segmentLimit = segmentStart; 431| 3.87k| } 432| 10.2k| start = rawStart; 433| 10.2k| checkDir = -1; 434| 10.2k| } 435| 29.8k|} _ZN6icu_7825FCDUTF16CollationIterator15previousSegmentER10UErrorCode: 438| 10.0k|FCDUTF16CollationIterator::previousSegment(UErrorCode &errorCode) { 439| 10.0k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (439:8): [True: 0, False: 10.0k] ------------------ 440| 10.0k| U_ASSERT(checkDir < 0 && pos != start); ------------------ | | 35| 10.0k|# define U_ASSERT(exp) (void)0 ------------------ 441| | // The input text [pos..segmentLimit[ passes the FCD check. 442| 10.0k| const char16_t *p = pos; 443| 10.0k| uint8_t nextCC = 0; 444| 14.6k| for(;;) { 445| | // Fetch the previous character's fcd16 value. 446| 14.6k| const char16_t *q = p; 447| 14.6k| uint16_t fcd16 = nfcImpl.previousFCD16(rawStart, p); 448| 14.6k| uint8_t trailCC = static_cast(fcd16); 449| 14.6k| if(trailCC == 0 && q != pos) { ------------------ | Branch (449:12): [True: 262, False: 14.4k] | Branch (449:28): [True: 212, False: 50] ------------------ 450| | // FCD boundary after the [p, q[ character. 451| 212| start = segmentStart = q; 452| 212| break; 453| 212| } 454| 14.4k| if(trailCC != 0 && ((nextCC != 0 && trailCC > nextCC) || ------------------ | Branch (454:12): [True: 14.4k, False: 50] | Branch (454:30): [True: 4.44k, False: 9.98k] | Branch (454:45): [True: 840, False: 3.60k] ------------------ 455| 14.4k| CollationFCD::isFCD16OfTibetanCompositeVowel(fcd16))) { ------------------ | Branch (455:29): [True: 8.92k, False: 4.66k] ------------------ 456| | // Fails FCD check. Find the previous FCD boundary and normalize. 457| 734k| do { 458| 734k| q = p; 459| 734k| } while(fcd16 > 0xff && p != rawStart && ------------------ | Branch (459:21): [True: 733k, False: 950] | Branch (459:37): [True: 733k, False: 0] ------------------ 460| 734k| (fcd16 = nfcImpl.previousFCD16(rawStart, p)) != 0); ------------------ | Branch (460:21): [True: 725k, False: 8.81k] ------------------ 461| 9.76k| if(!normalize(q, pos, errorCode)) { return false; } ------------------ | Branch (461:16): [True: 0, False: 9.76k] ------------------ 462| 9.76k| pos = limit; 463| 9.76k| break; 464| 9.76k| } 465| 4.71k| nextCC = static_cast(fcd16 >> 8); 466| 4.71k| if(p == rawStart || nextCC == 0) { ------------------ | Branch (466:12): [True: 0, False: 4.71k] | Branch (466:29): [True: 52, False: 4.65k] ------------------ 467| | // FCD boundary before the following character. 468| 52| start = segmentStart = p; 469| 52| break; 470| 52| } 471| 4.71k| } 472| 10.0k| U_ASSERT(pos != start); ------------------ | | 35| 10.0k|# define U_ASSERT(exp) (void)0 ------------------ 473| 10.0k| checkDir = 0; 474| 10.0k| return true; 475| 10.0k|} _ZN6icu_7825FCDUTF16CollationIterator9normalizeEPKDsS2_R10UErrorCode: 478| 20.7k|FCDUTF16CollationIterator::normalize(const char16_t *from, const char16_t *to, UErrorCode &errorCode) { 479| | // NFD without argument checking. 480| 20.7k| U_ASSERT(U_SUCCESS(errorCode)); ------------------ | | 35| 20.7k|# define U_ASSERT(exp) (void)0 ------------------ 481| 20.7k| nfcImpl.decompose(from, to, normalized, static_cast(to - from), errorCode); 482| 20.7k| if(U_FAILURE(errorCode)) { return false; } ------------------ | Branch (482:8): [True: 0, False: 20.7k] ------------------ 483| | // Switch collation processing into the FCD buffer 484| | // with the result of normalizing [segmentStart, segmentLimit[. 485| 20.7k| segmentStart = from; 486| 20.7k| segmentLimit = to; 487| 20.7k| start = normalized.getBuffer(); 488| 20.7k| limit = start + normalized.length(); 489| 20.7k| return true; 490| 20.7k|} _ZN6icu_7822UTF16CollationIteratorC2EPKNS_13CollationDataEaPKDsS5_S5_: 38| 5.83M| : CollationIterator(d, numeric), 39| 5.83M| start(s), pos(p), limit(lim) {} _ZN6icu_7825FCDUTF16CollationIteratorC2EPKNS_13CollationDataEaPKDsS5_S5_: 89| 914| : UTF16CollationIterator(data, numeric, s, p, lim), 90| 914| rawStart(s), segmentStart(p), segmentLimit(nullptr), rawLimit(lim), 91| 914| nfcImpl(data->nfcImpl), 92| 914| checkDir(1) {} LLVMFuzzerTestOneInput: 15| 7.71k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 16| 7.71k| UErrorCode status = U_ZERO_ERROR; 17| 7.71k| if (size > 2000) { ------------------ | Branch (17:7): [True: 43, False: 7.67k] ------------------ 18| | // Limit the effective test data to only 2000 bytes to avoid meaningless 19| | // timeout. 20| 43| size = 2000; 21| 43| } 22| | 23| 7.71k| size_t unistr_size = size/2; 24| 7.71k| std::unique_ptr fuzzbuff(new char16_t[unistr_size]); 25| 7.71k| std::memcpy(fuzzbuff.get(), data, unistr_size * 2); 26| 7.71k| icu::UnicodeString fuzzstr(false, fuzzbuff.get(), unistr_size); 27| | 28| 7.71k| icu::LocalPointer col1( 29| 7.71k| new icu::RuleBasedCollator(fuzzstr, status)); 30| | 31| 7.71k| if (U_SUCCESS(status)) { ------------------ | Branch (31:7): [True: 4.09k, False: 3.61k] ------------------ 32| 4.09k| col1->getVariableTop(status); 33| 4.09k| status = U_ZERO_ERROR; 34| 4.09k| icu::CollationKey key; 35| 4.09k| col1->getCollationKey(fuzzstr, key, status); 36| 4.09k| status = U_ZERO_ERROR; 37| 4.09k| icu::LocalPointer tailoredSet(col1->getTailoredSet(status)); 38| 4.09k| status = U_ZERO_ERROR; 39| 4.09k| col1->getLocale(ULOC_ACTUAL_LOCALE, status); 40| 4.09k| status = U_ZERO_ERROR; 41| 4.09k| col1->getLocale(ULOC_VALID_LOCALE, status); 42| 4.09k| col1->getMaxVariable(); 43| 4.09k| col1->getStrength(); 44| 4.09k| col1->getSortKey(fuzzstr, nullptr, 0); 45| 4.09k| } 46| 7.71k| return 0; 47| 7.71k|} _ZN14IcuEnvironmentC2Ev: 14| 2| IcuEnvironment() { 15| | // nothing to initialize yet; 16| 2| }