_ZN6icu_786BMPSetC2EPKii: 30| 27| list(parentList), listLength(parentListLength) { 31| 27| uprv_memset(latin1Contains, 0, sizeof(latin1Contains)); ------------------ | | 100| 27|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 27|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 32| 27| uprv_memset(table7FF, 0, sizeof(table7FF)); ------------------ | | 100| 27|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 27|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 33| 27| uprv_memset(bmpBlockBits, 0, sizeof(bmpBlockBits)); ------------------ | | 100| 27|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 27|#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| 27| list4kStarts[0]=findCodePoint(0x800, 0, listLength-1); 43| 27| int32_t i; 44| 459| for(i=1; i<=0x10; ++i) { ------------------ | Branch (44:14): [True: 432, False: 27] ------------------ 45| 432| list4kStarts[i]=findCodePoint(i<<12, list4kStarts[i-1], listLength-1); 46| 432| } 47| 27| list4kStarts[0x11]=listLength-1; 48| 27| containsFFFD=containsSlow(0xfffd, list4kStarts[0xf], list4kStarts[0x10]); 49| | 50| 27| initBits(); 51| 27| overrideIllegal(); 52| 27|} _ZN6icu_786BMPSet8initBitsEv: 121| 27|void BMPSet::initBits() { 122| 27| UChar32 start, limit; 123| 27| int32_t listIndex=0; 124| | 125| | // Set latin1Contains[]. 126| 120| do { 127| 120| start=list[listIndex++]; 128| 120| if(listIndex=0x100) { ------------------ | Branch (133:12): [True: 22, False: 98] ------------------ 134| 22| break; 135| 22| } 136| 925| do { 137| 925| latin1Contains[start++]=1; 138| 925| } while(start0x80) { ------------------ | Branch (150:12): [True: 27, False: 40] ------------------ 151| 27| if(start<0x80) { ------------------ | Branch (151:16): [True: 0, False: 27] ------------------ 152| 0| start=0x80; 153| 0| } 154| 27| break; 155| 27| } 156| 67| } 157| | 158| | // Set table7FF[]. 159| 1.45k| while(start<0x800) { ------------------ | Branch (159:11): [True: 1.42k, False: 27] ------------------ 160| 1.42k| set32x64Bits(table7FF, start, limit<=0x800 ? limit : 0x800); ------------------ | Branch (160:39): [True: 1.42k, False: 0] ------------------ 161| 1.42k| if(limit>0x800) { ------------------ | Branch (161:12): [True: 0, False: 1.42k] ------------------ 162| 0| start=0x800; 163| 0| break; 164| 0| } 165| | 166| 1.42k| start=list[listIndex++]; 167| 1.42k| if(listIndex0x10000) { ------------------ | Branch (177:12): [True: 0, False: 3.37k] ------------------ 178| 0| limit=0x10000; 179| 0| } 180| | 181| 3.37k| if(start>=6; 188| 496| bmpBlockBits[start&0x3f]|=0x10001<<(start>>6); 189| 496| start=(start+1)<<6; // Round up to the next block boundary. 190| 496| minStart=start; // Ignore further ranges in this block. 191| 496| } 192| 922| if(start>6, limit>>6); 196| 96| } 197| | 198| 462| if(limit&0x3f) { ------------------ | Branch (198:20): [True: 446, False: 16] ------------------ 199| | // Mixed-value block of 64 code points. 200| 446| limit>>=6; 201| 446| bmpBlockBits[limit&0x3f]|=0x10001<<(limit>>6); 202| 446| limit=(limit+1)<<6; // Round up to the next block boundary. 203| 446| minStart=limit; // Ignore further ranges in this block. 204| 446| } 205| 462| } 206| 922| } 207| | 208| 3.37k| if(limit==0x10000) { ------------------ | Branch (208:12): [True: 0, False: 3.37k] ------------------ 209| 0| break; 210| 0| } 211| | 212| 3.37k| start=list[listIndex++]; 213| 3.37k| 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| 27| } else { 250| 27| mask= static_cast(~(0x10001<<0xd)); // Lead byte 0xED. 251| 891| for(i=32; i<64; ++i) { // Second half of 4k block. ------------------ | Branch (251:19): [True: 864, False: 27] ------------------ 252| 864| bmpBlockBits[i]&=mask; 253| 864| } 254| 27| } 255| 27|} _ZNK6icu_786BMPSet13findCodePointEiii: 257| 486|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| 486| if (c < list[lo]) ------------------ | Branch (270:9): [True: 352, False: 134] ------------------ 271| 352| return lo; 272| | // High runner test. c is often after the last range, so an 273| | // initial check for this condition pays off. 274| 134| if (lo >= hi || c >= list[hi-1]) ------------------ | Branch (274:9): [True: 0, False: 134] | Branch (274:21): [True: 21, False: 113] ------------------ 275| 21| return hi; 276| | // invariant: c >= list[lo] 277| | // invariant: c < list[hi] 278| 983| for (;;) { 279| 983| int32_t i = (lo + hi) >> 1; 280| 983| if (i == lo) { ------------------ | Branch (280:13): [True: 113, False: 870] ------------------ 281| 113| break; // Found! 282| 870| } else if (c < list[i]) { ------------------ | Branch (282:20): [True: 499, False: 371] ------------------ 283| 499| hi = i; 284| 499| } else { 285| 371| lo = i; 286| 371| } 287| 983| } 288| 113| return hi; 289| 134|} bmpset.cpp:_ZN6icu_78L12set32x64BitsEPjii: 70| 1.51k|static void set32x64Bits(uint32_t table[64], int32_t start, int32_t limit) { 71| 1.51k| U_ASSERT(start>6; // Named for UTF-8 2-byte lead byte with upper 5 bits. 75| 1.51k| 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| 1.51k| uint32_t bits = static_cast(1) << lead; 79| 1.51k| if((start+1)==limit) { // Single-character shortcut. ------------------ | Branch (79:8): [True: 1.16k, False: 358] ------------------ 80| 1.16k| table[trail]|=bits; 81| 1.16k| return; 82| 1.16k| } 83| | 84| 358| int32_t limitLead=limit>>6; 85| 358| int32_t limitTrail=limit&0x3f; 86| | 87| 358| if(lead==limitLead) { ------------------ | Branch (87:8): [True: 277, False: 81] ------------------ 88| | // Partial vertical bit column. 89| 2.33k| while(trail0) { ------------------ | Branch (96:12): [True: 79, False: 2] ------------------ 97| 1.83k| do { 98| 1.83k| table[trail++]|=bits; 99| 1.83k| } while(trail<64); ------------------ | Branch (99:21): [True: 1.76k, False: 79] ------------------ 100| 79| ++lead; 101| 79| } 102| 81| if(lead(1) << lead) - 1); 104| 31| if(limitLead<0x20) { ------------------ | Branch (104:16): [True: 31, False: 0] ------------------ 105| 31| bits &= (static_cast(1) << limitLead) - 1; 106| 31| } 107| 2.01k| for(trail=0; trail<64; ++trail) { ------------------ | Branch (107:26): [True: 1.98k, False: 31] ------------------ 108| 1.98k| table[trail]|=bits; 109| 1.98k| } 110| 31| } 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: 0, False: 81] ------------------ 115| 2.09k| for(trail=0; trailkMaxBranchLinearSubNodeLength) { ------------------ | Branch (89:11): [True: 133k, False: 88.0k] ------------------ 90| 133k| if(inByte<*pos++) { ------------------ | Branch (90:12): [True: 67.2k, False: 66.3k] ------------------ 91| 67.2k| length>>=1; 92| 67.2k| pos=jumpByDelta(pos); 93| 67.2k| } else { 94| 66.3k| length=length-(length>>1); 95| 66.3k| pos=skipDelta(pos); 96| 66.3k| } 97| 133k| } 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| 179k| do { 102| 179k| if(inByte==*pos++) { ------------------ | Branch (102:12): [True: 56.5k, False: 122k] ------------------ 103| 56.5k| UStringTrieResult result; 104| 56.5k| int32_t node=*pos; 105| 56.5k| U_ASSERT(node>=kMinValueLead); ------------------ | | 35| 56.5k|# define U_ASSERT(exp) (void)0 ------------------ 106| 56.5k| if(node&kValueIsFinal) { ------------------ | Branch (106:16): [True: 5.74k, False: 50.8k] ------------------ 107| | // Leave the final value for getValue() to read. 108| 5.74k| result=USTRINGTRIE_FINAL_VALUE; 109| 50.8k| } else { 110| | // Use the non-final value as the jump delta. 111| 50.8k| ++pos; 112| | // int32_t delta=readValue(pos, node>>1); 113| 50.8k| node>>=1; 114| 50.8k| int32_t delta; 115| 50.8k| if(node=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (132:25): [True: 18.6k, False: 32.2k] ------------------ 133| 50.8k| } 134| 56.5k| pos_=pos; 135| 56.5k| return result; 136| 56.5k| } 137| 122k| --length; 138| 122k| pos=skipValue(pos); 139| 122k| } while(length>1); ------------------ | Branch (139:13): [True: 91.4k, False: 31.5k] ------------------ 140| 31.5k| if(inByte==*pos++) { ------------------ | Branch (140:8): [True: 22.1k, False: 9.33k] ------------------ 141| 22.1k| pos_=pos; 142| 22.1k| int32_t node=*pos; 143| 22.1k| return node>=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (143:16): [True: 16.1k, False: 6.07k] ------------------ 144| 22.1k| } else { 145| 9.33k| stop(); 146| 9.33k| return USTRINGTRIE_NO_MATCH; 147| 9.33k| } 148| 31.5k|} _ZN6icu_789BytesTrie8nextImplEPKhi: 151| 94.2k|BytesTrie::nextImpl(const uint8_t *pos, int32_t inByte) { 152| 101k| for(;;) { 153| 101k| int32_t node=*pos++; 154| 101k| if(node=kMinValueLead) ? ------------------ | Branch (162:25): [True: 1.28k, False: 3.59k] | Branch (162:37): [True: 1.07k, False: 212] ------------------ 163| 3.81k| valueResult(node) : USTRINGTRIE_NO_VALUE; 164| 4.88k| } else { 165| | // No match. 166| 1.27k| break; 167| 1.27k| } 168| 7.43k| } else if(node&kValueIsFinal) { ------------------ | Branch (168:19): [True: 0, False: 7.43k] ------------------ 169| | // No further matching bytes. 170| 0| break; 171| 7.43k| } else { 172| | // Skip intermediate value. 173| 7.43k| pos=skipValue(pos, node); 174| | // The next node must not also be a value node. 175| 7.43k| U_ASSERT(*pos=0) { ------------------ | Branch (192:8): [True: 4.07k, False: 94.2k] ------------------ 193| | // Remaining part of a linear-match node. 194| 4.07k| if(inByte==*pos++) { ------------------ | Branch (194:12): [True: 4.03k, False: 42] ------------------ 195| 4.03k| remainingMatchLength_=--length; 196| 4.03k| pos_=pos; 197| 4.03k| int32_t node; 198| 4.03k| return (length<0 && (node=*pos)>=kMinValueLead) ? ------------------ | Branch (198:21): [True: 2.31k, False: 1.71k] | Branch (198:33): [True: 1.98k, False: 336] ------------------ 199| 2.05k| valueResult(node) : USTRINGTRIE_NO_VALUE; 200| 4.03k| } else { 201| 42| stop(); 202| 42| return USTRINGTRIE_NO_MATCH; 203| 42| } 204| 4.07k| } 205| 94.2k| return nextImpl(pos, inByte); 206| 98.3k|} _ZN6icu_7819CharacterProperties24getInclusionsForPropertyE9UPropertyR10UErrorCode: 267| 22.5k| UProperty prop, UErrorCode &errorCode) { 268| 22.5k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (268:9): [True: 0, False: 22.5k] ------------------ 269| 22.5k| if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { ------------------ | Branch (269:9): [True: 22.5k, False: 27] | Branch (269:36): [True: 8.26k, False: 14.2k] ------------------ 270| 8.26k| int32_t inclIndex = UPROPS_SRC_COUNT + (prop - UCHAR_INT_START); 271| 8.26k| Inclusion &i = gInclusions[inclIndex]; 272| 8.26k| umtx_initOnce(i.fInitOnce, &initIntPropInclusion, prop, errorCode); 273| 8.26k| return i.fSet; 274| 14.2k| } else { 275| 14.2k| UPropertySource src = uprops_getSource(prop); ------------------ | | 1392| 14.2k|#define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource) | | ------------------ | | | | 123| 14.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 14.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 14.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 276| 14.2k| return getInclusionsForSource(src, errorCode); 277| 14.2k| } 278| 22.5k|} _ZN6icu_7819CharacterProperties20getBinaryPropertySetE9UPropertyR10UErrorCode: 394| 2.79k|const UnicodeSet *CharacterProperties::getBinaryPropertySet(UProperty property, UErrorCode &errorCode) { 395| 2.79k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (395:9): [True: 0, False: 2.79k] ------------------ 396| 2.79k| if (property < 0 || UCHAR_BINARY_LIMIT <= property) { ------------------ | Branch (396:9): [True: 0, False: 2.79k] | Branch (396:25): [True: 0, False: 2.79k] ------------------ 397| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 398| 0| return nullptr; 399| 0| } 400| 2.79k| Mutex m(&cpMutex); 401| 2.79k| UnicodeSet *set = sets[property]; 402| 2.79k| if (set == nullptr) { ------------------ | Branch (402:9): [True: 27, False: 2.76k] ------------------ 403| 27| sets[property] = set = makeSet(property, errorCode); 404| 27| } 405| 2.79k| return set; 406| 2.79k|} u_getBinaryPropertySet_78: 413| 2.79k|u_getBinaryPropertySet(UProperty property, UErrorCode *pErrorCode) { 414| 2.79k| const UnicodeSet *set = CharacterProperties::getBinaryPropertySet(property, *pErrorCode); 415| 2.79k| return U_SUCCESS(*pErrorCode) ? set->toUSet() : nullptr; ------------------ | Branch (415:12): [True: 2.79k, False: 0] ------------------ 416| 2.79k|} characterproperties.cpp:_ZN12_GLOBAL__N_120initIntPropInclusionE9UPropertyR10UErrorCode: 222| 10|void U_CALLCONV initIntPropInclusion(UProperty prop, UErrorCode &errorCode) { 223| | // This function is invoked only via umtx_initOnce(). 224| 10| U_ASSERT(UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT); ------------------ | | 35| 10|# define U_ASSERT(exp) (void)0 ------------------ 225| 10| int32_t inclIndex = UPROPS_SRC_COUNT + (prop - UCHAR_INT_START); 226| 10| U_ASSERT(gInclusions[inclIndex].fSet == nullptr); ------------------ | | 35| 10|# define U_ASSERT(exp) (void)0 ------------------ 227| 10| UPropertySource src = uprops_getSource(prop); ------------------ | | 1392| 10|#define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource) | | ------------------ | | | | 123| 10|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 10|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 10|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 228| 10| const UnicodeSet *incl = getInclusionsForSource(src, errorCode); 229| 10| if (U_FAILURE(errorCode)) { ------------------ | Branch (229:9): [True: 0, False: 10] ------------------ 230| 0| return; 231| 0| } 232| | 233| 10| LocalPointer intPropIncl(new UnicodeSet(0, 0)); 234| 10| if (intPropIncl.isNull()) { ------------------ | Branch (234:9): [True: 0, False: 10] ------------------ 235| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 236| 0| return; 237| 0| } 238| 10| int32_t numRanges = incl->getRangeCount(); 239| 10| int32_t prevValue = 0; 240| 15.4k| for (int32_t i = 0; i < numRanges; ++i) { ------------------ | Branch (240:25): [True: 15.4k, False: 10] ------------------ 241| 15.4k| UChar32 rangeEnd = incl->getRangeEnd(i); 242| 55.4k| for (UChar32 c = incl->getRangeStart(i); c <= rangeEnd; ++c) { ------------------ | Branch (242:50): [True: 40.0k, False: 15.4k] ------------------ 243| | // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch. 244| 40.0k| int32_t value = u_getIntPropertyValue(c, prop); ------------------ | | 280| 40.0k|#define u_getIntPropertyValue U_ICU_ENTRY_POINT_RENAME(u_getIntPropertyValue) | | ------------------ | | | | 123| 40.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 40.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 40.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 245| 40.0k| if (value != prevValue) { ------------------ | Branch (245:17): [True: 8.89k, False: 31.1k] ------------------ 246| 8.89k| intPropIncl->add(c); 247| 8.89k| prevValue = value; 248| 8.89k| } 249| 40.0k| } 250| 15.4k| } 251| | 252| 10| if (intPropIncl->isBogus()) { ------------------ | Branch (252:9): [True: 0, False: 10] ------------------ 253| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 254| 0| return; 255| 0| } 256| | // Compact for caching. 257| 10| intPropIncl->compact(); 258| 10| gInclusions[inclIndex].fSet = intPropIncl.orphan(); 259| 10| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); ------------------ | | 617| 10|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 10|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 10|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 10|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 260| 10|} characterproperties.cpp:_ZN12_GLOBAL__N_122getInclusionsForSourceE15UPropertySourceR10UErrorCode: 211| 14.2k|const UnicodeSet *getInclusionsForSource(UPropertySource src, UErrorCode &errorCode) { 212| 14.2k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (212:9): [True: 0, False: 14.2k] ------------------ 213| 14.2k| if (src < 0 || UPROPS_SRC_COUNT <= src) { ------------------ | Branch (213:9): [True: 0, False: 14.2k] | Branch (213:20): [True: 0, False: 14.2k] ------------------ 214| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 215| 0| return nullptr; 216| 0| } 217| 14.2k| Inclusion &i = gInclusions[src]; 218| 14.2k| umtx_initOnce(i.fInitOnce, &initInclusion, src, errorCode); 219| 14.2k| return i.fSet; 220| 14.2k|} characterproperties.cpp:_ZN12_GLOBAL__N_113initInclusionE15UPropertySourceR10UErrorCode: 91| 9|void U_CALLCONV initInclusion(UPropertySource src, UErrorCode &errorCode) { 92| | // This function is invoked only via umtx_initOnce(). 93| 9| U_ASSERT(0 <= src && src < UPROPS_SRC_COUNT); ------------------ | | 35| 9|# define U_ASSERT(exp) (void)0 ------------------ 94| 9| if (src == UPROPS_SRC_NONE) { ------------------ | Branch (94:9): [True: 0, False: 9] ------------------ 95| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 96| 0| return; 97| 0| } 98| 9| U_ASSERT(gInclusions[src].fSet == nullptr); ------------------ | | 35| 9|# define U_ASSERT(exp) (void)0 ------------------ 99| | 100| 9| LocalPointer incl(new UnicodeSet()); 101| 9| if (incl.isNull()) { ------------------ | Branch (101:9): [True: 0, False: 9] ------------------ 102| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 103| 0| return; 104| 0| } 105| 9| USetAdder sa = { 106| 9| reinterpret_cast(incl.getAlias()), 107| 9| _set_add, 108| 9| _set_addRange, 109| 9| _set_addString, 110| 9| nullptr, // don't need remove() 111| 9| nullptr // don't need removeRange() 112| 9| }; 113| | 114| 9| switch(src) { 115| 1| case UPROPS_SRC_CHAR: ------------------ | Branch (115:5): [True: 1, False: 8] ------------------ 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: 8] ------------------ 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: 9] ------------------ 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| 1| case UPROPS_SRC_CASE_AND_NORM: { ------------------ | Branch (126:5): [True: 1, False: 8] ------------------ 127| 1| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 128| 1| if(U_SUCCESS(errorCode)) { ------------------ | Branch (128:12): [True: 1, False: 0] ------------------ 129| 1| impl->addPropertyStarts(&sa, errorCode); 130| 1| } 131| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 132| 1| break; 133| 0| } 134| 1| case UPROPS_SRC_NFC: { ------------------ | Branch (134:5): [True: 1, False: 8] ------------------ 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: 9] ------------------ 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: 9] ------------------ 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: 9] ------------------ 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: 8] ------------------ 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| 1| case UPROPS_SRC_BIDI: ------------------ | Branch (166:5): [True: 1, False: 8] ------------------ 167| 1| ubidi_addPropertyStarts(&sa, &errorCode); ------------------ | | 435| 1|#define ubidi_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(ubidi_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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 168| 1| break; 169| 0| case UPROPS_SRC_INPC: ------------------ | Branch (169:5): [True: 0, False: 9] ------------------ 170| 0| case UPROPS_SRC_INSC: ------------------ | Branch (170:5): [True: 0, False: 9] ------------------ 171| 1| case UPROPS_SRC_VO: ------------------ | Branch (171:5): [True: 1, False: 8] ------------------ 172| 1| uprops_addPropertyStarts(src, &sa, &errorCode); ------------------ | | 1391| 1|#define uprops_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uprops_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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 173| 1| break; 174| 0| case UPROPS_SRC_EMOJI: { ------------------ | Branch (174:5): [True: 0, False: 9] ------------------ 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| 1| case UPROPS_SRC_IDSU: ------------------ | Branch (181:5): [True: 1, False: 8] ------------------ 182| | // New in Unicode 15.1 for just two characters. 183| 1| sa.add(sa.set, 0x2FFE); 184| 1| sa.add(sa.set, 0x2FFF + 1); 185| 1| break; 186| 0| case UPROPS_SRC_ID_COMPAT_MATH: ------------------ | Branch (186:5): [True: 0, False: 9] ------------------ 187| 1| case UPROPS_SRC_MCM: ------------------ | Branch (187:5): [True: 1, False: 8] ------------------ 188| 1| uprops_addPropertyStarts(src, &sa, &errorCode); ------------------ | | 1391| 1|#define uprops_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uprops_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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 189| 1| break; 190| 0| case UPROPS_SRC_BLOCK: ------------------ | Branch (190:5): [True: 0, False: 9] ------------------ 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: 9] ------------------ 194| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 195| 0| break; 196| 9| } 197| | 198| 9| if (U_FAILURE(errorCode)) { ------------------ | Branch (198:9): [True: 0, False: 9] ------------------ 199| 0| return; 200| 0| } 201| 9| if (incl->isBogus()) { ------------------ | Branch (201:9): [True: 0, False: 9] ------------------ 202| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 203| 0| return; 204| 0| } 205| | // Compact for caching. 206| 9| incl->compact(); 207| 9| gInclusions[src].fSet = incl.orphan(); 208| 9| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); ------------------ | | 617| 9|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 9|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 209| 9|} characterproperties.cpp:_ZN12_GLOBAL__N_18_set_addEP4USeti: 60| 31.4k|_set_add(USet *set, UChar32 c) { 61| 31.4k| reinterpret_cast(set)->add(c); 62| 31.4k|} characterproperties.cpp:_ZN12_GLOBAL__N_113_set_addRangeEP4USetii: 65| 40|_set_addRange(USet *set, UChar32 start, UChar32 end) { 66| 40| reinterpret_cast(set)->add(start, end); 67| 40|} characterproperties.cpp:_ZN12_GLOBAL__N_17makeSetE9UPropertyR10UErrorCode: 284| 27|UnicodeSet *makeSet(UProperty property, UErrorCode &errorCode) { 285| 27| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (285:9): [True: 0, False: 27] ------------------ 286| 27| LocalPointer set(new UnicodeSet()); 287| 27| if (set.isNull()) { ------------------ | Branch (287:9): [True: 0, False: 27] ------------------ 288| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 289| 0| return nullptr; 290| 0| } 291| 27| if (UCHAR_BASIC_EMOJI <= property && property <= UCHAR_RGI_EMOJI) { ------------------ | Branch (291:9): [True: 2, False: 25] | Branch (291:42): [True: 0, False: 2] ------------------ 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| 27| const UnicodeSet *inclusions = 312| 27| icu::CharacterProperties::getInclusionsForProperty(property, errorCode); 313| 27| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (313:9): [True: 0, False: 27] ------------------ 314| 27| int32_t numRanges = inclusions->getRangeCount(); 315| 27| UChar32 startHasProperty = -1; 316| | 317| 62.6k| for (int32_t i = 0; i < numRanges; ++i) { ------------------ | Branch (317:25): [True: 62.6k, False: 27] ------------------ 318| 62.6k| UChar32 rangeEnd = inclusions->getRangeEnd(i); 319| 215k| for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) { ------------------ | Branch (319:56): [True: 152k, False: 62.6k] ------------------ 320| | // TODO: Get a UCharacterProperty.BinaryProperty to avoid the property dispatch. 321| 152k| if (u_hasBinaryProperty(c, property)) { ------------------ | | 292| 152k|#define u_hasBinaryProperty U_ICU_ENTRY_POINT_RENAME(u_hasBinaryProperty) | | ------------------ | | | | 123| 152k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 152k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 152k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (321:17): [True: 23.6k, False: 129k] ------------------ 322| 23.6k| if (startHasProperty < 0) { ------------------ | Branch (322:21): [True: 6.55k, False: 17.0k] ------------------ 323| | // Transition from false to true. 324| 6.55k| startHasProperty = c; 325| 6.55k| } 326| 129k| } else if (startHasProperty >= 0) { ------------------ | Branch (326:24): [True: 6.55k, False: 122k] ------------------ 327| | // Transition from true to false. 328| 6.55k| set->add(startHasProperty, c - 1); 329| 6.55k| startHasProperty = -1; 330| 6.55k| } 331| 152k| } 332| 62.6k| } 333| 27| if (startHasProperty >= 0) { ------------------ | Branch (333:9): [True: 0, False: 27] ------------------ 334| 0| set->add(startHasProperty, 0x10FFFF); 335| 0| } 336| 27| set->freeze(); 337| 27| return set.orphan(); 338| 27|} _ZN6icu_7810CharString6appendEcR10UErrorCode: 113| 4|CharString &CharString::append(char c, UErrorCode &errorCode) { 114| 4| if(ensureCapacity(len+2, 0, errorCode)) { ------------------ | Branch (114:8): [True: 4, False: 0] ------------------ 115| 4| buffer[len++]=c; 116| 4| buffer[len]=0; 117| 4| } 118| 4| return *this; 119| 4|} _ZN6icu_7810CharString6appendEPKciR10UErrorCode: 121| 18|CharString &CharString::append(const char *s, int32_t sLength, UErrorCode &errorCode) { 122| 18| if(U_FAILURE(errorCode)) { ------------------ | Branch (122:8): [True: 0, False: 18] ------------------ 123| 0| return *this; 124| 0| } 125| 18| if(sLength<-1 || (s==nullptr && sLength!=0)) { ------------------ | Branch (125:8): [True: 0, False: 18] | Branch (125:23): [True: 0, False: 18] | Branch (125:37): [True: 0, False: 0] ------------------ 126| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 127| 0| return *this; 128| 0| } 129| 18| if(sLength<0) { ------------------ | Branch (129:8): [True: 0, False: 18] ------------------ 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| 18| if(sLength>0) { ------------------ | Branch (132:8): [True: 18, False: 0] ------------------ 133| 18| if(s==(buffer.getAlias()+len)) { ------------------ | Branch (133:12): [True: 0, False: 18] ------------------ 134| | // The caller wrote into the getAppendBuffer(). 135| 0| if(sLength>=(buffer.getCapacity()-len)) { ------------------ | Branch (135:16): [True: 0, False: 0] ------------------ 136| | // The caller wrote too much. 137| 0| errorCode=U_INTERNAL_PROGRAM_ERROR; 138| 0| } else { 139| 0| buffer[len+=sLength]=0; 140| 0| } 141| 18| } else if(buffer.getAlias()<=s && s<(buffer.getAlias()+len) && ------------------ | Branch (141:19): [True: 4, False: 14] | Branch (141:43): [True: 0, False: 4] ------------------ 142| 18| sLength>=(buffer.getCapacity()-len) ------------------ | Branch (142:19): [True: 0, False: 0] ------------------ 143| 18| ) { 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| 18| } else if(ensureCapacity(len+sLength+1, 0, errorCode)) { ------------------ | Branch (147:19): [True: 18, False: 0] ------------------ 148| 18| uprv_memcpy(buffer.getAlias()+len, s, sLength); ------------------ | | 42| 18|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 18|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 18| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 18| _Pragma("clang diagnostic push") \ | | 45| 18| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 18| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 18|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 18| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 18|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 18| _Pragma("clang diagnostic pop") \ | | 49| 18| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 18|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 18|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 18|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 149| 18| buffer[len+=sLength]=0; 150| 18| } 151| 18| } 152| 18| return *this; 153| 18|} _ZN6icu_7810CharString20appendInvariantCharsERKNS_13UnicodeStringER10UErrorCode: 208| 62.6k|CharString &CharString::appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode) { 209| 62.6k| return appendInvariantChars(s.getBuffer(), s.length(), errorCode); 210| 62.6k|} _ZN6icu_7810CharString20appendInvariantCharsEPKDsiR10UErrorCode: 212| 62.6k|CharString &CharString::appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode &errorCode) { 213| 62.6k| if(U_FAILURE(errorCode)) { ------------------ | Branch (213:8): [True: 0, False: 62.6k] ------------------ 214| 0| return *this; 215| 0| } 216| 62.6k| if (!uprv_isInvariantUString(uchars, ucharsLen)) { ------------------ | | 1518| 62.6k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 62.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 62.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 62.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (216:9): [True: 0, False: 62.6k] ------------------ 217| 0| errorCode = U_INVARIANT_CONVERSION_ERROR; 218| 0| return *this; 219| 0| } 220| 62.6k| if(ensureCapacity(len+ucharsLen+1, 0, errorCode)) { ------------------ | Branch (220:8): [True: 62.6k, False: 0] ------------------ 221| 62.6k| u_UCharsToChars(uchars, buffer.getAlias()+len, ucharsLen); ------------------ | | 211| 62.6k|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 123| 62.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 62.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 62.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 222| 62.6k| len += ucharsLen; 223| 62.6k| buffer[len] = 0; 224| 62.6k| } 225| 62.6k| return *this; 226| 62.6k|} _ZN6icu_7810CharString14ensureCapacityEiiR10UErrorCode: 230| 62.6k| UErrorCode &errorCode) { 231| 62.6k| if(U_FAILURE(errorCode)) { ------------------ | Branch (231:8): [True: 0, False: 62.6k] ------------------ 232| 0| return false; 233| 0| } 234| 62.6k| if(capacity>buffer.getCapacity()) { ------------------ | Branch (234:8): [True: 888, False: 61.7k] ------------------ 235| 888| if(desiredCapacityHint==0) { ------------------ | Branch (235:12): [True: 888, False: 0] ------------------ 236| 888| desiredCapacityHint=capacity+buffer.getCapacity(); 237| 888| } 238| 888| if( (desiredCapacityHint<=capacity || buffer.resize(desiredCapacityHint, len+1)==nullptr) && ------------------ | Branch (238:14): [True: 0, False: 888] | Branch (238:47): [True: 0, False: 888] ------------------ 239| 888| buffer.resize(capacity, len+1)==nullptr ------------------ | Branch (239:13): [True: 0, False: 0] ------------------ 240| 888| ) { 241| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 242| 0| return false; 243| 0| } 244| 888| } 245| 62.6k| return true; 246| 62.6k|} _ZN6icu_7810CharString4dataEv: 85| 66.9k| char *data() { return buffer.getAlias(); } _ZN6icu_7810CharStringD2Ev: 56| 62.6k| ~CharString() {} _ZN6icu_7810CharString6appendENS_11StringPieceER10UErrorCode: 131| 14| CharString &append(StringPiece s, UErrorCode &errorCode) { 132| 14| return append(s.data(), s.length(), errorCode); 133| 14| } _ZN6icu_7810CharStringC2Ev: 43| 62.6k| CharString() : len(0) { buffer[0]=0; } _ZNK6icu_7810CharString7isEmptyEv: 79| 2| UBool isEmpty() const { return len==0; } _ZNK6icu_7810CharString6lengthEv: 80| 6| int32_t length() const { return len; } _ZNK6icu_7810CharString4dataEv: 84| 4| const char *data() const { return buffer.getAlias(); } _ZN6icu_7810CharString6appendERKS0_R10UErrorCode: 134| 4| CharString &append(const CharString &s, UErrorCode &errorCode) { 135| 4| return append(s.data(), s.length(), errorCode); 136| 4| } uprv_malloc_78: 45| 2.29M|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| 2.29M| if (s > 0) { ------------------ | Branch (54:9): [True: 2.29M, False: 0] ------------------ 55| 2.29M| if (pAlloc) { ------------------ | Branch (55:13): [True: 0, False: 2.29M] ------------------ 56| 0| return (*pAlloc)(pContext, s); 57| 2.29M| } else { 58| 2.29M| return uprv_default_malloc(s); ------------------ | | 615| 2.29M|# define uprv_default_malloc(x) malloc(x) ------------------ 59| 2.29M| } 60| 2.29M| } else { 61| 0| return (void *)zeroMem; 62| 0| } 63| 2.29M|} uprv_realloc_78: 66| 39.5k|uprv_realloc(void * buffer, size_t size) { 67| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 68| | putchar('~'); 69| | fflush(stdout); 70| |#endif 71| 39.5k| if (buffer == zeroMem) { ------------------ | Branch (71:9): [True: 0, False: 39.5k] ------------------ 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| 39.5k| } else if (size == 0) { ------------------ | Branch (73:16): [True: 0, False: 39.5k] ------------------ 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| 39.5k| } else { 81| 39.5k| if (pRealloc) { ------------------ | Branch (81:13): [True: 0, False: 39.5k] ------------------ 82| 0| return (*pRealloc)(pContext, buffer, size); 83| 39.5k| } else { 84| 39.5k| return uprv_default_realloc(buffer, size); ------------------ | | 616| 39.5k|# define uprv_default_realloc(x,y) realloc(x,y) ------------------ 85| 39.5k| } 86| 39.5k| } 87| 39.5k|} uprv_free_78: 90| 2.50M|uprv_free(void *buffer) { 91| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 92| | putchar('<'); 93| | fflush(stdout); 94| |#endif 95| 2.50M| if (buffer != zeroMem) { ------------------ | Branch (95:9): [True: 2.50M, False: 0] ------------------ 96| 2.50M| if (pFree) { ------------------ | Branch (96:13): [True: 0, False: 2.50M] ------------------ 97| 0| (*pFree)(pContext, buffer); 98| 2.50M| } else { 99| 2.50M| uprv_default_free(buffer); ------------------ | | 617| 2.50M|# define uprv_default_free(x) free(x) ------------------ 100| 2.50M| } 101| 2.50M| } 102| 2.50M|} _ZN6icu_7815MaybeStackArrayIcLi40EEC2Ev: 344| 62.6k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7815MaybeStackArrayIcLi40EED2Ev: 363| 62.6k| ~MaybeStackArray() { releaseArray(); } _ZNK6icu_7815MaybeStackArrayIcLi40EE11getCapacityEv: 376| 63.5k| int32_t getCapacity() const { return capacity; } _ZNK6icu_7815MaybeStackArrayIcLi40EE8getAliasEv: 381| 129k| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayIcLi40EEixEl: 402| 125k| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EE6resizeEii: 505| 888|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 888| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 888, 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| 888| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 888|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 888|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 888|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 888|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 888| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 888, False: 0] ------------------ 512| 888| if(length>0) { ------------------ | Branch (512:16): [True: 888, False: 0] ------------------ 513| 888| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 888] ------------------ 514| 0| length=capacity; 515| 0| } 516| 888| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 888] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 888| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 888|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 888|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 888| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 888| _Pragma("clang diagnostic push") \ | | 45| 888| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 888| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 888|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 888| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 888|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 888| _Pragma("clang diagnostic pop") \ | | 49| 888| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 888|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 888|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 888|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 888| } 521| 888| releaseArray(); 522| 888| ptr=p; 523| 888| capacity=newCapacity; 524| 888| needToRelease=true; 525| 888| } 526| 888| return p; 527| 888| } else { 528| 0| return nullptr; 529| 0| } 530| 888|} _ZN6icu_7815MaybeStackArrayIcLi40EE12releaseArrayEv: 458| 63.5k| void releaseArray() { 459| 63.5k| if(needToRelease) { ------------------ | Branch (459:12): [True: 888, False: 62.6k] ------------------ 460| 888| uprv_free(ptr); ------------------ | | 1503| 888|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 888|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 888|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 888|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 888| } 462| 63.5k| } 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_toupper_78: 63| 15.0k|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| 15.0k| if('a'<=c && c<='z') { ------------------ | Branch (69:8): [True: 3.26k, False: 11.7k] | Branch (69:18): [True: 2.68k, False: 576] ------------------ 70| 2.68k| c=(char)(c+('A'-'a')); 71| 2.68k| } 72| 15.0k|#endif 73| 15.0k| return c; 74| 15.0k|} uprv_asciitolower_78: 103| 146k|uprv_asciitolower(char c) { 104| 146k| if(0x41<=c && c<=0x5a) { ------------------ | Branch (104:8): [True: 137k, False: 8.44k] | Branch (104:19): [True: 110k, False: 27.0k] ------------------ 105| 110k| c=(char)(c+0x20); 106| 110k| } 107| 146k| return c; 108| 146k|} _ZN6icu_785MutexC2EPNS_6UMutexE: 58| 2.82k| Mutex(UMutex *mutex = nullptr) : fMutex(mutex) { 59| 2.82k| umtx_lock(fMutex); ------------------ | | 1250| 2.82k|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 2.82k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.82k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.82k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 60| 2.82k| } _ZN6icu_785MutexD2Ev: 61| 2.82k| ~Mutex() { 62| 2.82k| umtx_unlock(fMutex); ------------------ | | 1251| 2.82k|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 2.82k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.82k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.82k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 2.82k| } _ZN6icu_7819Normalizer2WithImplC2ERKNS_15Normalizer2ImplE: 34| 4| Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {} _ZNK6icu_7819Normalizer2WithImpl16getDecompositionEiRNS_13UnicodeStringE: 110| 5.79k| getDecomposition(UChar32 c, UnicodeString &decomposition) const override { 111| 5.79k| char16_t buffer[4]; 112| 5.79k| int32_t length; 113| 5.79k| const char16_t *d=impl.getDecomposition(c, buffer, length); 114| 5.79k| if(d==nullptr) { ------------------ | Branch (114:12): [True: 2.92k, False: 2.86k] ------------------ 115| 2.92k| return false; 116| 2.92k| } 117| 2.86k| if(d==buffer) { ------------------ | Branch (117:12): [True: 799, False: 2.06k] ------------------ 118| 799| decomposition.setTo(buffer, length); // copy the string (Jamos from Hangul syllable c) 119| 2.06k| } else { 120| 2.06k| decomposition.setTo(false, d, length); // read-only alias 121| 2.06k| } 122| 2.86k| return true; 123| 5.79k| } _ZNK6icu_7819Normalizer2WithImpl17getCombiningClassEi: 145| 490k| getCombiningClass(UChar32 c) const override { 146| 490k| return impl.getCC(impl.getNorm16(c)); 147| 490k| } _ZN6icu_7820DecomposeNormalizer2C2ERKNS_15Normalizer2ImplE: 191| 1| DecomposeNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {} _ZN6icu_7818ComposeNormalizer2C2ERKNS_15Normalizer2ImplEa: 253| 2| Normalizer2WithImpl(ni), onlyContiguous(fcc) {} _ZN6icu_7814FCDNormalizer2C2ERKNS_15Normalizer2ImplE: 348| 1| FCDNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {} _ZN6icu_7813Norm2AllModesC2EPNS_15Normalizer2ImplE: 382| 1| : impl(i), comp(*i, false), decomp(*i), fcd(*i), fcc(*i, true) {} _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| 1.67M|Norm2AllModes::getNFCInstance(UErrorCode &errorCode) { 257| 1.67M| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (257:8): [True: 0, False: 1.67M] ------------------ 258| 1.67M| umtx_initOnce(nfcInitOnce, &initNFCSingleton, errorCode); 259| 1.67M| return nfcSingleton; 260| 1.67M|} _ZN6icu_7811Normalizer214getNFCInstanceER10UErrorCode: 263| 5.79k|Normalizer2::getNFCInstance(UErrorCode &errorCode) { 264| 5.79k| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 265| 5.79k| return allModes!=nullptr ? &allModes->comp : nullptr; ------------------ | Branch (265:12): [True: 5.79k, False: 0] ------------------ 266| 5.79k|} _ZN6icu_7811Normalizer214getNFDInstanceER10UErrorCode: 269| 490k|Normalizer2::getNFDInstance(UErrorCode &errorCode) { 270| 490k| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 271| 490k| return allModes!=nullptr ? &allModes->decomp : nullptr; ------------------ | Branch (271:12): [True: 490k, False: 0] ------------------ 272| 490k|} _ZN6icu_7818Normalizer2Factory10getNFCImplER10UErrorCode: 285| 1.17M|Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) { 286| 1.17M| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 287| 1.17M| return allModes!=nullptr ? allModes->impl : nullptr; ------------------ | Branch (287:12): [True: 1.17M, False: 0] ------------------ 288| 1.17M|} u_getCombiningClass_78: 551| 490k|u_getCombiningClass(UChar32 c) { 552| 490k| UErrorCode errorCode=U_ZERO_ERROR; 553| 490k| const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode); 554| 490k| if(U_SUCCESS(errorCode)) { ------------------ | Branch (554:8): [True: 490k, False: 0] ------------------ 555| 490k| return nfd->getCombiningClass(c); 556| 490k| } else { 557| 0| return 0; 558| 0| } 559| 490k|} unorm_getFCD16_78: 562| 1.17M|unorm_getFCD16(UChar32 c) { 563| 1.17M| UErrorCode errorCode=U_ZERO_ERROR; 564| 1.17M| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 565| 1.17M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (565:8): [True: 1.17M, False: 0] ------------------ 566| 1.17M| return impl->getFCD16(c); 567| 1.17M| } else { 568| 0| return 0; 569| 0| } 570| 1.17M|} 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_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| 2|Normalizer2Impl::addPropertyStarts(const USetAdder *sa, UErrorCode & /*errorCode*/) const { 482| | // Add the start code point of each same-value range of the trie. 483| 2| UChar32 start = 0, end; 484| 2| uint32_t value; 485| 8.02k| while ((end = ucptrie_getRange(normTrie, start, UCPMAP_RANGE_FIXED_LEAD_SURROGATES, INERT, ------------------ | | 806| 8.02k|#define ucptrie_getRange U_ICU_ENTRY_POINT_RENAME(ucptrie_getRange) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (485:12): [True: 8.01k, False: 2] ------------------ 486| 8.02k| nullptr, nullptr, &value)) >= 0) { 487| 8.01k| sa->add(sa->set, start); 488| 8.01k| if (start != end && isAlgorithmicNoNo(static_cast(value)) && ------------------ | Branch (488:13): [True: 1.86k, False: 6.15k] | Branch (488:29): [True: 2, False: 1.86k] ------------------ 489| 8.01k| (value & Normalizer2Impl::DELTA_TCCC_MASK) > Normalizer2Impl::DELTA_TCCC_1) { ------------------ | Branch (489:17): [True: 0, False: 2] ------------------ 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| 8.01k| start = end + 1; 502| 8.01k| } 503| | 504| | /* add Hangul LV syllables and LV+1 because of skippables */ 505| 800| for(char16_t c=Hangul::HANGUL_BASE; cadd(sa->set, c); 507| 798| sa->add(sa->set, c+1); 508| 798| } 509| 2| sa->add(sa->set, Hangul::HANGUL_LIMIT); /* add Hangul+1 to continue with other properties */ 510| 2|} _ZNK6icu_7815Normalizer2Impl16getDecompositionEiPDsRi: 948| 5.79k|Normalizer2Impl::getDecomposition(UChar32 c, char16_t buffer[4], int32_t &length) const { 949| 5.79k| uint16_t norm16; 950| 5.79k| if(c>10)+0xd7c0); \ | | 372| 0| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 373| 0| } \ | | 374| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 961| | // The mapping might decompose further. 962| 1| norm16 = getRawNorm16(c); 963| 1| } 964| 5.25k| if (norm16 < minYesNo) { ------------------ | Branch (964:9): [True: 2.38k, False: 2.86k] ------------------ 965| 2.38k| return decomp; 966| 2.86k| } else if(isHangulLV(norm16) || isHangulLVT(norm16)) { ------------------ | Branch (966:15): [True: 399, False: 2.46k] | Branch (966:37): [True: 399, False: 2.06k] ------------------ 967| | // Hangul syllable: decompose algorithmically 968| 798| length=Hangul::decompose(c, buffer); 969| 798| return buffer; 970| 798| } 971| | // c decomposes, get everything from the variable-length extra data 972| 2.06k| const uint16_t *mapping=getData(norm16); 973| 2.06k| length=*mapping&MAPPING_LENGTH_MASK; 974| 2.06k| return reinterpret_cast(mapping) + 1; 975| 5.25k|} _ZNK6icu_7815Normalizer2Impl20getFCD16FromNormDataEi: 2248| 1.16M|uint16_t Normalizer2Impl::getFCD16FromNormData(UChar32 c) const { 2249| 1.16M| uint16_t norm16=getNorm16(c); 2250| 1.16M| if (norm16 >= limitNoNo) { ------------------ | Branch (2250:9): [True: 580k, False: 581k] ------------------ 2251| 580k| if(norm16>=MIN_NORMAL_MAYBE_YES) { ------------------ | Branch (2251:12): [True: 580k, False: 32] ------------------ 2252| | // combining mark 2253| 580k| norm16=getCCFromNormalYesOrMaybe(norm16); 2254| 580k| return norm16|(norm16<<8); 2255| 580k| } else if(norm16>=minMaybeYes) { ------------------ | Branch (2255:19): [True: 8, False: 24] ------------------ 2256| 8| return 0; 2257| 24| } 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| 580k| } 2267| 581k| if(norm16<=minYesNo || isHangulLVT(norm16)) { ------------------ | Branch (2267:8): [True: 385k, False: 195k] | Branch (2267:28): [True: 0, False: 195k] ------------------ 2268| | // no decomposition or Hangul syllable, all zeros 2269| 385k| return 0; 2270| 385k| } 2271| | // c decomposes, get everything from the variable-length extra data 2272| 195k| const uint16_t *mapping=getData(norm16); 2273| 195k| uint16_t firstUnit=*mapping; 2274| 195k| norm16=firstUnit>>8; // tccc 2275| 195k| if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) { ------------------ | Branch (2275:8): [True: 2.40k, False: 193k] ------------------ 2276| 2.40k| norm16|=*(mapping-1)&0xff00; // lccc 2277| 2.40k| } 2278| 195k| return norm16; 2279| 581k|} _ZN6icu_786Hangul9decomposeEiPDs: 102| 798| static inline int32_t decompose(UChar32 c, char16_t buffer[3]) { 103| 798| c-=HANGUL_BASE; 104| 798| UChar32 c2=c%JAMO_T_COUNT; 105| 798| c/=JAMO_T_COUNT; 106| 798| buffer[0] = static_cast(JAMO_L_BASE + c / JAMO_V_COUNT); 107| 798| buffer[1] = static_cast(JAMO_V_BASE + c % JAMO_V_COUNT); 108| 798| if(c2==0) { ------------------ | Branch (108:12): [True: 399, False: 399] ------------------ 109| 399| return 2; 110| 399| } else { 111| 399| buffer[2] = static_cast(JAMO_T_BASE + c2); 112| 399| return 3; 113| 399| } 114| 798| } _ZN6icu_7815Normalizer2ImplC2Ev: 248| 1| Normalizer2Impl() : normTrie(nullptr), fCanonIterData(nullptr) {} _ZNK6icu_7815Normalizer2Impl9getNorm16Ei: 264| 1.65M| uint16_t getNorm16(UChar32 c) const { 265| 1.65M| return U_IS_LEAD(c) ? ------------------ | | 177| 1.65M|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 0, False: 1.65M] | | ------------------ ------------------ 266| 0| static_cast(INERT) : 267| 1.65M| UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); ------------------ | | 358| 1.65M|#define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c)) | | ------------------ | | | | 267| 1.65M| UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); | | | | ------------------ | | | | | | 326| 4.94M|#define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i]) | | | | | | ------------------ | | | | | | | Branch (326:49): [True: 6, False: 407k] | | | | | | | Branch (326:49): [True: 407k, False: 0] | | | | | | | Branch (326:49): [True: 1.25M, False: 407k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 268| 1.65M| } _ZNK6icu_7815Normalizer2Impl12getRawNorm16Ei: 269| 1| uint16_t getRawNorm16(UChar32 c) const { return UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); } ------------------ | | 358| 1|#define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c)) | | ------------------ | | | | 269| 1| uint16_t getRawNorm16(UChar32 c) const { return UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); } | | | | ------------------ | | | | | | 326| 2|#define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i]) | | | | | | ------------------ | | | | | | | Branch (326:49): [True: 0, False: 0] | | | | | | | Branch (326:49): [True: 0, False: 0] | | | | | | | Branch (326:49): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ _ZNK6icu_7815Normalizer2Impl17isAlgorithmicNoNoEt: 280| 1.86k| UBool isAlgorithmicNoNo(uint16_t norm16) const { return limitNoNo<=norm16 && norm16=MIN_NORMAL_MAYBE_YES) { ------------------ | Branch (285:12): [True: 325k, False: 165k] ------------------ 286| 325k| return getCCFromNormalYesOrMaybe(norm16); 287| 325k| } 288| 165k| if(norm16(norm16 >> OFFSET_SHIFT); 295| 906k| } _ZNK6icu_7815Normalizer2Impl8getFCD16Ei: 309| 1.17M| uint16_t getFCD16(UChar32 c) const { 310| 1.17M| if(c>8]; 366| 912k| if(bits==0) { return false; } ------------------ | Branch (366:12): [True: 4.02k, False: 908k] ------------------ 367| 908k| return (bits >> ((lead >> 5) & 7)) & 1; 368| 912k| } _ZNK6icu_7815Normalizer2Impl21isMaybeYesOrNonZeroCCEt: 564| 5.70k| UBool isMaybeYesOrNonZeroCC(uint16_t norm16) const { return norm16>=minMaybeYes; } _ZNK6icu_7815Normalizer2Impl9hangulLVTEv: 568| 198k| uint16_t hangulLVT() const { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; } _ZNK6icu_7815Normalizer2Impl10isHangulLVEt: 569| 2.86k| UBool isHangulLV(uint16_t norm16) const { return norm16==minYesNo; } _ZNK6icu_7815Normalizer2Impl11isHangulLVTEt: 570| 198k| UBool isHangulLVT(uint16_t norm16) const { 571| 198k| return norm16==hangulLVT(); 572| 198k| } _ZNK6icu_7815Normalizer2Impl21isDecompNoAlgorithmicEt: 596| 5.25k| UBool isDecompNoAlgorithmic(uint16_t norm16) const { return limitNoNo<=norm16 && norm16(*(mapping - 1)); 607| 2.47k| } else { 608| 1.92k| return 0; 609| 1.92k| } 610| 4.40k| } _ZNK6icu_7815Normalizer2Impl14mapAlgorithmicEit: 624| 1| UChar32 mapAlgorithmic(UChar32 c, uint16_t norm16) const { 625| 1| return c+(norm16>>DELTA_SHIFT)-centerNoNoDelta; 626| 1| } _ZNK6icu_7815Normalizer2Impl17getDataForYesOrNoEt: 631| 4.40k| const uint16_t *getDataForYesOrNo(uint16_t norm16) const { 632| 4.40k| return extraData+(norm16>>OFFSET_SHIFT); 633| 4.40k| } _ZNK6icu_7815Normalizer2Impl7getDataEt: 637| 197k| const uint16_t *getData(uint16_t norm16) const { 638| 197k| if(norm16>=minMaybeNo) { ------------------ | Branch (638:12): [True: 36, False: 197k] ------------------ 639| 36| norm16=norm16-minMaybeNo+limitNoNo; 640| 36| } 641| 197k| return extraData+(norm16>>OFFSET_SHIFT); 642| 197k| } _ZN6icu_7813ParsePositionD2Ev: 16| 42.6k|ParsePosition::~ParsePosition() {} _ZN6icu_7812PatternProps12isWhiteSpaceEi: 155| 90.1M|PatternProps::isWhiteSpace(UChar32 c) { 156| 90.1M| if(c<0) { ------------------ | Branch (156:8): [True: 3.31k, False: 90.1M] ------------------ 157| 3.31k| return false; 158| 90.1M| } else if(c<=0xff) { ------------------ | Branch (158:15): [True: 56.1M, False: 33.9M] ------------------ 159| 56.1M| return (latin1[c] >> 2) & 1; 160| 56.1M| } else if(0x200e<=c && c<=0x2029) { ------------------ | Branch (160:15): [True: 31.1M, False: 2.85M] | Branch (160:28): [True: 17.9k, False: 31.1M] ------------------ 161| 17.9k| return c<=0x200f || 0x2028<=c; ------------------ | Branch (161:16): [True: 1.69k, False: 16.2k] | Branch (161:29): [True: 498, False: 15.7k] ------------------ 162| 33.9M| } else { 163| 33.9M| return false; 164| 33.9M| } 165| 90.1M|} _ZN6icu_7812PatternProps14skipWhiteSpaceEPKDsi: 168| 33.4k|PatternProps::skipWhiteSpace(const char16_t *s, int32_t length) { 169| 35.1k| while(length>0 && isWhiteSpace(*s)) { ------------------ | Branch (169:11): [True: 33.8k, False: 1.22k] | Branch (169:23): [True: 1.65k, False: 32.2k] ------------------ 170| 1.65k| ++s; 171| 1.65k| --length; 172| 1.65k| } 173| 33.4k| return s; 174| 33.4k|} uprv_compareASCIIPropertyNames_78: 93| 4.05k|uprv_compareASCIIPropertyNames(const char *name1, const char *name2) { 94| 4.05k| int32_t rc, r1, r2; 95| | 96| 12.1k| for(;;) { 97| 12.1k| r1=getASCIIPropertyNameChar(name1); 98| 12.1k| r2=getASCIIPropertyNameChar(name2); 99| | 100| | /* If we reach the ends of both strings then they match */ 101| 12.1k| if(((r1|r2)&0xff)==0) { ------------------ | Branch (101:12): [True: 1.72k, False: 10.4k] ------------------ 102| 1.72k| return 0; 103| 1.72k| } 104| | 105| | /* Compare the lowercased characters */ 106| 10.4k| if(r1!=r2) { ------------------ | Branch (106:12): [True: 2.53k, False: 7.87k] ------------------ 107| 2.53k| rc=(r1&0xff)-(r2&0xff); 108| 2.53k| if(rc!=0) { ------------------ | Branch (108:16): [True: 2.33k, False: 204] ------------------ 109| 2.33k| return rc; 110| 2.33k| } 111| 2.53k| } 112| | 113| 8.08k| name1+=r1>>8; 114| 8.08k| name2+=r2>>8; 115| 8.08k| } 116| 4.05k|} _ZN6icu_7812PropNameData12findPropertyEi: 148| 29.6k|int32_t PropNameData::findProperty(int32_t property) { 149| 29.6k| int32_t i=1; // valueMaps index, initially after numRanges 150| 72.8k| for(int32_t numRanges=valueMaps[0]; numRanges>0; --numRanges) { ------------------ | Branch (150:41): [True: 72.8k, False: 0] ------------------ 151| | // Read and skip the start and limit of this range. 152| 72.8k| int32_t start=valueMaps[i]; 153| 72.8k| int32_t limit=valueMaps[i+1]; 154| 72.8k| i+=2; 155| 72.8k| if(property(c)); 235| 98.3k| } 236| 45.2k| return USTRINGTRIE_HAS_VALUE(result); ------------------ | | 86| 45.2k|#define USTRINGTRIE_HAS_VALUE(result) ((result)>=USTRINGTRIE_FINAL_VALUE) ------------------ 237| 52.1k|} _ZN6icu_7812PropNameData22getPropertyOrValueEnumEiPKc: 259| 52.1k|int32_t PropNameData::getPropertyOrValueEnum(int32_t bytesTrieOffset, const char *alias) { 260| 52.1k| BytesTrie trie(bytesTries+bytesTrieOffset); 261| 52.1k| if(containsName(trie, alias)) { ------------------ | Branch (261:8): [True: 36.0k, False: 16.0k] ------------------ 262| 36.0k| return trie.getValue(); 263| 36.0k| } else { 264| 16.0k| return UCHAR_INVALID_CODE; 265| 16.0k| } 266| 52.1k|} _ZN6icu_7812PropNameData15getPropertyEnumEPKc: 268| 22.4k|int32_t PropNameData::getPropertyEnum(const char *alias) { 269| 22.4k| return getPropertyOrValueEnum(0, alias); 270| 22.4k|} _ZN6icu_7812PropNameData20getPropertyValueEnumEiPKc: 272| 29.6k|int32_t PropNameData::getPropertyValueEnum(int32_t property, const char *alias) { 273| 29.6k| int32_t valueMapIndex=findProperty(property); 274| 29.6k| if(valueMapIndex==0) { ------------------ | Branch (274:8): [True: 0, False: 29.6k] ------------------ 275| 0| return UCHAR_INVALID_CODE; // Not a known property. 276| 0| } 277| 29.6k| valueMapIndex=valueMaps[valueMapIndex+1]; 278| 29.6k| if(valueMapIndex==0) { ------------------ | Branch (278:8): [True: 0, False: 29.6k] ------------------ 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| 29.6k| return getPropertyOrValueEnum(valueMaps[valueMapIndex], alias); 284| 29.6k|} u_getPropertyEnum_78: 301| 22.4k|u_getPropertyEnum(const char* alias) { 302| 22.4k| U_NAMESPACE_USE ------------------ | | 112| 22.4k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 303| 22.4k| return (UProperty)PropNameData::getPropertyEnum(alias); 304| 22.4k|} u_getPropertyValueEnum_78: 319| 29.6k| const char* alias) { 320| 29.6k| U_NAMESPACE_USE ------------------ | | 112| 29.6k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 321| 29.6k| return PropNameData::getPropertyValueEnum(property, alias); 322| 29.6k|} propname.cpp:_ZL24getASCIIPropertyNameCharPKc: 35| 24.2k|getASCIIPropertyNameChar(const char *name) { 36| 24.2k| int32_t i; 37| 24.2k| char c; 38| | 39| | /* Ignore delimiters '-', '_', and ASCII White_Space */ 40| 24.2k| for(i=0; 41| 27.7k| (c=name[i++])==0x2d || c==0x5f || ------------------ | Branch (41:9): [True: 448, False: 27.3k] | Branch (41:32): [True: 344, False: 26.9k] ------------------ 42| 27.7k| c==0x20 || (0x09<=c && c<=0x0d); ------------------ | Branch (42:9): [True: 466, False: 26.5k] | Branch (42:21): [True: 22.4k, False: 4.01k] | Branch (42:32): [True: 2.25k, False: 20.2k] ------------------ 43| 24.2k| ) {} 44| | 45| 24.2k| if(c!=0) { ------------------ | Branch (45:8): [True: 20.2k, False: 3.98k] ------------------ 46| 20.2k| return (i << 8) | static_cast(uprv_asciitolower(c)); ------------------ | | 1397| 20.2k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | ------------------ | | | | 123| 20.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 20.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 20.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 47| 20.2k| } else { 48| 3.98k| return i<<8; 49| 3.98k| } 50| 24.2k|} uprv_add32_overflow_78: 524| 1.51M|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| 1.51M| auto a64 = static_cast(a); 528| 1.51M| auto b64 = static_cast(b); 529| 1.51M| int64_t res64 = a64 + b64; 530| 1.51M| *res = static_cast(res64); 531| 1.51M| return res64 != *res; 532| 1.51M|} 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|} u_getDataDirectory_78: 1499| 2|u_getDataDirectory() { 1500| 2| umtx_initOnce(gDataDirInitOnce, &dataDirectoryInitFn); 1501| 2| return gDataDirectory; 1502| 2|} putil.cpp:_ZL19dataDirectoryInitFnv: 1424| 1|static void U_CALLCONV dataDirectoryInitFn() { 1425| | /* If we already have the directory, then return immediately. Will happen if user called 1426| | * u_setDataDirectory(). 1427| | */ 1428| 1| if (gDataDirectory) { ------------------ | Branch (1428:9): [True: 0, False: 1] ------------------ 1429| 0| return; 1430| 0| } 1431| | 1432| 1| const char *path = nullptr; 1433| |#if defined(ICU_DATA_DIR_PREFIX_ENV_VAR) 1434| | char datadir_path_buffer[PATH_MAX]; 1435| |#endif 1436| | 1437| | /* 1438| | When ICU_NO_USER_DATA_OVERRIDE is defined, users aren't allowed to 1439| | override ICU's data with the ICU_DATA environment variable. This prevents 1440| | problems where multiple custom copies of ICU's specific version of data 1441| | are installed on a system. Either the application must define the data 1442| | directory with u_setDataDirectory, define ICU_DATA_DIR when compiling 1443| | ICU, set the data with udata_setCommonData or trust that all of the 1444| | required data is contained in ICU's data library that contains 1445| | the entry point defined by U_ICUDATA_ENTRY_POINT. 1446| | 1447| | There may also be some platforms where environment variables 1448| | are not allowed. 1449| | */ 1450| 1|# if !defined(ICU_NO_USER_DATA_OVERRIDE) && !UCONFIG_NO_FILE_IO 1451| | /* First try to get the environment variable */ 1452| 1|# if U_PLATFORM_HAS_WINUWP_API == 0 // Windows UWP does not support getenv 1453| 1| path=getenv("ICU_DATA"); 1454| 1|# endif 1455| 1|# endif 1456| | 1457| | /* ICU_DATA_DIR may be set as a compile option. 1458| | * U_ICU_DATA_DEFAULT_DIR is provided and is set by ICU at compile time 1459| | * and is used only when data is built in archive mode eliminating the need 1460| | * for ICU_DATA_DIR to be set. U_ICU_DATA_DEFAULT_DIR is set to the installation 1461| | * directory of the data dat file. Users should use ICU_DATA_DIR if they want to 1462| | * set their own path. 1463| | */ 1464| |#if defined(ICU_DATA_DIR) || defined(U_ICU_DATA_DEFAULT_DIR) 1465| | if(path==nullptr || *path==0) { 1466| |# if defined(ICU_DATA_DIR_PREFIX_ENV_VAR) 1467| | const char *prefix = getenv(ICU_DATA_DIR_PREFIX_ENV_VAR); 1468| |# endif 1469| |# ifdef ICU_DATA_DIR 1470| | path=ICU_DATA_DIR; 1471| |# else 1472| | path=U_ICU_DATA_DEFAULT_DIR; 1473| |# endif 1474| |# if defined(ICU_DATA_DIR_PREFIX_ENV_VAR) 1475| | if (prefix != nullptr) { 1476| | snprintf(datadir_path_buffer, sizeof(datadir_path_buffer), "%s%s", prefix, path); 1477| | path=datadir_path_buffer; 1478| | } 1479| |# endif 1480| | } 1481| |#endif 1482| | 1483| |#if defined(ICU_DATA_DIR_WINDOWS) 1484| | char datadir_path_buffer[MAX_PATH]; 1485| | if (getIcuDataDirectoryUnderWindowsDirectory(datadir_path_buffer, UPRV_LENGTHOF(datadir_path_buffer))) { 1486| | path = datadir_path_buffer; 1487| | } 1488| |#endif 1489| | 1490| 1| if(path==nullptr) { ------------------ | Branch (1490:8): [True: 1, False: 0] ------------------ 1491| | /* It looks really bad, set it to something. */ 1492| 1| path = ""; 1493| 1| } 1494| | 1495| 1| u_setDataDirectory(path); ------------------ | | 347| 1|#define u_setDataDirectory U_ICU_ENTRY_POINT_RENAME(u_setDataDirectory) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1496| 1|} _ZN6icu_7810FileTracer9traceOpenEPKcS2_S2_: 140| 2| static void traceOpen(const char*, const char*, const char*) {} _ZN6icu_7821RuleCharacterIteratorC2ERKNS_13UnicodeStringEPKNS_11SymbolTableERNS_13ParsePositionE: 27| 10.6k| text(theText), 28| 10.6k| pos(thePos), 29| 10.6k| sym(theSym), 30| 10.6k| buf(nullptr), 31| 10.6k| bufPos(0) 32| 10.6k|{} _ZNK6icu_7821RuleCharacterIterator5atEndEv: 34| 44.3M|UBool RuleCharacterIterator::atEnd() const { 35| 44.3M| return buf == nullptr && pos.getIndex() == text.length(); ------------------ | Branch (35:12): [True: 44.3M, False: 0] | Branch (35:30): [True: 30.8k, False: 44.3M] ------------------ 36| 44.3M|} _ZN6icu_7821RuleCharacterIterator4nextEiRaR10UErrorCode: 38| 83.7M|UChar32 RuleCharacterIterator::next(int32_t options, UBool& isEscaped, UErrorCode& ec) { 39| 83.7M| if (U_FAILURE(ec)) return DONE; ------------------ | Branch (39:9): [True: 6.16k, False: 83.7M] ------------------ 40| | 41| 83.7M| UChar32 c = DONE; 42| 83.7M| isEscaped = false; 43| | 44| 83.8M| for (;;) { 45| 83.8M| c = _current(); 46| 83.8M| _advance(U16_LENGTH(c)); ------------------ | | 141| 83.8M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 83.7M, False: 37.9k] | | ------------------ ------------------ 47| | 48| 83.8M| if (c == SymbolTable::SYMBOL_REF && buf == nullptr && ------------------ | Branch (48:13): [True: 8.70k, False: 83.8M] | Branch (48:45): [True: 8.70k, False: 0] ------------------ 49| 83.8M| (options & PARSE_VARIABLES) != 0 && sym != nullptr) { ------------------ | Branch (49:13): [True: 8.70k, False: 0] | Branch (49:49): [True: 0, False: 8.70k] ------------------ 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| 83.8M| if ((options & SKIP_WHITESPACE) != 0 && PatternProps::isWhiteSpace(c)) { ------------------ | Branch (69:13): [True: 81.1M, False: 2.71M] | Branch (69:49): [True: 63.3k, False: 81.0M] ------------------ 70| 63.3k| continue; 71| 63.3k| } 72| | 73| 83.7M| if (c == 0x5C /*'\\'*/ && (options & PARSE_ESCAPES) != 0) { ------------------ | Branch (73:13): [True: 80.0k, False: 83.6M] | Branch (73:35): [True: 46.8k, False: 33.2k] ------------------ 74| 46.8k| UnicodeString tempEscape; 75| 46.8k| int32_t offset = 0; 76| 46.8k| c = lookahead(tempEscape, MAX_U_NOTATION_LEN).unescapeAt(offset); ------------------ | | 21| 46.8k|#define MAX_U_NOTATION_LEN 12 ------------------ 77| 46.8k| jumpahead(offset); 78| 46.8k| isEscaped = true; 79| 46.8k| if (c < 0) { ------------------ | Branch (79:17): [True: 362, False: 46.4k] ------------------ 80| 362| ec = U_MALFORMED_UNICODE_ESCAPE; 81| 362| return DONE; 82| 362| } 83| 46.8k| } 84| | 85| 83.7M| break; 86| 83.7M| } 87| | 88| 83.7M| return c; 89| 83.7M|} _ZNK6icu_7821RuleCharacterIterator6getPosERNS0_3PosE: 91| 70.9M|void RuleCharacterIterator::getPos(RuleCharacterIterator::Pos& p) const { 92| 70.9M| p.buf = buf; 93| 70.9M| p.pos = pos.getIndex(); 94| 70.9M| p.bufPos = bufPos; 95| 70.9M|} _ZN6icu_7821RuleCharacterIterator6setPosERKNS0_3PosE: 97| 36.9M|void RuleCharacterIterator::setPos(const RuleCharacterIterator::Pos& p) { 98| 36.9M| buf = p.buf; 99| 36.9M| pos.setIndex(p.pos); 100| 36.9M| bufPos = p.bufPos; 101| 36.9M|} _ZN6icu_7821RuleCharacterIterator11skipIgnoredEi: 103| 1.33M|void RuleCharacterIterator::skipIgnored(int32_t options) { 104| 1.33M| if ((options & SKIP_WHITESPACE) != 0) { ------------------ | Branch (104:9): [True: 1.33M, False: 0] ------------------ 105| 1.33M| for (;;) { 106| 1.33M| UChar32 a = _current(); 107| 1.33M| if (!PatternProps::isWhiteSpace(a)) break; ------------------ | Branch (107:17): [True: 1.33M, False: 4.15k] ------------------ 108| 4.15k| _advance(U16_LENGTH(a)); ------------------ | | 141| 4.15k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 4.15k, False: 0] | | ------------------ ------------------ 109| 4.15k| } 110| 1.33M| } 111| 1.33M|} _ZNK6icu_7821RuleCharacterIterator9lookaheadERNS_13UnicodeStringEi: 113| 78.8k|UnicodeString& RuleCharacterIterator::lookahead(UnicodeString& result, int32_t maxLookAhead) const { 114| 78.8k| if (maxLookAhead < 0) { ------------------ | Branch (114:9): [True: 32.0k, False: 46.8k] ------------------ 115| 32.0k| maxLookAhead = 0x7FFFFFFF; 116| 32.0k| } 117| 78.8k| if (buf != nullptr) { ------------------ | Branch (117:9): [True: 0, False: 78.8k] ------------------ 118| 0| buf->extract(bufPos, maxLookAhead, result); 119| 78.8k| } else { 120| 78.8k| text.extract(pos.getIndex(), maxLookAhead, result); 121| 78.8k| } 122| 78.8k| return result; 123| 78.8k|} _ZN6icu_7821RuleCharacterIterator9jumpaheadEi: 125| 76.7k|void RuleCharacterIterator::jumpahead(int32_t count) { 126| 76.7k| _advance(count); 127| 76.7k|} _ZNK6icu_7821RuleCharacterIterator8_currentEv: 137| 85.1M|UChar32 RuleCharacterIterator::_current() const { 138| 85.1M| if (buf != nullptr) { ------------------ | Branch (138:9): [True: 0, False: 85.1M] ------------------ 139| 0| return buf->char32At(bufPos); 140| 85.1M| } else { 141| 85.1M| int i = pos.getIndex(); 142| 85.1M| return (i < text.length()) ? text.char32At(i) : static_cast(DONE); ------------------ | Branch (142:16): [True: 85.1M, False: 7.07k] ------------------ 143| 85.1M| } 144| 85.1M|} _ZN6icu_7821RuleCharacterIterator8_advanceEi: 146| 83.9M|void RuleCharacterIterator::_advance(int32_t count) { 147| 83.9M| if (buf != nullptr) { ------------------ | Branch (147:9): [True: 0, False: 83.9M] ------------------ 148| 0| bufPos += count; 149| 0| if (bufPos == buf->length()) { ------------------ | Branch (149:13): [True: 0, False: 0] ------------------ 150| 0| buf = nullptr; 151| 0| } 152| 83.9M| } else { 153| 83.9M| pos.setIndex(pos.getIndex() + count); 154| 83.9M| if (pos.getIndex() > text.length()) { ------------------ | Branch (154:13): [True: 5.40k, False: 83.9M] ------------------ 155| 5.40k| pos.setIndex(text.length()); 156| 5.40k| } 157| 83.9M| } 158| 83.9M|} _ZNK6icu_7821RuleCharacterIterator10inVariableEv: 226| 1.55k|inline UBool RuleCharacterIterator::inVariable() const { 227| 1.55k| return buf != nullptr; 228| 1.55k|} _ZN6icu_7811StringPieceC2EPKc: 19| 14| : ptr_(str), length_((str == nullptr) ? 0 : static_cast(uprv_strlen(str))) { } ------------------ | | 37| 14|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 14|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (19:26): [True: 0, False: 14] ------------------ ubidi_addPropertyStarts_78: 60| 1|ubidi_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 61| 1| int32_t i, length; 62| 1| UChar32 c, start, limit; 63| | 64| 1| const uint8_t *jgArray; 65| 1| uint8_t prev, jg; 66| | 67| 1| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (67:8): [True: 0, False: 1] ------------------ 68| 0| return; 69| 0| } 70| | 71| | /* add the start code point of each same-value range of the trie */ 72| 1| utrie2_enum(&ubidi_props_singleton.trie, 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 73| | 74| | /* add the code points from the bidi mirroring table */ 75| 1| length=ubidi_props_singleton.indexes[UBIDI_IX_MIRROR_LENGTH]; 76| 41| for(i=0; iaddRange(sa->set, c, c+1); 79| 40| } 80| | 81| | /* add the code points from the Joining_Group array where the value changes */ 82| 1| start=ubidi_props_singleton.indexes[UBIDI_IX_JG_START]; 83| 1| limit=ubidi_props_singleton.indexes[UBIDI_IX_JG_LIMIT]; 84| 1| jgArray=ubidi_props_singleton.jgArray; 85| 2| for(;;) { 86| 2| prev=0; 87| 1.71k| while(startadd(sa->set, start); 91| 246| prev=jg; 92| 246| } 93| 1.71k| ++start; 94| 1.71k| } 95| 2| if(prev!=0) { ------------------ | Branch (95:12): [True: 1, False: 1] ------------------ 96| | /* add the limit code point if the last value was not 0 (it is now start==limit) */ 97| 1| sa->add(sa->set, limit); 98| 1| } 99| 2| if(limit==ubidi_props_singleton.indexes[UBIDI_IX_JG_LIMIT]) { ------------------ | Branch (99:12): [True: 1, False: 1] ------------------ 100| | /* switch to the second Joining_Group range */ 101| 1| start=ubidi_props_singleton.indexes[UBIDI_IX_JG_START2]; 102| 1| limit=ubidi_props_singleton.indexes[UBIDI_IX_JG_LIMIT2]; 103| 1| jgArray=ubidi_props_singleton.jgArray2; 104| 1| } else { 105| 1| break; 106| 1| } 107| 2| } 108| | 109| | /* add code points with hardcoded properties, plus the ones following them */ 110| | 111| | /* (none right now) */ 112| 1|} ubidi_getClass_78: 134| 1.17M|ubidi_getClass(UChar32 c) { 135| 1.17M| uint16_t props=UTRIE2_GET16(&ubidi_props_singleton.trie, c); ------------------ | | 360| 1.17M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 1.17M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 1.17M| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 666k, False: 510k] | | | | | | ------------------ | | | | | | 846| 1.17M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 666k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 666k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 56.9k] | | | | | | | | ------------------ | | | | | | | | 816| 56.9k| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 510k| (trie)->index, c) : \ | | | | | | 851| 510k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 453k] | | | | | | ------------------ | | | | | | 852| 453k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 453k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 453k] | | | | | | ------------------ | | | | | | 854| 453k| (trie)->highValueIndex : \ | | | | | | 855| 453k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 453k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 453k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 453k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 453k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 453k| <indexLength, (c)) | | ------------------ | | | | 871| 769k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 769k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 450k, False: 318k] | | | | | | ------------------ | | | | | | 846| 769k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 450k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 450k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 8.48k] | | | | | | | | ------------------ | | | | | | | | 816| 8.48k| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 318k| (trie)->index, c) : \ | | | | | | 851| 318k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 309k] | | | | | | ------------------ | | | | | | 852| 309k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 309k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 309k] | | | | | | ------------------ | | | | | | 854| 309k| (trie)->highValueIndex : \ | | | | | | 855| 309k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 309k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 309k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 309k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 309k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 309k| <>UBIDI_JT_SHIFT); ------------------ | | 114| 769k|#define UBIDI_JT_MASK 0x000000e0 ------------------ 199| 769k|} ubidi_getJoiningGroup_78: 202| 314k|ubidi_getJoiningGroup(UChar32 c) { 203| 314k| UChar32 start, limit; 204| | 205| 314k| start=ubidi_props_singleton.indexes[UBIDI_IX_JG_START]; 206| 314k| limit=ubidi_props_singleton.indexes[UBIDI_IX_JG_LIMIT]; 207| 314k| if(start<=c && c(context); 55| 1.98k| sa->add(sa->set, start); 56| 1.98k| return true; 57| 1.98k|} ucase_addPropertyStarts_78: 47| 2|ucase_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 48| 2| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (48:8): [True: 0, False: 2] ------------------ 49| 0| return; 50| 0| } 51| | 52| | /* add the start code point of each same-value range of the trie */ 53| 2| utrie2_enum(&ucase_props_singleton.trie, nullptr, _enumPropertyStartsRange, sa); ------------------ | | 1962| 2|#define utrie2_enum U_ICU_ENTRY_POINT_RENAME(utrie2_enum) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 54| | 55| | /* add code points with hardcoded properties, plus the ones following them */ 56| | 57| | /* (none right now, see comment below) */ 58| | 59| | /* 60| | * Omit code points with hardcoded specialcasing properties 61| | * because we do not build property UnicodeSets for them right now. 62| | */ 63| 2|} ucase_getTrie_78: 75| 1.86k|ucase_getTrie() { 76| 1.86k| return &ucase_props_singleton.trie; 77| 1.86k|} ucase_getTypeOrIgnorable_78: 680| 3.09k|ucase_getTypeOrIgnorable(UChar32 c) { 681| 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| <= 0); ------------------ | | 35| 6.19k|# define U_ASSERT(exp) (void)0 ------------------ 1156| 6.19k| UChar32 result=c; 1157| | // Reset the output pointer in case it was uninitialized. 1158| 6.19k| *pString=nullptr; 1159| 6.19k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 6.19k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 6.19k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 6.19k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 4.99k, False: 1.20k] | | | | | | ------------------ | | | | | | 846| 6.19k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 4.99k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 4.99k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 106] | | | | | | | | ------------------ | | | | | | | | 816| 106| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 1.20k| (trie)->index, c) : \ | | | | | | 851| 1.20k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 1.09k] | | | | | | ------------------ | | | | | | 852| 1.09k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 1.09k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 1.09k] | | | | | | ------------------ | | | | | | 854| 1.09k| (trie)->highValueIndex : \ | | | | | | 855| 1.09k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 1.09k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 1.09k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 1.09k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 1.09k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 1.09k| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 1.36k|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1163| 1.36k| } 1164| 5.42k| } else { 1165| 776| const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2; ------------------ | | 79| 776|#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 776|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 1166| 776| uint16_t excWord=*pe++; 1167| 776| int32_t full; 1168| | 1169| 776| pe2=pe; 1170| | 1171| 776| if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) { ------------------ | | 444| 776|#define UCASE_EXC_CONDITIONAL_SPECIAL 0x4000 ------------------ | Branch (1171:12): [True: 20, False: 756] ------------------ 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| 20| if( loc==UCASE_LOC_LITHUANIAN && ------------------ | Branch (1180:17): [True: 0, False: 20] ------------------ 1181| | /* base characters, find accents above */ 1182| 20| (((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| 20| ) { 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| 20| } else if(loc==UCASE_LOC_TURKISH && c==0x130) { ------------------ | Branch (1226:23): [True: 0, False: 20] | 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| 20| } else if(loc==UCASE_LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, context)) { ------------------ | Branch (1235:23): [True: 0, False: 20] | 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| 20| } else if(loc==UCASE_LOC_TURKISH && c==0x49 && !isFollowedByDotAbove(iter, context)) { ------------------ | Branch (1244:23): [True: 0, False: 20] | 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| 20| } else if(c==0x130) { ------------------ | Branch (1252:23): [True: 2, False: 18] ------------------ 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| 2| *pString=iDot; 1259| 2| return 2; 1260| 18| } else if( c==0x3a3 && ------------------ | Branch (1260:25): [True: 2, False: 16] ------------------ 1261| 18| !isFollowedByCasedLetter(iter, context, 1) && ------------------ | Branch (1261:25): [True: 2, False: 0] ------------------ 1262| 18| isFollowedByCasedLetter(iter, context, -1) /* -1=preceded */ ------------------ | Branch (1262:25): [True: 0, False: 2] ------------------ 1263| 18| ) { 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| 18| } else { 1272| | /* no known conditional special case mapping, use a normal mapping */ 1273| 18| } 1274| 756| } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) { ------------------ | | 101| 756|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 204, False: 552] | | ------------------ ------------------ 1275| 204| GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full); ------------------ | | 113| 204|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 204|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 204| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 204|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 204, False: 0] | | ------------------ | | 115| 204| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 204|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 204| (value)=*pExc16; \ | | 117| 204| } 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| 204|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 204|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1276| 204| full&=UCASE_FULL_LOWER; ------------------ | | 448| 204|#define UCASE_FULL_LOWER 0xf ------------------ 1277| 204| if(full!=0) { ------------------ | Branch (1277:16): [True: 0, False: 204] ------------------ 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| 204| } 1285| | 1286| 774| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 101| 1.54k|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 250, False: 524] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 374| 250|#define UCASE_IS_UPPER_OR_TITLE(props) ((props)&2) | | ------------------ | | | Branch (374:40): [True: 138, False: 112] | | ------------------ ------------------ 1287| 138| int32_t delta; 1288| 138| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 138|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 138|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 138| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 138|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 138, False: 0] | | ------------------ | | 115| 138| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 138|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 138| (value)=*pExc16; \ | | 117| 138| } 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| 138|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 138|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1289| 138| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1289:20): [True: 28, False: 110] ------------------ 1290| 138| } 1291| 636| if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) { ------------------ | | 101| 636|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 62, False: 574] | | ------------------ ------------------ 1292| 62| GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result); ------------------ | | 113| 62|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 62|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 62| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 62|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 62, False: 0] | | ------------------ | | 115| 62| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 62|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 62| (value)=*pExc16; \ | | 117| 62| } 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| 62|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 62|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1293| 62| } 1294| 636| } 1295| | 1296| 6.05k| return (result==c) ? ~result : result; ------------------ | Branch (1296:12): [True: 4.73k, False: 1.32k] ------------------ 1297| 6.19k|} ucase_toFullUpper_78: 1415| 5.46k| int32_t caseLocale) { 1416| 5.46k| return toUpperOrTitle(c, iter, context, pString, caseLocale, true); 1417| 5.46k|} ucase_toFullTitle_78: 1423| 4.54k| int32_t caseLocale) { 1424| 4.54k| return toUpperOrTitle(c, iter, context, pString, caseLocale, false); 1425| 4.54k|} ucase_toFullFolding_78: 1540| 4.24k| uint32_t options) { 1541| | // The sign of the result has meaning, input must be non-negative so that it can be returned as is. 1542| 4.24k| U_ASSERT(c >= 0); ------------------ | | 35| 4.24k|# define U_ASSERT(exp) (void)0 ------------------ 1543| 4.24k| UChar32 result=c; 1544| | // Reset the output pointer in case it was uninitialized. 1545| 4.24k| *pString=nullptr; 1546| 4.24k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 4.24k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 4.24k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 4.24k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 3.35k, False: 892] | | | | | | ------------------ | | | | | | 846| 4.24k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 3.35k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 3.35k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 68] | | | | | | | | ------------------ | | | | | | | | 816| 68| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 892| (trie)->index, c) : \ | | | | | | 851| 892| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 824] | | | | | | ------------------ | | | | | | 852| 824| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 824| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 824] | | | | | | ------------------ | | | | | | 854| 824| (trie)->highValueIndex : \ | | | | | | 855| 824| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 824| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 824| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 824| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 824| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 824| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 459|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1550| 459| } 1551| 3.73k| } else { 1552| 508| const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2; ------------------ | | 79| 508|#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 508|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 1553| 508| uint16_t excWord=*pe++; 1554| 508| int32_t full, idx; 1555| | 1556| 508| pe2=pe; 1557| | 1558| 508| if(excWord&UCASE_EXC_CONDITIONAL_FOLD) { ------------------ | | 445| 508|#define UCASE_EXC_CONDITIONAL_FOLD 0x8000 ------------------ | Branch (1558:12): [True: 1, False: 507] ------------------ 1559| | /* use hardcoded conditions and mappings */ 1560| 1| if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) { ------------------ | | 83| 1|#define _FOLD_CASE_OPTIONS_MASK 7 ------------------ if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) { ------------------ | | 22| 1|#define U_FOLD_CASE_DEFAULT 0 ------------------ | Branch (1560:16): [True: 1, False: 0] ------------------ 1561| | /* default mappings */ 1562| 1| if(c==0x49) { ------------------ | Branch (1562:20): [True: 1, False: 0] ------------------ 1563| | /* 0049; C; 0069; # LATIN CAPITAL LETTER I */ 1564| 1| return 0x69; 1565| 1| } else if(c==0x130) { ------------------ | Branch (1565:27): [True: 0, False: 0] ------------------ 1566| | /* 0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE */ 1567| 0| *pString=iDot; 1568| 0| return 2; 1569| 0| } 1570| 1| } else { 1571| | /* Turkic mappings */ 1572| 0| if(c==0x49) { ------------------ | Branch (1572:20): [True: 0, False: 0] ------------------ 1573| | /* 0049; T; 0131; # LATIN CAPITAL LETTER I */ 1574| 0| return 0x131; 1575| 0| } else if(c==0x130) { ------------------ | Branch (1575:27): [True: 0, False: 0] ------------------ 1576| | /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */ 1577| 0| return 0x69; 1578| 0| } 1579| 0| } 1580| 507| } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) { ------------------ | | 101| 507|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 17, False: 490] | | ------------------ ------------------ 1581| 17| GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full); ------------------ | | 113| 17|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 17|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 17| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 17|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 17, False: 0] | | ------------------ | | 115| 17| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 17|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 17| (value)=*pExc16; \ | | 117| 17| } 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| 17|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 17|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1582| | 1583| | /* start of full case mapping strings */ 1584| 17| ++pe; 1585| | 1586| | /* skip the lowercase result string */ 1587| 17| pe+=full&UCASE_FULL_LOWER; ------------------ | | 448| 17|#define UCASE_FULL_LOWER 0xf ------------------ 1588| 17| full=(full>>4)&0xf; 1589| | 1590| 17| if(full!=0) { ------------------ | Branch (1590:16): [True: 17, False: 0] ------------------ 1591| | /* set the output pointer to the result string */ 1592| 17| *pString=reinterpret_cast(pe); 1593| | 1594| | /* return the string length */ 1595| 17| return full; 1596| 17| } 1597| 17| } 1598| | 1599| 490| if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) { ------------------ | Branch (1599:12): [True: 2, False: 488] ------------------ 1600| 2| return ~c; 1601| 2| } 1602| 488| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 101| 976|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 61, False: 427] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 374| 61|#define UCASE_IS_UPPER_OR_TITLE(props) ((props)&2) | | ------------------ | | | Branch (374:40): [True: 32, False: 29] | | ------------------ ------------------ 1603| 32| int32_t delta; 1604| 32| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 32|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 32|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 32| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 32|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 32, False: 0] | | ------------------ | | 115| 32| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 32|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 32| (value)=*pExc16; \ | | 117| 32| } 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| 32|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 32|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1605| 32| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1605:20): [True: 8, False: 24] ------------------ 1606| 32| } 1607| 456| if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) { ------------------ | | 101| 456|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 170, False: 286] | | ------------------ ------------------ 1608| 170| idx=UCASE_EXC_FOLD; 1609| 286| } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) { ------------------ | | 101| 286|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 76, False: 210] | | ------------------ ------------------ 1610| 76| idx=UCASE_EXC_LOWER; 1611| 210| } else { 1612| 210| return ~c; 1613| 210| } 1614| 456| GET_SLOT_VALUE(excWord, idx, pe2, result); ------------------ | | 113| 246|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 246|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 246| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 246|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 246, False: 0] | | ------------------ | | 115| 246| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 246|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 246| (value)=*pExc16; \ | | 117| 246| } 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| 456|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 456|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1615| 246| } 1616| | 1617| 3.98k| return (result==c) ? ~result : result; ------------------ | Branch (1617:12): [True: 3.32k, False: 657] ------------------ 1618| 4.24k|} ucase_hasBinaryProperty_78: 1659| 18.5k|ucase_hasBinaryProperty(UChar32 c, UProperty which) { 1660| | /* case mapping properties */ 1661| 18.5k| const char16_t *resultString; 1662| 18.5k| switch(which) { 1663| 0| case UCHAR_LOWERCASE: ------------------ | Branch (1663:5): [True: 0, False: 18.5k] ------------------ 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: 18.5k] ------------------ 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: 15.4k] ------------------ 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: 18.5k] ------------------ 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: 18.5k] ------------------ 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: 15.4k] ------------------ 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: 15.4k] ------------------ 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| 3.09k| case UCHAR_CHANGES_WHEN_UPPERCASED: ------------------ | Branch (1689:5): [True: 3.09k, False: 15.4k] ------------------ 1690| 3.09k| return (UBool)(ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 583| 3.09k|#define ucase_toFullUpper U_ICU_ENTRY_POINT_RENAME(ucase_toFullUpper) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1691| 3.09k| case UCHAR_CHANGES_WHEN_TITLECASED: ------------------ | Branch (1691:5): [True: 3.09k, False: 15.4k] ------------------ 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| 3.09k| case UCHAR_CHANGES_WHEN_CASEMAPPED: ------------------ | Branch (1694:5): [True: 3.09k, False: 15.4k] ------------------ 1695| 3.09k| return (UBool)( 1696| 3.09k| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1696:13): [True: 733, False: 2.36k] ------------------ 1697| 3.09k| ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 || ------------------ | | 583| 2.36k|#define ucase_toFullUpper U_ICU_ENTRY_POINT_RENAME(ucase_toFullUpper) | | ------------------ | | | | 123| 2.36k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.36k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.36k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1697:13): [True: 924, False: 1.44k] ------------------ 1698| 3.09k| ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 582| 1.44k|#define ucase_toFullTitle U_ICU_ENTRY_POINT_RENAME(ucase_toFullTitle) | | ------------------ | | | | 123| 1.44k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.44k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.44k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1698:13): [True: 0, False: 1.44k] ------------------ 1699| 0| default: ------------------ | Branch (1699:5): [True: 0, False: 18.5k] ------------------ 1700| 0| return false; 1701| 18.5k| } 1702| 18.5k|} ucase.cpp:_ZL24_enumPropertyStartsRangePKviij: 39| 6.19k|_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 /*end*/, uint32_t /*value*/) { 40| | /* add the start code point to the USet */ 41| 6.19k| const USetAdder* sa = static_cast(context); 42| 6.19k| sa->add(sa->set, start); 43| 6.19k| return true; 44| 6.19k|} 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| 4|isFollowedByCasedLetter(UCaseContextIterator *iter, void *context, int8_t dir) { 1001| 4| UChar32 c; 1002| | 1003| 4| if(iter==nullptr) { ------------------ | Branch (1003:8): [True: 4, False: 0] ------------------ 1004| 4| return false; 1005| 4| } 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| 10.0k| UBool upperNotTitle) { 1306| | // The sign of the result has meaning, input must be non-negative so that it can be returned as is. 1307| 10.0k| U_ASSERT(c >= 0); ------------------ | | 35| 10.0k|# define U_ASSERT(exp) (void)0 ------------------ 1308| 10.0k| UChar32 result=c; 1309| | // Reset the output pointer in case it was uninitialized. 1310| 10.0k| *pString=nullptr; 1311| 10.0k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 10.0k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 10.0k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 10.0k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 7.65k, False: 2.35k] | | | | | | ------------------ | | | | | | 846| 10.0k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 7.65k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 7.65k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 197] | | | | | | | | ------------------ | | | | | | | | 816| 197| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 2.35k| (trie)->index, c) : \ | | | | | | 851| 2.35k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 2.15k] | | | | | | ------------------ | | | | | | 852| 2.15k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 2.15k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 2.15k] | | | | | | ------------------ | | | | | | 854| 2.15k| (trie)->highValueIndex : \ | | | | | | 855| 2.15k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 2.15k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 2.15k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 2.15k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 2.15k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 2.15k| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 2.53k|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1315| 2.53k| } 1316| 8.94k| } else { 1317| 1.06k| const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2; ------------------ | | 79| 1.06k|#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 1.06k|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 1318| 1.06k| uint16_t excWord=*pe++; 1319| 1.06k| int32_t full, idx; 1320| | 1321| 1.06k| pe2=pe; 1322| | 1323| 1.06k| if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) { ------------------ | | 444| 1.06k|#define UCASE_EXC_CONDITIONAL_SPECIAL 0x4000 ------------------ | Branch (1323:12): [True: 24, False: 1.04k] ------------------ 1324| | /* use hardcoded conditions and mappings */ 1325| 24| if(loc==UCASE_LOC_TURKISH && c==0x69) { ------------------ | Branch (1325:16): [True: 0, False: 24] | 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| 24| } else if(loc==UCASE_LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, context)) { ------------------ | Branch (1338:23): [True: 0, False: 24] | 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| 24| } else if(c==0x0587) { ------------------ | Branch (1349:23): [True: 3, False: 21] ------------------ 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| 3| if(loc==UCASE_LOC_ARMENIAN) { ------------------ | Branch (1354:20): [True: 0, False: 3] ------------------ 1355| 0| *pString=upperNotTitle ? u"ԵՎ" : u"Եվ"; ------------------ | Branch (1355:30): [True: 0, False: 0] ------------------ 1356| 3| } else { 1357| 3| *pString=upperNotTitle ? u"ԵՒ" : u"Եւ"; ------------------ | Branch (1357:30): [True: 2, False: 1] ------------------ 1358| 3| } 1359| 3| return 2; 1360| 21| } else { 1361| | /* no known conditional special case mapping, use a normal mapping */ 1362| 21| } 1363| 1.04k| } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) { ------------------ | | 101| 1.04k|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 278, False: 762] | | ------------------ ------------------ 1364| 278| GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full); ------------------ | | 113| 278|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 278|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 278| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 278|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 278, False: 0] | | ------------------ | | 115| 278| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 278|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 278| (value)=*pExc16; \ | | 117| 278| } 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| 278|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 278|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1365| | 1366| | /* start of full case mapping strings */ 1367| 278| ++pe; 1368| | 1369| | /* skip the lowercase and case-folding result strings */ 1370| 278| pe+=full&UCASE_FULL_LOWER; ------------------ | | 448| 278|#define UCASE_FULL_LOWER 0xf ------------------ 1371| 278| full>>=4; 1372| 278| pe+=full&0xf; 1373| 278| full>>=4; 1374| | 1375| 278| if(upperNotTitle) { ------------------ | Branch (1375:16): [True: 176, False: 102] ------------------ 1376| 176| full&=0xf; 1377| 176| } else { 1378| | /* skip the uppercase result string */ 1379| 102| pe+=full&0xf; 1380| 102| full=(full>>4)&0xf; 1381| 102| } 1382| | 1383| 278| if(full!=0) { ------------------ | Branch (1383:16): [True: 222, False: 56] ------------------ 1384| | /* set the output pointer to the result string */ 1385| 222| *pString=reinterpret_cast(pe); 1386| | 1387| | /* return the string length */ 1388| 222| return full; 1389| 222| } 1390| 278| } 1391| | 1392| 839| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) { ------------------ | | 101| 1.67k|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 227, False: 612] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) { ------------------ | | 371| 227|#define UCASE_GET_TYPE(props) ((props)&UCASE_TYPE_MASK) | | ------------------ | | | | 363| 227|#define UCASE_TYPE_MASK 3 | | ------------------ ------------------ | Branch (1392:50): [True: 114, False: 113] ------------------ 1393| 114| int32_t delta; 1394| 114| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 114|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 114|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 114| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 114|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 114, False: 0] | | ------------------ | | 115| 114| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 114|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 114| (value)=*pExc16; \ | | 117| 114| } 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| 114|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 114|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1395| 114| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1395:20): [True: 93, False: 21] ------------------ 1396| 114| } 1397| 725| if(!upperNotTitle && HAS_SLOT(excWord, UCASE_EXC_TITLE)) { ------------------ | | 101| 285|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 58, False: 227] | | ------------------ ------------------ | Branch (1397:12): [True: 285, False: 440] ------------------ 1398| 58| idx=UCASE_EXC_TITLE; 1399| 667| } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) { ------------------ | | 101| 667|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 500, False: 167] | | ------------------ ------------------ 1400| | /* here, titlecase is same as uppercase */ 1401| 500| idx=UCASE_EXC_UPPER; 1402| 500| } else { 1403| 167| return ~c; 1404| 167| } 1405| 725| GET_SLOT_VALUE(excWord, idx, pe2, result); ------------------ | | 113| 558|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 558|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 558| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 558|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 558, False: 0] | | ------------------ | | 115| 558| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 558|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 558| (value)=*pExc16; \ | | 117| 558| } 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| 725|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 725|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1406| 558| } 1407| | 1408| 9.50k| return (result==c) ? ~result : result; ------------------ | Branch (1408:12): [True: 7.07k, False: 2.42k] ------------------ 1409| 10.0k|} u_charType_78: 50| 41.6M|u_charType(UChar32 c) { 51| 41.6M| uint32_t props; 52| 41.6M| GET_PROPS(c, props); ------------------ | | 44| 41.6M|#define GET_PROPS(c, result) ((result)=UTRIE2_GET16(&propsTrie, c)) | | ------------------ | | | | 360| 41.6M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | | | ------------------ | | | | | | 871| 41.6M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 41.6M| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 24.4M, False: 17.1M] | | | | | | | | ------------------ | | | | | | | | 846| 41.6M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 24.4M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 24.4M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 6.94k, False: 1.24M] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 1.25M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 17.1M| (trie)->index, c) : \ | | | | | | | | 851| 17.1M| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 15.8M] | | | | | | | | ------------------ | | | | | | | | 852| 15.8M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 15.8M| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 15.8M] | | | | | | | | ------------------ | | | | | | | | 854| 15.8M| (trie)->highValueIndex : \ | | | | | | | | 855| 15.8M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 15.8M| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 15.8M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 15.8M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 15.8M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 15.8M| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 28.6M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 28.6M| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 16.8M, False: 11.7M] | | | | | | | | ------------------ | | | | | | | | 846| 28.6M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 16.8M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 16.8M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 4.76k, False: 857k] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 862k| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 11.7M| (trie)->index, c) : \ | | | | | | | | 851| 11.7M| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 10.9M] | | | | | | | | ------------------ | | | | | | | | 852| 10.9M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 10.9M| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 10.9M] | | | | | | | | ------------------ | | | | | | | | 854| 10.9M| (trie)->highValueIndex : \ | | | | | | | | 855| 10.9M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 10.9M| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 10.9M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 10.9M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 10.9M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 10.9M| <>UPROPS_NUMERIC_TYPE_VALUE_SHIFT) ------------------ 361| | 362| 28.6M| if(ntv==UPROPS_NTV_NONE) { ------------------ | Branch (362:8): [True: 19.2M, False: 9.34M] ------------------ 363| 19.2M| return U_NO_NUMERIC_VALUE; ------------------ | | 3134| 19.2M|#define U_NO_NUMERIC_VALUE ((double)-123456789.) ------------------ 364| 19.2M| } else if(ntv>4)-12; 376| 490k| int32_t denominator=(ntv&0xf)+1; 377| 490k| return (double)numerator/denominator; 378| 991k| } else if(ntv>5)-14; 382| 905k| int32_t exp=(ntv&0x1f)+2; 383| 905k| numValue=mant; 384| | 385| | /* multiply by 10^exp without math.h */ 386| 1.30M| while(exp>=4) { ------------------ | Branch (386:15): [True: 395k, False: 905k] ------------------ 387| 395k| numValue*=10000.; 388| 395k| exp-=4; 389| 395k| } 390| 905k| switch(exp) { 391| 285k| case 3: ------------------ | Branch (391:9): [True: 285k, False: 619k] ------------------ 392| 285k| numValue*=1000.; 393| 285k| break; 394| 295k| case 2: ------------------ | Branch (394:9): [True: 295k, False: 610k] ------------------ 395| 295k| numValue*=100.; 396| 295k| break; 397| 71.4k| case 1: ------------------ | Branch (397:9): [True: 71.4k, False: 834k] ------------------ 398| 71.4k| numValue*=10.; 399| 71.4k| break; 400| 252k| case 0: ------------------ | Branch (400:9): [True: 252k, False: 652k] ------------------ 401| 252k| default: ------------------ | Branch (401:9): [True: 0, False: 905k] ------------------ 402| 252k| break; 403| 905k| } 404| | 405| 905k| return numValue; 406| 905k| } else if(ntv>2)-0xbf; 409| 9.53k| int32_t exp=(ntv&3)+1; 410| | 411| 9.53k| switch(exp) { 412| 0| case 4: ------------------ | Branch (412:9): [True: 0, False: 9.53k] ------------------ 413| 0| numValue*=60*60*60*60; 414| 0| break; 415| 9.53k| case 3: ------------------ | Branch (415:9): [True: 9.53k, False: 0] ------------------ 416| 9.53k| numValue*=60*60*60; 417| 9.53k| break; 418| 0| case 2: ------------------ | Branch (418:9): [True: 0, False: 9.53k] ------------------ 419| 0| numValue*=60*60; 420| 0| break; 421| 0| case 1: ------------------ | Branch (421:9): [True: 0, False: 9.53k] ------------------ 422| 0| numValue*=60; 423| 0| break; 424| 0| case 0: ------------------ | Branch (424:9): [True: 0, False: 9.53k] ------------------ 425| 0| default: ------------------ | Branch (425:9): [True: 0, False: 9.53k] ------------------ 426| 0| break; 427| 9.53k| } 428| | 429| 9.53k| return numValue; 430| 76.2k| } else if(ntv>2); 435| 61.9k| return (double)numerator/denominator; 436| 61.9k| } else if(ntv>2); 441| 14.2k| return (double)numerator/denominator; 442| 14.2k| } else { 443| | /* reserved */ 444| 0| return U_NO_NUMERIC_VALUE; ------------------ | | 3134| 0|#define U_NO_NUMERIC_VALUE ((double)-123456789.) ------------------ 445| 0| } 446| 28.6M|} u_getUnicodeProperties_78: 499| 22.2M|u_getUnicodeProperties(UChar32 c, int32_t column) { 500| 22.2M| U_ASSERT(column>=0); ------------------ | | 35| 22.2M|# define U_ASSERT(exp) (void)0 ------------------ 501| 22.2M| if(column>=propsVectorsColumns) { ------------------ | Branch (501:8): [True: 0, False: 22.2M] ------------------ 502| 0| return 0; 503| 22.2M| } else { 504| 22.2M| uint16_t vecIndex=UTRIE2_GET16(&propsVectorsTrie, c); ------------------ | | 360| 22.2M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 22.2M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 22.2M| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 14.4M, False: 7.81M] | | | | | | ------------------ | | | | | | 846| 22.2M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 14.4M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 14.4M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 2.58k, False: 1.58M] | | | | | | | | ------------------ | | | | | | | | 816| 1.59M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 7.81M| (trie)->index, c) : \ | | | | | | 851| 7.81M| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 6.22M] | | | | | | ------------------ | | | | | | 852| 6.22M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 6.22M| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 6.22M] | | | | | | ------------------ | | | | | | 854| 6.22M| (trie)->highValueIndex : \ | | | | | | 855| 6.22M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 6.22M| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 6.22M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 6.22M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 6.22M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 6.22M| <0x10ffff) { ------------------ | Branch (538:8): [True: 0, False: 3.55M] ------------------ 539| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 540| 0| return USCRIPT_INVALID_CODE; 541| 0| } 542| 3.55M| uint32_t scriptX=u_getUnicodeProperties(c, 0)&UPROPS_SCRIPT_X_MASK; ------------------ | | 288| 3.55M|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 3.55M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.55M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.55M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 543| 3.55M| uint32_t codeOrIndex=scriptX&UPROPS_MAX_SCRIPT; 544| 3.55M| if(scriptX=UPROPS_SCRIPT_X_WITH_OTHER) { ------------------ | Branch (564:8): [True: 74.4k, False: 479k] ------------------ 565| 74.4k| scx=scriptExtensions+scx[1]; 566| 74.4k| } 567| 554k| uint32_t sc32=sc; 568| 554k| if(sc32>0x7fff) { ------------------ | Branch (568:8): [True: 0, False: 554k] ------------------ 569| | /* Guard against bogus input that would make us go past the Script_Extensions terminator. */ 570| 0| return false; 571| 0| } 572| 1.70M| while(sc32>*scx) { ------------------ | Branch (572:11): [True: 1.14M, False: 554k] ------------------ 573| 1.14M| ++scx; 574| 1.14M| } 575| 554k| return sc32==(*scx&0x7fff); 576| 554k|} uchar_addPropertyStarts_78: 647| 1|uchar_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 648| 1| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (648:8): [True: 0, False: 1] ------------------ 649| 0| return; 650| 0| } 651| | 652| | /* add the start code point of each same-value range of the main trie */ 653| 1| utrie2_enum(&propsTrie, 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 654| | 655| | /* add code points with hardcoded properties, plus the ones following them */ 656| | 657| | /* add for u_isblank() */ 658| 1| USET_ADD_CP_AND_NEXT(sa, TAB); ------------------ | | 644| 1|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(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|} ucln_common_registerCleanup_78: 67| 25|{ 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| 25| U_ASSERT(UCLN_COMMON_START < type && type < UCLN_COMMON_COUNT); ------------------ | | 35| 25|# define U_ASSERT(exp) (void)0 ------------------ 79| 25| if (type == UCLN_COMMON_MUTEX) { ------------------ | Branch (79:9): [True: 1, False: 24] ------------------ 80| 1| gCommonCleanupFunctions[type] = func; 81| 24| } else if (UCLN_COMMON_START < type && type < UCLN_COMMON_COUNT) { ------------------ | Branch (81:16): [True: 24, False: 0] | Branch (81:44): [True: 24, False: 0] ------------------ 82| 24| icu::Mutex m; // See ticket 10295 for discussion. 83| 24| gCommonCleanupFunctions[type] = func; 84| 24| } 85| |#if !UCLN_NO_AUTO_CLEANUP && (defined(UCLN_AUTO_ATEXIT) || defined(UCLN_AUTO_LOCAL)) 86| | ucln_registerAutomaticCleanup(); 87| |#endif 88| 25|} udata_getHeaderSize_78: 36| 3|udata_getHeaderSize(const DataHeader *udh) { 37| 3| if(udh==nullptr) { ------------------ | Branch (37:8): [True: 0, False: 3] ------------------ 38| 0| return 0; 39| 3| } else if(udh->info.isBigEndian==U_IS_BIG_ENDIAN) { ------------------ | | 353| 3|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (39:15): [True: 3, False: 0] ------------------ 40| | /* same endianness */ 41| 3| return udh->dataHeader.headerSize; 42| 3| } else { 43| | /* opposite endianness */ 44| 0| uint16_t x=udh->dataHeader.headerSize; 45| 0| return (uint16_t)((x<<8)|(x>>8)); 46| 0| } 47| 3|} 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| 2| UErrorCode *pErrorCode) { 230| 2| (void)pErrorCode; 231| 2| const UDataOffsetTOC *toc = (UDataOffsetTOC *)pData->toc; 232| 2| if(toc!=nullptr) { ------------------ | Branch (232:8): [True: 2, False: 0] ------------------ 233| 2| const char *base=(const char *)toc; 234| 2| 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| 2| number=offsetTOCPrefixBinarySearch(tocEntryName, base, toc->entry, count); 244| 2| if(number>=0) { ------------------ | Branch (244:12): [True: 2, False: 0] ------------------ 245| | /* found it */ 246| 2| const UDataOffsetTOCEntry *entry=toc->entry+number; 247| |#ifdef UDATA_DEBUG 248| | fprintf(stderr, "%s: Found.\n", tocEntryName); 249| |#endif 250| 2| if((number+1) < count) { ------------------ | Branch (250:16): [True: 2, False: 0] ------------------ 251| 2| *pLength = (int32_t)(entry[1].dataOffset - entry->dataOffset); 252| 2| } else { 253| 0| *pLength = -1; 254| 0| } 255| 2| return (const DataHeader *)(base+entry->dataOffset); 256| 2| } else { 257| |#ifdef UDATA_DEBUG 258| | fprintf(stderr, "%s: Not found.\n", tocEntryName); 259| |#endif 260| 0| return nullptr; 261| 0| } 262| 2| } else { 263| |#ifdef UDATA_DEBUG 264| | fprintf(stderr, "returning header\n"); 265| |#endif 266| | 267| 0| return pData->pHeader; 268| 0| } 269| 2|} ucmndata.cpp:_ZL27offsetTOCPrefixBinarySearchPKcS0_PK19UDataOffsetTOCEntryi: 125| 2| const UDataOffsetTOCEntry *toc, int32_t count) { 126| 2| int32_t start=0; 127| 2| 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| 2| int32_t startPrefixLength=0; 134| 2| int32_t limitPrefixLength=0; 135| 2| if(count==0) { ------------------ | Branch (135:8): [True: 0, False: 2] ------------------ 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| 2| if(0==strcmpAfterPrefix(s, names+toc[0].nameOffset, &startPrefixLength)) { ------------------ | Branch (144:8): [True: 0, False: 2] ------------------ 145| 0| return 0; 146| 0| } 147| 2| ++start; 148| 2| --limit; 149| 2| if(0==strcmpAfterPrefix(s, names+toc[limit].nameOffset, &limitPrefixLength)) { ------------------ | Branch (149:8): [True: 0, False: 2] ------------------ 150| 0| return limit; 151| 0| } 152| 23| while(start(*s1++); 112| 94| int32_t c2 = static_cast(*s2++); 113| 94| cmp=c1-c2; 114| 94| if(cmp!=0 || c1==0) { /* different or done */ ------------------ | Branch (114:12): [True: 25, False: 69] | Branch (114:22): [True: 2, False: 67] ------------------ 115| 27| break; 116| 27| } 117| 67| ++pl; /* increment shared same-prefix length */ 118| 67| } 119| 27| *pPrefixLength=pl; 120| 27| return cmp; 121| 27|} ucptrie_openFromBinary_78: 24| 3| UErrorCode *pErrorCode) { 25| 3| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (25:9): [True: 0, False: 3] ------------------ 26| 0| return nullptr; 27| 0| } 28| | 29| 3| if (length <= 0 || (U_POINTER_MASK_LSB(data, 3) != 0) || ------------------ | | 123| 3|#define U_POINTER_MASK_LSB(ptr, mask) ((uintptr_t)(ptr) & (mask)) ------------------ | Branch (29:9): [True: 0, False: 3] | Branch (29:24): [True: 0, False: 3] ------------------ 30| 3| type < UCPTRIE_TYPE_ANY || UCPTRIE_TYPE_SMALL < type || ------------------ | Branch (30:13): [True: 0, False: 3] | Branch (30:40): [True: 0, False: 3] ------------------ 31| 3| valueWidth < UCPTRIE_VALUE_BITS_ANY || UCPTRIE_VALUE_BITS_8 < valueWidth) { ------------------ | Branch (31:13): [True: 0, False: 3] | Branch (31:52): [True: 0, False: 3] ------------------ 32| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 33| 0| return nullptr; 34| 0| } 35| | 36| | // Enough data for a trie header? 37| 3| if (length < (int32_t)sizeof(UCPTrieHeader)) { ------------------ | Branch (37:9): [True: 0, False: 3] ------------------ 38| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 39| 0| return nullptr; 40| 0| } 41| | 42| | // Check the signature. 43| 3| const UCPTrieHeader *header = (const UCPTrieHeader *)data; 44| 3| if (header->signature != UCPTRIE_SIG) { ------------------ | | 17| 3|#define UCPTRIE_SIG 0x54726933 ------------------ | Branch (44:9): [True: 0, False: 3] ------------------ 45| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 46| 0| return nullptr; 47| 0| } 48| | 49| 3| int32_t options = header->options; 50| 3| int32_t typeInt = (options >> 6) & 3; 51| 3| int32_t valueWidthInt = options & UCPTRIE_OPTIONS_VALUE_BITS_MASK; 52| 3| if (typeInt > UCPTRIE_TYPE_SMALL || valueWidthInt > UCPTRIE_VALUE_BITS_8 || ------------------ | Branch (52:9): [True: 0, False: 3] | Branch (52:41): [True: 0, False: 3] ------------------ 53| 3| (options & UCPTRIE_OPTIONS_RESERVED_MASK) != 0) { ------------------ | Branch (53:13): [True: 0, False: 3] ------------------ 54| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 55| 0| return nullptr; 56| 0| } 57| 3| UCPTrieType actualType = (UCPTrieType)typeInt; 58| 3| UCPTrieValueWidth actualValueWidth = (UCPTrieValueWidth)valueWidthInt; 59| 3| if (type < 0) { ------------------ | Branch (59:9): [True: 3, False: 0] ------------------ 60| 3| type = actualType; 61| 3| } 62| 3| if (valueWidth < 0) { ------------------ | Branch (62:9): [True: 3, False: 0] ------------------ 63| 3| valueWidth = actualValueWidth; 64| 3| } 65| 3| if (type != actualType || valueWidth != actualValueWidth) { ------------------ | Branch (65:9): [True: 0, False: 3] | Branch (65:31): [True: 0, False: 3] ------------------ 66| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 67| 0| return nullptr; 68| 0| } 69| | 70| | // Get the length values and offsets. 71| 3| UCPTrie tempTrie; 72| 3| uprv_memset(&tempTrie, 0, sizeof(tempTrie)); ------------------ | | 100| 3|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 73| 3| tempTrie.indexLength = header->indexLength; 74| 3| tempTrie.dataLength = 75| 3| ((options & UCPTRIE_OPTIONS_DATA_LENGTH_MASK) << 4) | header->dataLength; 76| 3| tempTrie.index3NullOffset = header->index3NullOffset; 77| 3| tempTrie.dataNullOffset = 78| 3| ((options & UCPTRIE_OPTIONS_DATA_NULL_OFFSET_MASK) << 8) | header->dataNullOffset; 79| | 80| 3| tempTrie.highStart = header->shiftedHighStart << UCPTRIE_SHIFT_2; 81| 3| tempTrie.shifted12HighStart = (tempTrie.highStart + 0xfff) >> 12; 82| 3| tempTrie.type = type; 83| 3| tempTrie.valueWidth = valueWidth; 84| | 85| | // Calculate the actual length. 86| 3| int32_t actualLength = (int32_t)sizeof(UCPTrieHeader) + tempTrie.indexLength * 2; 87| 3| if (valueWidth == UCPTRIE_VALUE_BITS_16) { ------------------ | Branch (87:9): [True: 0, False: 3] ------------------ 88| 0| actualLength += tempTrie.dataLength * 2; 89| 3| } else if (valueWidth == UCPTRIE_VALUE_BITS_32) { ------------------ | Branch (89:16): [True: 0, False: 3] ------------------ 90| 0| actualLength += tempTrie.dataLength * 4; 91| 3| } else { 92| 3| actualLength += tempTrie.dataLength; 93| 3| } 94| 3| if (length < actualLength) { ------------------ | Branch (94:9): [True: 0, False: 3] ------------------ 95| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; // Not enough bytes. 96| 0| return nullptr; 97| 0| } 98| | 99| | // Allocate the trie. 100| 3| UCPTrie *trie = (UCPTrie *)uprv_malloc(sizeof(UCPTrie)); ------------------ | | 1524| 3|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 101| 3| if (trie == nullptr) { ------------------ | Branch (101:9): [True: 0, False: 3] ------------------ 102| 0| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 103| 0| return nullptr; 104| 0| } 105| 3| uprv_memcpy(trie, &tempTrie, sizeof(tempTrie)); ------------------ | | 42| 3|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3| _Pragma("clang diagnostic push") \ | | 45| 3| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3| _Pragma("clang diagnostic pop") \ | | 49| 3| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 106| |#ifdef UCPTRIE_DEBUG 107| | trie->name = "fromSerialized"; 108| |#endif 109| | 110| | // Set the pointers to its index and data arrays. 111| 3| const uint16_t *p16 = (const uint16_t *)(header + 1); 112| 3| trie->index = p16; 113| 3| p16 += trie->indexLength; 114| | 115| | // Get the data. 116| 3| int32_t nullValueOffset = trie->dataNullOffset; 117| 3| if (nullValueOffset >= trie->dataLength) { ------------------ | Branch (117:9): [True: 0, False: 3] ------------------ 118| 0| nullValueOffset = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 119| 0| } 120| 3| switch (valueWidth) { 121| 0| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (121:5): [True: 0, False: 3] ------------------ 122| 0| trie->data.ptr16 = p16; 123| 0| trie->nullValue = trie->data.ptr16[nullValueOffset]; 124| 0| break; 125| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (125:5): [True: 0, False: 3] ------------------ 126| 0| trie->data.ptr32 = (const uint32_t *)p16; 127| 0| trie->nullValue = trie->data.ptr32[nullValueOffset]; 128| 0| break; 129| 3| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (129:5): [True: 3, False: 0] ------------------ 130| 3| trie->data.ptr8 = (const uint8_t *)p16; 131| 3| trie->nullValue = trie->data.ptr8[nullValueOffset]; 132| 3| break; 133| 0| default: ------------------ | Branch (133:5): [True: 0, False: 3] ------------------ 134| | // Unreachable because valueWidth was checked above. 135| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 136| 0| return nullptr; 137| 3| } 138| | 139| 3| if (pActualLength != nullptr) { ------------------ | Branch (139:9): [True: 0, False: 3] ------------------ 140| 0| *pActualLength = actualLength; 141| 0| } 142| 3| return trie; 143| 3|} ucptrie_internalSmallIndex_78: 161| 531k|ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c) { 162| 531k| int32_t i1 = c >> UCPTRIE_SHIFT_1; 163| 531k| if (trie->type == UCPTRIE_TYPE_FAST) { ------------------ | Branch (163:9): [True: 407k, False: 124k] ------------------ 164| 407k| U_ASSERT(0xffff < c && c < trie->highStart); ------------------ | | 35| 407k|# define U_ASSERT(exp) (void)0 ------------------ 165| 407k| i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 166| 407k| } else { 167| 124k| U_ASSERT((uint32_t)c < (uint32_t)trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); ------------------ | | 35| 124k|# define U_ASSERT(exp) (void)0 ------------------ 168| 124k| i1 += UCPTRIE_SMALL_INDEX_LENGTH; 169| 124k| } 170| 531k| int32_t i3Block = trie->index[ 171| 531k| (int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 172| 531k| int32_t i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 173| 531k| int32_t dataBlock; 174| 531k| if ((i3Block & 0x8000) == 0) { ------------------ | Branch (174:9): [True: 531k, False: 0] ------------------ 175| | // 16-bit indexes 176| 531k| dataBlock = trie->index[i3Block + i3]; 177| 531k| } 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| 531k| return dataBlock + (c & UCPTRIE_SMALL_DATA_MASK); 185| 531k|} ucptrie_get_78: 233| 132k|ucptrie_get(const UCPTrie *trie, UChar32 c) { 234| 132k| int32_t dataIndex; 235| 132k| if ((uint32_t)c <= 0x7f) { ------------------ | Branch (235:9): [True: 503, False: 132k] ------------------ 236| | // linear ASCII 237| 503| dataIndex = c; 238| 132k| } else { 239| 132k| UChar32 fastMax = trie->type == UCPTRIE_TYPE_FAST ? 0xffff : UCPTRIE_SMALL_MAX; ------------------ | Branch (239:27): [True: 0, False: 132k] ------------------ 240| 132k| dataIndex = _UCPTRIE_CP_INDEX(trie, fastMax, c); ------------------ | | 616| 132k| ((uint32_t)(c) <= (uint32_t)(fastMax) ? \ | | ------------------ | | | Branch (616:6): [True: 8.04k, False: 124k] | | ------------------ | | 617| 132k| _UCPTRIE_FAST_INDEX(trie, c) : \ | | ------------------ | | | | 602| 8.04k| ((int32_t)(trie)->index[(c) >> UCPTRIE_FAST_SHIFT] + ((c) & UCPTRIE_FAST_DATA_MASK)) | | ------------------ | | 618| 132k| (uint32_t)(c) <= 0x10ffff ? \ | | ------------------ | | | Branch (618:9): [True: 124k, False: 0] | | ------------------ | | 619| 124k| _UCPTRIE_SMALL_INDEX(trie, c) : \ | | ------------------ | | | | 606| 124k| ((c) >= (trie)->highStart ? \ | | | | ------------------ | | | | | Branch (606:6): [True: 0, False: 124k] | | | | ------------------ | | | | 607| 124k| (trie)->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET : \ | | | | 608| 124k| ucptrie_internalSmallIndex(trie, c)) | | | | ------------------ | | | | | | 810| 124k|#define ucptrie_internalSmallIndex U_ICU_ENTRY_POINT_RENAME(ucptrie_internalSmallIndex) | | | | | | ------------------ | | | | | | | | 123| 124k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | | | ------------------ | | | | | | | | | | 122| 124k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | | | ------------------ | | | | | | | | | | | | 121| 124k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 620| 124k| (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET) ------------------ 241| 132k| } 242| 132k| return getValue(trie->data, (UCPTrieValueWidth)trie->valueWidth, dataIndex); 243| 132k|} ucptrie_internalGetRange_78: 418| 8.28k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 419| 8.28k| if (option == UCPMAP_RANGE_NORMAL) { ------------------ | Branch (419:9): [True: 265, False: 8.02k] ------------------ 420| 265| return getRange(trie, start, filter, context, pValue); 421| 265| } 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.28k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 464| 8.28k| return ucptrie_internalGetRange(getRange, trie, start, ------------------ | | 809| 8.28k|#define ucptrie_internalGetRange U_ICU_ENTRY_POINT_RENAME(ucptrie_internalGetRange) | | ------------------ | | | | 123| 8.28k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.28k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.28k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 465| 8.28k| option, surrogateValue, 466| 8.28k| filter, context, pValue); 467| 8.28k|} ucptrie.cpp:_ZN12_GLOBAL__N_18getValueE11UCPTrieData17UCPTrieValueWidthi: 216| 185k|inline uint32_t getValue(UCPTrieData data, UCPTrieValueWidth valueWidth, int32_t dataIndex) { 217| 185k| switch (valueWidth) { 218| 50.5k| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (218:5): [True: 50.5k, False: 135k] ------------------ 219| 50.5k| return data.ptr16[dataIndex]; 220| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (220:5): [True: 0, False: 185k] ------------------ 221| 0| return data.ptr32[dataIndex]; 222| 135k| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (222:5): [True: 135k, False: 50.5k] ------------------ 223| 135k| return data.ptr8[dataIndex]; 224| 0| default: ------------------ | Branch (224:5): [True: 0, False: 185k] ------------------ 225| | // Unreachable if the trie is properly initialized. 226| 0| return 0xffffffff; 227| 185k| } 228| 185k|} ucptrie.cpp:_ZN12_GLOBAL__N_18getRangeEPKviPFjS1_jES1_Pj: 260| 8.28k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 261| 8.28k| if (static_cast(start) > MAX_UNICODE) { ------------------ | Branch (261:9): [True: 3, False: 8.28k] ------------------ 262| 3| return U_SENTINEL; ------------------ | | 469| 3|#define U_SENTINEL (-1) ------------------ 263| 3| } 264| 8.28k| const UCPTrie *trie = reinterpret_cast(t); 265| 8.28k| UCPTrieValueWidth valueWidth = static_cast(trie->valueWidth); 266| 8.28k| if (start >= trie->highStart) { ------------------ | Branch (266:9): [True: 0, False: 8.28k] ------------------ 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.28k| uint32_t nullValue = trie->nullValue; 277| 8.28k| if (filter != nullptr) { nullValue = filter(context, nullValue); } ------------------ | Branch (277:9): [True: 0, False: 8.28k] ------------------ 278| 8.28k| const uint16_t *index = trie->index; 279| | 280| 8.28k| int32_t prevI3Block = -1; 281| 8.28k| int32_t prevBlock = -1; 282| 8.28k| UChar32 c = start; 283| 8.28k| uint32_t trieValue, value = nullValue; 284| 8.28k| bool haveValue = false; 285| 10.9k| do { 286| 10.9k| int32_t i3Block; 287| 10.9k| int32_t i3; 288| 10.9k| int32_t i3BlockLength; 289| 10.9k| int32_t dataBlockLength; 290| 10.9k| if (c <= 0xffff && (trie->type == UCPTRIE_TYPE_FAST || c <= UCPTRIE_SMALL_MAX)) { ------------------ | Branch (290:13): [True: 6.73k, False: 4.22k] | Branch (290:29): [True: 6.38k, False: 350] | Branch (290:64): [True: 17, False: 333] ------------------ 291| 6.40k| i3Block = 0; 292| 6.40k| i3 = c >> UCPTRIE_FAST_SHIFT; 293| 6.40k| i3BlockLength = trie->type == UCPTRIE_TYPE_FAST ? ------------------ | Branch (293:29): [True: 6.38k, False: 17] ------------------ 294| 6.38k| UCPTRIE_BMP_INDEX_LENGTH : UCPTRIE_SMALL_INDEX_LENGTH; 295| 6.40k| dataBlockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 296| 6.40k| } else { 297| | // Use the multi-stage index. 298| 4.55k| int32_t i1 = c >> UCPTRIE_SHIFT_1; 299| 4.55k| if (trie->type == UCPTRIE_TYPE_FAST) { ------------------ | Branch (299:17): [True: 2.14k, False: 2.41k] ------------------ 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.41k| } else { 303| 2.41k| U_ASSERT(c < trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); ------------------ | | 35| 2.41k|# define U_ASSERT(exp) (void)0 ------------------ 304| 2.41k| i1 += UCPTRIE_SMALL_INDEX_LENGTH; 305| 2.41k| } 306| 4.55k| i3Block = trie->index[ 307| 4.55k| static_cast(trie->index[i1]) + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 308| 4.55k| if (i3Block == prevI3Block && (c - start) >= UCPTRIE_CP_PER_INDEX_2_ENTRY) { ------------------ | Branch (308:17): [True: 2.53k, False: 2.01k] | Branch (308:43): [True: 2.53k, False: 0] ------------------ 309| | // The index-3 block is the same as the previous one, and filled with value. 310| 2.53k| U_ASSERT((c & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0); ------------------ | | 35| 2.53k|# define U_ASSERT(exp) (void)0 ------------------ 311| 2.53k| c += UCPTRIE_CP_PER_INDEX_2_ENTRY; 312| 2.53k| continue; 313| 2.53k| } 314| 2.01k| prevI3Block = i3Block; 315| 2.01k| if (i3Block == trie->index3NullOffset) { ------------------ | Branch (315:17): [True: 39, False: 1.97k] ------------------ 316| | // This is the index-3 null block. 317| 39| if (haveValue) { ------------------ | Branch (317:21): [True: 35, False: 4] ------------------ 318| 35| if (nullValue != value) { ------------------ | Branch (318:25): [True: 4, False: 31] ------------------ 319| 4| return c - 1; 320| 4| } 321| 35| } else { 322| 4| trieValue = trie->nullValue; 323| 4| value = nullValue; 324| 4| if (pValue != nullptr) { *pValue = nullValue; } ------------------ | Branch (324:25): [True: 0, False: 4] ------------------ 325| 4| haveValue = true; 326| 4| } 327| 35| prevBlock = trie->dataNullOffset; 328| 35| c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 329| 35| continue; 330| 39| } 331| 1.97k| i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 332| 1.97k| i3BlockLength = UCPTRIE_INDEX_3_BLOCK_LENGTH; 333| 1.97k| dataBlockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 334| 1.97k| } 335| | // Enumerate data blocks for one index-3 block. 336| 13.6k| do { 337| 13.6k| int32_t block; 338| 13.6k| if ((i3Block & 0x8000) == 0) { ------------------ | Branch (338:17): [True: 13.6k, False: 0] ------------------ 339| 13.6k| block = index[i3Block + i3]; 340| 13.6k| } 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| 13.6k| if (block == prevBlock && (c - start) >= dataBlockLength) { ------------------ | Branch (347:17): [True: 4.16k, False: 9.45k] | Branch (347:39): [True: 4.16k, False: 0] ------------------ 348| | // The block is the same as the previous one, and filled with value. 349| 4.16k| U_ASSERT((c & (dataBlockLength - 1)) == 0); ------------------ | | 35| 4.16k|# define U_ASSERT(exp) (void)0 ------------------ 350| 4.16k| c += dataBlockLength; 351| 9.45k| } else { 352| 9.45k| int32_t dataMask = dataBlockLength - 1; 353| 9.45k| prevBlock = block; 354| 9.45k| if (block == trie->dataNullOffset) { ------------------ | Branch (354:21): [True: 260, False: 9.19k] ------------------ 355| | // This is the data null block. 356| 260| if (haveValue) { ------------------ | Branch (356:25): [True: 210, False: 50] ------------------ 357| 210| if (nullValue != value) { ------------------ | Branch (357:29): [True: 47, False: 163] ------------------ 358| 47| return c - 1; 359| 47| } 360| 210| } else { 361| 50| trieValue = trie->nullValue; 362| 50| value = nullValue; 363| 50| if (pValue != nullptr) { *pValue = nullValue; } ------------------ | Branch (363:29): [True: 28, False: 22] ------------------ 364| 50| haveValue = true; 365| 50| } 366| 213| c = (c + dataBlockLength) & ~dataMask; 367| 9.19k| } else { 368| 9.19k| int32_t di = block + (c & dataMask); 369| 9.19k| uint32_t trieValue2 = getValue(trie->data, valueWidth, di); 370| 9.19k| if (haveValue) { ------------------ | Branch (370:25): [True: 966, False: 8.23k] ------------------ 371| 966| if (trieValue2 != trieValue) { ------------------ | Branch (371:29): [True: 287, False: 679] ------------------ 372| 287| if (filter == nullptr || ------------------ | Branch (372:33): [True: 287, False: 0] ------------------ 373| 287| maybeFilterValue(trieValue2, trie->nullValue, nullValue, ------------------ | Branch (373:37): [True: 0, False: 0] ------------------ 374| 287| filter, context) != value) { 375| 287| return c - 1; 376| 287| } 377| 0| trieValue = trieValue2; // may or may not help 378| 0| } 379| 8.23k| } else { 380| 8.23k| trieValue = trieValue2; 381| 8.23k| value = maybeFilterValue(trieValue2, trie->nullValue, nullValue, 382| 8.23k| filter, context); 383| 8.23k| if (pValue != nullptr) { *pValue = value; } ------------------ | Branch (383:29): [True: 7.99k, False: 238] ------------------ 384| 8.23k| haveValue = true; 385| 8.23k| } 386| 44.7k| while ((++c & dataMask) != 0) { ------------------ | Branch (386:28): [True: 43.7k, False: 966] ------------------ 387| 43.7k| trieValue2 = getValue(trie->data, valueWidth, ++di); 388| 43.7k| if (trieValue2 != trieValue) { ------------------ | Branch (388:29): [True: 7.94k, False: 35.8k] ------------------ 389| 7.94k| if (filter == nullptr || ------------------ | Branch (389:33): [True: 7.94k, False: 0] ------------------ 390| 7.94k| maybeFilterValue(trieValue2, trie->nullValue, nullValue, ------------------ | Branch (390:37): [True: 0, False: 0] ------------------ 391| 7.94k| filter, context) != value) { 392| 7.94k| return c - 1; 393| 7.94k| } 394| 0| trieValue = trieValue2; // may or may not help 395| 0| } 396| 43.7k| } 397| 8.90k| } 398| 9.45k| } 399| 13.6k| } while (++i3 < i3BlockLength); ------------------ | Branch (399:18): [True: 5.23k, False: 105] ------------------ 400| 8.38k| } while (c < trie->highStart); ------------------ | Branch (400:14): [True: 2.67k, False: 3] ------------------ 401| 3| U_ASSERT(haveValue); ------------------ | | 35| 3|# define U_ASSERT(exp) (void)0 ------------------ 402| 3| int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 403| 3| uint32_t highValue = getValue(trie->data, valueWidth, di); 404| 3| if (maybeFilterValue(highValue, trie->nullValue, nullValue, ------------------ | Branch (404:9): [True: 0, False: 3] ------------------ 405| 3| filter, context) != value) { 406| 0| return c - 1; 407| 3| } else { 408| 3| return MAX_UNICODE; 409| 3| } 410| 3|} ucptrie.cpp:_ZN12_GLOBAL__N_116maybeFilterValueEjjjPFjPKvjES1_: 250| 8.23k| UCPMapValueFilter *filter, const void *context) { 251| 8.23k| if (value == trieNullValue) { ------------------ | Branch (251:9): [True: 944, False: 7.28k] ------------------ 252| 944| value = nullValue; 253| 7.28k| } else if (filter != nullptr) { ------------------ | Branch (253:16): [True: 0, False: 7.28k] ------------------ 254| 0| value = filter(context, value); 255| 0| } 256| 8.23k| return value; 257| 8.23k|} udata_openChoice_78: 1406| 2| 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| 2| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1411:8): [True: 0, False: 2] | Branch (1411:31): [True: 0, False: 2] ------------------ 1412| 0| return nullptr; 1413| 2| } else if(name==nullptr || *name==0 || isAcceptable==nullptr) { ------------------ | Branch (1413:15): [True: 0, False: 2] | Branch (1413:32): [True: 0, False: 2] | Branch (1413:44): [True: 0, False: 2] ------------------ 1414| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1415| 0| return nullptr; 1416| 2| } else { 1417| 2| return doOpenChoice(path, type, name, isAcceptable, context, pErrorCode); 1418| 2| } 1419| 2|} 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:_ZL12doOpenChoicePKcS0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCode: 1151| 2|{ 1152| 2| UDataMemory *retVal = nullptr; 1153| | 1154| 2| const char *dataPath; 1155| | 1156| 2| int32_t tocEntrySuffixIndex; 1157| 2| const char *tocEntryPathSuffix; 1158| 2| UErrorCode subErrorCode=U_ZERO_ERROR; 1159| 2| const char *treeChar; 1160| | 1161| 2| UBool isICUData = false; 1162| | 1163| | 1164| 2| FileTracer::traceOpen(path, type, name); 1165| | 1166| | 1167| | /* Is this path ICU data? */ 1168| 2| if(path == nullptr || ------------------ | Branch (1168:8): [True: 2, False: 0] ------------------ 1169| 2| !strcmp(path, U_ICUDATA_ALIAS) || /* "ICUDATA" */ ------------------ | | 74| 0|#define U_ICUDATA_ALIAS "ICUDATA" ------------------ | Branch (1169:8): [True: 0, False: 0] ------------------ 1170| 2| !uprv_strncmp(path, U_ICUDATA_NAME U_TREE_SEPARATOR_STRING, /* "icudt26e-" */ ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1170:8): [True: 0, False: 0] ------------------ 1171| 2| uprv_strlen(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING)) || 1172| 2| !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| 2| uprv_strlen(U_ICUDATA_ALIAS U_TREE_SEPARATOR_STRING))) { 1174| 2| isICUData = true; 1175| 2| } 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| 2| CharString tocEntryName; /* entry name in tree format. ex: 'icudt28b/coll/ar.res' */ 1196| 2| CharString tocEntryPath; /* entry name in path format. ex: 'icudt28b\\coll\\ar.res' */ 1197| | 1198| 2| CharString pkgName; 1199| 2| CharString treeName; 1200| | 1201| | /* ======= Set up strings */ 1202| 2| if(path==nullptr) { ------------------ | Branch (1202:8): [True: 2, False: 0] ------------------ 1203| 2| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 2|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 2|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1204| 2| } else { 1205| 0| const char *pkg; 1206| 0| const char *first; 1207| 0| pkg = uprv_strrchr(path, U_FILE_SEP_CHAR); ------------------ | | 42| 0|#define uprv_strrchr(s, c) U_STANDARD_CPP_NAMESPACE strrchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1208| 0| first = uprv_strchr(path, U_FILE_SEP_CHAR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1209| 0| if(uprv_pathIsAbsolute(path) || (pkg != first)) { /* more than one slash in the path- not a tree name */ ------------------ | | 1533| 0|#define uprv_pathIsAbsolute U_ICU_ENTRY_POINT_RENAME(uprv_pathIsAbsolute) | | ------------------ | | | | 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 (1209:12): [True: 0, False: 0] | Branch (1209:41): [True: 0, False: 0] ------------------ 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| 0| } else { 1217| 0| treeChar = uprv_strchr(path, U_TREE_SEPARATOR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1218| 0| if(treeChar) { ------------------ | Branch (1218:16): [True: 0, False: 0] ------------------ 1219| 0| treeName.append(treeChar+1, *pErrorCode); /* following '-' */ 1220| 0| if(isICUData) { ------------------ | Branch (1220:20): [True: 0, False: 0] ------------------ 1221| 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" | | ------------------ ------------------ 1222| 0| } 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| 0| } 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| 0| } 1240| 0| } 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| 2| tocEntryName.append(pkgName, *pErrorCode); 1253| 2| tocEntryPath.append(pkgName, *pErrorCode); 1254| 2| tocEntrySuffixIndex = tocEntryName.length(); 1255| | 1256| 2| if(!treeName.isEmpty()) { ------------------ | Branch (1256:8): [True: 0, False: 2] ------------------ 1257| 0| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(treeName, *pErrorCode); ------------------ | | 62| 0|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1258| 0| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(treeName, *pErrorCode); ------------------ | | 130| 0|# define U_FILE_SEP_CHAR '/' ------------------ 1259| 0| } 1260| | 1261| 2| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 62| 2|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1262| 2| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 130| 2|# define U_FILE_SEP_CHAR '/' ------------------ 1263| 2| if(type!=nullptr && *type!=0) { ------------------ | Branch (1263:8): [True: 2, False: 0] | Branch (1263:25): [True: 2, False: 0] ------------------ 1264| 2| tocEntryName.append(".", *pErrorCode).append(type, *pErrorCode); 1265| 2| tocEntryPath.append(".", *pErrorCode).append(type, *pErrorCode); 1266| 2| } 1267| | // The +1 is for the U_FILE_SEP_CHAR that is always appended above. 1268| 2| 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| 2|#if !defined(ICU_DATA_DIR_WINDOWS) 1276| 2| if(path == nullptr) { ------------------ | Branch (1276:8): [True: 2, False: 0] ------------------ 1277| 2| path = COMMON_DATA_NAME; /* "icudt26e" */ ------------------ | | 34| 2|#define COMMON_DATA_NAME U_ICUDATA_NAME | | ------------------ | | | | 154| 2|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | | | ------------------ | | | | | | 144| 2|# define U_ICUDATA_TYPE_LETTER "l" | | | | ------------------ | | ------------------ ------------------ 1278| 2| } 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| 2| dataPath = u_getDataDirectory(); ------------------ | | 271| 2|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1291| | 1292| | /**** Time zone individual files override */ 1293| 2| if (isICUData && isTimeZoneFile(name, type)) { ------------------ | Branch (1293:9): [True: 2, False: 0] | Branch (1293:22): [True: 0, False: 2] ------------------ 1294| 0| const char *tzFilesDir = u_getTimeZoneFilesDirectory(pErrorCode); ------------------ | | 287| 0|#define u_getTimeZoneFilesDirectory U_ICU_ENTRY_POINT_RENAME(u_getTimeZoneFilesDirectory) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1295| 0| if (tzFilesDir[0] != 0) { ------------------ | Branch (1295:13): [True: 0, False: 0] ------------------ 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| 0| } 1306| | 1307| | /**** COMMON PACKAGE - only if packages are first. */ 1308| 2| if(gDataFileAccess == UDATA_PACKAGES_FIRST) { ------------------ | Branch (1308:8): [True: 0, False: 2] ------------------ 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| 2| if((gDataFileAccess==UDATA_PACKAGES_FIRST) || ------------------ | Branch (1322:8): [True: 0, False: 2] ------------------ 1323| 2| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1323:8): [True: 2, 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| 2| if ((dataPath && *dataPath) || !isICUData) { ------------------ | Branch (1328:14): [True: 2, False: 0] | Branch (1328:26): [True: 0, False: 2] | Branch (1328:40): [True: 0, False: 2] ------------------ 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| 2| } 1336| | 1337| | /**** COMMON PACKAGE */ 1338| 2| if((gDataFileAccess==UDATA_ONLY_PACKAGES) || ------------------ | Branch (1338:8): [True: 0, False: 2] ------------------ 1339| 2| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1339:8): [True: 2, False: 0] ------------------ 1340| |#ifdef UDATA_DEBUG 1341| | fprintf(stderr, "Trying packages (UDATA_ONLY_PACKAGES || UDATA_FILES_FIRST)\n"); 1342| |#endif 1343| 2| retVal = doLoadFromCommonData(isICUData, 1344| 2| pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(), 1345| 2| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1346| 2| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1346:12): [True: 2, False: 0] | Branch (1346:35): [True: 0, False: 0] ------------------ 1347| 2| return retVal; 1348| 2| } 1349| 2| } 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| 0| if(gDataFileAccess==UDATA_NO_FILES) { ------------------ | Branch (1354:8): [True: 0, False: 0] ------------------ 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| 0| if(U_SUCCESS(*pErrorCode)) { ------------------ | Branch (1367:8): [True: 0, False: 0] ------------------ 1368| 0| if(U_SUCCESS(subErrorCode)) { ------------------ | Branch (1368:12): [True: 0, False: 0] ------------------ 1369| | /* file not found */ 1370| 0| *pErrorCode=U_FILE_ACCESS_ERROR; 1371| 0| } else { 1372| | /* entry point not found or rejected */ 1373| 0| *pErrorCode=subErrorCode; 1374| 0| } 1375| 0| } 1376| 0| return retVal; 1377| 0|} udata.cpp:_ZL14isTimeZoneFilePKcS0_: 1107| 2|static UBool isTimeZoneFile(const char *name, const char *type) { 1108| 2| return ((uprv_strcmp(type, "res") == 0) && ------------------ | | 38| 2|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1108:13): [True: 0, False: 2] ------------------ 1109| 2| (uprv_strcmp(name, "zoneinfo64") == 0 || ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1109:14): [True: 0, False: 0] ------------------ 1110| 0| uprv_strcmp(name, "timezoneTypes") == 0 || ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1110:14): [True: 0, False: 0] ------------------ 1111| 0| uprv_strcmp(name, "windowsZones") == 0 || ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1111:14): [True: 0, False: 0] ------------------ 1112| 0| uprv_strcmp(name, "metaZones") == 0)); ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1112:14): [True: 0, False: 0] ------------------ 1113| 2|} udata.cpp:_ZL13checkDataItemPK10DataHeaderPFaPvPKcS4_PK9UDataInfoES2_S4_S4_P10UErrorCodeSB_: 949| 2|{ 950| 2| UDataMemory *rDataMem = nullptr; /* the new UDataMemory, to be returned. */ 951| | 952| 2| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (952:9): [True: 0, False: 2] ------------------ 953| 0| return nullptr; 954| 0| } 955| | 956| 2| if(pHeader->dataHeader.magic1==0xda && ------------------ | Branch (956:8): [True: 2, False: 0] ------------------ 957| 2| pHeader->dataHeader.magic2==0x27 && ------------------ | Branch (957:9): [True: 2, False: 0] ------------------ 958| 2| (isAcceptable==nullptr || isAcceptable(context, type, name, &pHeader->info)) ------------------ | Branch (958:10): [True: 0, False: 2] | Branch (958:35): [True: 2, False: 0] ------------------ 959| 2| ) { 960| 2| rDataMem=UDataMemory_createNewInstance(fatalErr); ------------------ | | 79| 2|#define UDataMemory_createNewInstance U_ICU_ENTRY_POINT_RENAME(UDataMemory_createNewInstance) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 961| 2| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (961:13): [True: 0, False: 2] ------------------ 962| 0| return nullptr; 963| 0| } 964| 2| rDataMem->pHeader = pHeader; 965| 2| } 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| 2| return rDataMem; 972| 2|} udata.cpp:_ZL20doLoadFromCommonDataaPKcS0_S0_S0_S0_S0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCodeS8_: 1042| 2|{ 1043| 2| UDataMemory *pEntryData; 1044| 2| const DataHeader *pHeader; 1045| 2| UDataMemory *pCommonData; 1046| 2| int32_t commonDataIndex; 1047| 2| 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| 2| for (commonDataIndex = isICUData ? 0 : -1;;) { ------------------ | Branch (1057:28): [True: 2, False: 0] ------------------ 1058| 2| pCommonData=openCommonData(path, commonDataIndex, subErrorCode); /** search for pkg **/ 1059| | 1060| 2| if(U_SUCCESS(*subErrorCode) && pCommonData!=nullptr) { ------------------ | Branch (1060:12): [True: 2, False: 0] | Branch (1060:40): [True: 2, False: 0] ------------------ 1061| 2| int32_t length; 1062| | 1063| | /* look up the data piece in the common data */ 1064| 2| 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| 2| if(pHeader!=nullptr) { ------------------ | Branch (1069:16): [True: 2, False: 0] ------------------ 1070| 2| pEntryData = checkDataItem(pHeader, isAcceptable, context, type, name, subErrorCode, pErrorCode); 1071| |#ifdef UDATA_DEBUG 1072| | fprintf(stderr, "pEntryData=%p\n", (void*) pEntryData); 1073| |#endif 1074| 2| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1074:21): [True: 0, False: 2] ------------------ 1075| 0| return nullptr; 1076| 0| } 1077| 2| if (pEntryData != nullptr) { ------------------ | Branch (1077:21): [True: 2, False: 0] ------------------ 1078| 2| pEntryData->length = length; 1079| 2| return pEntryData; 1080| 2| } 1081| 2| } 1082| 2| } 1083| | // If we failed due to being out-of-memory, then stop early and report the error. 1084| 0| if (*subErrorCode == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (1084:13): [True: 0, False: 0] ------------------ 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| 0| if (!isICUData) { ------------------ | Branch (1091:13): [True: 0, False: 0] ------------------ 1092| 0| return nullptr; 1093| 0| } else if (pCommonData != nullptr) { ------------------ | Branch (1093:20): [True: 0, False: 0] ------------------ 1094| 0| ++commonDataIndex; /* try the next data package */ 1095| 0| } else if ((!checkedExtendedICUData) && extendICUData(subErrorCode)) { ------------------ | Branch (1095:20): [True: 0, False: 0] | Branch (1095:49): [True: 0, False: 0] ------------------ 1096| 0| checkedExtendedICUData = true; 1097| | /* try this data package slot again: it changed from nullptr to non-nullptr */ 1098| 0| } else { 1099| 0| return nullptr; 1100| 0| } 1101| 0| } 1102| 2|} udata.cpp:_ZL14openCommonDataPKciP10UErrorCode: 673| 2|{ 674| 2| UDataMemory tData; 675| 2| const char *pathBuffer; 676| 2| const char *inBasename; 677| | 678| 2| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (678:9): [True: 0, False: 2] ------------------ 679| 0| return nullptr; 680| 0| } 681| | 682| 2| UDataMemory_init(&tData); ------------------ | | 80| 2|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 683| | 684| | /* ??????? TODO revisit this */ 685| 2| if (commonDataIndex >= 0) { ------------------ | Branch (685:9): [True: 2, False: 0] ------------------ 686| | /* "mini-cache" for common ICU data */ 687| 2| if(commonDataIndex >= UPRV_LENGTHOF(gCommonICUDataArray)) { ------------------ | | 99| 2|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (687:12): [True: 0, False: 2] ------------------ 688| 0| return nullptr; 689| 0| } 690| 2| { 691| 2| Mutex lock; 692| 2| if(gCommonICUDataArray[commonDataIndex] != nullptr) { ------------------ | Branch (692:16): [True: 1, False: 1] ------------------ 693| 1| return gCommonICUDataArray[commonDataIndex]; 694| 1| } 695| 1|#if !defined(ICU_DATA_DIR_WINDOWS) 696| |// When using the Windows system data, we expect only a single data file. 697| 1| int32_t i; 698| 1| for(i = 0; i < commonDataIndex; ++i) { ------------------ | Branch (698:24): [True: 0, False: 1] ------------------ 699| 0| if(gCommonICUDataArray[i]->pHeader == &U_ICUDATA_ENTRY_POINT) { ------------------ | | 171| 0|#define U_ICUDATA_ENTRY_POINT U_DEF2_ICUDATA_ENTRY_POINT(U_ICU_VERSION_MAJOR_NUM,U_LIB_SUFFIX_C_NAME) | | ------------------ | | | | 178| 0|#define U_DEF2_ICUDATA_ENTRY_POINT(major,suff) U_DEF_ICUDATA_ENTRY_POINT(major,suff) | | | | ------------------ | | | | | | 187| 0|#define U_DEF_ICUDATA_ENTRY_POINT(major, suff) icudt##major##_dat | | | | ------------------ | | ------------------ ------------------ | Branch (699:20): [True: 0, False: 0] ------------------ 700| | /* The linked-in data is already in the list. */ 701| 0| return nullptr; 702| 0| } 703| 0| } 704| 1|#endif 705| 1| } 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| 1| } 727| 1|#endif 728| 1| } 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| 0| inBasename = findBasename(path); 736| |#ifdef UDATA_DEBUG 737| | fprintf(stderr, "inBasename = %s\n", inBasename); 738| |#endif 739| | 740| 0| if(*inBasename==0) { ------------------ | Branch (740:8): [True: 0, False: 0] ------------------ 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| 0| UDataMemory *dataToReturn = udata_findCachedData(inBasename, *pErrorCode); 756| 0| if (dataToReturn != nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (756:9): [True: 0, False: 0] | Branch (756:36): [True: 0, False: 0] ------------------ 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| 0| UDataPathIterator iter(u_getDataDirectory(), inBasename, path, ".dat", true, pErrorCode); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 765| | 766| 0| while ((UDataMemory_isLoaded(&tData)==false) && (pathBuffer = iter.next(pErrorCode)) != nullptr) ------------------ | | 81| 0|#define UDataMemory_isLoaded U_ICU_ENTRY_POINT_RENAME(UDataMemory_isLoaded) | | ------------------ | | | | 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 (766:12): [True: 0, False: 0] | Branch (766:53): [True: 0, False: 0] ------------------ 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| 0| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (776:9): [True: 0, False: 0] ------------------ 777| 0| return nullptr; 778| 0| } 779| | 780| 0| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (780:9): [True: 0, False: 0] ------------------ 781| 0| return nullptr; 782| 0| } 783| 0| if (!UDataMemory_isLoaded(&tData)) { ------------------ | | 81| 0|#define UDataMemory_isLoaded U_ICU_ENTRY_POINT_RENAME(UDataMemory_isLoaded) | | ------------------ | | | | 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 (783:9): [True: 0, False: 0] ------------------ 784| | /* no common data */ 785| 0| *pErrorCode=U_FILE_ACCESS_ERROR; 786| 0| return nullptr; 787| 0| } 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| 0|} 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|} UDataMemory_init_78: 28| 6|U_CFUNC void UDataMemory_init(UDataMemory *This) { 29| 6| uprv_memset(This, 0, sizeof(UDataMemory)); ------------------ | | 100| 6|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 6|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 30| 6| This->length=-1; 31| 6|} 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| 3|U_CFUNC UDataMemory *UDataMemory_createNewInstance(UErrorCode *pErr) { 42| 3| UDataMemory *This; 43| | 44| 3| if (U_FAILURE(*pErr)) { ------------------ | Branch (44:9): [True: 0, False: 3] ------------------ 45| 0| return nullptr; 46| 0| } 47| 3| This = (UDataMemory *)uprv_malloc(sizeof(UDataMemory)); ------------------ | | 1524| 3|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 48| 3| if (This == nullptr) { ------------------ | Branch (48:9): [True: 0, False: 3] ------------------ 49| 0| *pErr = U_MEMORY_ALLOCATION_ERROR; } 50| 3| else { 51| 3| UDataMemory_init(This); ------------------ | | 80| 3|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 52| 3| This->heapAllocated = true; 53| 3| } 54| 3| return This; 55| 3|} 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_getMemory_78: 104| 2|udata_getMemory(UDataMemory *pData) { 105| 2| if(pData!=nullptr && pData->pHeader!=nullptr) { ------------------ | Branch (105:8): [True: 2, False: 0] | Branch (105:26): [True: 2, False: 0] ------------------ 106| 2| return (char *)(pData->pHeader)+udata_getHeaderSize(pData->pHeader); ------------------ | | 887| 2|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 2| } else { 108| 0| return nullptr; 109| 0| } 110| 2|} u_UCharsToChars_78: 204| 62.6k|u_UCharsToChars(const char16_t *us, char *cs, int32_t length) { 205| 62.6k| char16_t u; 206| | 207| 1.44M| while(length>0) { ------------------ | Branch (207:11): [True: 1.37M, False: 62.6k] ------------------ 208| 1.37M| u=*us++; 209| 1.37M| if(!UCHAR_IS_INVARIANT(u)) { ------------------ | | 168| 1.37M|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 1.37M, False: 0] | | | Branch (168:47): [True: 1.37M, 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| 1.37M| *cs++=(char)UCHAR_TO_CHAR(u); ------------------ | | 175| 1.37M|#define UCHAR_TO_CHAR(c) c ------------------ 214| 1.37M| --length; 215| 1.37M| } 216| 62.6k|} uprv_isInvariantUString_78: 263| 125k|uprv_isInvariantUString(const char16_t *s, int32_t length) { 264| 125k| char16_t c; 265| | 266| 3.06M| for(;;) { 267| 3.06M| if(length<0) { ------------------ | Branch (267:12): [True: 0, False: 3.06M] ------------------ 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| 3.06M| } else { 274| | /* count length */ 275| 3.06M| if(length==0) { ------------------ | Branch (275:16): [True: 125k, False: 2.94M] ------------------ 276| 125k| break; 277| 125k| } 278| 2.94M| --length; 279| 2.94M| c=*s++; 280| 2.94M| } 281| | 282| | /* 283| | * no assertions here because these functions are legitimately called 284| | * for strings with variant characters 285| | */ 286| 2.94M| if(!UCHAR_IS_INVARIANT(c)) { ------------------ | | 168| 2.94M|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 2.94M, False: 310] | | | Branch (168:47): [True: 2.94M, False: 46] | | ------------------ ------------------ 287| 356| return false; /* found a variant char */ 288| 356| } 289| 2.94M| } 290| 125k| return true; 291| 125k|} _ZN6icu_786UMutex8getMutexEv: 80| 2|std::mutex *UMutex::getMutex() { 81| 2| std::mutex *retPtr = fMutex.load(std::memory_order_acquire); 82| 2| if (retPtr == nullptr) { ------------------ | Branch (82:9): [True: 2, False: 0] ------------------ 83| 2| std::call_once(*pInitFlag, umtx_init); 84| 2| std::lock_guard guard(*initMutex); 85| 2| retPtr = fMutex.load(std::memory_order_acquire); 86| 2| if (retPtr == nullptr) { ------------------ | Branch (86:13): [True: 2, False: 0] ------------------ 87| 2| fMutex = new(fStorage) std::mutex(); 88| 2| retPtr = fMutex; 89| 2| fListLink = gListHead; 90| 2| gListHead = this; 91| 2| } 92| 2| } 93| 2| U_ASSERT(retPtr != nullptr); ------------------ | | 35| 2|# define U_ASSERT(exp) (void)0 ------------------ 94| 2| return retPtr; 95| 2|} umtx_lock_78: 112| 2.82k|umtx_lock(UMutex *mutex) { 113| 2.82k| if (mutex == nullptr) { ------------------ | Branch (113:9): [True: 28, False: 2.79k] ------------------ 114| 28| mutex = &globalMutex; 115| 28| } 116| 2.82k| mutex->lock(); 117| 2.82k|} umtx_unlock_78: 122| 2.82k|{ 123| 2.82k| if (mutex == nullptr) { ------------------ | Branch (123:9): [True: 28, False: 2.79k] ------------------ 124| 28| mutex = &globalMutex; 125| 28| } 126| 2.82k| mutex->unlock(); 127| 2.82k|} _ZN6icu_7820umtx_initImplPreInitERNS_9UInitOnceE: 145| 23|umtx_initImplPreInit(UInitOnce &uio) { 146| 23| std::call_once(*pInitFlag, umtx_init); 147| 23| std::unique_lock lock(*initMutex); 148| 23| if (umtx_loadAcquire(uio.fState) == 0) { ------------------ | Branch (148:9): [True: 23, False: 0] ------------------ 149| 23| umtx_storeRelease(uio.fState, 1); 150| 23| return true; // Caller will next call the init function. 151| 23| } 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| 23|} _ZN6icu_7821umtx_initImplPostInitERNS_9UInitOnceE: 170| 23|umtx_initImplPostInit(UInitOnce &uio) { 171| 23| { 172| 23| std::unique_lock lock(*initMutex); 173| 23| umtx_storeRelease(uio.fState, 2); 174| 23| } 175| 23| initCondition->notify_all(); 176| 23|} 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_7813umtx_initOnceERNS_9UInitOnceEPFvR10UErrorCodeES3_: 135| 1.80M|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(UErrorCode &), UErrorCode &errCode) { 136| 1.80M| if (U_FAILURE(errCode)) { ------------------ | Branch (136:9): [True: 0, False: 1.80M] ------------------ 137| 0| return; 138| 0| } 139| 1.80M| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (139:9): [True: 3, False: 1.80M] | Branch (139:46): [True: 3, False: 0] ------------------ 140| | // We run the initialization. 141| 3| (*fp)(errCode); 142| 3| uio.fErrCode = errCode; 143| 3| umtx_initImplPostInit(uio); 144| 1.80M| } else { 145| | // Someone else already ran the initialization. 146| 1.80M| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (146:13): [True: 0, False: 1.80M] ------------------ 147| 0| errCode = uio.fErrCode; 148| 0| } 149| 1.80M| } 150| 1.80M|} _ZN6icu_7816umtx_loadAcquireERNSt3__16atomicIiEE: 75| 317M|inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 76| 317M| return var.load(std::memory_order_acquire); 77| 317M|} _ZN6icu_786UMutex4lockEv: 229| 2.82k| void lock() { 230| 2.82k| std::mutex *m = fMutex.load(std::memory_order_acquire); 231| 2.82k| if (m == nullptr) { m = getMutex(); } ------------------ | Branch (231:13): [True: 2, False: 2.82k] ------------------ 232| 2.82k| m->lock(); 233| 2.82k| } _ZN6icu_786UMutex6unlockEv: 234| 2.82k| void unlock() { fMutex.load(std::memory_order_relaxed)->unlock(); } _ZN6icu_7817umtx_storeReleaseERNSt3__16atomicIiEEi: 79| 46|inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 80| 46| var.store(val, std::memory_order_release); 81| 46|} _ZN6icu_7815umtx_atomic_incEPNSt3__16atomicIiEE: 83| 93.5k|inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) { 84| 93.5k| return var->fetch_add(1) + 1; 85| 93.5k|} _ZN6icu_7815umtx_atomic_decEPNSt3__16atomicIiEE: 87| 1.60M|inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) { 88| 1.60M| return var->fetch_sub(1) - 1; 89| 1.60M|} _ZN6icu_7813umtx_initOnceERNS_9UInitOnceEPFvvE: 123| 2|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)()) { 124| 2| if (umtx_loadAcquire(uio.fState) == 2) { ------------------ | Branch (124:9): [True: 1, False: 1] ------------------ 125| 1| return; 126| 1| } 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_7813umtx_initOnceI15UPropertySourceEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES4_S6_: 166| 14.2k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 14.2k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 14.2k] ------------------ 168| 0| return; 169| 0| } 170| 14.2k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 9, False: 14.2k] | Branch (170:46): [True: 9, False: 0] ------------------ 171| | // We run the initialization. 172| 9| (*fp)(context, errCode); 173| 9| uio.fErrCode = errCode; 174| 9| umtx_initImplPostInit(uio); 175| 14.2k| } else { 176| | // Someone else already ran the initialization. 177| 14.2k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 14.2k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 14.2k| } 181| 14.2k|} _ZN6icu_7813umtx_initOnceI9UPropertyEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES4_S6_: 166| 8.26k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 8.26k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 8.26k] ------------------ 168| 0| return; 169| 0| } 170| 8.26k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 10, False: 8.25k] | Branch (170:46): [True: 10, False: 0] ------------------ 171| | // We run the initialization. 172| 10| (*fp)(context, errCode); 173| 10| uio.fErrCode = errCode; 174| 10| umtx_initImplPostInit(uio); 175| 8.25k| } else { 176| | // Someone else already ran the initialization. 177| 8.25k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 8.25k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 8.25k| } 181| 8.26k|} u_charFromName_78: 1521| 3.67k| UErrorCode *pErrorCode) { 1522| 3.67k| char upper[120] = {0}; 1523| 3.67k| char lower[120] = {0}; 1524| 3.67k| FindName findName; 1525| 3.67k| AlgorithmicRange *algRange; 1526| 3.67k| uint32_t *p; 1527| 3.67k| uint32_t i; 1528| 3.67k| UChar32 cp = 0; 1529| 3.67k| char c0; 1530| 3.67k| static constexpr UChar32 error = 0xffff; /* Undefined, but use this for backwards compatibility. */ 1531| | 1532| 3.67k| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1532:8): [True: 0, False: 3.67k] | Branch (1532:31): [True: 0, False: 3.67k] ------------------ 1533| 0| return error; 1534| 0| } 1535| | 1536| 3.67k| if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT || name==nullptr || *name==0) { ------------------ | Branch (1536:8): [True: 0, False: 3.67k] | Branch (1536:48): [True: 0, False: 3.67k] | Branch (1536:65): [True: 38, False: 3.63k] ------------------ 1537| 38| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1538| 38| return error; 1539| 38| } 1540| | 1541| 3.63k| if(!isDataLoaded(pErrorCode)) { ------------------ | Branch (1541:8): [True: 0, False: 3.63k] ------------------ 1542| 0| return error; 1543| 0| } 1544| | 1545| | /* construct the uppercase and lowercase of the name first */ 1546| 18.6k| for(i=0; i') { ------------------ | Branch (1564:13): [True: 470, False: 0] | Branch (1564:51): [True: 444, False: 26] ------------------ 1565| | // Parse a string like "" where HHHH is a hex code point. 1566| 444| uint32_t limit = i; 1567| 1.84k| while (i >= 3 && lower[--i] != '-') {} ------------------ | Branch (1567:20): [True: 1.81k, False: 34] | Branch (1567:30): [True: 1.40k, False: 410] ------------------ 1568| | 1569| | // There should be 1 to 8 hex digits. 1570| 444| int32_t hexLength = limit - (i + 1); 1571| 444| if (i >= 2 && lower[i] == '-' && 1 <= hexLength && hexLength <= 8) { ------------------ | Branch (1571:17): [True: 442, False: 2] | Branch (1571:27): [True: 410, False: 32] | Branch (1571:46): [True: 406, False: 4] | Branch (1571:64): [True: 398, False: 8] ------------------ 1572| 398| uint32_t cIdx; 1573| | 1574| 398| lower[i] = 0; 1575| | 1576| 1.27k| for (++i; i < limit; ++i) { ------------------ | Branch (1576:27): [True: 900, False: 374] ------------------ 1577| 900| if (lower[i] >= '0' && lower[i] <= '9') { ------------------ | Branch (1577:25): [True: 894, False: 6] | Branch (1577:44): [True: 286, False: 608] ------------------ 1578| 286| cp = (cp << 4) + lower[i] - '0'; 1579| 614| } else if (lower[i] >= 'a' && lower[i] <= 'f') { ------------------ | Branch (1579:32): [True: 608, False: 6] | Branch (1579:51): [True: 596, False: 12] ------------------ 1580| 596| cp = (cp << 4) + lower[i] - 'a' + 10; 1581| 596| } else { 1582| 18| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1583| 18| return error; 1584| 18| } 1585| | // Prevent signed-integer overflow and out-of-range code points. 1586| 882| if (cp > UCHAR_MAX_VALUE) { ------------------ | | 168| 882|#define UCHAR_MAX_VALUE 0x10ffff ------------------ | Branch (1586:25): [True: 6, False: 876] ------------------ 1587| 6| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1588| 6| return error; 1589| 6| } 1590| 882| } 1591| | 1592| | /* Now validate the category name. 1593| | We could use a binary search, or a trie, if 1594| | we really wanted to. */ 1595| 374| uint8_t cat = getCharCat(cp); 1596| 12.7k| for (lower[i] = 0, cIdx = 0; cIdx < UPRV_LENGTHOF(charCatNames); ++cIdx) { ------------------ | | 99| 12.7k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1596:46): [True: 12.3k, False: 374] ------------------ 1597| | 1598| 12.3k| if (!uprv_strcmp(lower + 1, charCatNames[cIdx])) { ------------------ | | 38| 12.3k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 12.3k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1598:25): [True: 0, False: 12.3k] ------------------ 1599| 0| if (cat == cIdx) { ------------------ | Branch (1599:29): [True: 0, False: 0] ------------------ 1600| 0| return cp; 1601| 0| } 1602| 0| break; 1603| 0| } 1604| 12.3k| } 1605| 374| } 1606| 444| } 1607| | 1608| 446| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1609| 446| return error; 1610| 470| } 1611| | 1612| | /* try algorithmic names now */ 1613| 3.15k| p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset); 1614| 3.15k| i=*p; 1615| 3.15k| algRange=(AlgorithmicRange *)(p+1); 1616| 44.1k| while(i>0) { ------------------ | Branch (1616:11): [True: 41.0k, False: 3.15k] ------------------ 1617| 41.0k| if((cp=findAlgName(algRange, nameChoice, upper))!=0xffff) { ------------------ | Branch (1617:12): [True: 0, False: 41.0k] ------------------ 1618| 0| return cp; 1619| 0| } 1620| 41.0k| algRange=(AlgorithmicRange *)((uint8_t *)algRange+algRange->size); 1621| 41.0k| --i; 1622| 41.0k| } 1623| | 1624| | /* normal character name */ 1625| 3.15k| findName.otherName=upper; 1626| 3.15k| findName.code=error; 1627| 3.15k| enumNames(uCharNames, 0, UCHAR_MAX_VALUE + 1, DO_FIND_NAME, &findName, nameChoice); ------------------ | | 168| 3.15k|#define UCHAR_MAX_VALUE 0x10ffff ------------------ enumNames(uCharNames, 0, UCHAR_MAX_VALUE + 1, DO_FIND_NAME, &findName, nameChoice); ------------------ | | 104| 3.15k|#define DO_FIND_NAME nullptr ------------------ 1628| 3.15k| if (findName.code == error) { ------------------ | Branch (1628:9): [True: 240, False: 2.91k] ------------------ 1629| 240| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1630| 240| } 1631| 3.15k| return findName.code; 1632| 3.15k|} unames.cpp:_ZN6icu_78L12isDataLoadedEP10UErrorCode: 210| 3.63k|isDataLoaded(UErrorCode *pErrorCode) { 211| 3.63k| umtx_initOnce(gCharNamesInitOnce, &loadCharNames, *pErrorCode); 212| 3.63k| return U_SUCCESS(*pErrorCode); 213| 3.63k|} 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| 3.15k|getGroup(UCharNames *names, uint32_t code) { 484| 3.15k| const uint16_t *groups=GET_GROUPS(names); ------------------ | | 97| 3.15k|#define GET_GROUPS(names) (const uint16_t *)((const char *)names+names->groupsOffset) ------------------ 485| 3.15k| uint16_t groupMSB = static_cast(code >> GROUP_SHIFT), ------------------ | | 41| 3.15k|#define GROUP_SHIFT 5 ------------------ 486| 3.15k| start=0, 487| 3.15k| limit=*groups++, 488| 3.15k| number; 489| | 490| | /* binary search for the group of names that contains the one for code */ 491| 34.6k| while(start((start + limit) / 2); 493| 31.5k| if(groupMSB=0xfdd0 && \ | | ------------------ | | | Branch (131:6): [True: 68, False: 306] | | ------------------ | | 132| 374| ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff) | | ------------------ | | | Branch (132:7): [True: 8, False: 60] | | | Branch (132:22): [True: 2, False: 58] | | | Branch (132:47): [True: 10, False: 0] | | ------------------ ------------------ 425| 10| return U_NONCHARACTER_CODE_POINT; ------------------ | | 121| 10|#define U_NONCHARACTER_CODE_POINT U_CHAR_CATEGORY_COUNT ------------------ 426| 10| } 427| | 428| 364| if ((cat = u_charType(cp)) == U_SURROGATE) { ------------------ | | 225| 364|#define u_charType U_ICU_ENTRY_POINT_RENAME(u_charType) | | ------------------ | | | | 123| 364|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 364|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 364|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (428:9): [True: 20, False: 344] ------------------ 429| 20| cat = U_IS_LEAD(cp) ? U_LEAD_SURROGATE : U_TRAIL_SURROGATE; ------------------ | | 177| 20|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 18, False: 2] | | ------------------ ------------------ cat = U_IS_LEAD(cp) ? U_LEAD_SURROGATE : U_TRAIL_SURROGATE; ------------------ | | 122| 18|#define U_LEAD_SURROGATE U_CHAR_CATEGORY_COUNT + 1 ------------------ cat = U_IS_LEAD(cp) ? U_LEAD_SURROGATE : U_TRAIL_SURROGATE; ------------------ | | 123| 22|#define U_TRAIL_SURROGATE U_CHAR_CATEGORY_COUNT + 2 ------------------ 430| 20| } 431| | 432| 364| return cat; 433| 374|} unames.cpp:_ZN6icu_78L11findAlgNameEPNS_16AlgorithmicRangeE15UCharNameChoicePKc: 1078| 41.0k|findAlgName(AlgorithmicRange *range, UCharNameChoice nameChoice, const char *otherName) { 1079| 41.0k| UChar32 code; 1080| | 1081| 41.0k| if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) { ------------------ | Branch (1081:8): [True: 41.0k, False: 0] | Branch (1081:43): [True: 0, False: 41.0k] ------------------ 1082| 0| return 0xffff; 1083| 0| } 1084| | 1085| 41.0k| switch(range->type) { 1086| 37.8k| case 0: { ------------------ | Branch (1086:5): [True: 37.8k, False: 3.15k] ------------------ 1087| | /* name = prefix hex-digits */ 1088| 37.8k| const char* s = reinterpret_cast(range + 1); 1089| 37.8k| char c; 1090| | 1091| 37.8k| uint16_t i, count; 1092| | 1093| | /* compare prefix */ 1094| 38.1k| while((c=*s++)!=0) { ------------------ | Branch (1094:15): [True: 38.1k, False: 0] ------------------ 1095| 38.1k| if (c != *otherName++) { ------------------ | Branch (1095:17): [True: 37.8k, False: 296] ------------------ 1096| 37.8k| return 0xffff; 1097| 37.8k| } 1098| 38.1k| } 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| 3.15k| case 1: { ------------------ | Branch (1120:5): [True: 3.15k, False: 37.8k] ------------------ 1121| 3.15k| char buffer[64]; 1122| 3.15k| uint16_t indexes[8]; 1123| 3.15k| const char *elementBases[8], *elements[8]; 1124| 3.15k| const uint16_t* factors = reinterpret_cast(range + 1); 1125| 3.15k| uint16_t count=range->variant; 1126| 3.15k| const char *s = reinterpret_cast(factors + count), *t; 1127| 3.15k| UChar32 start, limit; 1128| 3.15k| uint16_t i, idx; 1129| | 1130| 3.15k| char c; 1131| | 1132| | /* name = prefix factorized-elements */ 1133| | 1134| | /* compare prefix */ 1135| 3.16k| while((c=*s++)!=0) { ------------------ | Branch (1135:15): [True: 3.16k, False: 0] ------------------ 1136| 3.16k| if (c != *otherName++) { ------------------ | Branch (1136:17): [True: 3.15k, False: 14] ------------------ 1137| 3.15k| return 0xffff; 1138| 3.15k| } 1139| 3.16k| } 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| 3.15k|#define GROUP_SHIFT 5 ------------------ 675| 3.15k| endGroupMSB = static_cast((limit - 1) >> GROUP_SHIFT); ------------------ | | 41| 3.15k|#define GROUP_SHIFT 5 ------------------ 676| | 677| | /* find the group that contains start, or the highest before it */ 678| 3.15k| group=getGroup(names, start); 679| | 680| 3.15k| if(startGroupMSB(group[GROUP_MSB]) << GROUP_SHIFT; ------------------ | | 41| 3.15k|#define GROUP_SHIFT 5 ------------------ 683| 3.15k| if(extLimit>limit) { ------------------ | Branch (683:12): [True: 0, False: 3.15k] ------------------ 684| 0| extLimit=limit; 685| 0| } 686| 3.15k| if(!enumExtNames(start, extLimit-1, fn, context)) { ------------------ | Branch (686:12): [True: 0, False: 3.15k] ------------------ 687| 0| return false; 688| 0| } 689| 3.15k| start=extLimit; 690| 3.15k| } 691| | 692| 3.15k| if(startGroupMSB==endGroupMSB) { ------------------ | Branch (692:8): [True: 0, False: 3.15k] ------------------ 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| 3.15k| } else { 698| 3.15k| const uint16_t *groups=GET_GROUPS(names); ------------------ | | 97| 3.15k|#define GET_GROUPS(names) (const uint16_t *)((const char *)names+names->groupsOffset) ------------------ 699| 3.15k| groupCount=*groups++; 700| 3.15k| groupLimit=groups+groupCount*GROUP_LENGTH; 701| | 702| 3.15k| if(startGroupMSB==group[GROUP_MSB]) { ------------------ | Branch (702:12): [True: 0, False: 3.15k] ------------------ 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: 3.15k] ------------------ 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| 4.02M| while(group(group[GROUP_MSB]) << GROUP_SHIFT; ------------------ | | 41| 4.02M|#define GROUP_SHIFT 5 ------------------ 731| 4.02M| if(!enumGroupNames(names, group, start, start+LINES_PER_GROUP-1, fn, context, nameChoice)) { ------------------ | | 42| 4.02M|#define LINES_PER_GROUP (1L< group[GROUP_MSB] + 1 && nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (735:17): [True: 4.02M, False: 240] | Branch (735:43): [True: 194k, False: 3.82M] | Branch (735:90): [True: 194k, False: 0] ------------------ 736| 194k| UChar32 end = nextGroup[GROUP_MSB] << GROUP_SHIFT; ------------------ | | 41| 194k|#define GROUP_SHIFT 5 ------------------ 737| 194k| if (end > limit) { ------------------ | Branch (737:21): [True: 0, False: 194k] ------------------ 738| 0| end = limit; 739| 0| } 740| 194k| if (!enumExtNames((group[GROUP_MSB] + 1) << GROUP_SHIFT, end - 1, fn, context)) { ------------------ | | 41| 194k|#define GROUP_SHIFT 5 ------------------ | Branch (740:21): [True: 0, False: 194k] ------------------ 741| 0| return false; 742| 0| } 743| 194k| } 744| 4.02M| group=nextGroup; 745| 4.02M| } 746| | 747| | /* enumerate within the end group (group[GROUP_MSB]==endGroupMSB) */ 748| 240| if(group start) { ------------------ | Branch (752:17): [True: 240, False: 0] ------------------ 753| 240| start = next; 754| 240| } 755| 240| } else { 756| 0| return true; 757| 0| } 758| 240| } 759| | 760| | /* we have not found a group, which means everything is made of 761| | extended names. */ 762| 240| if (nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (762:9): [True: 240, False: 0] ------------------ 763| 240| if (limit > UCHAR_MAX_VALUE + 1) { ------------------ | | 168| 240|#define UCHAR_MAX_VALUE 0x10ffff ------------------ | Branch (763:13): [True: 0, False: 240] ------------------ 764| 0| limit = UCHAR_MAX_VALUE + 1; ------------------ | | 168| 0|#define UCHAR_MAX_VALUE 0x10ffff ------------------ 765| 0| } 766| 240| return enumExtNames(start, limit - 1, fn, context); 767| 240| } 768| | 769| 0| return true; 770| 240|} unames.cpp:_ZN6icu_78L12enumExtNamesEiiPFaPvi15UCharNameChoicePKciES0_: 646| 198k|{ 647| 198k| if(fn!=DO_FIND_NAME) { ------------------ | | 104| 198k|#define DO_FIND_NAME nullptr ------------------ | Branch (647:8): [True: 0, False: 198k] ------------------ 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| 198k| return true; 664| 198k|} unames.cpp:_ZN6icu_78L14enumGroupNamesEPNS_10UCharNamesEPKtiiPFaPvi15UCharNameChoicePKciES4_S5_: 602| 4.02M| UCharNameChoice nameChoice) { 603| 4.02M| uint16_t offsets[LINES_PER_GROUP+2], lengths[LINES_PER_GROUP+2]; 604| 4.02M| const uint8_t* s = reinterpret_cast(names) + names->groupStringOffset + GET_GROUP_OFFSET(group); ------------------ | | 73| 4.02M|#define GET_GROUP_OFFSET(group) ((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW]) ------------------ 605| | 606| 4.02M| s=expandGroupLengths(s, offsets, lengths); 607| 4.02M| if(fn!=DO_FIND_NAME) { ------------------ | | 104| 4.02M|#define DO_FIND_NAME nullptr ------------------ | Branch (607:8): [True: 0, False: 4.02M] ------------------ 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| 4.02M| } else { 625| 4.02M| const char* otherName = static_cast(context)->otherName; 626| 132M| while(start<=end) { ------------------ | Branch (626:15): [True: 128M, False: 4.02M] ------------------ 627| 128M| if(compareName(names, s+offsets[start&GROUP_MASK], lengths[start&GROUP_MASK], nameChoice, otherName)) { ------------------ | | 43| 128M|#define GROUP_MASK (LINES_PER_GROUP-1) | | ------------------ | | | | 42| 128M|#define LINES_PER_GROUP (1L<(context)->code = start; 629| 2.91k| return false; 630| 2.91k| } 631| 128M| ++start; 632| 128M| } 633| 4.02M| } 634| 4.02M| return true; 635| 4.02M|} unames.cpp:_ZN6icu_78L11compareNameEPNS_10UCharNamesEPKht15UCharNameChoicePKc: 333| 128M| const char *otherName) { 334| 128M| uint16_t* tokens = reinterpret_cast(names) + 8; 335| 128M| uint16_t token, tokenCount=*tokens++; 336| 128M| uint8_t* tokenStrings = reinterpret_cast(names) + names->tokenStringOffset; 337| 128M| uint8_t c; 338| 128M| const char *origOtherName = otherName; 339| | 340| 128M| if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) { ------------------ | Branch (340:8): [True: 128M, False: 0] | Branch (340:43): [True: 0, False: 128M] ------------------ 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| 128M| while(nameLength>0) { ------------------ | Branch (366:11): [True: 117M, False: 11.3M] ------------------ 367| 117M| --nameLength; 368| 117M| c=*name++; 369| | 370| 117M| if(c>=tokenCount) { ------------------ | Branch (370:12): [True: 0, False: 117M] ------------------ 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| 117M| } else { 381| 117M| token=tokens[c]; 382| 117M| if (token == static_cast(-2)) { ------------------ | Branch (382:17): [True: 22.4M, False: 95.0M] ------------------ 383| | /* this is a lead byte for a double-byte token */ 384| 22.4M| token=tokens[c<<8|*name++]; 385| 22.4M| --nameLength; 386| 22.4M| } 387| 117M| if (token == static_cast(-1)) { ------------------ | Branch (387:17): [True: 1.90M, False: 115M] ------------------ 388| 1.90M| if(c!=';') { ------------------ | Branch (388:20): [True: 1.90M, False: 0] ------------------ 389| | /* explicit letter */ 390| 1.90M| if (static_cast(c) != *otherName++) { ------------------ | Branch (390:25): [True: 1.85M, False: 47.5k] ------------------ 391| 1.85M| return false; 392| 1.85M| } 393| 1.90M| } 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| 115M| } else { 406| | /* write token word */ 407| 115M| uint8_t *tokenString=tokenStrings+token; 408| 118M| while((c=*tokenString++)!=0) { ------------------ | Branch (408:23): [True: 118M, False: 2.54k] ------------------ 409| 118M| if (static_cast(c) != *otherName++) { ------------------ | Branch (409:25): [True: 115M, False: 3.07M] ------------------ 410| 115M| return false; 411| 115M| } 412| 118M| } 413| 115M| } 414| 117M| } 415| 117M| } 416| | 417| | /* complete match? */ 418| 11.3M| return *otherName == 0; 419| 128M|} unames.cpp:_ZN6icu_78L18expandGroupLengthsEPKhPtS2_: 516| 4.02M| 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| 4.02M| uint16_t i=0, offset=0, length=0; 519| 4.02M| uint8_t lengthByte; 520| | 521| | /* all 32 lengths must be read to get the offset of the first group string */ 522| 72.0M| while(i=12) { ------------------ | Branch (526:12): [True: 2.73M, False: 65.3M] ------------------ 527| | /* double-nibble length spread across two bytes */ 528| 2.73M| length = static_cast(((length & 0x3) << 4 | lengthByte >> 4) + 12); 529| 2.73M| lengthByte&=0xf; 530| 65.3M| } else if((lengthByte /* &0xf0 */)>=0xc0) { ------------------ | Branch (530:19): [True: 3.76M, False: 61.5M] ------------------ 531| | /* double-nibble length spread across this one byte */ 532| 3.76M| length = static_cast((lengthByte & 0x3f) + 12); 533| 61.5M| } else { 534| | /* single-nibble length in MSBs */ 535| 61.5M| length = static_cast(lengthByte >> 4); 536| 61.5M| lengthByte&=0xf; 537| 61.5M| } 538| | 539| 68.0M| *offsets++=offset; 540| 68.0M| *lengths++=length; 541| | 542| 68.0M| offset+=length; 543| 68.0M| ++i; 544| | 545| | /* read odd nibble - LSBs of lengthByte */ 546| 68.0M| if((lengthByte&0xf0)==0) { ------------------ | Branch (546:12): [True: 64.2M, False: 3.76M] ------------------ 547| | /* this nibble was not consumed for a double-nibble length above */ 548| 64.2M| length=lengthByte; 549| 64.2M| if(length<12) { ------------------ | Branch (549:16): [True: 61.5M, False: 2.73M] ------------------ 550| | /* single-nibble length in LSBs */ 551| 61.5M| *offsets++=offset; 552| 61.5M| *lengths++=length; 553| | 554| 61.5M| offset+=length; 555| 61.5M| ++i; 556| 61.5M| } 557| 64.2M| } else { 558| 3.76M| length=0; /* prevent double-nibble detection in the next iteration */ 559| 3.76M| } 560| 68.0M| } 561| | 562| | /* now, s is at the first group string */ 563| 4.02M| return s; 564| 4.02M|} _ZN6icu_789BytesTrieC2EPKv: 72| 52.1k| : ownedArray_(nullptr), bytes_(static_cast(trieBytes)), 73| 52.1k| pos_(bytes_), remainingMatchLength_(-1) {} _ZNK6icu_789BytesTrie8getValueEv: 246| 36.0k| inline int32_t getValue() const { 247| 36.0k| const uint8_t *pos=pos_; 248| 36.0k| int32_t leadByte=*pos++; 249| | // U_ASSERT(leadByte>=kMinValueLead); 250| 36.0k| return readValue(pos, leadByte>>1); 251| 36.0k| } _ZN6icu_789BytesTrie4stopEv: 399| 10.6k| inline void stop() { 400| 10.6k| pos_=nullptr; 401| 10.6k| } _ZN6icu_789BytesTrie9skipValueEPKhi: 406| 130k| static inline const uint8_t *skipValue(const uint8_t *pos, int32_t leadByte) { 407| | // U_ASSERT(leadByte>=kMinValueLead); 408| 130k| if(leadByte>=(kMinTwoByteValueLead<<1)) { ------------------ | Branch (408:12): [True: 78.4k, False: 51.9k] ------------------ 409| 78.4k| if(leadByte<(kMinThreeByteValueLead<<1)) { ------------------ | Branch (409:16): [True: 69.3k, False: 9.13k] ------------------ 410| 69.3k| ++pos; 411| 69.3k| } else if(leadByte<(kFourByteValueLead<<1)) { ------------------ | Branch (411:23): [True: 7.41k, False: 1.72k] ------------------ 412| 7.41k| pos+=2; 413| 7.41k| } else { 414| 1.72k| pos+=3+((leadByte>>1)&1); 415| 1.72k| } 416| 78.4k| } 417| 130k| return pos; 418| 130k| } _ZN6icu_789BytesTrie9skipValueEPKh: 419| 122k| static inline const uint8_t *skipValue(const uint8_t *pos) { 420| 122k| int32_t leadByte=*pos++; 421| 122k| return skipValue(pos, leadByte); 422| 122k| } _ZN6icu_789BytesTrie9skipDeltaEPKh: 427| 66.3k| static inline const uint8_t *skipDelta(const uint8_t *pos) { 428| 66.3k| int32_t delta=*pos++; 429| 66.3k| if(delta>=kMinTwoByteDeltaLead) { ------------------ | Branch (429:12): [True: 46.6k, False: 19.7k] ------------------ 430| 46.6k| if(delta(USTRINGTRIE_INTERMEDIATE_VALUE - (node & kValueIsFinal)); 443| 37.7k| } _ZN6icu_7814ConstChar16PtrC2EPKDs: 229| 7.58k|ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) : p_(p) {} _ZN6icu_7814ConstChar16PtrD2Ev: 237| 7.58k|ConstChar16Ptr::~ConstChar16Ptr() { 238| 7.58k| U_ALIASING_BARRIER(p_); ------------------ | | 35| 7.58k|# define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory") ------------------ 239| 7.58k|} _ZNK6icu_7814ConstChar16PtrcvPKDsEv: 205| 7.58k| inline operator const char16_t *() const { return get(); } _ZNK6icu_7814ConstChar16Ptr3getEv: 241| 7.58k|const char16_t *ConstChar16Ptr::get() const { return p_; } _ZN6icu_788internal15toU16StringViewENSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 400| 3.85k|inline std::u16string_view toU16StringView(std::u16string_view sv) { return sv; } _ZN6icu_7812LocalPointerINS_10UnicodeSetEEC2EPS1_: 200| 5.36k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEEC2EPS1_: 82| 5.36k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_10UnicodeSetEED2Ev: 245| 5.36k| ~LocalPointer() { 246| 5.36k| delete LocalPointerBase::ptr; 247| 5.36k| } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEED2Ev: 88| 5.36k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7812LocalPointerINS_10UnicodeSetEE12adoptInsteadEPS1_: 300| 58.4k| void adoptInstead(T *p) { 301| 58.4k| delete LocalPointerBase::ptr; 302| 58.4k| LocalPointerBase::ptr=p; 303| 58.4k| } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEEptEv: 134| 63.3k| T *operator->() const { return ptr; } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEEC2EPS1_: 82| 482k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_13UnicodeStringEED2Ev: 245| 482k| ~LocalPointer() { 246| 482k| delete LocalPointerBase::ptr; 247| 482k| } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEED2Ev: 88| 482k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEE6orphanEv: 141| 482k| T *orphan() { 142| 482k| T *p=ptr; 143| 482k| ptr=nullptr; 144| 482k| return p; 145| 482k| } _ZN6icu_7812LocalPointerINS_13UnicodeStringEEC2EPS1_: 200| 482k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZNK6icu_7816LocalPointerBaseINS_13UnicodeStringEE6isNullEv: 94| 482k| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEE6isNullEv: 94| 46| UBool isNull() const { return ptr==nullptr; } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEE6orphanEv: 141| 46| T *orphan() { 142| 46| T *p=ptr; 143| 46| ptr=nullptr; 144| 46| return p; 145| 46| } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEE8getAliasEv: 122| 9| T *getAlias() const { return ptr; } _ZN6icu_7813ParsePositionC2Ei: 70| 42.6k| : UObject(), 71| 42.6k| index(newIndex), 72| 42.6k| errorIndex(-1) 73| 42.6k| {} _ZNK6icu_7813ParsePosition8getIndexEv: 212| 368M|{ 213| 368M| return index; 214| 368M|} _ZN6icu_7813ParsePosition8setIndexEi: 218| 120M|{ 219| 120M| this->index = offset; 220| 120M|} _ZN6icu_7811ReplaceableC2Ev: 243| 3.32M|inline Replaceable::Replaceable() {} _ZNK6icu_7811StringPiece4dataEv: 200| 14| const char* data() const { return ptr_; } _ZNK6icu_7811StringPiece6lengthEv: 212| 14| int32_t length() const { return length_; } _ZN6icu_7810UnicodeSet10setPatternERKNS_13UnicodeStringE: 1830| 1.55k| void setPattern(const UnicodeString& newPat) { 1831| 1.55k| setPattern(newPat.getBuffer(), newPat.length()); 1832| 1.55k| } _ZNK6icu_7810UnicodeSet8isFrozenEv: 1848| 29.6M|inline UBool UnicodeSet::isFrozen() const { 1849| 29.6M| return bmpSet != nullptr || stringSpan != nullptr; ------------------ | Branch (1849:12): [True: 0, False: 29.6M] | Branch (1849:33): [True: 0, False: 29.6M] ------------------ 1850| 29.6M|} _ZNK6icu_7810UnicodeSet7isBogusEv: 1864| 28.3M|inline UBool UnicodeSet::isBogus() const { 1865| 28.3M| return fFlags & kIsBogus; 1866| 28.3M|} _ZN6icu_7810UnicodeSet8fromUSetEPK4USet: 1872| 2.79k|inline const UnicodeSet *UnicodeSet::fromUSet(const USet *uset) { 1873| 2.79k| return reinterpret_cast(uset); 1874| 2.79k|} _ZNK6icu_7810UnicodeSet6toUSetEv: 1880| 2.79k|inline const USet *UnicodeSet::toUSet() const { 1881| 2.79k| return reinterpret_cast(this); 1882| 2.79k|} _ZNK6icu_7813UnicodeString8doEqualsERKS0_i: 3773| 2.96M| inline UBool doEquals(const UnicodeString &text, int32_t len) const { 3774| 2.96M| return doEquals(text.getArrayStart(), len); 3775| 2.96M| } _ZNK6icu_7813UnicodeString8pinIndexERi: 4138| 156k|{ 4139| | // pin index 4140| 156k| if(start < 0) { ------------------ | Branch (4140:6): [True: 0, False: 156k] ------------------ 4141| 0| start = 0; 4142| 156k| } else if(start > length()) { ------------------ | Branch (4142:13): [True: 0, False: 156k] ------------------ 4143| 0| start = length(); 4144| 0| } 4145| 156k|} _ZNK6icu_7813UnicodeString10pinIndicesERiS1_: 4150| 5.23M|{ 4151| | // pin indices 4152| 5.23M| int32_t len = length(); 4153| 5.23M| if(start < 0) { ------------------ | Branch (4153:6): [True: 0, False: 5.23M] ------------------ 4154| 0| start = 0; 4155| 5.23M| } else if(start > len) { ------------------ | Branch (4155:13): [True: 0, False: 5.23M] ------------------ 4156| 0| start = len; 4157| 0| } 4158| 5.23M| if(_length < 0) { ------------------ | Branch (4158:6): [True: 0, False: 5.23M] ------------------ 4159| 0| _length = 0; 4160| 5.23M| } else if(_length > (len - start)) { ------------------ | Branch (4160:13): [True: 34.5k, False: 5.19M] ------------------ 4161| 34.5k| _length = (len - start); 4162| 34.5k| } 4163| 5.23M|} _ZN6icu_7813UnicodeString13getArrayStartEv: 4166| 353M|UnicodeString::getArrayStart() { 4167| 353M| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4167:10): [True: 35.4M, False: 318M] ------------------ 4168| 318M| fUnion.fStackFields.fBuffer : fUnion.fFields.fArray; 4169| 353M|} _ZNK6icu_7813UnicodeString13getArrayStartEv: 4172| 354M|UnicodeString::getArrayStart() const { 4173| 354M| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4173:10): [True: 10.2M, False: 344M] ------------------ 4174| 344M| fUnion.fStackFields.fBuffer : fUnion.fFields.fArray; 4175| 354M|} _ZNK6icu_7813UnicodeString14hasShortLengthEv: 4202| 1.29G|UnicodeString::hasShortLength() const { 4203| 1.29G| return fUnion.fFields.fLengthAndFlags>=0; 4204| 1.29G|} _ZNK6icu_7813UnicodeString14getShortLengthEv: 4207| 235M|UnicodeString::getShortLength() const { 4208| | // fLengthAndFlags must be non-negative -> short length >= 0 4209| | // and arithmetic or logical shift does not matter. 4210| 235M| return fUnion.fFields.fLengthAndFlags>>kLengthShift; 4211| 235M|} _ZNK6icu_7813UnicodeString6lengthEv: 4214| 1.29G|UnicodeString::length() const { 4215| 1.29G| return hasShortLength() ? getShortLength() : fUnion.fFields.fLength; ------------------ | Branch (4215:10): [True: 235M, False: 1.05G] ------------------ 4216| 1.29G|} _ZNK6icu_7813UnicodeString11getCapacityEv: 4219| 353M|UnicodeString::getCapacity() const { 4220| 353M| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4220:10): [True: 36.6M, False: 317M] ------------------ 4221| 317M| US_STACKBUF_SIZE : fUnion.fFields.fCapacity; 4222| 353M|} _ZNK6icu_7813UnicodeString7isBogusEv: 4230| 117M|{ return fUnion.fFields.fLengthAndFlags & kIsBogus; } _ZNK6icu_7813UnicodeString10isWritableEv: 4234| 352M|{ return !(fUnion.fFields.fLengthAndFlags & (kOpenGetBuffer | kIsBogus)); } _ZNK6icu_7813UnicodeString16isBufferWritableEv: 4238| 350M|{ 4239| 350M| return 4240| 350M| !(fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kIsBogus|kBufferIsReadonly)) && ------------------ | Branch (4240:7): [True: 350M, False: 0] ------------------ 4241| 350M| (!(fUnion.fFields.fLengthAndFlags&kRefCounted) || refCount()==1); ------------------ | Branch (4241:8): [True: 35.4M, False: 315M] | Branch (4241:57): [True: 315M, False: 13.2k] ------------------ 4242| 350M|} _ZNK6icu_7813UnicodeString9getBufferEv: 4245| 164k|UnicodeString::getBuffer() const { 4246| 164k| if(fUnion.fFields.fLengthAndFlags&(kIsBogus|kOpenGetBuffer)) { ------------------ | Branch (4246:6): [True: 0, False: 164k] ------------------ 4247| 0| return nullptr; 4248| 164k| } else if(fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) { ------------------ | Branch (4248:13): [True: 130k, False: 33.7k] ------------------ 4249| 130k| return fUnion.fStackFields.fBuffer; 4250| 130k| } else { 4251| 33.7k| return fUnion.fFields.fArray; 4252| 33.7k| } 4253| 164k|} _ZNK6icu_7813UnicodeString9doCompareEiiRKS0_ii: 4264| 2.48M|{ 4265| 2.48M| if(srcText.isBogus()) { ------------------ | Branch (4265:6): [True: 0, False: 2.48M] ------------------ 4266| 0| return static_cast(!isBogus()); // 0 if both are bogus, 1 otherwise 4267| 2.48M| } else { 4268| 2.48M| srcText.pinIndices(srcStart, srcLength); 4269| 2.48M| return doCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength); 4270| 2.48M| } 4271| 2.48M|} _ZNK6icu_7813UnicodeStringeqERKS0_: 4290| 56.0M|{ 4291| 56.0M| if(isBogus()) { ------------------ | Branch (4291:6): [True: 0, False: 56.0M] ------------------ 4292| 0| return text.isBogus(); 4293| 56.0M| } else { 4294| 56.0M| int32_t len = length(), textLength = text.length(); 4295| 56.0M| return !text.isBogus() && len == textLength && doEquals(text, len); ------------------ | Branch (4295:12): [True: 56.0M, False: 0] | Branch (4295:31): [True: 2.96M, False: 53.0M] | Branch (4295:52): [True: 14.4k, False: 2.94M] ------------------ 4296| 56.0M| } 4297| 56.0M|} _ZNK6icu_7813UnicodeString7compareERKS0_: 4321| 2.48M|{ return doCompare(0, length(), text, 0, text.length()); } _ZNK6icu_7813UnicodeString7indexOfEPKDsii: 4536| 16.8k| int32_t start) const { 4537| 16.8k| pinIndex(start); 4538| 16.8k| return indexOf(srcChars, 0, srcLength, start, length() - start); 4539| 16.8k|} _ZNK6icu_7813UnicodeString7indexOfEDsi: 4570| 46.6k| int32_t start) const { 4571| 46.6k| pinIndex(start); 4572| 46.6k| return doIndexOf(c, start, length() - start); 4573| 46.6k|} _ZN6icu_7813UnicodeString7replaceEiiRKS0_ii: 4741| 125k|{ return doReplace(start, _length, srcText, srcStart, srcLength); } _ZNK6icu_7813UnicodeString9doExtractEiiRS0_: 4799| 125k|{ target.replace(0, target.length(), *this, start, _length); } _ZNK6icu_7813UnicodeString7extractEiiRS0_: 4812| 78.8k|{ doExtract(start, _length, target); } _ZNK6icu_7813UnicodeString8doCharAtEi: 4846| 238k|{ 4847| 238k| if (static_cast(offset) < static_cast(length())) { ------------------ | Branch (4847:7): [True: 238k, False: 0] ------------------ 4848| 238k| return getArrayStart()[offset]; 4849| 238k| } else { 4850| 0| return kInvalidUChar; 4851| 0| } 4852| 238k|} _ZNK6icu_7813UnicodeString6charAtEi: 4856| 237k|{ return doCharAt(offset); } _ZNK6icu_7813UnicodeStringixEi: 4860| 894|{ return doCharAt(offset); } _ZNK6icu_7813UnicodeString7isEmptyEv: 4863| 486k|UnicodeString::isEmpty() const { 4864| | // Arithmetic or logical right shift does not matter: only testing for 0. 4865| 486k| return (fUnion.fFields.fLengthAndFlags>>kLengthShift) == 0; 4866| 486k|} _ZN6icu_7813UnicodeString13setZeroLengthEv: 4872| 644|UnicodeString::setZeroLength() { 4873| 644| fUnion.fFields.fLengthAndFlags &= kAllStorageFlags; 4874| 644|} _ZN6icu_7813UnicodeString14setShortLengthEi: 4877| 104M|UnicodeString::setShortLength(int32_t len) { 4878| | // requires 0 <= len <= kMaxShortLength 4879| 104M| fUnion.fFields.fLengthAndFlags = 4880| 104M| static_cast((fUnion.fFields.fLengthAndFlags & kAllStorageFlags) | (len << kLengthShift)); 4881| 104M|} _ZN6icu_7813UnicodeString9setLengthEi: 4884| 352M|UnicodeString::setLength(int32_t len) { 4885| 352M| if(len <= kMaxShortLength) { ------------------ | Branch (4885:6): [True: 104M, False: 248M] ------------------ 4886| 104M| setShortLength(len); 4887| 248M| } else { 4888| 248M| fUnion.fFields.fLengthAndFlags |= kLengthIsLarge; 4889| 248M| fUnion.fFields.fLength = len; 4890| 248M| } 4891| 352M|} _ZN6icu_7813UnicodeString10setToEmptyEv: 4894| 16.4k|UnicodeString::setToEmpty() { 4895| 16.4k| fUnion.fFields.fLengthAndFlags = kShortString; 4896| 16.4k|} _ZN6icu_7813UnicodeString8setArrayEPDsii: 4899| 7.38k|UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) { 4900| 7.38k| setLength(len); 4901| 7.38k| fUnion.fFields.fArray = array; 4902| 7.38k| fUnion.fFields.fCapacity = capacity; 4903| 7.38k|} _ZN6icu_7813UnicodeString5setToEPKDsi: 4940| 799|{ 4941| 799| unBogus(); 4942| 799| return doReplace(0, length(), srcChars, 0, srcLength); 4943| 799|} _ZN6icu_7813UnicodeString6appendERKS0_ii: 4963| 29.9k|{ return doAppend(srcText, srcStart, srcLength); } _ZN6icu_7813UnicodeString6appendERKS0_: 4967| 43.3k|{ return doAppend(srcText, 0, srcText.length()); } _ZN6icu_7813UnicodeString6appendENS_14ConstChar16PtrEi: 4978| 198|{ return doAppend(srcChars, 0, srcLength); } _ZN6icu_7813UnicodeString6appendEDs: 4982| 332M|{ return doAppend(&srcChar, 0, 1); } _ZN6icu_7813UnicodeString8truncateEi: 5069| 54.8k|{ 5070| 54.8k| if(isBogus() && targetLength == 0) { ------------------ | Branch (5070:6): [True: 0, False: 54.8k] | 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| 54.8k| } else if (static_cast(targetLength) < static_cast(length())) { ------------------ | Branch (5074:14): [True: 38.7k, False: 16.1k] ------------------ 5075| 38.7k| setLength(targetLength); 5076| 38.7k| return true; 5077| 38.7k| } else { 5078| 16.1k| return false; 5079| 16.1k| } 5080| 54.8k|} _ZN6icu_7813UnicodeStringC2Ev: 4182| 2.83M|UnicodeString::UnicodeString() { 4183| 2.83M| fUnion.fStackFields.fLengthAndFlags=kShortString; 4184| 2.83M|} _ZN6icu_7813UnicodeStringaSIA3_DsvEERS0_RKT_: 1960| 3.85k| inline UnicodeString &operator=(const S &src) { 1961| 3.85k| unBogus(); 1962| 3.85k| return doReplace(0, length(), internal::toU16StringView(src)); 1963| 3.85k| } uniset.cpp:_ZL9U_FAILURE10UErrorCode: 737| 547k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset_props.cpp:_ZL9U_FAILURE10UErrorCode: 737| 48.4M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset_props.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 69.5k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uprops.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 134k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uprops.cpp:_ZL9U_FAILURE10UErrorCode: 737| 404k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ustrcase.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1.86k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ustrcase.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1.86k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ustring.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1.86k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uvector.cpp:_ZL9U_FAILURE10UErrorCode: 737| 514k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } characterproperties.cpp:_ZL9U_FAILURE10UErrorCode: 737| 84.8k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } characterproperties.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2.79k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } charstr.cpp:_ZL9U_FAILURE10UErrorCode: 737| 125k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2.cpp:_ZL9U_FAILURE10UErrorCode: 737| 5.02M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1.66M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ruleiter.cpp:_ZL9U_FAILURE10UErrorCode: 737| 83.7M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ubidi_props.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucase.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uchar.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3.55M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucptrie.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 11| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } udatamem.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } unames.cpp:_ZL9U_FAILURE10UErrorCode: 737| 10.9k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } unames.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 3.63k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ucmndata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } _ZN6icu_7814UnicodeMatcherD2Ev: 23| 159k|UnicodeMatcher::~UnicodeMatcher() {} _ZN6icu_7813UnicodeFilterD2Ev: 25| 159k|UnicodeFilter::~UnicodeFilter() {} _ZN6icu_7814UnicodeFunctorD2Ev: 16| 159k|UnicodeFunctor::~UnicodeFunctor() {} _ZNK6icu_7810UnicodeSet10hasStringsEv: 120| 1.24M|UBool UnicodeSet::hasStrings() const { 121| 1.24M| return strings_ != nullptr && !strings_->isEmpty(); ------------------ | Branch (121:12): [True: 16.3k, False: 1.22M] | Branch (121:35): [True: 9.15k, False: 7.14k] ------------------ 122| 1.24M|} _ZNK6icu_7810UnicodeSet15stringsContainsERKNS_13UnicodeStringE: 128| 499k|UBool UnicodeSet::stringsContains(const UnicodeString &s) const { 129| 499k| return strings_ != nullptr && strings_->contains((void*) &s); ------------------ | Branch (129:12): [True: 461k, False: 37.9k] | Branch (129:35): [True: 11.7k, False: 449k] ------------------ 130| 499k|} _ZN6icu_7810UnicodeSetC2Ev: 139| 154k|UnicodeSet::UnicodeSet() { 140| 154k| list[0] = UNICODESET_HIGH; ------------------ | | 34| 154k|#define UNICODESET_HIGH 0x0110000 ------------------ 141| 154k| _dbgct(this); 142| 154k|} _ZN6icu_7810UnicodeSetC2Eii: 151| 10|UnicodeSet::UnicodeSet(UChar32 start, UChar32 end) { 152| 10| list[0] = UNICODESET_HIGH; ------------------ | | 34| 10|#define UNICODESET_HIGH 0x0110000 ------------------ 153| 10| add(start, end); 154| 10| _dbgct(this); 155| 10|} _ZN6icu_7810UnicodeSetD2Ev: 189| 159k|UnicodeSet::~UnicodeSet() { 190| 159k| _dbgdt(this); // first! 191| 159k| if (list != stackList) { ------------------ | Branch (191:9): [True: 62.7k, False: 97.0k] ------------------ 192| 62.7k| uprv_free(list); ------------------ | | 1503| 62.7k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 62.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 62.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 62.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 193| 62.7k| } 194| 159k| delete bmpSet; 195| 159k| if (buffer != stackList) { ------------------ | Branch (195:9): [True: 114k, False: 45.4k] ------------------ 196| 114k| uprv_free(buffer); ------------------ | | 1503| 114k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 114k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 114k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 114k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 197| 114k| } 198| 159k| delete strings_; 199| 159k| delete stringSpan; 200| 159k| releasePattern(); 201| 159k|} _ZN6icu_7810UnicodeSetaSERKS0_: 206| 328|UnicodeSet& UnicodeSet::operator=(const UnicodeSet& o) { 207| 328| return copyFrom(o, false); 208| 328|} _ZN6icu_7810UnicodeSet8copyFromERKS0_a: 210| 3.12k|UnicodeSet& UnicodeSet::copyFrom(const UnicodeSet& o, UBool asThawed) { 211| 3.12k| if (this == &o) { ------------------ | Branch (211:9): [True: 0, False: 3.12k] ------------------ 212| 0| return *this; 213| 0| } 214| 3.12k| if (isFrozen()) { ------------------ | Branch (214:9): [True: 0, False: 3.12k] ------------------ 215| 0| return *this; 216| 0| } 217| 3.12k| if (o.isBogus()) { ------------------ | Branch (217:9): [True: 0, False: 3.12k] ------------------ 218| 0| setToBogus(); 219| 0| return *this; 220| 0| } 221| 3.12k| if (!ensureCapacity(o.len)) { ------------------ | Branch (221:9): [True: 0, False: 3.12k] ------------------ 222| | // ensureCapacity will mark the UnicodeSet as Bogus if OOM failure happens. 223| 0| return *this; 224| 0| } 225| 3.12k| len = o.len; 226| 3.12k| uprv_memcpy(list, o.list, (size_t)len*sizeof(UChar32)); ------------------ | | 42| 3.12k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 3.12k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 3.12k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 3.12k| _Pragma("clang diagnostic push") \ | | 45| 3.12k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 3.12k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 3.12k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 3.12k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 3.12k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 3.12k| _Pragma("clang diagnostic pop") \ | | 49| 3.12k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 3.12k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 3.12k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 3.12k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 227| 3.12k| if (o.bmpSet != nullptr && !asThawed) { ------------------ | Branch (227:9): [True: 2.79k, False: 328] | Branch (227:32): [True: 0, False: 2.79k] ------------------ 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| 3.12k| if (o.hasStrings()) { ------------------ | Branch (234:9): [True: 0, False: 3.12k] ------------------ 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| 3.12k| } else if (hasStrings()) { ------------------ | Branch (241:16): [True: 352, False: 2.77k] ------------------ 242| 352| strings_->removeAllElements(); 243| 352| } 244| 3.12k| if (o.stringSpan != nullptr && !asThawed) { ------------------ | Branch (244:9): [True: 0, False: 3.12k] | 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| 3.12k| releasePattern(); 252| 3.12k| if (o.pat) { ------------------ | Branch (252:9): [True: 0, False: 3.12k] ------------------ 253| 0| setPattern(o.pat, o.patLen); 254| 0| } 255| 3.12k| return *this; 256| 3.12k|} _ZNK6icu_7810UnicodeSet13findCodePointEi: 370| 279M|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| 279M| if (c < list[0]) ------------------ | Branch (383:9): [True: 1.39M, False: 277M] ------------------ 384| 1.39M| return 0; 385| | // High runner test. c is often after the last range, so an 386| | // initial check for this condition pays off. 387| 277M| int32_t lo = 0; 388| 277M| int32_t hi = len - 1; 389| 277M| if (lo >= hi || c >= list[hi-1]) ------------------ | Branch (389:9): [True: 0, False: 277M] | Branch (389:21): [True: 6.78M, False: 270M] ------------------ 390| 6.78M| return hi; 391| | // invariant: c >= list[lo] 392| | // invariant: c < list[hi] 393| 2.57G| for (;;) { 394| 2.57G| int32_t i = (lo + hi) >> 1; 395| 2.57G| if (i == lo) { ------------------ | Branch (395:13): [True: 270M, False: 2.30G] ------------------ 396| 270M| break; // Found! 397| 2.30G| } else if (c < list[i]) { ------------------ | Branch (397:20): [True: 1.83G, False: 468M] ------------------ 398| 1.83G| hi = i; 399| 1.83G| } else { 400| 468M| lo = i; 401| 468M| } 402| 2.57G| } 403| 270M| return hi; 404| 277M|} _ZN6icu_7810UnicodeSet3setEii: 748| 1.72k|UnicodeSet& UnicodeSet::set(UChar32 start, UChar32 end) { 749| 1.72k| clear(); 750| 1.72k| complement(start, end); 751| 1.72k| return *this; 752| 1.72k|} _ZN6icu_7810UnicodeSet3addEii: 765| 35.0M|UnicodeSet& UnicodeSet::add(UChar32 start, UChar32 end) { 766| 35.0M| if (pinCodePoint(start) < pinCodePoint(end)) { ------------------ | Branch (766:9): [True: 3.02M, False: 31.9M] ------------------ 767| 3.02M| UChar32 limit = end + 1; 768| | // Fast path for adding a new range after the last one. 769| | // Odd list length: [..., lastStart, lastLimit, HIGH] 770| 3.02M| if ((len & 1) != 0) { ------------------ | Branch (770:13): [True: 3.02M, False: 198] ------------------ 771| | // If the list is empty, set lastLimit low enough to not be adjacent to 0. 772| 3.02M| UChar32 lastLimit = len == 1 ? -2 : list[len - 2]; ------------------ | Branch (772:33): [True: 16.1k, False: 3.00M] ------------------ 773| 3.02M| if (lastLimit <= start && !isFrozen() && !isBogus()) { ------------------ | Branch (773:17): [True: 3.02M, False: 806] | Branch (773:39): [True: 3.02M, False: 0] | Branch (773:54): [True: 3.02M, False: 0] ------------------ 774| 3.02M| if (lastLimit == start) { ------------------ | Branch (774:21): [True: 670, False: 3.02M] ------------------ 775| | // Extend the last range. 776| 670| list[len - 2] = limit; 777| 670| if (limit == UNICODESET_HIGH) { ------------------ | | 34| 670|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (777:25): [True: 190, False: 480] ------------------ 778| 190| --len; 779| 190| } 780| 3.02M| } else { 781| 3.02M| list[len - 1] = start; 782| 3.02M| if (limit < UNICODESET_HIGH) { ------------------ | | 34| 3.02M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (782:25): [True: 3.01M, False: 4.30k] ------------------ 783| 3.01M| if (ensureCapacity(len + 2)) { ------------------ | Branch (783:29): [True: 3.01M, False: 0] ------------------ 784| 3.01M| list[len++] = limit; 785| 3.01M| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 3.01M|#define UNICODESET_HIGH 0x0110000 ------------------ 786| 3.01M| } 787| 3.01M| } else { // limit == UNICODESET_HIGH 788| 4.30k| if (ensureCapacity(len + 1)) { ------------------ | Branch (788:29): [True: 4.30k, False: 0] ------------------ 789| 4.30k| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 4.30k|#define UNICODESET_HIGH 0x0110000 ------------------ 790| 4.30k| } 791| 4.30k| } 792| 3.02M| } 793| 3.02M| releasePattern(); 794| 3.02M| return *this; 795| 3.02M| } 796| 3.02M| } 797| | // This is slow. Could be much faster using findCodePoint(start) 798| | // and modifying the list, dealing with adjacent & overlapping ranges. 799| 1.00k| UChar32 range[3] = { start, limit, UNICODESET_HIGH }; ------------------ | | 34| 1.00k|#define UNICODESET_HIGH 0x0110000 ------------------ 800| 1.00k| add(range, 2, 0); 801| 31.9M| } else if (start == end) { ------------------ | Branch (801:16): [True: 31.9M, False: 0] ------------------ 802| 31.9M| add(start); 803| 31.9M| } 804| 31.9M| return *this; 805| 35.0M|} _ZN6icu_7810UnicodeSet3addEi: 833| 279M|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| 279M| int32_t i = findCodePoint(pinCodePoint(c)); 838| | 839| | // already in set? 840| 279M| if ((i & 1) != 0 || isFrozen() || isBogus()) return *this; ------------------ | Branch (840:9): [True: 258M, False: 20.8M] | Branch (840:26): [True: 0, False: 20.8M] | Branch (840:40): [True: 0, False: 20.8M] ------------------ 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| 20.8M| if (c == list[i]-1) { ------------------ | Branch (863:9): [True: 1.71M, False: 19.1M] ------------------ 864| | // c is before start of next range 865| 1.71M| list[i] = c; 866| | // if we touched the HIGH mark, then add a new one 867| 1.71M| if (c == (UNICODESET_HIGH - 1)) { ------------------ | | 34| 1.71M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (867:13): [True: 4.54k, False: 1.71M] ------------------ 868| 4.54k| if (!ensureCapacity(len+1)) { ------------------ | Branch (868:17): [True: 0, False: 4.54k] ------------------ 869| | // ensureCapacity will mark the object as Bogus if OOM failure happens. 870| 0| return *this; 871| 0| } 872| 4.54k| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 4.54k|#define UNICODESET_HIGH 0x0110000 ------------------ 873| 4.54k| } 874| 1.71M| if (i > 0 && c == list[i-1]) { ------------------ | Branch (874:13): [True: 1.70M, False: 5.59k] | Branch (874:22): [True: 728k, False: 980k] ------------------ 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: 17.7M, False: 1.39M] | Branch (893:23): [True: 1.02M, False: 16.7M] ------------------ 894| | // c is after end of prior range 895| 1.02M| list[i-1]++; 896| | // no need to check for collapse here 897| 1.02M| } 898| | 899| 18.1M| 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| 18.1M| if (!ensureCapacity(len+2)) { ------------------ | Branch (912:13): [True: 0, False: 18.1M] ------------------ 913| | // ensureCapacity will mark the object as Bogus if OOM failure happens. 914| 0| return *this; 915| 0| } 916| | 917| 18.1M| UChar32 *p = list + i; 918| 18.1M| uprv_memmove(p + 2, p, (len - i) * sizeof(*p)); ------------------ | | 51| 18.1M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 18.1M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 18.1M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 18.1M| _Pragma("clang diagnostic push") \ | | 54| 18.1M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 18.1M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 18.1M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 18.1M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 18.1M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 18.1M| _Pragma("clang diagnostic pop") \ | | 58| 18.1M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 18.1M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 18.1M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 18.1M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 919| 18.1M| list[i] = c; 920| 18.1M| list[i+1] = c+1; 921| 18.1M| len += 2; 922| 18.1M| } 923| | 924| |#ifdef DEBUG_US_ADD 925| | dump(list, len); 926| | printf("\n"); 927| | 928| | for (i=1; i(cp)); 960| 2.98k| } 961| 65.1k| return *this; 962| 65.1k|} _ZN6icu_7810UnicodeSet4_addERKNS_13UnicodeStringE: 968| 482k|void UnicodeSet::_add(const UnicodeString& s) { 969| 482k| if (isFrozen() || isBogus()) { ------------------ | Branch (969:9): [True: 0, False: 482k] | Branch (969:23): [True: 0, False: 482k] ------------------ 970| 0| return; 971| 0| } 972| 482k| UErrorCode ec = U_ZERO_ERROR; 973| 482k| if (strings_ == nullptr && !allocateStrings(ec)) { ------------------ | Branch (973:9): [True: 32.7k, False: 449k] | Branch (973:32): [True: 0, False: 32.7k] ------------------ 974| 0| setToBogus(); 975| 0| return; 976| 0| } 977| 482k| LocalPointer t(new UnicodeString(s)); 978| 482k| if (t.isNull()) { // Check for memory allocation error. ------------------ | Branch (978:9): [True: 0, False: 482k] ------------------ 979| 0| setToBogus(); 980| 0| return; 981| 0| } 982| 482k| strings_->sortedInsert(t.orphan(), compareUnicodeString, ec); 983| 482k| if (U_FAILURE(ec)) { ------------------ | Branch (983:9): [True: 0, False: 482k] ------------------ 984| 0| setToBogus(); 985| 0| } 986| 482k|} _ZN6icu_7810UnicodeSet11getSingleCPERKNS_13UnicodeStringE: 993| 81.1k|int32_t UnicodeSet::getSingleCP(const UnicodeString& s) { 994| 81.1k| int32_t sLength = s.length(); 995| 81.1k| if (sLength == 1) return s.charAt(0); ------------------ | Branch (995:9): [True: 2.82k, False: 78.3k] ------------------ 996| 78.3k| if (sLength == 2) { ------------------ | Branch (996:9): [True: 15.7k, False: 62.5k] ------------------ 997| 15.7k| UChar32 cp = s.char32At(0); 998| 15.7k| if (cp > 0xFFFF) { // is surrogate pair ------------------ | Branch (998:13): [True: 551, False: 15.2k] ------------------ 999| 551| return cp; 1000| 551| } 1001| 15.7k| } 1002| 77.7k| return -1; 1003| 78.3k|} _ZN6icu_7810UnicodeSet6addAllERKNS_13UnicodeStringE: 1011| 26.5k|UnicodeSet& UnicodeSet::addAll(const UnicodeString& s) { 1012| 26.5k| UChar32 cp; 1013| 247M| for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 247M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 246M, False: 138k] | | ------------------ ------------------ | Branch (1013:25): [True: 247M, False: 26.5k] ------------------ 1014| 247M| cp = s.char32At(i); 1015| 247M| add(cp); 1016| 247M| } 1017| 26.5k| return *this; 1018| 26.5k|} _ZN6icu_7810UnicodeSet9retainAllERKNS_13UnicodeStringE: 1026| 5.31k|UnicodeSet& UnicodeSet::retainAll(const UnicodeString& s) { 1027| 5.31k| UnicodeSet set; 1028| 5.31k| set.addAll(s); 1029| 5.31k| retainAll(set); 1030| 5.31k| return *this; 1031| 5.31k|} _ZN6icu_7810UnicodeSet13complementAllERKNS_13UnicodeStringE: 1039| 5.31k|UnicodeSet& UnicodeSet::complementAll(const UnicodeString& s) { 1040| 5.31k| UnicodeSet set; 1041| 5.31k| set.addAll(s); 1042| 5.31k| complementAll(set); 1043| 5.31k| return *this; 1044| 5.31k|} _ZN6icu_7810UnicodeSet9removeAllERKNS_13UnicodeStringE: 1052| 5.31k|UnicodeSet& UnicodeSet::removeAll(const UnicodeString& s) { 1053| 5.31k| UnicodeSet set; 1054| 5.31k| set.addAll(s); 1055| 5.31k| removeAll(set); 1056| 5.31k| return *this; 1057| 5.31k|} _ZN6icu_7810UnicodeSet16removeAllStringsEv: 1059| 1.20M|UnicodeSet& UnicodeSet::removeAllStrings() { 1060| 1.20M| if (!isFrozen() && hasStrings()) { ------------------ | Branch (1060:9): [True: 1.20M, False: 0] | Branch (1060:24): [True: 494, False: 1.20M] ------------------ 1061| 494| strings_->removeAllElements(); 1062| 494| releasePattern(); 1063| 494| } 1064| 1.20M| return *this; 1065| 1.20M|} _ZN6icu_7810UnicodeSet10createFromERKNS_13UnicodeStringE: 1074| 5.31k|UnicodeSet* U_EXPORT2 UnicodeSet::createFrom(const UnicodeString& s) { 1075| 5.31k| UnicodeSet *set = new UnicodeSet(); 1076| 5.31k| if (set != nullptr) { // Check for memory allocation error. ------------------ | Branch (1076:9): [True: 5.31k, False: 0] ------------------ 1077| 5.31k| set->add(s); 1078| 5.31k| } 1079| 5.31k| return set; 1080| 5.31k|} _ZN6icu_7810UnicodeSet13createFromAllERKNS_13UnicodeStringE: 1088| 5.31k|UnicodeSet* U_EXPORT2 UnicodeSet::createFromAll(const UnicodeString& s) { 1089| 5.31k| UnicodeSet *set = new UnicodeSet(); 1090| 5.31k| if (set != nullptr) { // Check for memory allocation error. ------------------ | Branch (1090:9): [True: 5.31k, False: 0] ------------------ 1091| 5.31k| set->addAll(s); 1092| 5.31k| } 1093| 5.31k| return set; 1094| 5.31k|} _ZN6icu_7810UnicodeSet6retainEii: 1106| 128|UnicodeSet& UnicodeSet::retain(UChar32 start, UChar32 end) { 1107| 128| if (pinCodePoint(start) <= pinCodePoint(end)) { ------------------ | Branch (1107:9): [True: 128, False: 0] ------------------ 1108| 128| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; ------------------ | | 34| 128|#define UNICODESET_HIGH 0x0110000 ------------------ 1109| 128| retain(range, 2, 0); 1110| 128| } else { 1111| 0| clear(); 1112| 0| } 1113| 128| return *this; 1114| 128|} _ZN6icu_7810UnicodeSet6retainERKNS_13UnicodeStringE: 1120| 5.31k|UnicodeSet& UnicodeSet::retain(const UnicodeString &s) { 1121| 5.31k| if (isFrozen() || isBogus()) { return *this; } ------------------ | Branch (1121:9): [True: 0, False: 5.31k] | Branch (1121:23): [True: 0, False: 5.31k] ------------------ 1122| 5.31k| UChar32 cp = getSingleCP(s); 1123| 5.31k| if (cp < 0) { ------------------ | Branch (1123:9): [True: 5.18k, False: 128] ------------------ 1124| 5.18k| bool isIn = stringsContains(s); 1125| | // Check for getRangeCount() first to avoid somewhat-expensive size() 1126| | // when there are single code points. 1127| 5.18k| if (isIn && getRangeCount() == 0 && size() == 1) { ------------------ | Branch (1127:13): [True: 0, False: 5.18k] | Branch (1127:21): [True: 0, False: 0] | Branch (1127:45): [True: 0, False: 0] ------------------ 1128| 0| return *this; 1129| 0| } 1130| 5.18k| clear(); 1131| 5.18k| if (isIn) { ------------------ | Branch (1131:13): [True: 0, False: 5.18k] ------------------ 1132| 0| _add(s); 1133| 0| } 1134| 5.18k| } else { 1135| 128| retain(cp, cp); 1136| 128| } 1137| 5.31k| return *this; 1138| 5.31k|} _ZN6icu_7810UnicodeSet6removeEii: 1151| 128|UnicodeSet& UnicodeSet::remove(UChar32 start, UChar32 end) { 1152| 128| if (pinCodePoint(start) <= pinCodePoint(end)) { ------------------ | Branch (1152:9): [True: 128, False: 0] ------------------ 1153| 128| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; ------------------ | | 34| 128|#define UNICODESET_HIGH 0x0110000 ------------------ 1154| 128| retain(range, 2, 2); 1155| 128| } 1156| 128| return *this; 1157| 128|} _ZN6icu_7810UnicodeSet6removeERKNS_13UnicodeStringE: 1175| 5.31k|UnicodeSet& UnicodeSet::remove(const UnicodeString& s) { 1176| 5.31k| if (isFrozen() || isBogus()) return *this; ------------------ | Branch (1176:9): [True: 0, False: 5.31k] | Branch (1176:23): [True: 0, False: 5.31k] ------------------ 1177| 5.31k| int32_t cp = getSingleCP(s); 1178| 5.31k| if (cp < 0) { ------------------ | Branch (1178:9): [True: 5.18k, False: 128] ------------------ 1179| 5.18k| if (strings_ != nullptr && strings_->removeElement((void*) &s)) { ------------------ | Branch (1179:13): [True: 0, False: 5.18k] | Branch (1179:36): [True: 0, False: 0] ------------------ 1180| 0| releasePattern(); 1181| 0| } 1182| 5.18k| } else { 1183| 128| remove(static_cast(cp), static_cast(cp)); 1184| 128| } 1185| 5.31k| return *this; 1186| 5.31k|} _ZN6icu_7810UnicodeSet10complementEii: 1199| 1.85k|UnicodeSet& UnicodeSet::complement(UChar32 start, UChar32 end) { 1200| 1.85k| if (isFrozen() || isBogus()) { ------------------ | Branch (1200:9): [True: 0, False: 1.85k] | Branch (1200:23): [True: 0, False: 1.85k] ------------------ 1201| 0| return *this; 1202| 0| } 1203| 1.85k| if (pinCodePoint(start) <= pinCodePoint(end)) { ------------------ | Branch (1203:9): [True: 1.85k, False: 0] ------------------ 1204| 1.85k| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; ------------------ | | 34| 1.85k|#define UNICODESET_HIGH 0x0110000 ------------------ 1205| 1.85k| exclusiveOr(range, 2, 0); 1206| 1.85k| } 1207| 1.85k| releasePattern(); 1208| 1.85k| return *this; 1209| 1.85k|} _ZN6icu_7810UnicodeSet10complementEv: 1219| 1.20M|UnicodeSet& UnicodeSet::complement() { 1220| 1.20M| if (isFrozen() || isBogus()) { ------------------ | Branch (1220:9): [True: 0, False: 1.20M] | Branch (1220:23): [True: 0, False: 1.20M] ------------------ 1221| 0| return *this; 1222| 0| } 1223| 1.20M| if (list[0] == UNICODESET_LOW) { ------------------ | | 37| 1.20M|#define UNICODESET_LOW 0x000000 ------------------ | Branch (1223:9): [True: 1.19M, False: 13.3k] ------------------ 1224| 1.19M| uprv_memmove(list, list + 1, (size_t)(len-1)*sizeof(UChar32)); ------------------ | | 51| 1.19M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.19M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 1.19M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 1.19M| _Pragma("clang diagnostic push") \ | | 54| 1.19M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 1.19M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.19M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 1.19M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.19M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 1.19M| _Pragma("clang diagnostic pop") \ | | 58| 1.19M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 1.19M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 1.19M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.19M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1225| 1.19M| --len; 1226| 1.19M| } else { 1227| 13.3k| if (!ensureCapacity(len+1)) { ------------------ | Branch (1227:13): [True: 0, False: 13.3k] ------------------ 1228| 0| return *this; 1229| 0| } 1230| 13.3k| uprv_memmove(list + 1, list, (size_t)len*sizeof(UChar32)); ------------------ | | 51| 13.3k|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 13.3k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 13.3k| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 13.3k| _Pragma("clang diagnostic push") \ | | 54| 13.3k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 13.3k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 13.3k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 13.3k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 13.3k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 13.3k| _Pragma("clang diagnostic pop") \ | | 58| 13.3k| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 13.3k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 13.3k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 13.3k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1231| 13.3k| list[0] = UNICODESET_LOW; ------------------ | | 37| 13.3k|#define UNICODESET_LOW 0x000000 ------------------ 1232| 13.3k| ++len; 1233| 13.3k| } 1234| 1.20M| releasePattern(); 1235| 1.20M| return *this; 1236| 1.20M|} _ZN6icu_7810UnicodeSet10complementERKNS_13UnicodeStringE: 1246| 5.31k|UnicodeSet& UnicodeSet::complement(const UnicodeString& s) { 1247| 5.31k| if (isFrozen() || isBogus()) return *this; ------------------ | Branch (1247:9): [True: 0, False: 5.31k] | Branch (1247:23): [True: 0, False: 5.31k] ------------------ 1248| 5.31k| int32_t cp = getSingleCP(s); 1249| 5.31k| if (cp < 0) { ------------------ | Branch (1249:9): [True: 5.18k, False: 128] ------------------ 1250| 5.18k| if (stringsContains(s)) { ------------------ | Branch (1250:13): [True: 0, False: 5.18k] ------------------ 1251| 0| strings_->removeElement((void*) &s); 1252| 5.18k| } else { 1253| 5.18k| _add(s); 1254| 5.18k| } 1255| 5.18k| releasePattern(); 1256| 5.18k| } else { 1257| 128| complement(static_cast(cp), static_cast(cp)); 1258| 128| } 1259| 5.31k| return *this; 1260| 5.31k|} _ZN6icu_7810UnicodeSet6addAllERKS0_: 1272| 1.35M|UnicodeSet& UnicodeSet::addAll(const UnicodeSet& c) { 1273| 1.35M| if ( c.len>0 && c.list!=nullptr ) { ------------------ | Branch (1273:10): [True: 1.35M, False: 0] | Branch (1273:21): [True: 1.35M, False: 0] ------------------ 1274| 1.35M| add(c.list, c.len, 0); 1275| 1.35M| } 1276| | 1277| | // Add strings in order 1278| 1.35M| if ( c.strings_!=nullptr ) { ------------------ | Branch (1278:10): [True: 25.0k, False: 1.32M] ------------------ 1279| 451k| for (int32_t i=0; isize(); ++i) { ------------------ | Branch (1279:27): [True: 426k, False: 25.0k] ------------------ 1280| 426k| const UnicodeString* s = static_cast(c.strings_->elementAt(i)); 1281| 426k| if (!stringsContains(*s)) { ------------------ | Branch (1281:17): [True: 419k, False: 7.39k] ------------------ 1282| 419k| _add(*s); 1283| 419k| } 1284| 426k| } 1285| 25.0k| } 1286| 1.35M| return *this; 1287| 1.35M|} _ZN6icu_7810UnicodeSet9retainAllERKS0_: 1298| 8.42k|UnicodeSet& UnicodeSet::retainAll(const UnicodeSet& c) { 1299| 8.42k| if (isFrozen() || isBogus()) { ------------------ | Branch (1299:9): [True: 0, False: 8.42k] | Branch (1299:23): [True: 0, False: 8.42k] ------------------ 1300| 0| return *this; 1301| 0| } 1302| 8.42k| retain(c.list, c.len, 0); 1303| 8.42k| if (hasStrings()) { ------------------ | Branch (1303:9): [True: 1.67k, False: 6.75k] ------------------ 1304| 1.67k| if (!c.hasStrings()) { ------------------ | Branch (1304:13): [True: 716, False: 954] ------------------ 1305| 716| strings_->removeAllElements(); 1306| 954| } else { 1307| 954| strings_->retainAll(*c.strings_); 1308| 954| } 1309| 1.67k| } 1310| 8.42k| return *this; 1311| 8.42k|} _ZN6icu_7810UnicodeSet9removeAllERKS0_: 1322| 9.03k|UnicodeSet& UnicodeSet::removeAll(const UnicodeSet& c) { 1323| 9.03k| if (isFrozen() || isBogus()) { ------------------ | Branch (1323:9): [True: 0, False: 9.03k] | Branch (1323:23): [True: 0, False: 9.03k] ------------------ 1324| 0| return *this; 1325| 0| } 1326| 9.03k| retain(c.list, c.len, 2); 1327| 9.03k| if (hasStrings() && c.hasStrings()) { ------------------ | Branch (1327:9): [True: 2.65k, False: 6.38k] | Branch (1327:25): [True: 1.71k, False: 934] ------------------ 1328| 1.71k| strings_->removeAll(*c.strings_); 1329| 1.71k| } 1330| 9.03k| return *this; 1331| 9.03k|} _ZN6icu_7810UnicodeSet13complementAllERKS0_: 1341| 5.31k|UnicodeSet& UnicodeSet::complementAll(const UnicodeSet& c) { 1342| 5.31k| if (isFrozen() || isBogus()) { ------------------ | Branch (1342:9): [True: 0, False: 5.31k] | Branch (1342:23): [True: 0, False: 5.31k] ------------------ 1343| 0| return *this; 1344| 0| } 1345| 5.31k| exclusiveOr(c.list, c.len, 0); 1346| | 1347| 5.31k| if (c.strings_ != nullptr) { ------------------ | Branch (1347:9): [True: 0, False: 5.31k] ------------------ 1348| 0| for (int32_t i=0; isize(); ++i) { ------------------ | Branch (1348:27): [True: 0, False: 0] ------------------ 1349| 0| void* e = c.strings_->elementAt(i); 1350| 0| if (strings_ == nullptr || !strings_->removeElement(e)) { ------------------ | Branch (1350:17): [True: 0, False: 0] | Branch (1350:40): [True: 0, False: 0] ------------------ 1351| 0| _add(*static_cast(e)); 1352| 0| } 1353| 0| } 1354| 0| } 1355| 5.31k| return *this; 1356| 5.31k|} _ZN6icu_7810UnicodeSet5clearEv: 1362| 1.37M|UnicodeSet& UnicodeSet::clear() { 1363| 1.37M| if (isFrozen()) { ------------------ | Branch (1363:9): [True: 0, False: 1.37M] ------------------ 1364| 0| return *this; 1365| 0| } 1366| 1.37M| list[0] = UNICODESET_HIGH; ------------------ | | 34| 1.37M|#define UNICODESET_HIGH 0x0110000 ------------------ 1367| 1.37M| len = 1; 1368| 1.37M| releasePattern(); 1369| 1.37M| if (strings_ != nullptr) { ------------------ | Branch (1369:9): [True: 13.8k, False: 1.35M] ------------------ 1370| 13.8k| strings_->removeAllElements(); 1371| 13.8k| } 1372| | // Remove bogus 1373| 1.37M| fFlags = 0; 1374| 1.37M| return *this; 1375| 1.37M|} _ZNK6icu_7810UnicodeSet13getRangeCountEv: 1383| 22.5k|int32_t UnicodeSet::getRangeCount() const { 1384| 22.5k| return len/2; 1385| 22.5k|} _ZNK6icu_7810UnicodeSet13getRangeStartEi: 1393| 36.1M|UChar32 UnicodeSet::getRangeStart(int32_t index) const { 1394| 36.1M| return list[index*2]; 1395| 36.1M|} _ZNK6icu_7810UnicodeSet11getRangeEndEi: 1403| 36.1M|UChar32 UnicodeSet::getRangeEnd(int32_t index) const { 1404| 36.1M| return list[index*2 + 1] - 1; 1405| 36.1M|} _ZN6icu_7810UnicodeSet7compactEv: 1415| 46|UnicodeSet& UnicodeSet::compact() { 1416| 46| if (isFrozen() || isBogus()) { ------------------ | Branch (1416:9): [True: 0, False: 46] | Branch (1416:23): [True: 0, False: 46] ------------------ 1417| 0| return *this; 1418| 0| } 1419| | // Delete buffer first to defragment memory less. 1420| 46| if (buffer != stackList) { ------------------ | Branch (1420:9): [True: 46, False: 0] ------------------ 1421| 46| uprv_free(buffer); ------------------ | | 1503| 46|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 46|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 46|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 46|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1422| 46| buffer = nullptr; 1423| 46| bufferCapacity = 0; 1424| 46| } 1425| 46| if (list == stackList) { ------------------ | Branch (1425:9): [True: 13, False: 33] ------------------ 1426| | // pass 1427| 33| } else if (len <= INITIAL_CAPACITY) { ------------------ | Branch (1427:16): [True: 0, False: 33] ------------------ 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| 33| } else if ((len + 7) < capacity) { ------------------ | Branch (1432:16): [True: 33, False: 0] ------------------ 1433| | // If we have more than a little unused capacity, shrink it to len. 1434| 33| UChar32* temp = static_cast(uprv_realloc(list, sizeof(UChar32) * len)); ------------------ | | 1536| 33|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 33|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 33|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 33|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1435| 33| if (temp) { ------------------ | Branch (1435:13): [True: 33, False: 0] ------------------ 1436| 33| list = temp; 1437| 33| capacity = len; 1438| 33| } 1439| | // else what the heck happened?! We allocated less memory! 1440| | // Oh well. We'll keep our original array. 1441| 33| } 1442| 46| if (strings_ != nullptr && strings_->isEmpty()) { ------------------ | Branch (1442:9): [True: 0, False: 46] | Branch (1442:32): [True: 0, False: 0] ------------------ 1443| 0| delete strings_; 1444| 0| strings_ = nullptr; 1445| 0| } 1446| 46| return *this; 1447| 46|} _ZN6icu_7810UnicodeSet15allocateStringsER10UErrorCode: 1606| 32.7k|UBool UnicodeSet::allocateStrings(UErrorCode &status) { 1607| 32.7k| if (U_FAILURE(status)) { ------------------ | Branch (1607:9): [True: 0, False: 32.7k] ------------------ 1608| 0| return false; 1609| 0| } 1610| 32.7k| strings_ = new UVector(uprv_deleteUObject, ------------------ | | 1489| 32.7k|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 32.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 32.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 32.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 32.7k| uhash_compareUnicodeString, 1, status); ------------------ | | 999| 32.7k|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 32.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 32.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 32.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1612| 32.7k| if (strings_ == nullptr) { // Check for memory allocation error. ------------------ | Branch (1612:9): [True: 0, False: 32.7k] ------------------ 1613| 0| status = U_MEMORY_ALLOCATION_ERROR; 1614| 0| return false; 1615| 0| } 1616| 32.7k| if (U_FAILURE(status)) { ------------------ | Branch (1616:9): [True: 0, False: 32.7k] ------------------ 1617| 0| delete strings_; 1618| 0| strings_ = nullptr; 1619| 0| return false; 1620| 0| } 1621| 32.7k| return true; 1622| 32.7k|} _ZN6icu_7810UnicodeSet12nextCapacityEi: 1624| 87.0k|int32_t UnicodeSet::nextCapacity(int32_t minCapacity) { 1625| | // Grow exponentially to reduce the frequency of allocations. 1626| 87.0k| if (minCapacity < INITIAL_CAPACITY) { ------------------ | Branch (1626:9): [True: 42.6k, False: 44.3k] ------------------ 1627| 42.6k| return minCapacity + INITIAL_CAPACITY; 1628| 44.3k| } else if (minCapacity <= 2500) { ------------------ | Branch (1628:16): [True: 40.6k, False: 3.68k] ------------------ 1629| 40.6k| return 5 * minCapacity; 1630| 40.6k| } else { 1631| 3.68k| int32_t newCapacity = 2 * minCapacity; 1632| 3.68k| if (newCapacity > MAX_LENGTH) { ------------------ | Branch (1632:13): [True: 0, False: 3.68k] ------------------ 1633| 0| newCapacity = MAX_LENGTH; 1634| 0| } 1635| 3.68k| return newCapacity; 1636| 3.68k| } 1637| 87.0k|} _ZN6icu_7810UnicodeSet14ensureCapacityEi: 1639| 21.1M|bool UnicodeSet::ensureCapacity(int32_t newLen) { 1640| 21.1M| if (newLen > MAX_LENGTH) { ------------------ | Branch (1640:9): [True: 0, False: 21.1M] ------------------ 1641| 0| newLen = MAX_LENGTH; 1642| 0| } 1643| 21.1M| if (newLen <= capacity) { ------------------ | Branch (1643:9): [True: 21.1M, False: 22.6k] ------------------ 1644| 21.1M| return true; 1645| 21.1M| } 1646| 22.6k| int32_t newCapacity = nextCapacity(newLen); 1647| 22.6k| UChar32* temp = static_cast(uprv_malloc(newCapacity * sizeof(UChar32))); ------------------ | | 1524| 22.6k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 22.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 22.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 22.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1648| 22.6k| if (temp == nullptr) { ------------------ | Branch (1648:9): [True: 0, False: 22.6k] ------------------ 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| 22.6k| uprv_memcpy(temp, list, len * sizeof(UChar32)); ------------------ | | 42| 22.6k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 22.6k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 22.6k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 22.6k| _Pragma("clang diagnostic push") \ | | 45| 22.6k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 22.6k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 22.6k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 22.6k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 22.6k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 22.6k| _Pragma("clang diagnostic pop") \ | | 49| 22.6k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 22.6k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 22.6k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 22.6k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1654| 22.6k| if (list != stackList) { ------------------ | Branch (1654:9): [True: 9.96k, False: 12.6k] ------------------ 1655| 9.96k| uprv_free(list); ------------------ | | 1503| 9.96k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 9.96k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.96k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.96k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1656| 9.96k| } 1657| 22.6k| list = temp; 1658| 22.6k| capacity = newCapacity; 1659| 22.6k| return true; 1660| 22.6k|} _ZN6icu_7810UnicodeSet20ensureBufferCapacityEi: 1662| 1.37M|bool UnicodeSet::ensureBufferCapacity(int32_t newLen) { 1663| 1.37M| if (newLen > MAX_LENGTH) { ------------------ | Branch (1663:9): [True: 0, False: 1.37M] ------------------ 1664| 0| newLen = MAX_LENGTH; 1665| 0| } 1666| 1.37M| if (newLen <= bufferCapacity) { ------------------ | Branch (1666:9): [True: 1.31M, False: 64.3k] ------------------ 1667| 1.31M| return true; 1668| 1.31M| } 1669| 64.3k| int32_t newCapacity = nextCapacity(newLen); 1670| 64.3k| UChar32* temp = static_cast(uprv_malloc(newCapacity * sizeof(UChar32))); ------------------ | | 1524| 64.3k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 64.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 64.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 64.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1671| 64.3k| if (temp == nullptr) { ------------------ | Branch (1671:9): [True: 0, False: 64.3k] ------------------ 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| 64.3k| if (buffer != stackList) { ------------------ | Branch (1677:9): [True: 59.6k, False: 4.71k] ------------------ 1678| 59.6k| uprv_free(buffer); ------------------ | | 1503| 59.6k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 59.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 59.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 59.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1679| 59.6k| } 1680| 64.3k| buffer = temp; 1681| 64.3k| bufferCapacity = newCapacity; 1682| 64.3k| return true; 1683| 64.3k|} _ZN6icu_7810UnicodeSet11swapBuffersEv: 1688| 1.37M|void UnicodeSet::swapBuffers() { 1689| | // swap list and buffer 1690| 1.37M| UChar32* temp = list; 1691| 1.37M| list = buffer; 1692| 1.37M| buffer = temp; 1693| | 1694| 1.37M| int32_t c = capacity; 1695| 1.37M| capacity = bufferCapacity; 1696| 1.37M| bufferCapacity = c; 1697| 1.37M|} _ZN6icu_7810UnicodeSet11exclusiveOrEPKiia: 1715| 7.16k|void UnicodeSet::exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity) { 1716| 7.16k| if (isFrozen() || isBogus()) { ------------------ | Branch (1716:9): [True: 0, False: 7.16k] | Branch (1716:23): [True: 0, False: 7.16k] ------------------ 1717| 0| return; 1718| 0| } 1719| 7.16k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1719:9): [True: 0, False: 7.16k] ------------------ 1720| 0| return; 1721| 0| } 1722| | 1723| 7.16k| int32_t i = 0, j = 0, k = 0; 1724| 7.16k| UChar32 a = list[i++]; 1725| 7.16k| UChar32 b; 1726| 7.16k| if (polarity == 1 || polarity == 2) { ------------------ | Branch (1726:9): [True: 0, False: 7.16k] | Branch (1726:26): [True: 0, False: 7.16k] ------------------ 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| 7.16k| } else { 1733| 7.16k| b = other[j++]; 1734| 7.16k| } 1735| | // simplest of all the routines 1736| | // sort the values, discarding identicals! 1737| 1.60M| for (;;) { 1738| 1.60M| if (a < b) { ------------------ | Branch (1738:13): [True: 0, False: 1.60M] ------------------ 1739| 0| buffer[k++] = a; 1740| 0| a = list[i++]; 1741| 1.60M| } else if (b < a) { ------------------ | Branch (1741:20): [True: 1.59M, False: 7.16k] ------------------ 1742| 1.59M| buffer[k++] = b; 1743| 1.59M| b = other[j++]; 1744| 1.59M| } else if (a != UNICODESET_HIGH) { // at this point, a == b ------------------ | | 34| 7.16k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1744:20): [True: 0, False: 7.16k] ------------------ 1745| | // discard both values! 1746| 0| a = list[i++]; 1747| 0| b = other[j++]; 1748| 7.16k| } else { // DONE! 1749| 7.16k| buffer[k++] = UNICODESET_HIGH; ------------------ | | 34| 7.16k|#define UNICODESET_HIGH 0x0110000 ------------------ 1750| 7.16k| len = k; 1751| 7.16k| break; 1752| 7.16k| } 1753| 1.60M| } 1754| 7.16k| swapBuffers(); 1755| 7.16k| releasePattern(); 1756| 7.16k|} _ZN6icu_7810UnicodeSet3addEPKiia: 1763| 1.35M|void UnicodeSet::add(const UChar32* other, int32_t otherLen, int8_t polarity) { 1764| 1.35M| if (isFrozen() || isBogus() || other==nullptr) { ------------------ | Branch (1764:9): [True: 0, False: 1.35M] | Branch (1764:23): [True: 0, False: 1.35M] | Branch (1764:36): [True: 0, False: 1.35M] ------------------ 1765| 0| return; 1766| 0| } 1767| 1.35M| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1767:9): [True: 0, False: 1.35M] ------------------ 1768| 0| return; 1769| 0| } 1770| | 1771| 1.35M| int32_t i = 0, j = 0, k = 0; 1772| 1.35M| UChar32 a = list[i++]; 1773| 1.35M| 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| 45.5M| for (;;) { 1777| 45.5M| switch (polarity) { ------------------ | Branch (1777:17): [True: 0, False: 45.5M] ------------------ 1778| 21.7M| case 0: // both first; take lower if unequal ------------------ | Branch (1778:11): [True: 21.7M, False: 23.7M] ------------------ 1779| 21.7M| if (a < b) { // take a ------------------ | Branch (1779:17): [True: 6.18M, False: 15.5M] ------------------ 1780| | // Back up over overlapping ranges in buffer[] 1781| 6.18M| if (k > 0 && a <= buffer[k-1]) { ------------------ | Branch (1781:21): [True: 4.93M, False: 1.24M] | Branch (1781:30): [True: 321k, False: 4.61M] ------------------ 1782| | // Pick latter end value in buffer[] vs. list[] 1783| 321k| a = max(list[i], buffer[--k]); 1784| 5.86M| } else { 1785| | // No overlap 1786| 5.86M| buffer[k++] = a; 1787| 5.86M| a = list[i]; 1788| 5.86M| } 1789| 6.18M| i++; // Common if/else code factored out 1790| 6.18M| polarity ^= 1; 1791| 15.5M| } else if (b < a) { // take b ------------------ | Branch (1791:24): [True: 9.38M, False: 6.20M] ------------------ 1792| 9.38M| if (k > 0 && b <= buffer[k-1]) { ------------------ | Branch (1792:21): [True: 9.36M, False: 22.7k] | Branch (1792:30): [True: 1.57M, False: 7.78M] ------------------ 1793| 1.57M| b = max(other[j], buffer[--k]); 1794| 7.81M| } else { 1795| 7.81M| buffer[k++] = b; 1796| 7.81M| b = other[j]; 1797| 7.81M| } 1798| 9.38M| j++; 1799| 9.38M| polarity ^= 2; 1800| 9.38M| } else { // a == b, take a, drop b 1801| 6.20M| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 6.20M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1801:21): [True: 105k, False: 6.10M] ------------------ 1802| | // This is symmetrical; it doesn't matter if 1803| | // we backtrack with a or b. - liu 1804| 6.10M| if (k > 0 && a <= buffer[k-1]) { ------------------ | Branch (1804:21): [True: 6.04M, False: 63.6k] | Branch (1804:30): [True: 0, False: 6.04M] ------------------ 1805| 0| a = max(list[i], buffer[--k]); 1806| 6.10M| } else { 1807| | // No overlap 1808| 6.10M| buffer[k++] = a; 1809| 6.10M| a = list[i]; 1810| 6.10M| } 1811| 6.10M| i++; 1812| 6.10M| polarity ^= 1; 1813| 6.10M| b = other[j++]; 1814| 6.10M| polarity ^= 2; 1815| 6.10M| } 1816| 21.6M| break; 1817| 21.6M| case 3: // both second; take higher if unequal, and drop other ------------------ | Branch (1817:11): [True: 7.66M, False: 37.8M] ------------------ 1818| 7.66M| if (b <= a) { // take a ------------------ | Branch (1818:17): [True: 7.53M, False: 126k] ------------------ 1819| 7.53M| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 7.53M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1819:21): [True: 1.16M, False: 6.37M] ------------------ 1820| 6.37M| buffer[k++] = a; 1821| 6.37M| } else { // take b 1822| 126k| if (b == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 126k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1822:21): [True: 2.38k, False: 123k] ------------------ 1823| 123k| buffer[k++] = b; 1824| 123k| } 1825| 6.49M| a = list[i++]; 1826| 6.49M| polarity ^= 1; // factored common code 1827| 6.49M| b = other[j++]; 1828| 6.49M| polarity ^= 2; 1829| 6.49M| break; 1830| 6.40M| case 1: // a second, b first; if b < a, overlap ------------------ | Branch (1830:11): [True: 6.40M, False: 39.1M] ------------------ 1831| 6.40M| if (a < b) { // no overlap, take a ------------------ | Branch (1831:17): [True: 4.64M, False: 1.76M] ------------------ 1832| 4.64M| buffer[k++] = a; a = list[i++]; polarity ^= 1; 1833| 4.64M| } else if (b < a) { // OVERLAP, drop b ------------------ | Branch (1833:24): [True: 1.42M, False: 338k] ------------------ 1834| 1.42M| b = other[j++]; 1835| 1.42M| polarity ^= 2; 1836| 1.42M| } else { // a == b, drop both! 1837| 338k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 338k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1837:21): [True: 41.8k, False: 296k] ------------------ 1838| 296k| a = list[i++]; 1839| 296k| polarity ^= 1; 1840| 296k| b = other[j++]; 1841| 296k| polarity ^= 2; 1842| 296k| } 1843| 6.36M| break; 1844| 9.67M| case 2: // a first, b second; if a < b, overlap ------------------ | Branch (1844:11): [True: 9.67M, False: 35.8M] ------------------ 1845| 9.67M| if (b < a) { // no overlap, take b ------------------ | Branch (1845:17): [True: 9.28M, False: 391k] ------------------ 1846| 9.28M| buffer[k++] = b; 1847| 9.28M| b = other[j++]; 1848| 9.28M| polarity ^= 2; 1849| 9.28M| } else if (a < b) { // OVERLAP, drop a ------------------ | Branch (1849:25): [True: 135k, False: 255k] ------------------ 1850| 135k| a = list[i++]; 1851| 135k| polarity ^= 1; 1852| 255k| } else { // a == b, drop both! 1853| 255k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 255k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1853:21): [True: 38.8k, False: 216k] ------------------ 1854| 216k| a = list[i++]; 1855| 216k| polarity ^= 1; 1856| 216k| b = other[j++]; 1857| 216k| polarity ^= 2; 1858| 216k| } 1859| 9.64M| break; 1860| 45.5M| } 1861| 45.5M| } 1862| 1.35M| loop_end: 1863| 1.35M| buffer[k++] = UNICODESET_HIGH; // terminate ------------------ | | 34| 1.35M|#define UNICODESET_HIGH 0x0110000 ------------------ 1864| 1.35M| len = k; 1865| 1.35M| swapBuffers(); 1866| 1.35M| releasePattern(); 1867| 1.35M|} _ZN6icu_7810UnicodeSet6retainEPKiia: 1874| 17.7k|void UnicodeSet::retain(const UChar32* other, int32_t otherLen, int8_t polarity) { 1875| 17.7k| if (isFrozen() || isBogus()) { ------------------ | Branch (1875:9): [True: 0, False: 17.7k] | Branch (1875:23): [True: 0, False: 17.7k] ------------------ 1876| 0| return; 1877| 0| } 1878| 17.7k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1878:9): [True: 0, False: 17.7k] ------------------ 1879| 0| return; 1880| 0| } 1881| | 1882| 17.7k| int32_t i = 0, j = 0, k = 0; 1883| 17.7k| UChar32 a = list[i++]; 1884| 17.7k| 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| 4.04M| for (;;) { 1888| 4.04M| switch (polarity) { ------------------ | Branch (1888:17): [True: 0, False: 4.04M] ------------------ 1889| 1.91M| case 0: // both first; drop the smaller ------------------ | Branch (1889:11): [True: 1.91M, False: 2.13M] ------------------ 1890| 1.91M| if (a < b) { // drop a ------------------ | Branch (1890:17): [True: 23.8k, False: 1.88M] ------------------ 1891| 23.8k| a = list[i++]; 1892| 23.8k| polarity ^= 1; 1893| 1.88M| } else if (b < a) { // drop b ------------------ | Branch (1893:24): [True: 1.87M, False: 17.6k] ------------------ 1894| 1.87M| b = other[j++]; 1895| 1.87M| polarity ^= 2; 1896| 1.87M| } else { // a == b, take one, drop other 1897| 17.6k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 17.6k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1897:21): [True: 7.85k, False: 9.81k] ------------------ 1898| 9.81k| buffer[k++] = a; 1899| 9.81k| a = list[i++]; 1900| 9.81k| polarity ^= 1; 1901| 9.81k| b = other[j++]; 1902| 9.81k| polarity ^= 2; 1903| 9.81k| } 1904| 1.90M| break; 1905| 1.90M| case 3: // both second; take lower if unequal ------------------ | Branch (1905:11): [True: 110k, False: 3.93M] ------------------ 1906| 110k| if (a < b) { // take a ------------------ | Branch (1906:17): [True: 57.8k, False: 52.3k] ------------------ 1907| 57.8k| buffer[k++] = a; 1908| 57.8k| a = list[i++]; 1909| 57.8k| polarity ^= 1; 1910| 57.8k| } else if (b < a) { // take b ------------------ | Branch (1910:24): [True: 41.5k, False: 10.8k] ------------------ 1911| 41.5k| buffer[k++] = b; 1912| 41.5k| b = other[j++]; 1913| 41.5k| polarity ^= 2; 1914| 41.5k| } else { // a == b, take one, drop other 1915| 10.8k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 10.8k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1915:21): [True: 1.17k, False: 9.66k] ------------------ 1916| 9.66k| buffer[k++] = a; 1917| 9.66k| a = list[i++]; 1918| 9.66k| polarity ^= 1; 1919| 9.66k| b = other[j++]; 1920| 9.66k| polarity ^= 2; 1921| 9.66k| } 1922| 109k| break; 1923| 109k| case 1: // a second, b first; ------------------ | Branch (1923:11): [True: 74.4k, False: 3.96M] ------------------ 1924| 74.4k| if (a < b) { // NO OVERLAP, drop a ------------------ | Branch (1924:17): [True: 23.4k, False: 50.9k] ------------------ 1925| 23.4k| a = list[i++]; 1926| 23.4k| polarity ^= 1; 1927| 50.9k| } else if (b < a) { // OVERLAP, take b ------------------ | Branch (1927:24): [True: 41.6k, False: 9.28k] ------------------ 1928| 41.6k| buffer[k++] = b; 1929| 41.6k| b = other[j++]; 1930| 41.6k| polarity ^= 2; 1931| 41.6k| } else { // a == b, drop both! 1932| 9.28k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 9.28k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1932:21): [True: 642, False: 8.64k] ------------------ 1933| 8.64k| a = list[i++]; 1934| 8.64k| polarity ^= 1; 1935| 8.64k| b = other[j++]; 1936| 8.64k| polarity ^= 2; 1937| 8.64k| } 1938| 73.7k| break; 1939| 1.94M| case 2: // a first, b second; if a < b, overlap ------------------ | Branch (1939:11): [True: 1.94M, False: 2.09M] ------------------ 1940| 1.94M| if (b < a) { // no overlap, drop b ------------------ | Branch (1940:17): [True: 1.87M, False: 75.8k] ------------------ 1941| 1.87M| b = other[j++]; 1942| 1.87M| polarity ^= 2; 1943| 1.87M| } else if (a < b) { // OVERLAP, take a ------------------ | Branch (1943:25): [True: 58.7k, False: 17.0k] ------------------ 1944| 58.7k| buffer[k++] = a; 1945| 58.7k| a = list[i++]; 1946| 58.7k| polarity ^= 1; 1947| 58.7k| } else { // a == b, drop both! 1948| 17.0k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 17.0k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1948:21): [True: 8.05k, False: 9.03k] ------------------ 1949| 9.03k| a = list[i++]; 1950| 9.03k| polarity ^= 1; 1951| 9.03k| b = other[j++]; 1952| 9.03k| polarity ^= 2; 1953| 9.03k| } 1954| 1.93M| break; 1955| 4.04M| } 1956| 4.04M| } 1957| 17.7k| loop_end: 1958| 17.7k| buffer[k++] = UNICODESET_HIGH; // terminate ------------------ | | 34| 17.7k|#define UNICODESET_HIGH 0x0110000 ------------------ 1959| 17.7k| len = k; 1960| 17.7k| swapBuffers(); 1961| 17.7k| releasePattern(); 1962| 17.7k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringERKS1_a: 1968| 74.0k|void UnicodeSet::_appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable) { 1969| 74.0k| UChar32 cp; 1970| 10.8M| for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 10.7M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 10.7M, False: 10.4k] | | ------------------ ------------------ | Branch (1970:25): [True: 10.7M, False: 74.0k] ------------------ 1971| 10.7M| _appendToPat(buf, cp = s.char32At(i), escapeUnprintable); 1972| 10.7M| } 1973| 74.0k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringEia: 1979| 60.0M|void UnicodeSet::_appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable) { 1980| 60.0M| if (escapeUnprintable ? ICU_Utility::isUnprintable(c) : ICU_Utility::shouldAlwaysBeEscaped(c)) { ------------------ | Branch (1980:9): [True: 0, False: 60.0M] | Branch (1980:9): [True: 51.9M, False: 8.01M] ------------------ 1981| | // Use hex escape notation (\uxxxx or \Uxxxxxxxx) for anything 1982| | // unprintable 1983| 51.9M| ICU_Utility::escape(buf, c); 1984| 51.9M| return; 1985| 51.9M| } 1986| | // Okay to let ':' pass through 1987| 8.01M| switch (c) { 1988| 193k| case u'[': ------------------ | Branch (1988:5): [True: 193k, False: 7.82M] ------------------ 1989| 290k| case u']': ------------------ | Branch (1989:5): [True: 96.6k, False: 7.92M] ------------------ 1990| 293k| case u'-': ------------------ | Branch (1990:5): [True: 3.26k, False: 8.01M] ------------------ 1991| 302k| case u'^': ------------------ | Branch (1991:5): [True: 9.17k, False: 8.01M] ------------------ 1992| 307k| case u'&': ------------------ | Branch (1992:5): [True: 5.31k, False: 8.01M] ------------------ 1993| 308k| case u'\\': ------------------ | Branch (1993:5): [True: 772, False: 8.01M] ------------------ 1994| 329k| case u'{': ------------------ | Branch (1994:5): [True: 20.4k, False: 7.99M] ------------------ 1995| 338k| case u'}': ------------------ | Branch (1995:5): [True: 9.79k, False: 8.00M] ------------------ 1996| 351k| case u':': ------------------ | Branch (1996:5): [True: 12.4k, False: 8.00M] ------------------ 1997| 355k| case SymbolTable::SYMBOL_REF: ------------------ | Branch (1997:5): [True: 3.91k, False: 8.01M] ------------------ 1998| 355k| buf.append(u'\\'); 1999| 355k| break; 2000| 7.66M| default: ------------------ | Branch (2000:5): [True: 7.66M, False: 355k] ------------------ 2001| | // Escape whitespace 2002| 7.66M| if (PatternProps::isWhiteSpace(c)) { ------------------ | Branch (2002:13): [True: 224, False: 7.66M] ------------------ 2003| 224| buf.append(u'\\'); 2004| 224| } 2005| 7.66M| break; 2006| 8.01M| } 2007| 8.01M| buf.append(c); 2008| 8.01M|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringEiia: 2011| 9.83M| UBool escapeUnprintable) { 2012| 9.83M| _appendToPat(result, start, escapeUnprintable); 2013| 9.83M| if (start != end) { ------------------ | Branch (2013:9): [True: 9.25M, False: 583k] ------------------ 2014| 9.25M| if ((start+1) != end || ------------------ | Branch (2014:13): [True: 9.20M, False: 52.6k] ------------------ 2015| | // Avoid writing what looks like a lead+trail surrogate pair. 2016| 9.25M| start == 0xdbff) { ------------------ | Branch (2016:17): [True: 802, False: 51.8k] ------------------ 2017| 9.20M| result.append(u'-'); 2018| 9.20M| } 2019| 9.25M| _appendToPat(result, end, escapeUnprintable); 2020| 9.25M| } 2021| 9.83M|} _ZNK6icu_7810UnicodeSet16_generatePatternERNS_13UnicodeStringEa: 2082| 1.25M|{ 2083| 1.25M| result.append(u'['); 2084| | 2085| 1.25M| int32_t i = 0; 2086| 1.25M| 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| 1.25M| if (len >= 4 && list[0] == 0 && limit == len && !hasStrings()) { ------------------ | Branch (2099:9): [True: 1.20M, False: 50.5k] | Branch (2099:21): [True: 13.2k, False: 1.18M] | Branch (2099:37): [True: 8.53k, False: 4.76k] | Branch (2099:53): [True: 7.21k, False: 1.31k] ------------------ 2100| | // Emit the inverse 2101| 7.21k| result.append(u'^'); 2102| | // Offsetting the inversion list index by one lets us 2103| | // iterate over the ranges of the set complement. 2104| 7.21k| i = 1; 2105| 7.21k| --limit; 2106| 7.21k| } 2107| | 2108| | // Emit the ranges as pairs. 2109| 4.09M| while (i < limit) { ------------------ | Branch (2109:12): [True: 2.84M, False: 1.25M] ------------------ 2110| 2.84M| UChar32 start = list[i]; // getRangeStart() 2111| 2.84M| UChar32 end = list[i + 1] - 1; // getRangeEnd() = range limit minus one 2112| 2.84M| if (!(0xd800 <= end && end <= 0xdbff)) { ------------------ | Branch (2112:15): [True: 1.27M, False: 1.57M] | Branch (2112:32): [True: 1.19M, False: 74.6k] ------------------ 2113| 1.64M| _appendToPat(result, start, end, escapeUnprintable); 2114| 1.64M| i += 2; 2115| 1.64M| } 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| 1.19M| int32_t firstLead = i; 2120| 8.10M| while ((i += 2) < limit && list[i] <= 0xdbff) {} ------------------ | Branch (2120:20): [True: 6.93M, False: 1.17M] | Branch (2120:40): [True: 6.91M, False: 23.0k] ------------------ 2121| 1.19M| int32_t firstAfterLead = i; 2122| | // 2. Write following ranges that start with a trail surrogate code point. 2123| 1.27M| while (i < limit && (start = list[i]) <= 0xdfff) { ------------------ | Branch (2123:20): [True: 88.0k, False: 1.19M] | Branch (2123:33): [True: 82.4k, False: 5.58k] ------------------ 2124| 82.4k| _appendToPat(result, start, list[i + 1] - 1, escapeUnprintable); 2125| 82.4k| i += 2; 2126| 82.4k| } 2127| | // 3. Now write the postponed ranges. 2128| 9.30M| for (int j = firstLead; j < firstAfterLead; j += 2) { ------------------ | Branch (2128:37): [True: 8.10M, False: 1.19M] ------------------ 2129| 8.10M| _appendToPat(result, list[j], list[j + 1] - 1, escapeUnprintable); 2130| 8.10M| } 2131| 1.19M| } 2132| 2.84M| } 2133| | 2134| 1.25M| if (strings_ != nullptr) { ------------------ | Branch (2134:9): [True: 13.3k, False: 1.23M] ------------------ 2135| 32.8k| for (int32_t i = 0; isize(); ++i) { ------------------ | Branch (2135:29): [True: 19.5k, False: 13.3k] ------------------ 2136| 19.5k| result.append(u'{'); 2137| 19.5k| _appendToPat(result, 2138| 19.5k| *static_cast(strings_->elementAt(i)), 2139| 19.5k| escapeUnprintable); 2140| 19.5k| result.append(u'}'); 2141| 19.5k| } 2142| 13.3k| } 2143| 1.25M| return result.append(u']'); 2144| 1.25M|} _ZN6icu_7810UnicodeSet14releasePatternEv: 2149| 28.0M|void UnicodeSet::releasePattern() { 2150| 28.0M| if (pat) { ------------------ | Branch (2150:9): [True: 1.55k, False: 28.0M] ------------------ 2151| 1.55k| uprv_free(pat); ------------------ | | 1503| 1.55k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2152| 1.55k| pat = nullptr; 2153| 1.55k| patLen = 0; 2154| 1.55k| } 2155| 28.0M|} _ZN6icu_7810UnicodeSet10setPatternEPKDsi: 2160| 1.55k|void UnicodeSet::setPattern(const char16_t *newPat, int32_t newPatLen) { 2161| 1.55k| releasePattern(); 2162| 1.55k| pat = static_cast(uprv_malloc((newPatLen + 1) * sizeof(char16_t))); ------------------ | | 1524| 1.55k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2163| 1.55k| if (pat) { ------------------ | Branch (2163:9): [True: 1.55k, False: 0] ------------------ 2164| 1.55k| patLen = newPatLen; 2165| 1.55k| u_memcpy(pat, newPat, patLen); ------------------ | | 334| 1.55k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 1.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2166| 1.55k| pat[patLen] = 0; 2167| 1.55k| } 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| 1.55k|} _ZN6icu_7810UnicodeSet6freezeEv: 2172| 27|UnicodeSet *UnicodeSet::freeze() { 2173| 27| if(!isFrozen() && !isBogus()) { ------------------ | Branch (2173:8): [True: 27, False: 0] | Branch (2173:23): [True: 27, False: 0] ------------------ 2174| 27| compact(); 2175| | 2176| | // Optimize contains() and span() and similar functions. 2177| 27| if (hasStrings()) { ------------------ | Branch (2177:13): [True: 0, False: 27] ------------------ 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| 27| if (stringSpan == nullptr) { ------------------ | Branch (2192:13): [True: 27, False: 0] ------------------ 2193| | // No span-relevant strings: Optimize for code point spans. 2194| 27| bmpSet=new BMPSet(list, len); 2195| 27| if (bmpSet == nullptr) { // Check for memory allocation error. ------------------ | Branch (2195:17): [True: 0, False: 27] ------------------ 2196| 0| setToBogus(); 2197| 0| } 2198| 27| } 2199| 27| } 2200| 27| return this; 2201| 27|} uniset.cpp:_ZN6icu_78L12pinCodePointERi: 54| 349M|static inline UChar32 pinCodePoint(UChar32& c) { 55| 349M| if (c < UNICODESET_LOW) { ------------------ | | 37| 349M|#define UNICODESET_LOW 0x000000 ------------------ | Branch (55:9): [True: 0, False: 349M] ------------------ 56| 0| c = UNICODESET_LOW; ------------------ | | 37| 0|#define UNICODESET_LOW 0x000000 ------------------ 57| 349M| } else if (c > (UNICODESET_HIGH-1)) { ------------------ | | 34| 349M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (57:16): [True: 0, False: 349M] ------------------ 58| 0| c = (UNICODESET_HIGH-1); ------------------ | | 34| 0|#define UNICODESET_HIGH 0x0110000 ------------------ 59| 0| } 60| 349M| return c; 61| 349M|} uniset.cpp:_ZN6icu_78L20compareUnicodeStringE8UElementS0_: 114| 2.48M|static int32_t U_CALLCONV compareUnicodeString(UElement t1, UElement t2) { 115| 2.48M| const UnicodeString& a = *static_cast(t1.pointer); 116| 2.48M| const UnicodeString& b = *static_cast(t2.pointer); 117| 2.48M| return a.compare(b); 118| 2.48M|} uniset.cpp:_ZN6icu_78L3maxEii: 1708| 1.89M|static inline UChar32 max(UChar32 a, UChar32 b) { 1709| 1.89M| return (a > b) ? a : b; ------------------ | Branch (1709:12): [True: 94.7k, False: 1.79M] ------------------ 1710| 1.89M|} _ZN6icu_7810UnicodeSetC2ERKNS_13UnicodeStringER10UErrorCode: 156| 5.31k| UErrorCode& status) { 157| 5.31k| applyPattern(pattern, status); 158| 5.31k| _dbgct(this); 159| 5.31k|} _ZN6icu_7810UnicodeSet12applyPatternERKNS_13UnicodeStringER10UErrorCode: 166| 10.6k| UErrorCode& status) { 167| | // Equivalent to 168| | // return applyPattern(pattern, USET_IGNORE_SPACE, nullptr, status); 169| | // but without dependency on closeOver(). 170| 10.6k| ParsePosition pos(0); 171| 10.6k| applyPatternIgnoreSpace(pattern, pos, nullptr, status); 172| 10.6k| if (U_FAILURE(status)) return *this; ------------------ | Branch (172:9): [True: 9.07k, False: 1.55k] ------------------ 173| | 174| 1.55k| int32_t i = pos.getIndex(); 175| | // Skip over trailing whitespace 176| 1.55k| ICU_Utility::skipWhitespace(pattern, i, true); 177| 1.55k| if (i != pattern.length()) { ------------------ | Branch (177:9): [True: 354, False: 1.20k] ------------------ 178| 354| status = U_ILLEGAL_ARGUMENT_ERROR; 179| 354| } 180| 1.55k| return *this; 181| 10.6k|} _ZN6icu_7810UnicodeSet23applyPatternIgnoreSpaceERKNS_13UnicodeStringERNS_13ParsePositionEPKNS_11SymbolTableER10UErrorCode: 187| 10.6k| UErrorCode& status) { 188| 10.6k| if (U_FAILURE(status)) { ------------------ | Branch (188:9): [True: 0, False: 10.6k] ------------------ 189| 0| return; 190| 0| } 191| 10.6k| if (isFrozen()) { ------------------ | Branch (191:9): [True: 0, False: 10.6k] ------------------ 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| 10.6k| UnicodeString rebuiltPat; 198| 10.6k| RuleCharacterIterator chars(pattern, symbols, pos); 199| 10.6k| applyPattern(chars, symbols, rebuiltPat, USET_IGNORE_SPACE, nullptr, 0, status); 200| 10.6k| if (U_FAILURE(status)) return; ------------------ | Branch (200:9): [True: 9.07k, False: 1.55k] ------------------ 201| 1.55k| if (chars.inVariable()) { ------------------ | Branch (201:9): [True: 0, False: 1.55k] ------------------ 202| | // syntaxError(chars, "Extra chars in variable value"); 203| 0| status = U_MALFORMED_SET; 204| 0| return; 205| 0| } 206| 1.55k| setPattern(rebuiltPat); 207| 1.55k|} _ZN6icu_7810UnicodeSet12applyPatternERNS_21RuleCharacterIteratorEPKNS_11SymbolTableERNS_13UnicodeStringEjMS0_FRS0_iEiR10UErrorCode: 267| 1.33M| UErrorCode& ec) { 268| 1.33M| if (U_FAILURE(ec)) return; ------------------ | Branch (268:9): [True: 0, False: 1.33M] ------------------ 269| 1.33M| if (depth > MAX_DEPTH) { ------------------ | Branch (269:9): [True: 36, False: 1.33M] ------------------ 270| 36| ec = U_ILLEGAL_ARGUMENT_ERROR; 271| 36| return; 272| 36| } 273| | 274| | // Syntax characters: [ ] ^ - & { } 275| | 276| | // Recognized special forms for chars, sets: c-c s-s s&s 277| | 278| 1.33M| int32_t opts = RuleCharacterIterator::PARSE_VARIABLES | 279| 1.33M| RuleCharacterIterator::PARSE_ESCAPES; 280| 1.33M| if ((options & USET_IGNORE_SPACE) != 0) { ------------------ | Branch (280:9): [True: 1.33M, False: 0] ------------------ 281| 1.33M| opts |= RuleCharacterIterator::SKIP_WHITESPACE; 282| 1.33M| } 283| | 284| 1.33M| UnicodeString patLocal, buf; 285| 1.33M| UBool usePat = false; 286| 1.33M| UnicodeSetPointer scratch; 287| 1.33M| RuleCharacterIterator::Pos backup; 288| | 289| | // mode: 0=before [, 1=between [...], 2=after ] 290| | // lastItem: 0=none, 1=char, 2=set 291| 1.33M| int8_t lastItem = 0, mode = 0; 292| 1.33M| UChar32 lastChar = 0; 293| 1.33M| char16_t op = 0; 294| | 295| 1.33M| UBool invert = false; 296| | 297| 1.33M| clear(); 298| | 299| 35.5M| while (mode != 2 && !chars.atEnd()) { ------------------ | Branch (299:12): [True: 34.2M, False: 1.29M] | Branch (299:25): [True: 34.2M, False: 30.5k] ------------------ 300| 34.2M| U_ASSERT((lastItem == 0 && op == 0) || ------------------ | | 35| 34.2M|# define U_ASSERT(exp) (void)0 ------------------ 301| 34.2M| (lastItem == 1 && (op == 0 || op == u'-')) || 302| 34.2M| (lastItem == 2 && (op == 0 || op == u'-' || op == u'&'))); 303| | 304| 34.2M| UChar32 c = 0; 305| 34.2M| UBool literal = false; 306| 34.2M| 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| 34.2M| int8_t setMode = 0; 312| 34.2M| if (resemblesPropertyPattern(chars, opts)) { ------------------ | Branch (312:13): [True: 34.2k, False: 34.2M] ------------------ 313| 34.2k| setMode = 2; 314| 34.2k| } 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| 34.2M| else { 325| | // Prepare to backup if necessary 326| 34.2M| chars.getPos(backup); 327| 34.2M| c = chars.next(opts, literal, ec); 328| 34.2M| if (U_FAILURE(ec)) return; ------------------ | Branch (328:17): [True: 6.49k, False: 34.1M] ------------------ 329| | 330| 34.1M| if (c == u'[' && !literal) { ------------------ | Branch (330:17): [True: 2.66M, False: 31.5M] | Branch (330:30): [True: 2.66M, False: 1.58k] ------------------ 331| 2.66M| if (mode == 1) { ------------------ | Branch (331:21): [True: 1.32M, False: 1.33M] ------------------ 332| 1.32M| chars.setPos(backup); // backup 333| 1.32M| setMode = 1; 334| 1.33M| } else { 335| | // Handle opening '[' delimiter 336| 1.33M| mode = 1; 337| 1.33M| patLocal.append(u'['); 338| 1.33M| chars.getPos(backup); // prepare to backup 339| 1.33M| c = chars.next(opts, literal, ec); 340| 1.33M| if (U_FAILURE(ec)) return; ------------------ | Branch (340:25): [True: 14, False: 1.33M] ------------------ 341| 1.33M| if (c == u'^' && !literal) { ------------------ | Branch (341:25): [True: 1.19M, False: 140k] | Branch (341:38): [True: 1.19M, False: 306] ------------------ 342| 1.19M| invert = true; 343| 1.19M| patLocal.append(u'^'); 344| 1.19M| chars.getPos(backup); // prepare to backup 345| 1.19M| c = chars.next(opts, literal, ec); 346| 1.19M| if (U_FAILURE(ec)) return; ------------------ | Branch (346:29): [True: 2, False: 1.19M] ------------------ 347| 1.19M| } 348| | // Fall through to handle special leading '-'; 349| | // otherwise restart loop for nested [], \p{}, etc. 350| 1.33M| if (c == u'-') { ------------------ | Branch (350:25): [True: 276, False: 1.33M] ------------------ 351| 276| literal = true; 352| | // Fall through to handle literal '-' below 353| 1.33M| } else { 354| 1.33M| chars.setPos(backup); // backup 355| 1.33M| continue; 356| 1.33M| } 357| 1.33M| } 358| 31.5M| } else if (symbols != nullptr) { ------------------ | Branch (358:24): [True: 0, False: 31.5M] ------------------ 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| 34.1M| } 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| 32.8M| if (setMode != 0) { ------------------ | Branch (379:13): [True: 1.36M, False: 31.5M] ------------------ 380| 1.36M| if (lastItem == 1) { ------------------ | Branch (380:17): [True: 79.8k, False: 1.28M] ------------------ 381| 79.8k| if (op != 0) { ------------------ | Branch (381:21): [True: 8, False: 79.8k] ------------------ 382| | // syntaxError(chars, "Char expected after operator"); 383| 8| ec = U_MALFORMED_SET; 384| 8| return; 385| 8| } 386| 79.8k| add(lastChar, lastChar); 387| 79.8k| _appendToPat(patLocal, lastChar, false); 388| 79.8k| lastItem = 0; 389| 79.8k| op = 0; 390| 79.8k| } 391| | 392| 1.36M| if (op == u'-' || op == u'&') { ------------------ | Branch (392:17): [True: 3.72k, False: 1.35M] | Branch (392:31): [True: 3.11k, False: 1.35M] ------------------ 393| 6.83k| patLocal.append(op); 394| 6.83k| } 395| | 396| 1.36M| if (nested == nullptr) { ------------------ | Branch (396:17): [True: 1.36M, False: 0] ------------------ 397| | // lazy allocation 398| 1.36M| if (!scratch.allocate()) { ------------------ | Branch (398:21): [True: 0, False: 1.36M] ------------------ 399| 0| ec = U_MEMORY_ALLOCATION_ERROR; 400| 0| return; 401| 0| } 402| 1.36M| nested = scratch.pointer(); 403| 1.36M| } 404| 1.36M| switch (setMode) { ------------------ | Branch (404:21): [True: 0, False: 1.36M] ------------------ 405| 1.32M| case 1: ------------------ | Branch (405:13): [True: 1.32M, False: 34.2k] ------------------ 406| 1.32M| nested->applyPattern(chars, symbols, patLocal, options, caseClosure, depth + 1, ec); 407| 1.32M| break; 408| 34.2k| case 2: ------------------ | Branch (408:13): [True: 34.2k, False: 1.32M] ------------------ 409| 34.2k| chars.skipIgnored(opts); 410| 34.2k| nested->applyPropertyPattern(chars, patLocal, ec); 411| 34.2k| if (U_FAILURE(ec)) return; ------------------ | Branch (411:21): [True: 4.29k, False: 29.9k] ------------------ 412| 29.9k| break; 413| 29.9k| case 3: // `nested' already parsed ------------------ | Branch (413:13): [True: 0, False: 1.36M] ------------------ 414| 0| nested->_toPattern(patLocal, false); 415| 0| break; 416| 1.36M| } 417| | 418| 1.35M| usePat = true; 419| | 420| 1.35M| if (mode == 0) { ------------------ | Branch (420:17): [True: 328, False: 1.35M] ------------------ 421| | // Entire pattern is a category; leave parse loop 422| 328| *this = *nested; 423| 328| mode = 2; 424| 328| break; 425| 328| } 426| | 427| 1.35M| switch (op) { ------------------ | Branch (427:21): [True: 0, False: 1.35M] ------------------ 428| 3.72k| case u'-': ------------------ | Branch (428:13): [True: 3.72k, False: 1.35M] ------------------ 429| 3.72k| removeAll(*nested); 430| 3.72k| break; 431| 3.11k| case u'&': ------------------ | Branch (431:13): [True: 3.11k, False: 1.35M] ------------------ 432| 3.11k| retainAll(*nested); 433| 3.11k| break; 434| 1.35M| case 0: ------------------ | Branch (434:13): [True: 1.35M, False: 6.83k] ------------------ 435| 1.35M| addAll(*nested); 436| 1.35M| break; 437| 1.35M| } 438| | 439| 1.35M| op = 0; 440| 1.35M| lastItem = 2; 441| | 442| 1.35M| continue; 443| 1.35M| } 444| | 445| 31.5M| if (mode == 0) { ------------------ | Branch (445:13): [True: 858, False: 31.5M] ------------------ 446| | // syntaxError(chars, "Missing '['"); 447| 858| ec = U_MALFORMED_SET; 448| 858| return; 449| 858| } 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| 31.5M| if (!literal) { ------------------ | Branch (455:13): [True: 31.5M, False: 7.78k] ------------------ 456| 31.5M| switch (c) { 457| 1.29M| case u']': ------------------ | Branch (457:13): [True: 1.29M, False: 30.2M] ------------------ 458| 1.29M| if (lastItem == 1) { ------------------ | Branch (458:21): [True: 1.24M, False: 52.4k] ------------------ 459| 1.24M| add(lastChar, lastChar); 460| 1.24M| _appendToPat(patLocal, lastChar, false); 461| 1.24M| } 462| | // Treat final trailing '-' as a literal 463| 1.29M| if (op == u'-') { ------------------ | Branch (463:21): [True: 224, False: 1.29M] ------------------ 464| 224| add(op, op); 465| 224| patLocal.append(op); 466| 1.29M| } else if (op == u'&') { ------------------ | Branch (466:28): [True: 2, False: 1.29M] ------------------ 467| | // syntaxError(chars, "Trailing '&'"); 468| 2| ec = U_MALFORMED_SET; 469| 2| return; 470| 2| } 471| 1.29M| patLocal.append(u']'); 472| 1.29M| mode = 2; 473| 1.29M| continue; 474| 10.0k| case u'-': ------------------ | Branch (474:13): [True: 10.0k, False: 31.5M] ------------------ 475| 10.0k| if (op == 0) { ------------------ | Branch (475:21): [True: 10.0k, False: 2] ------------------ 476| 10.0k| if (lastItem != 0) { ------------------ | Branch (476:25): [True: 9.83k, False: 248] ------------------ 477| 9.83k| op = static_cast(c); 478| 9.83k| continue; 479| 9.83k| } else { 480| | // Treat final trailing '-' as a literal 481| 248| add(c, c); 482| 248| c = chars.next(opts, literal, ec); 483| 248| if (U_FAILURE(ec)) return; ------------------ | Branch (483:29): [True: 2, False: 246] ------------------ 484| 246| if (c == u']' && !literal) { ------------------ | Branch (484:29): [True: 200, False: 46] | Branch (484:42): [True: 198, False: 2] ------------------ 485| 198| patLocal.append(u"-]", 2); 486| 198| mode = 2; 487| 198| continue; 488| 198| } 489| 246| } 490| 10.0k| } 491| | // syntaxError(chars, "'-' not after char or set"); 492| 50| ec = U_MALFORMED_SET; 493| 50| return; 494| 3.19k| case u'&': ------------------ | Branch (494:13): [True: 3.19k, False: 31.5M] ------------------ 495| 3.19k| if (lastItem == 2 && op == 0) { ------------------ | Branch (495:21): [True: 3.14k, False: 58] | Branch (495:38): [True: 3.13k, False: 2] ------------------ 496| 3.13k| op = static_cast(c); 497| 3.13k| continue; 498| 3.13k| } 499| | // syntaxError(chars, "'&' not after set"); 500| 60| ec = U_MALFORMED_SET; 501| 60| return; 502| 28| case u'^': ------------------ | Branch (502:13): [True: 28, False: 31.5M] ------------------ 503| | // syntaxError(chars, "'^' not after '['"); 504| 28| ec = U_MALFORMED_SET; 505| 28| return; 506| 54.8k| case u'{': ------------------ | Branch (506:13): [True: 54.8k, False: 31.4M] ------------------ 507| 54.8k| if (op != 0) { ------------------ | Branch (507:21): [True: 6, False: 54.8k] ------------------ 508| | // syntaxError(chars, "Missing operand after operator"); 509| 6| ec = U_MALFORMED_SET; 510| 6| return; 511| 6| } 512| 54.8k| if (lastItem == 1) { ------------------ | Branch (512:21): [True: 15.2k, False: 39.5k] ------------------ 513| 15.2k| add(lastChar, lastChar); 514| 15.2k| _appendToPat(patLocal, lastChar, false); 515| 15.2k| } 516| 54.8k| lastItem = 0; 517| 54.8k| buf.truncate(0); 518| 54.8k| { 519| 54.8k| UBool ok = false; 520| 10.0M| while (!chars.atEnd()) { ------------------ | Branch (520:28): [True: 10.0M, False: 304] ------------------ 521| 10.0M| c = chars.next(opts, literal, ec); 522| 10.0M| if (U_FAILURE(ec)) return; ------------------ | Branch (522:29): [True: 6, False: 10.0M] ------------------ 523| 10.0M| if (c == u'}' && !literal) { ------------------ | Branch (523:29): [True: 54.8k, False: 10.0M] | Branch (523:42): [True: 54.5k, False: 254] ------------------ 524| 54.5k| ok = true; 525| 54.5k| break; 526| 54.5k| } 527| 10.0M| buf.append(c); 528| 10.0M| } 529| 54.8k| if (!ok) { ------------------ | Branch (529:25): [True: 304, False: 54.5k] ------------------ 530| | // syntaxError(chars, "Invalid multicharacter string"); 531| 304| ec = U_MALFORMED_SET; 532| 304| return; 533| 304| } 534| 54.8k| } 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| 54.5k| add(buf); 539| 54.5k| patLocal.append(u'{'); 540| 54.5k| _appendToPat(patLocal, buf, false); 541| 54.5k| patLocal.append(u'}'); 542| 54.5k| continue; 543| 2.48k| case SymbolTable::SYMBOL_REF: ------------------ | Branch (543:13): [True: 2.48k, False: 31.5M] ------------------ 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| 2.48k| { 551| 2.48k| chars.getPos(backup); 552| 2.48k| c = chars.next(opts, literal, ec); 553| 2.48k| if (U_FAILURE(ec)) return; ------------------ | Branch (553:25): [True: 2, False: 2.47k] ------------------ 554| 2.47k| UBool anchor = (c == u']' && !literal); ------------------ | Branch (554:37): [True: 1.12k, False: 1.35k] | Branch (554:50): [True: 1.12k, False: 0] ------------------ 555| 2.47k| if (symbols == nullptr && !anchor) { ------------------ | Branch (555:25): [True: 2.47k, False: 0] | Branch (555:47): [True: 1.35k, False: 1.12k] ------------------ 556| 1.35k| c = SymbolTable::SYMBOL_REF; 557| 1.35k| chars.setPos(backup); 558| 1.35k| break; // literal '$' 559| 1.35k| } 560| 1.12k| if (anchor && op == 0) { ------------------ | Branch (560:25): [True: 1.12k, False: 0] | Branch (560:35): [True: 1.12k, False: 4] ------------------ 561| 1.12k| if (lastItem == 1) { ------------------ | Branch (561:29): [True: 740, False: 380] ------------------ 562| 740| add(lastChar, lastChar); 563| 740| _appendToPat(patLocal, lastChar, false); 564| 740| } 565| 1.12k| add(U_ETHER); ------------------ | | 37| 1.12k|#define U_ETHER ((char16_t)0xFFFF) ------------------ 566| 1.12k| usePat = true; 567| 1.12k| patLocal.append(static_cast(SymbolTable::SYMBOL_REF)); 568| 1.12k| patLocal.append(u']'); 569| 1.12k| mode = 2; 570| 1.12k| continue; 571| 1.12k| } 572| | // syntaxError(chars, "Unquoted '$'"); 573| 4| ec = U_MALFORMED_SET; 574| 4| return; 575| 1.12k| } 576| 30.1M| default: ------------------ | Branch (576:13): [True: 30.1M, False: 1.36M] ------------------ 577| 30.1M| break; 578| 31.5M| } 579| 31.5M| } 580| | 581| | // -------- Parse literal characters. This includes both 582| | // escaped chars ("\u4E01") and non-syntax characters 583| | // ("a"). 584| | 585| 30.1M| switch (lastItem) { ------------------ | Branch (585:17): [True: 0, False: 30.1M] ------------------ 586| 1.27M| case 0: ------------------ | Branch (586:9): [True: 1.27M, False: 28.8M] ------------------ 587| 1.27M| lastItem = 1; 588| 1.27M| lastChar = c; 589| 1.27M| break; 590| 28.8M| case 1: ------------------ | Branch (590:9): [True: 28.8M, False: 1.34M] ------------------ 591| 28.8M| if (op == u'-') { ------------------ | Branch (591:17): [True: 5.84k, False: 28.8M] ------------------ 592| 5.84k| if (lastChar >= c) { ------------------ | Branch (592:21): [True: 68, False: 5.78k] ------------------ 593| | // Don't allow redundant (a-a) or empty (b-a) ranges; 594| | // these are most likely typos. 595| | // syntaxError(chars, "Invalid range"); 596| 68| ec = U_MALFORMED_SET; 597| 68| return; 598| 68| } 599| 5.78k| add(lastChar, c); 600| 5.78k| _appendToPat(patLocal, lastChar, false); 601| 5.78k| patLocal.append(op); 602| 5.78k| _appendToPat(patLocal, c, false); 603| 5.78k| lastItem = 0; 604| 5.78k| op = 0; 605| 28.8M| } else { 606| 28.8M| add(lastChar, lastChar); 607| 28.8M| _appendToPat(patLocal, lastChar, false); 608| 28.8M| lastChar = c; 609| 28.8M| } 610| 28.8M| break; 611| 28.8M| case 2: ------------------ | Branch (611:9): [True: 69.4k, False: 30.1M] ------------------ 612| 69.4k| if (op != 0) { ------------------ | Branch (612:17): [True: 14, False: 69.4k] ------------------ 613| | // syntaxError(chars, "Set expected after operator"); 614| 14| ec = U_MALFORMED_SET; 615| 14| return; 616| 14| } 617| 69.4k| lastChar = c; 618| 69.4k| lastItem = 1; 619| 69.4k| break; 620| 30.1M| } 621| 30.1M| } 622| | 623| 1.32M| if (mode != 2) { ------------------ | Branch (623:9): [True: 30.5k, False: 1.29M] ------------------ 624| | // syntaxError(chars, "Missing ']'"); 625| 30.5k| ec = U_MALFORMED_SET; 626| 30.5k| return; 627| 30.5k| } 628| | 629| 1.29M| 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| 1.29M| if ((options & USET_CASE_MASK) != 0) { ------------------ | Branch (637:9): [True: 0, False: 1.29M] ------------------ 638| 0| (this->*caseClosure)(options); 639| 0| } 640| 1.29M| if (invert) { ------------------ | Branch (640:9): [True: 1.19M, False: 101k] ------------------ 641| 1.19M| complement().removeAllStrings(); // code point complement 642| 1.19M| } 643| | 644| | // Use the rebuilt pattern (patLocal) only if necessary. Prefer the 645| | // generated pattern. 646| 1.29M| if (usePat) { ------------------ | Branch (646:9): [True: 43.3k, False: 1.25M] ------------------ 647| 43.3k| rebuiltPat.append(patLocal); 648| 1.25M| } else { 649| 1.25M| _generatePattern(rebuiltPat, false); 650| 1.25M| } 651| 1.29M| if (isBogus() && U_SUCCESS(ec)) { ------------------ | Branch (651:9): [True: 0, False: 1.29M] | 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| 1.29M|} _ZN6icu_7810UnicodeSet11applyFilterEPFaiPvES1_PKS0_R10UErrorCode: 706| 22.5k| UErrorCode &status) { 707| 22.5k| if (U_FAILURE(status)) return; ------------------ | Branch (707:9): [True: 0, False: 22.5k] ------------------ 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| 22.5k| clear(); 720| | 721| 22.5k| UChar32 startHasProperty = -1; 722| 22.5k| int32_t limitRange = inclusions->getRangeCount(); 723| | 724| 36.0M| for (int j=0; jgetRangeStart(j); 727| 36.0M| UChar32 end = inclusions->getRangeEnd(j); 728| | 729| | // for all the code points in the range, process 730| 132M| for (UChar32 ch = start; ch <= end; ++ch) { ------------------ | Branch (730:34): [True: 96.4M, False: 36.0M] ------------------ 731| | // only add to this UnicodeSet on inflection points -- 732| | // where the hasProperty value changes to false 733| 96.4M| if ((*filter)(ch, context)) { ------------------ | Branch (733:17): [True: 8.39M, False: 88.0M] ------------------ 734| 8.39M| if (startHasProperty < 0) { ------------------ | Branch (734:21): [True: 4.84M, False: 3.54M] ------------------ 735| 4.84M| startHasProperty = ch; 736| 4.84M| } 737| 88.0M| } else if (startHasProperty >= 0) { ------------------ | Branch (737:24): [True: 4.84M, False: 83.1M] ------------------ 738| 4.84M| add(startHasProperty, ch-1); 739| 4.84M| startHasProperty = -1; 740| 4.84M| } 741| 96.4M| } 742| 36.0M| } 743| 22.5k| if (startHasProperty >= 0) { ------------------ | Branch (743:9): [True: 4.29k, False: 18.2k] ------------------ 744| 4.29k| add(startHasProperty, static_cast(0x10FFFF)); 745| 4.29k| } 746| 22.5k| if (isBogus() && U_SUCCESS(status)) { ------------------ | Branch (746:9): [True: 0, False: 22.5k] | 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| 22.5k|} _ZN6icu_7810UnicodeSet21applyIntPropertyValueE9UPropertyiR10UErrorCode: 783| 20.5k|UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode& ec) { 784| 20.5k| if (U_FAILURE(ec) || isFrozen()) { return *this; } ------------------ | Branch (784:9): [True: 0, False: 20.5k] | Branch (784:26): [True: 0, False: 20.5k] ------------------ 785| 20.5k| if (prop == UCHAR_GENERAL_CATEGORY_MASK) { ------------------ | Branch (785:9): [True: 6.93k, False: 13.6k] ------------------ 786| 6.93k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 787| 6.93k| applyFilter(generalCategoryMaskFilter, &value, inclusions, ec); 788| 13.6k| } else if (prop == UCHAR_SCRIPT_EXTENSIONS) { ------------------ | Branch (788:16): [True: 2.56k, False: 11.0k] ------------------ 789| 2.56k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 790| 2.56k| UScriptCode script = static_cast(value); 791| 2.56k| applyFilter(scriptExtensionsFilter, &script, inclusions, ec); 792| 11.0k| } else if (prop == UCHAR_IDENTIFIER_TYPE) { ------------------ | Branch (792:16): [True: 0, False: 11.0k] ------------------ 793| 0| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 794| 0| UIdentifierType idType = static_cast(value); 795| 0| applyFilter(idTypeFilter, &idType, inclusions, ec); 796| 11.0k| } else if (0 <= prop && prop < UCHAR_BINARY_LIMIT) { ------------------ | Branch (796:16): [True: 11.0k, False: 0] | Branch (796:29): [True: 2.79k, False: 8.26k] ------------------ 797| 2.79k| if (value == 0 || value == 1) { ------------------ | Branch (797:13): [True: 254, False: 2.54k] | Branch (797:27): [True: 2.54k, False: 0] ------------------ 798| 2.79k| const USet *set = u_getBinaryPropertySet(prop, &ec); ------------------ | | 269| 2.79k|#define u_getBinaryPropertySet U_ICU_ENTRY_POINT_RENAME(u_getBinaryPropertySet) | | ------------------ | | | | 123| 2.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 799| 2.79k| if (U_FAILURE(ec)) { return *this; } ------------------ | Branch (799:17): [True: 0, False: 2.79k] ------------------ 800| 2.79k| copyFrom(*UnicodeSet::fromUSet(set), true); 801| 2.79k| if (value == 0) { ------------------ | Branch (801:17): [True: 254, False: 2.54k] ------------------ 802| 254| complement().removeAllStrings(); // code point complement 803| 254| } 804| 2.79k| } else { 805| 0| clear(); 806| 0| } 807| 8.26k| } else if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { ------------------ | Branch (807:16): [True: 8.26k, False: 0] | Branch (807:43): [True: 8.26k, False: 0] ------------------ 808| 8.26k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 809| 8.26k| IntPropertyContext c = {prop, value}; 810| 8.26k| applyFilter(intPropertyFilter, &c, inclusions, ec); 811| 8.26k| } else { 812| 0| ec = U_ILLEGAL_ARGUMENT_ERROR; 813| 0| } 814| 20.5k| return *this; 815| 20.5k|} _ZN6icu_7810UnicodeSet18applyPropertyAliasERKNS_13UnicodeStringES3_R10UErrorCode: 820| 31.6k| UErrorCode& ec) { 821| 31.6k| if (U_FAILURE(ec) || isFrozen()) return *this; ------------------ | Branch (821:9): [True: 0, False: 31.6k] | Branch (821:26): [True: 0, False: 31.6k] ------------------ 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| 31.6k| if( !uprv_isInvariantUString(prop.getBuffer(), prop.length()) || ------------------ | | 1518| 31.6k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 31.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 31.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 31.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (829:9): [True: 174, False: 31.4k] ------------------ 830| 31.6k| !uprv_isInvariantUString(value.getBuffer(), value.length()) ------------------ | | 1518| 31.4k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 31.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 31.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 31.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (830:9): [True: 182, False: 31.3k] ------------------ 831| 31.6k| ) { 832| 356| FAIL(ec); ------------------ | | 777| 356|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 356|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 356| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 356| return *this; \ | | 780| 356|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 356|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 833| 356| } 834| 31.3k| CharString pname, vname; 835| 31.3k| pname.appendInvariantChars(prop, ec); 836| 31.3k| vname.appendInvariantChars(value, ec); 837| 31.3k| if (U_FAILURE(ec)) return *this; ------------------ | Branch (837:9): [True: 0, False: 31.3k] ------------------ 838| | 839| 31.3k| UProperty p; 840| 31.3k| int32_t v; 841| 31.3k| UBool invert = false; 842| | 843| 31.3k| if (value.length() > 0) { ------------------ | Branch (843:9): [True: 17.7k, False: 13.5k] ------------------ 844| 17.7k| p = u_getPropertyEnum(pname.data()); ------------------ | | 283| 17.7k|#define u_getPropertyEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyEnum) | | ------------------ | | | | 123| 17.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 17.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 17.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 845| 17.7k| if (p == UCHAR_INVALID_CODE) FAIL(ec); ------------------ | | 777| 22|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 22|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 22| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 22| return *this; \ | | 780| 22|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 22|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ | Branch (845:13): [True: 22, False: 17.7k] ------------------ 846| | 847| | // Treat gc as gcm 848| 17.7k| if (p == UCHAR_GENERAL_CATEGORY) { ------------------ | Branch (848:13): [True: 198, False: 17.5k] ------------------ 849| 198| p = UCHAR_GENERAL_CATEGORY_MASK; 850| 198| } 851| | 852| 17.7k| if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) || ------------------ | Branch (852:14): [True: 17.7k, False: 0] | Branch (852:41): [True: 268, False: 17.4k] ------------------ 853| 17.7k| (p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) || ------------------ | Branch (853:14): [True: 17.4k, False: 0] | Branch (853:38): [True: 6.20k, False: 11.2k] ------------------ 854| 17.7k| (p >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) { ------------------ | Branch (854:14): [True: 11.2k, False: 0] | Branch (854:39): [True: 198, False: 11.0k] ------------------ 855| 6.67k| v = u_getPropertyValueEnum(p, vname.data()); ------------------ | | 285| 6.67k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 6.67k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.67k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.67k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 856| 6.67k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (856:17): [True: 2.25k, False: 4.42k] ------------------ 857| | // Handle numeric CCC 858| 2.25k| if (p == UCHAR_CANONICAL_COMBINING_CLASS || ------------------ | Branch (858:21): [True: 750, False: 1.50k] ------------------ 859| 2.25k| p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS || ------------------ | Branch (859:21): [True: 678, False: 822] ------------------ 860| 2.25k| p == UCHAR_LEAD_CANONICAL_COMBINING_CLASS) { ------------------ | Branch (860:21): [True: 796, False: 26] ------------------ 861| 2.22k| char* end; 862| 2.22k| double val = uprv_strtod(vname.data(), &end); ------------------ | | 75| 2.22k|#define uprv_strtod(source, end) U_STANDARD_CPP_NAMESPACE strtod(source, end) | | ------------------ | | | | 393| 2.22k|#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| 2.22k| if (*end != 0 || !(0 <= val && val <= 255) || ------------------ | Branch (867:25): [True: 4, False: 2.22k] | Branch (867:40): [True: 2.21k, False: 2] | Branch (867:52): [True: 2.21k, False: 2] ------------------ 868| 2.22k| (v = static_cast(val)) != val) { ------------------ | Branch (868:29): [True: 2, False: 2.21k] ------------------ 869| | // non-integral value or outside 0..255, or trailing junk 870| 10| FAIL(ec); ------------------ | | 777| 10|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 10|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 10| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 10| return *this; \ | | 780| 10|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 10|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 871| 10| } 872| 2.22k| } else { 873| 26| FAIL(ec); ------------------ | | 777| 26|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 26|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 26| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 26| return *this; \ | | 780| 26|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 26|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 874| 26| } 875| 2.25k| } 876| 6.67k| } 877| | 878| 11.0k| else { 879| | 880| 11.0k| switch (p) { 881| 4.78k| case UCHAR_NUMERIC_VALUE: ------------------ | Branch (881:13): [True: 4.78k, False: 6.25k] ------------------ 882| 4.78k| { 883| 4.78k| char* end; 884| 4.78k| double val = uprv_strtod(vname.data(), &end); ------------------ | | 75| 4.78k|#define uprv_strtod(source, end) U_STANDARD_CPP_NAMESPACE strtod(source, end) | | ------------------ | | | | 393| 4.78k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 885| 4.78k| if (*end != 0) { ------------------ | Branch (885:25): [True: 16, False: 4.76k] ------------------ 886| 16| FAIL(ec); ------------------ | | 777| 16|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 16|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 16| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 16| return *this; \ | | 780| 16|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 16|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 887| 16| } 888| 4.76k| applyFilter(numericValueFilter, &val, 889| 4.76k| CharacterProperties::getInclusionsForProperty(p, ec), ec); 890| 4.76k| return *this; 891| 4.78k| } 892| 3.67k| case UCHAR_NAME: ------------------ | Branch (892:13): [True: 3.67k, False: 7.36k] ------------------ 893| 3.67k| { 894| | // Must munge name, since u_charFromName() does not do 895| | // 'loose' matching. 896| 3.67k| char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength 897| 3.67k| if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec); ------------------ | | 777| 6|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 6|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 6| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 6| return *this; \ | | 780| 6|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 6|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ | Branch (897:25): [True: 6, False: 3.67k] ------------------ 898| 3.67k| UChar32 ch = u_charFromName(U_EXTENDED_CHAR_NAME, buf, &ec); ------------------ | | 222| 3.67k|#define u_charFromName U_ICU_ENTRY_POINT_RENAME(u_charFromName) | | ------------------ | | | | 123| 3.67k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.67k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.67k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 899| 3.67k| if (U_SUCCESS(ec)) { ------------------ | Branch (899:25): [True: 2.91k, False: 756] ------------------ 900| 2.91k| clear(); 901| 2.91k| add(ch); 902| 2.91k| return *this; 903| 2.91k| } else { 904| 756| FAIL(ec); ------------------ | | 777| 756|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 756|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 756| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 756| return *this; \ | | 780| 756|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 756|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 905| 756| } 906| 3.67k| } 907| 2| case UCHAR_UNICODE_1_NAME: ------------------ | Branch (907:13): [True: 2, False: 11.0k] ------------------ 908| | // ICU 49 deprecates the Unicode_1_Name property APIs. 909| 2| FAIL(ec); ------------------ | | 777| 2|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 2| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 2| return *this; \ | | 780| 2|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 910| 0| case UCHAR_AGE: ------------------ | Branch (910:13): [True: 0, False: 11.0k] ------------------ 911| 0| { 912| | // Must munge name, since u_versionFromString() does not do 913| | // 'loose' matching. 914| 0| char buf[128]; 915| 0| 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: 0] ------------------ 916| 0| UVersionInfo version; 917| 0| u_versionFromString(version, buf); ------------------ | | 417| 0|#define u_versionFromString U_ICU_ENTRY_POINT_RENAME(u_versionFromString) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 918| 0| applyFilter(versionFilter, &version, 919| 0| CharacterProperties::getInclusionsForProperty(p, ec), ec); 920| 0| return *this; 921| 0| } 922| 2.57k| case UCHAR_SCRIPT_EXTENSIONS: ------------------ | Branch (922:13): [True: 2.57k, False: 8.46k] ------------------ 923| 2.57k| v = u_getPropertyValueEnum(UCHAR_SCRIPT, vname.data()); ------------------ | | 285| 2.57k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 2.57k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.57k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.57k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 924| 2.57k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (924:21): [True: 8, False: 2.56k] ------------------ 925| 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] | | | | ------------------ | | ------------------ ------------------ 926| 8| } 927| | // fall through to calling applyIntPropertyValue() 928| 2.56k| break; 929| 2.56k| case UCHAR_IDENTIFIER_TYPE: ------------------ | Branch (929:13): [True: 0, False: 11.0k] ------------------ 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| 6| default: ------------------ | Branch (936:13): [True: 6, False: 11.0k] ------------------ 937| | // p is a non-binary, non-enumerated property that we 938| | // don't support (yet). 939| 6| FAIL(ec); ------------------ | | 777| 6|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 6|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 6| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 6| return *this; \ | | 780| 6|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 6|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 940| 11.0k| } 941| 11.0k| } 942| 17.7k| } 943| | 944| 13.5k| else { 945| | // value is empty. Interpret as General Category, Script, or 946| | // Binary property. 947| 13.5k| p = UCHAR_GENERAL_CATEGORY_MASK; 948| 13.5k| v = u_getPropertyValueEnum(p, pname.data()); ------------------ | | 285| 13.5k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 13.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 13.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 13.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 949| 13.5k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (949:13): [True: 6.84k, False: 6.73k] ------------------ 950| 6.84k| p = UCHAR_SCRIPT; 951| 6.84k| v = u_getPropertyValueEnum(p, pname.data()); ------------------ | | 285| 6.84k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 6.84k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.84k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.84k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 952| 6.84k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (952:17): [True: 4.76k, False: 2.07k] ------------------ 953| 4.76k| p = u_getPropertyEnum(pname.data()); ------------------ | | 283| 4.76k|#define u_getPropertyEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyEnum) | | ------------------ | | | | 123| 4.76k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.76k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.76k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| 4.76k| if (p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) { ------------------ | Branch (954:21): [True: 2.56k, False: 2.20k] | Branch (954:48): [True: 2.54k, False: 18] ------------------ 955| 2.54k| v = 1; 956| 2.54k| } else if (0 == uprv_comparePropertyNames(ANY, pname.data())) { ------------------ | | 60| 2.22k|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 2.22k|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 2.22k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 2.22k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 2.22k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (956:28): [True: 898, False: 1.32k] ------------------ 957| 898| set(MIN_VALUE, MAX_VALUE); 958| 898| return *this; 959| 1.32k| } else if (0 == uprv_comparePropertyNames(ASCII, pname.data())) { ------------------ | | 60| 1.32k|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 1.32k|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 1.32k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 1.32k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.32k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (959:28): [True: 824, False: 502] ------------------ 960| 824| set(0, 0x7F); 961| 824| return *this; 962| 824| } else if (0 == uprv_comparePropertyNames(ASSIGNED, pname.data())) { ------------------ | | 60| 502|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 502|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 502|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 502|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 502|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (962:28): [True: 0, False: 502] ------------------ 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| 502| } else { 968| 502| FAIL(ec); ------------------ | | 777| 502|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 502|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 502| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 502| return *this; \ | | 780| 502|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 502|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 969| 502| } 970| 4.76k| } 971| 6.84k| } 972| 13.5k| } 973| | 974| 20.5k| applyIntPropertyValue(p, v, ec); 975| 20.5k| if(invert) { ------------------ | Branch (975:8): [True: 0, False: 20.5k] ------------------ 976| 0| complement().removeAllStrings(); // code point complement 977| 0| } 978| | 979| 20.5k| if (isBogus() && U_SUCCESS(ec)) { ------------------ | Branch (979:9): [True: 0, False: 20.5k] | 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| 20.5k| return *this; 984| 31.3k|} _ZN6icu_7810UnicodeSet24resemblesPropertyPatternERNS_21RuleCharacterIteratorEi: 1014| 34.2M| int32_t iterOpts) { 1015| | // NOTE: literal will always be false, because we don't parse escapes. 1016| 34.2M| UBool result = false, literal; 1017| 34.2M| UErrorCode ec = U_ZERO_ERROR; 1018| 34.2M| iterOpts &= ~RuleCharacterIterator::PARSE_ESCAPES; 1019| 34.2M| RuleCharacterIterator::Pos pos; 1020| 34.2M| chars.getPos(pos); 1021| 34.2M| UChar32 c = chars.next(iterOpts, literal, ec); 1022| 34.2M| if (c == u'[' || c == u'\\') { ------------------ | Branch (1022:9): [True: 2.68M, False: 31.5M] | Branch (1022:22): [True: 24.7k, False: 31.5M] ------------------ 1023| 2.71M| UChar32 d = chars.next(iterOpts & ~RuleCharacterIterator::SKIP_WHITESPACE, 1024| 2.71M| literal, ec); 1025| 2.71M| result = (c == u'[') ? (d == u':') : ------------------ | Branch (1025:18): [True: 2.68M, False: 24.7k] ------------------ 1026| 2.71M| (d == u'N' || d == u'p' || d == u'P'); ------------------ | Branch (1026:33): [True: 4.80k, False: 19.9k] | Branch (1026:46): [True: 2.80k, False: 17.1k] | Branch (1026:59): [True: 8.88k, False: 8.27k] ------------------ 1027| 2.71M| } 1028| 34.2M| chars.setPos(pos); 1029| 34.2M| return result && U_SUCCESS(ec); ------------------ | Branch (1029:12): [True: 34.2k, False: 34.2M] | Branch (1029:22): [True: 34.2k, False: 0] ------------------ 1030| 34.2M|} _ZN6icu_7810UnicodeSet20applyPropertyPatternERKNS_13UnicodeStringERNS_13ParsePositionER10UErrorCode: 1037| 32.0k| UErrorCode &ec) { 1038| 32.0k| int32_t pos = ppos.getIndex(); 1039| | 1040| 32.0k| UBool posix = false; // true for [:pat:], false for \p{pat} \P{pat} \N{pat} 1041| 32.0k| UBool isName = false; // true for \N{pat}, o/w false 1042| 32.0k| UBool invert = false; 1043| | 1044| 32.0k| if (U_FAILURE(ec)) return *this; ------------------ | Branch (1044:9): [True: 0, False: 32.0k] ------------------ 1045| | 1046| | // Minimum length is 5 characters, e.g. \p{L} 1047| 32.0k| if ((pos+5) > pattern.length()) { ------------------ | Branch (1047:9): [True: 108, False: 31.9k] ------------------ 1048| 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] | | | | ------------------ | | ------------------ ------------------ 1049| 108| } 1050| | 1051| | // On entry, ppos should point to one of the following locations: 1052| | // Look for an opening [:, [:^, \p, or \P 1053| 31.9k| if (isPOSIXOpen(pattern, pos)) { ------------------ | Branch (1053:9): [True: 16.8k, False: 15.0k] ------------------ 1054| 16.8k| posix = true; 1055| 16.8k| pos += 2; 1056| 16.8k| pos = ICU_Utility::skipWhitespace(pattern, pos); 1057| 16.8k| if (pos < pattern.length() && pattern.charAt(pos) == u'^') { ------------------ | Branch (1057:13): [True: 16.8k, False: 12] | Branch (1057:39): [True: 194, False: 16.6k] ------------------ 1058| 194| ++pos; 1059| 194| invert = true; 1060| 194| } 1061| 16.8k| } else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) { ------------------ | Branch (1061:16): [True: 11.1k, False: 3.90k] | Branch (1061:44): [True: 3.90k, False: 0] ------------------ 1062| 15.0k| char16_t c = pattern.charAt(pos+1); 1063| 15.0k| invert = (c == u'P'); 1064| 15.0k| isName = (c == u'N'); 1065| 15.0k| pos += 2; 1066| 15.0k| pos = ICU_Utility::skipWhitespace(pattern, pos); 1067| 15.0k| if (pos == pattern.length() || pattern.charAt(pos++) != u'{') { ------------------ | Branch (1067:13): [True: 16, False: 15.0k] | Branch (1067:40): [True: 56, False: 14.9k] ------------------ 1068| | // Syntax error; "\p" or "\P" not followed by "{" 1069| 72| FAIL(ec); ------------------ | | 777| 72|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 72|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 72| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 72| return *this; \ | | 780| 72|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 72|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1070| 72| } 1071| 15.0k| } 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| 31.8k| int32_t close; 1078| 31.8k| if (posix) { ------------------ | Branch (1078:9): [True: 16.8k, False: 14.9k] ------------------ 1079| 16.8k| close = pattern.indexOf(u":]", 2, pos); 1080| 16.8k| } else { 1081| 14.9k| close = pattern.indexOf(u'}', pos); 1082| 14.9k| } 1083| 31.8k| if (close < 0) { ------------------ | Branch (1083:9): [True: 178, False: 31.6k] ------------------ 1084| | // Syntax error; close delimiter missing 1085| 178| FAIL(ec); ------------------ | | 777| 178|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 178|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 178| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 178| return *this; \ | | 780| 178|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 178|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1086| 178| } 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| 31.6k| int32_t equals = pattern.indexOf(u'=', pos); 1092| 31.6k| UnicodeString propName, valueName; 1093| 31.6k| if (equals >= 0 && equals < close && !isName) { ------------------ | Branch (1093:9): [True: 17.2k, False: 14.3k] | Branch (1093:24): [True: 15.1k, False: 2.07k] | Branch (1093:42): [True: 14.9k, False: 202] ------------------ 1094| | // Equals seen; parse medium/long pattern 1095| 14.9k| pattern.extractBetween(pos, equals, propName); 1096| 14.9k| pattern.extractBetween(equals+1, close, valueName); 1097| 14.9k| } 1098| | 1099| 16.6k| else { 1100| | // Handle case where no '=' is seen, and \N{} 1101| 16.6k| pattern.extractBetween(pos, close, propName); 1102| | 1103| | // Handle \N{name} 1104| 16.6k| if (isName) { ------------------ | Branch (1104:13): [True: 3.85k, False: 12.8k] ------------------ 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| 3.85k| valueName = propName; 1111| 3.85k| propName = NAME_PROP; 1112| 3.85k| } 1113| 16.6k| } 1114| | 1115| 31.6k| applyPropertyAlias(propName, valueName, ec); 1116| | 1117| 31.6k| if (U_SUCCESS(ec)) { ------------------ | Branch (1117:9): [True: 29.9k, False: 1.71k] ------------------ 1118| 29.9k| if (invert) { ------------------ | Branch (1118:13): [True: 8.51k, False: 21.4k] ------------------ 1119| 8.51k| complement().removeAllStrings(); // code point complement 1120| 8.51k| } 1121| | 1122| | // Move to the limit position after the close delimiter if the 1123| | // parse succeeded. 1124| 29.9k| ppos.setIndex(close + (posix ? 2 : 1)); ------------------ | Branch (1124:32): [True: 16.2k, False: 13.7k] ------------------ 1125| 29.9k| } 1126| | 1127| 31.6k| return *this; 1128| 31.8k|} _ZN6icu_7810UnicodeSet20applyPropertyPatternERNS_21RuleCharacterIteratorERNS_13UnicodeStringER10UErrorCode: 1141| 34.2k| UErrorCode& ec) { 1142| 34.2k| if (U_FAILURE(ec)) return; ------------------ | Branch (1142:9): [True: 2.22k, False: 32.0k] ------------------ 1143| 32.0k| UnicodeString pattern; 1144| 32.0k| chars.lookahead(pattern); 1145| 32.0k| ParsePosition pos(0); 1146| 32.0k| applyPropertyPattern(pattern, pos, ec); 1147| 32.0k| if (U_FAILURE(ec)) return; ------------------ | Branch (1147:9): [True: 2.06k, False: 29.9k] ------------------ 1148| 29.9k| if (pos.getIndex() == 0) { ------------------ | Branch (1148:9): [True: 0, False: 29.9k] ------------------ 1149| | // syntaxError(chars, "Invalid property pattern"); 1150| 0| ec = U_MALFORMED_SET; 1151| 0| return; 1152| 0| } 1153| 29.9k| chars.jumpahead(pos.getIndex()); 1154| 29.9k| rebuiltPat.append(pattern, 0, pos.getIndex()); 1155| 29.9k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointerC2Ev: 232| 1.33M| inline UnicodeSetPointer() : p(nullptr) {} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointer8allocateEv: 235| 1.36M| inline UBool allocate() { 236| 1.36M| if (p == nullptr) { ------------------ | Branch (236:13): [True: 80.0k, False: 1.28M] ------------------ 237| 80.0k| p = new UnicodeSet(); 238| 80.0k| } 239| 1.36M| return p != nullptr; 240| 1.36M| } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointer7pointerEv: 234| 1.36M| inline UnicodeSet* pointer() { return p; } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointerD2Ev: 233| 1.33M| inline ~UnicodeSetPointer() { delete p; } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_125generalCategoryMaskFilterEiPv: 667| 41.6M|UBool generalCategoryMaskFilter(UChar32 ch, void* context) { 668| 41.6M| int32_t value = *static_cast(context); 669| 41.6M| return (U_GET_GC_MASK((UChar32) ch) & value) != 0; ------------------ | | 3644| 41.6M|#define U_GET_GC_MASK(c) U_MASK(u_charType(c)) | | ------------------ | | | | 174| 41.6M|#define U_MASK(x) ((uint32_t)1<<(x)) | | ------------------ ------------------ 670| 41.6M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_122scriptExtensionsFilterEiPv: 690| 18.2M|UBool scriptExtensionsFilter(UChar32 ch, void* context) { 691| 18.2M| return uscript_hasScript(ch, *static_cast(context)); ------------------ | | 1710| 18.2M|#define uscript_hasScript U_ICU_ENTRY_POINT_RENAME(uscript_hasScript) | | ------------------ | | | | 123| 18.2M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 18.2M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 18.2M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 692| 18.2M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117intPropertyFilterEiPv: 685| 7.88M|UBool intPropertyFilter(UChar32 ch, void* context) { 686| 7.88M| IntPropertyContext* c = static_cast(context); 687| 7.88M| return u_getIntPropertyValue(ch, c->prop) == c->value; ------------------ | | 280| 7.88M|#define u_getIntPropertyValue U_ICU_ENTRY_POINT_RENAME(u_getIntPropertyValue) | | ------------------ | | | | 123| 7.88M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7.88M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7.88M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 688| 7.88M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_118numericValueFilterEiPv: 663| 28.6M|UBool numericValueFilter(UChar32 ch, void* context) { 664| 28.6M| return u_getNumericValue(ch) == *static_cast(context); ------------------ | | 282| 28.6M|#define u_getNumericValue U_ICU_ENTRY_POINT_RENAME(u_getNumericValue) | | ------------------ | | | | 123| 28.6M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 28.6M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 28.6M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 665| 28.6M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_113mungeCharNameEPcPKci: 754| 3.67k|UBool mungeCharName(char* dst, const char* src, int32_t dstCapacity) { 755| | /* Note: we use ' ' in compiler code page */ 756| 3.67k| int32_t j = 0; 757| 3.67k| char ch; 758| 3.67k| --dstCapacity; /* make room for term. zero */ 759| 21.1k| while ((ch = *src++) != 0) { ------------------ | Branch (759:12): [True: 17.5k, False: 3.67k] ------------------ 760| 17.5k| if (ch == ' ' && (j==0 || (j>0 && dst[j-1]==' '))) { ------------------ | Branch (760:13): [True: 2.02k, False: 15.4k] | Branch (760:27): [True: 580, False: 1.44k] | Branch (760:36): [True: 1.44k, False: 0] | Branch (760:43): [True: 542, False: 902] ------------------ 761| 1.12k| continue; 762| 1.12k| } 763| 16.3k| if (j >= dstCapacity) return false; ------------------ | Branch (763:13): [True: 6, False: 16.3k] ------------------ 764| 16.3k| dst[j++] = ch; 765| 16.3k| } 766| 3.67k| if (j > 0 && dst[j-1] == ' ') --j; ------------------ | Branch (766:9): [True: 3.63k, False: 38] | Branch (766:18): [True: 574, False: 3.05k] ------------------ 767| 3.67k| dst[j] = 0; 768| 3.67k| return true; 769| 3.67k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_111isPOSIXOpenERKNS_13UnicodeStringEi: 129| 31.9k|isPOSIXOpen(const UnicodeString &pattern, int32_t pos) { 130| 31.9k| return pattern.charAt(pos)==u'[' && pattern.charAt(pos+1)==u':'; ------------------ | Branch (130:12): [True: 16.8k, False: 15.0k] | Branch (130:41): [True: 16.8k, False: 0] ------------------ 131| 31.9k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_110isPerlOpenERKNS_13UnicodeStringEi: 113| 15.0k|isPerlOpen(const UnicodeString &pattern, int32_t pos) { 114| 15.0k| char16_t c; 115| 15.0k| return pattern.charAt(pos)==u'\\' && ((c=pattern.charAt(pos+1))==u'p' || c==u'P'); ------------------ | Branch (115:12): [True: 15.0k, False: 0] | Branch (115:43): [True: 2.57k, False: 12.4k] | Branch (115:78): [True: 8.54k, False: 3.90k] ------------------ 116| 15.0k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_110isNameOpenERKNS_13UnicodeStringEi: 124| 3.90k|isNameOpen(const UnicodeString &pattern, int32_t pos) { 125| 3.90k| return pattern.charAt(pos)==u'\\' && pattern.charAt(pos+1)==u'N'; ------------------ | Branch (125:12): [True: 3.90k, False: 0] | Branch (125:42): [True: 3.90k, False: 0] ------------------ 126| 3.90k|} _ZN6icu_7811ReplaceableD2Ev: 106| 3.32M|Replaceable::~Replaceable() {} _ZN6icu_7813UnicodeString6addRefEv: 146| 93.5k|UnicodeString::addRef() { 147| 93.5k| umtx_atomic_inc(reinterpret_cast(fUnion.fFields.fArray) - 1); 148| 93.5k|} _ZN6icu_7813UnicodeString9removeRefEv: 151| 1.33M|UnicodeString::removeRef() { 152| 1.33M| return umtx_atomic_dec(reinterpret_cast(fUnion.fFields.fArray) - 1); 153| 1.33M|} _ZNK6icu_7813UnicodeString8refCountEv: 156| 315M|UnicodeString::refCount() const { 157| 315M| return umtx_loadAcquire(*(reinterpret_cast(fUnion.fFields.fArray) - 1)); 158| 315M|} _ZN6icu_7813UnicodeString12releaseArrayEv: 161| 3.81M|UnicodeString::releaseArray() { 162| 3.81M| if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) { ------------------ | Branch (162:6): [True: 1.33M, False: 2.47M] | Branch (162:56): [True: 1.25M, False: 86.6k] ------------------ 163| 1.25M| uprv_free(reinterpret_cast(fUnion.fFields.fArray) - 1); ------------------ | | 1503| 1.25M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.25M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.25M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.25M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 1.25M| } 165| 3.81M|} _ZN6icu_7813UnicodeStringC2EaNS_14ConstChar16PtrEi: 241| 5.31k| int32_t textLength) { 242| 5.31k| fUnion.fFields.fLengthAndFlags = kReadonlyAlias; 243| 5.31k| const char16_t *text = textPtr; 244| 5.31k| if(text == nullptr) { ------------------ | Branch (244:6): [True: 0, False: 5.31k] ------------------ 245| | // treat as an empty string, do not alias 246| 0| setToEmpty(); 247| 5.31k| } else if(textLength < -1 || ------------------ | Branch (247:13): [True: 0, False: 5.31k] ------------------ 248| 5.31k| (textLength == -1 && !isTerminated) || ------------------ | Branch (248:14): [True: 0, False: 5.31k] | Branch (248:34): [True: 0, False: 0] ------------------ 249| 5.31k| (textLength >= 0 && isTerminated && text[textLength] != 0) ------------------ | Branch (249:14): [True: 5.31k, False: 0] | Branch (249:33): [True: 0, False: 5.31k] | Branch (249:49): [True: 0, False: 0] ------------------ 250| 5.31k| ) { 251| 0| setToBogus(); 252| 5.31k| } else { 253| 5.31k| if(textLength == -1) { ------------------ | Branch (253:8): [True: 0, False: 5.31k] ------------------ 254| | // text is terminated, or else it would have failed the above test 255| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 256| 0| } 257| 5.31k| setArray(const_cast(text), textLength, 258| 5.31k| isTerminated ? textLength + 1 : textLength); ------------------ | Branch (258:14): [True: 0, False: 5.31k] ------------------ 259| 5.31k| } 260| 5.31k|} _ZN6icu_7813UnicodeStringC2ERKS0_: 345| 482k|UnicodeString::UnicodeString(const UnicodeString& that) { 346| 482k| fUnion.fFields.fLengthAndFlags = kShortString; 347| 482k| copyFrom(that); 348| 482k|} _ZN6icu_7813UnicodeString8allocateEi: 409| 1.53M|UnicodeString::allocate(int32_t capacity) { 410| 1.53M| if(capacity <= US_STACKBUF_SIZE) { ------------------ | Branch (410:6): [True: 16.7k, False: 1.51M] ------------------ 411| 16.7k| fUnion.fFields.fLengthAndFlags = kShortString; 412| 16.7k| return true; 413| 16.7k| } 414| 1.51M| if(capacity <= kMaxCapacity) { ------------------ | Branch (414:6): [True: 1.51M, False: 0] ------------------ 415| 1.51M| ++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| 1.51M| size_t numBytes = sizeof(int32_t) + static_cast(capacity) * U_SIZEOF_UCHAR; ------------------ | | 352| 1.51M|#define U_SIZEOF_UCHAR 2 ------------------ 419| | // Round up to a multiple of 16. 420| 1.51M| numBytes = (numBytes + 15) & ~15; 421| 1.51M| int32_t* array = static_cast(uprv_malloc(numBytes)); ------------------ | | 1524| 1.51M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.51M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.51M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.51M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| 1.51M| if(array != nullptr) { ------------------ | Branch (422:8): [True: 1.51M, False: 0] ------------------ 423| | // set initial refCount and point behind the refCount 424| 1.51M| *array++ = 1; 425| 1.51M| numBytes -= sizeof(int32_t); 426| | 427| | // have fArray point to the first char16_t 428| 1.51M| fUnion.fFields.fArray = reinterpret_cast(array); 429| 1.51M| fUnion.fFields.fCapacity = static_cast(numBytes / U_SIZEOF_UCHAR); ------------------ | | 352| 1.51M|#define U_SIZEOF_UCHAR 2 ------------------ 430| 1.51M| fUnion.fFields.fLengthAndFlags = kLongString; 431| 1.51M| return true; 432| 1.51M| } 433| 1.51M| } 434| 0| fUnion.fFields.fLengthAndFlags = kIsBogus; 435| 0| fUnion.fFields.fArray = nullptr; 436| 0| fUnion.fFields.fCapacity = 0; 437| 0| return false; 438| 1.51M|} _ZN6icu_7813UnicodeStringD2Ev: 462| 3.32M|{ 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| 3.32M| releaseArray(); 478| 3.32M|} _ZN6icu_7813UnicodeStringaSERKS0_: 527| 3.85k|UnicodeString::operator=(const UnicodeString &src) { 528| 3.85k| return copyFrom(src); 529| 3.85k|} _ZN6icu_7813UnicodeString8copyFromERKS0_a: 537| 486k|UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) { 538| | // if assigning to ourselves, do nothing 539| 486k| if(this == &src) { ------------------ | Branch (539:6): [True: 0, False: 486k] ------------------ 540| 0| return *this; 541| 0| } 542| | 543| | // is the right side bogus? 544| 486k| if(src.isBogus()) { ------------------ | Branch (544:6): [True: 0, False: 486k] ------------------ 545| 0| setToBogus(); 546| 0| return *this; 547| 0| } 548| | 549| | // delete the current contents 550| 486k| releaseArray(); 551| | 552| 486k| if(src.isEmpty()) { ------------------ | Branch (552:6): [True: 16.4k, False: 469k] ------------------ 553| | // empty string - use the stack buffer 554| 16.4k| setToEmpty(); 555| 16.4k| return *this; 556| 16.4k| } 557| | 558| | // fLength>0 and not an "open" src.getBuffer(minCapacity) 559| 469k| fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags; 560| 469k| switch(src.fUnion.fFields.fLengthAndFlags & kAllStorageFlags) { 561| 360k| case kShortString: ------------------ | Branch (561:3): [True: 360k, False: 109k] ------------------ 562| | // short string using the stack buffer, do the same 563| 360k| uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer, ------------------ | | 42| 360k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 360k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 360k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 360k| _Pragma("clang diagnostic push") \ | | 45| 360k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 360k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 360k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 360k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 360k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 360k| _Pragma("clang diagnostic pop") \ | | 49| 360k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 360k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 360k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 360k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 564| 360k| getShortLength() * U_SIZEOF_UCHAR); 565| 360k| break; 566| 93.5k| case kLongString: ------------------ | Branch (566:3): [True: 93.5k, False: 376k] ------------------ 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| 93.5k| const_cast(src).addRef(); 570| | // copy all fields, share the reference-counted buffer 571| 93.5k| fUnion.fFields.fArray = src.fUnion.fFields.fArray; 572| 93.5k| fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity; 573| 93.5k| if(!hasShortLength()) { ------------------ | Branch (573:8): [True: 8.56k, False: 85.0k] ------------------ 574| 8.56k| fUnion.fFields.fLength = src.fUnion.fFields.fLength; 575| 8.56k| } 576| 93.5k| break; 577| 15.5k| case kReadonlyAlias: ------------------ | Branch (577:3): [True: 15.5k, False: 454k] ------------------ 578| 15.5k| if(fastCopy) { ------------------ | Branch (578:8): [True: 0, False: 15.5k] ------------------ 579| | // src is a readonly alias, do the same 580| | // -> maintain the readonly alias as such 581| 0| fUnion.fFields.fArray = src.fUnion.fFields.fArray; 582| 0| fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity; 583| 0| if(!hasShortLength()) { ------------------ | Branch (583:10): [True: 0, False: 0] ------------------ 584| 0| fUnion.fFields.fLength = src.fUnion.fFields.fLength; 585| 0| } 586| 0| break; 587| 0| } 588| | // else if(!fastCopy) fall through to case kWritableAlias 589| | // -> allocate a new buffer and copy the contents 590| 15.5k| U_FALLTHROUGH; ------------------ | | 511| 15.5k|# define U_FALLTHROUGH [[clang::fallthrough]] ------------------ 591| 15.5k| case kWritableAlias: { ------------------ | Branch (591:3): [True: 0, False: 469k] ------------------ 592| | // src is a writable alias; we make a copy of that instead 593| 15.5k| int32_t srcLength = src.length(); 594| 15.5k| if(allocate(srcLength)) { ------------------ | Branch (594:8): [True: 15.5k, False: 0] ------------------ 595| 15.5k| u_memcpy(getArrayStart(), src.getArrayStart(), srcLength); ------------------ | | 334| 15.5k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 596| 15.5k| setLength(srcLength); 597| 15.5k| break; 598| 15.5k| } 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: 469k] ------------------ 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| 469k| } 610| | 611| 469k| return *this; 612| 469k|} _ZNK6icu_7813UnicodeString10unescapeAtERi: 690| 46.8k|UChar32 UnicodeString::unescapeAt(int32_t &offset) const { 691| 46.8k| return u_unescapeAt(UnicodeString_charAt, &offset, length(), (void*)this); ------------------ | | 416| 46.8k|#define u_unescapeAt U_ICU_ENTRY_POINT_RENAME(u_unescapeAt) | | ------------------ | | | | 123| 46.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 46.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 46.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 692| 46.8k|} _ZNK6icu_7813UnicodeString8doEqualsEPKDsi: 698| 2.96M|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| 2.96M| return uprv_memcmp(getArrayStart(), text, len * U_SIZEOF_UCHAR) == 0; ------------------ | | 101| 2.96M|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 2.96M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 702| 2.96M|} _ZNK6icu_7813UnicodeString9doCompareEiiPKDsii: 752| 2.48M|{ 753| | // compare illegal string values 754| 2.48M| if(isBogus()) { ------------------ | Branch (754:6): [True: 0, False: 2.48M] ------------------ 755| 0| return -1; 756| 0| } 757| | 758| | // pin indices to legal values 759| 2.48M| pinIndices(start, length); 760| | 761| 2.48M| if(srcChars == nullptr) { ------------------ | Branch (761:6): [True: 0, False: 2.48M] ------------------ 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| 2.48M| const char16_t *chars = getArrayStart(); 768| | 769| 2.48M| chars += start; 770| 2.48M| srcChars += srcStart; 771| | 772| 2.48M| int32_t minLength; 773| 2.48M| int8_t lengthResult; 774| | 775| | // get the srcLength if necessary 776| 2.48M| if(srcLength < 0) { ------------------ | Branch (776:6): [True: 0, False: 2.48M] ------------------ 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| 2.48M| if(length != srcLength) { ------------------ | Branch (781:6): [True: 2.25M, False: 222k] ------------------ 782| 2.25M| if(length < srcLength) { ------------------ | Branch (782:8): [True: 1.16M, False: 1.09M] ------------------ 783| 1.16M| minLength = length; 784| 1.16M| lengthResult = -1; 785| 1.16M| } else { 786| 1.09M| minLength = srcLength; 787| 1.09M| lengthResult = 1; 788| 1.09M| } 789| 2.25M| } else { 790| 222k| minLength = length; 791| 222k| lengthResult = 0; 792| 222k| } 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| 2.48M| if(minLength > 0 && chars != srcChars) { ------------------ | Branch (802:6): [True: 2.46M, False: 12.6k] | Branch (802:23): [True: 2.46M, False: 0] ------------------ 803| 2.46M| 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.87M| do { 814| 7.87M| result = static_cast(*(chars++)) - static_cast(*(srcChars++)); 815| 7.87M| if(result != 0) { ------------------ | Branch (815:12): [True: 2.43M, False: 5.44M] ------------------ 816| 2.43M| return static_cast(result >> 15 | 1); 817| 2.43M| } 818| 7.87M| } while(--minLength > 0); ------------------ | Branch (818:15): [True: 5.40M, False: 37.5k] ------------------ 819| 2.46M|# endif 820| 2.46M| } 821| 50.1k| return lengthResult; 822| 2.48M|} _ZNK6icu_7813UnicodeString8char32AtEi: 871| 343M|{ 872| 343M| int32_t len = length(); 873| 343M| if (static_cast(offset) < static_cast(len)) { ------------------ | Branch (873:7): [True: 343M, False: 0] ------------------ 874| 343M| const char16_t *array = getArrayStart(); 875| 343M| UChar32 c; 876| 343M| U16_GET(array, 0, offset, len, c); ------------------ | | 201| 343M|#define U16_GET(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 343M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 202| 343M| (c)=(s)[i]; \ | | 203| 343M| if(U16_IS_SURROGATE(c)) { \ | | ------------------ | | | | 75| 343M|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | | | ------------------ | | | | | | 193| 343M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | | | ------------------ | | | | | | | Branch (193:27): [True: 36.2M, False: 306M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 204| 36.2M| uint16_t __c2; \ | | 205| 36.2M| if(U16_IS_SURROGATE_LEAD(c)) { \ | | ------------------ | | | | 84| 36.2M|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | | | ------------------ | | | | | Branch (84:34): [True: 35.1M, False: 1.10M] | | | | ------------------ | | ------------------ | | 206| 35.1M| if((i)+1!=(length) && U16_IS_TRAIL(__c2=(s)[(i)+1])) { \ | | ------------------ | | | | 67| 35.1M|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 182k, False: 34.9M] | | | | ------------------ | | ------------------ | | | Branch (206:16): [True: 35.1M, False: 2.27k] | | ------------------ | | 207| 182k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 182k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 182k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 208| 182k| } \ | | 209| 35.1M| } else { \ | | 210| 1.10M| if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \ | | ------------------ | | | | 59| 1.10M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 0, False: 1.10M] | | | | ------------------ | | ------------------ | | | Branch (210:16): [True: 1.10M, False: 348] | | ------------------ | | 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| 1.10M| } \ | | 214| 36.2M| } \ | | 215| 343M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 343M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 877| 343M| return c; 878| 343M| } else { 879| 0| return kInvalidUChar; 880| 0| } 881| 343M|} _ZNK6icu_7813UnicodeString14extractBetweenEiiRS0_: 1040| 46.6k| UnicodeString& target) const { 1041| 46.6k| pinIndex(start); 1042| 46.6k| pinIndex(limit); 1043| 46.6k| doExtract(start, limit - start, target); 1044| 46.6k|} _ZNK6icu_7813UnicodeString7indexOfEPKDsiiii: 1112| 16.8k|{ 1113| 16.8k| if (isBogus() || srcChars == nullptr || srcStart < 0 || srcLength == 0) { ------------------ | Branch (1113:7): [True: 0, False: 16.8k] | Branch (1113:20): [True: 0, False: 16.8k] | Branch (1113:43): [True: 0, False: 16.8k] | Branch (1113:59): [True: 0, False: 16.8k] ------------------ 1114| 0| return -1; 1115| 0| } 1116| | 1117| | // UnicodeString does not find empty substrings 1118| 16.8k| if(srcLength < 0 && srcChars[srcStart] == 0) { ------------------ | Branch (1118:6): [True: 0, False: 16.8k] | Branch (1118:23): [True: 0, False: 0] ------------------ 1119| 0| return -1; 1120| 0| } 1121| | 1122| | // get the indices within bounds 1123| 16.8k| pinIndices(start, length); 1124| | 1125| | // find the first occurrence of the substring 1126| 16.8k| const char16_t *array = getArrayStart(); 1127| 16.8k| const char16_t *match = u_strFindFirst(array + start, length, srcChars + srcStart, srcLength); ------------------ | | 361| 16.8k|#define u_strFindFirst U_ICU_ENTRY_POINT_RENAME(u_strFindFirst) | | ------------------ | | | | 123| 16.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 16.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 16.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1128| 16.8k| if(match == nullptr) { ------------------ | Branch (1128:6): [True: 152, False: 16.7k] ------------------ 1129| 152| return -1; 1130| 16.7k| } else { 1131| 16.7k| return static_cast(match - array); 1132| 16.7k| } 1133| 16.8k|} _ZNK6icu_7813UnicodeString9doIndexOfEDsii: 1139| 46.6k|{ 1140| | // pin indices 1141| 46.6k| pinIndices(start, length); 1142| | 1143| | // find the first occurrence of c 1144| 46.6k| const char16_t *array = getArrayStart(); 1145| 46.6k| const char16_t *match = u_memchr(array + start, c, length); ------------------ | | 330| 46.6k|#define u_memchr U_ICU_ENTRY_POINT_RENAME(u_memchr) | | ------------------ | | | | 123| 46.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 46.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 46.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1146| 46.6k| if(match == nullptr) { ------------------ | Branch (1146:6): [True: 14.4k, False: 32.1k] ------------------ 1147| 14.4k| return -1; 1148| 32.1k| } else { 1149| 32.1k| return static_cast(match - array); 1150| 32.1k| } 1151| 46.6k|} _ZN6icu_7813UnicodeString7unBogusEv: 1293| 4.65k|UnicodeString::unBogus() { 1294| 4.65k| if(fUnion.fFields.fLengthAndFlags & kIsBogus) { ------------------ | Branch (1294:6): [True: 0, False: 4.65k] ------------------ 1295| 0| setToEmpty(); 1296| 0| } 1297| 4.65k|} _ZN6icu_7813UnicodeString5setToEaNS_14ConstChar16PtrEi: 1342| 2.06k|{ 1343| 2.06k| if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) { ------------------ | Branch (1343:6): [True: 0, False: 2.06k] ------------------ 1344| | // do not modify a string that has an "open" getBuffer(minCapacity) 1345| 0| return *this; 1346| 0| } 1347| | 1348| 2.06k| const char16_t *text = textPtr; 1349| 2.06k| if(text == nullptr) { ------------------ | Branch (1349:6): [True: 0, False: 2.06k] ------------------ 1350| | // treat as an empty string, do not alias 1351| 0| releaseArray(); 1352| 0| setToEmpty(); 1353| 0| return *this; 1354| 0| } 1355| | 1356| 2.06k| if( textLength < -1 || ------------------ | Branch (1356:7): [True: 0, False: 2.06k] ------------------ 1357| 2.06k| (textLength == -1 && !isTerminated) || ------------------ | Branch (1357:8): [True: 0, False: 2.06k] | Branch (1357:28): [True: 0, False: 0] ------------------ 1358| 2.06k| (textLength >= 0 && isTerminated && text[textLength] != 0) ------------------ | Branch (1358:8): [True: 2.06k, False: 0] | Branch (1358:27): [True: 0, False: 2.06k] | Branch (1358:43): [True: 0, False: 0] ------------------ 1359| 2.06k| ) { 1360| 0| setToBogus(); 1361| 0| return *this; 1362| 0| } 1363| | 1364| 2.06k| releaseArray(); 1365| | 1366| 2.06k| if(textLength == -1) { ------------------ | Branch (1366:6): [True: 0, False: 2.06k] ------------------ 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| 2.06k| fUnion.fFields.fLengthAndFlags = kReadonlyAlias; 1371| 2.06k| setArray(const_cast(text), textLength, isTerminated ? textLength + 1 : textLength); ------------------ | Branch (1371:53): [True: 0, False: 2.06k] ------------------ 1372| 2.06k| return *this; 1373| 2.06k|} _ZN6icu_7813UnicodeString6appendEi: 1468| 18.0M|UnicodeString::append(UChar32 srcChar) { 1469| 18.0M| char16_t buffer[U16_MAX_LENGTH]; 1470| 18.0M| int32_t _length = 0; 1471| 18.0M| UBool isError = false; 1472| 18.0M| U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError); ------------------ | | 393| 18.0M|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 18.0M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 18.0M| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 18.0M, False: 22.7k] | | ------------------ | | 395| 18.0M| (s)[(i)++]=(uint16_t)(c); \ | | 396| 18.0M| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 22.7k, False: 4] | | | Branch (396:42): [True: 22.7k, False: 0] | | ------------------ | | 397| 22.7k| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 22.7k| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 22.7k| } else /* c>0x10ffff or not enough space */ { \ | | 400| 4| (isError)=true; \ | | 401| 4| } \ | | 402| 18.0M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 18.0M|#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| 18.0M| return isError ? *this : doAppend(buffer, 0, _length); ------------------ | Branch (1475:10): [True: 4, False: 18.0M] ------------------ 1476| 18.0M|} _ZN6icu_7813UnicodeString9doReplaceEiiRKS0_ii: 1484| 125k|{ 1485| | // pin the indices to legal values 1486| 125k| src.pinIndices(srcStart, srcLength); 1487| | 1488| | // get the characters from src 1489| | // and replace the range in ourselves with them 1490| 125k| return doReplace(start, length, src.getArrayStart(), srcStart, srcLength); 1491| 125k|} _ZN6icu_7813UnicodeString9doReplaceEiiPKDsii: 1499| 130k|{ 1500| 130k| if(!isWritable()) { ------------------ | Branch (1500:6): [True: 0, False: 130k] ------------------ 1501| 0| return *this; 1502| 0| } 1503| | 1504| 130k| int32_t oldLength = this->length(); 1505| | 1506| | // optimize (read-only alias).remove(0, start) and .remove(start, end) 1507| 130k| if((fUnion.fFields.fLengthAndFlags&kBufferIsReadonly) && srcLength == 0) { ------------------ | Branch (1507:6): [True: 0, False: 130k] | Branch (1507:60): [True: 0, False: 0] ------------------ 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| 130k| if(start == oldLength) { ------------------ | Branch (1526:6): [True: 126k, False: 3.84k] ------------------ 1527| 126k| return doAppend(srcChars, srcStart, srcLength); 1528| 126k| } 1529| | 1530| 3.84k| if (srcChars == nullptr) { ------------------ | Branch (1530:7): [True: 0, False: 3.84k] ------------------ 1531| 0| srcLength = 0; 1532| 3.84k| } else { 1533| | // Perform all remaining operations relative to srcChars + srcStart. 1534| | // From this point forward, do not use srcStart. 1535| 3.84k| srcChars += srcStart; 1536| 3.84k| if (srcLength < 0) { ------------------ | Branch (1536:9): [True: 0, False: 3.84k] ------------------ 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| 3.84k| } 1541| | 1542| | // pin the indices to legal values 1543| 3.84k| pinIndices(start, length); 1544| | 1545| | // Calculate the size of the string after the replace. 1546| | // Avoid int32_t overflow. 1547| 3.84k| int32_t newLength = oldLength - length; 1548| 3.84k| if(srcLength > (INT32_MAX - newLength)) { ------------------ | Branch (1548:6): [True: 0, False: 3.84k] ------------------ 1549| 0| setToBogus(); 1550| 0| return *this; 1551| 0| } 1552| 3.84k| newLength += srcLength; 1553| | 1554| | // Check for insertion into ourself 1555| 3.84k| const char16_t *oldArray = getArrayStart(); 1556| 3.84k| if (isBufferWritable() && ------------------ | Branch (1556:7): [True: 3.20k, False: 644] ------------------ 1557| 3.84k| oldArray < srcChars + srcLength && ------------------ | Branch (1557:7): [True: 0, False: 3.20k] ------------------ 1558| 3.84k| srcChars < oldArray + oldLength) { ------------------ | Branch (1558:7): [True: 0, False: 0] ------------------ 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| 3.84k| char16_t oldStackBuffer[US_STACKBUF_SIZE]; 1571| 3.84k| if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) { ------------------ | Branch (1571:6): [True: 3.20k, False: 644] | Branch (1571:60): [True: 0, False: 3.20k] ------------------ 1572| | // copy the stack buffer contents because it will be overwritten with 1573| | // fUnion.fFields values 1574| 0| u_memcpy(oldStackBuffer, oldArray, oldLength); ------------------ | | 334| 0|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1575| 0| oldArray = oldStackBuffer; 1576| 0| } 1577| | 1578| | // clone our array and allocate a bigger array if needed 1579| 3.84k| int32_t *bufferToDelete = nullptr; 1580| 3.84k| if(!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength), ------------------ | Branch (1580:6): [True: 0, False: 3.84k] ------------------ 1581| 3.84k| false, &bufferToDelete) 1582| 3.84k| ) { 1583| 0| return *this; 1584| 0| } 1585| | 1586| | // now do the replace 1587| | 1588| 3.84k| char16_t *newArray = getArrayStart(); 1589| 3.84k| if(newArray != oldArray) { ------------------ | Branch (1589:6): [True: 644, False: 3.20k] ------------------ 1590| | // if fArray changed, then we need to copy everything except what will change 1591| 644| us_arrayCopy(oldArray, 0, newArray, 0, start); 1592| 644| us_arrayCopy(oldArray, start + length, 1593| 644| newArray, start + srcLength, 1594| 644| oldLength - (start + length)); 1595| 3.20k| } else if(length != srcLength) { ------------------ | Branch (1595:13): [True: 1.59k, False: 1.60k] ------------------ 1596| | // fArray did not change; copy only the portion that isn't changing, leaving a hole 1597| 1.59k| us_arrayCopy(oldArray, start + length, 1598| 1.59k| newArray, start + srcLength, 1599| 1.59k| oldLength - (start + length)); 1600| 1.59k| } 1601| | 1602| | // now fill in the hole with the new string 1603| 3.84k| us_arrayCopy(srcChars, 0, newArray, start, srcLength); 1604| | 1605| 3.84k| setLength(newLength); 1606| | 1607| | // delayed delete in case srcChars == fArray when we started, and 1608| | // to keep oldArray alive for the above operations 1609| 3.84k| if (bufferToDelete) { ------------------ | Branch (1609:7): [True: 0, False: 3.84k] ------------------ 1610| 0| uprv_free(bufferToDelete); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 0| } 1612| | 1613| 3.84k| return *this; 1614| 3.84k|} _ZN6icu_7813UnicodeString9doReplaceEiiNSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 1617| 3.85k|UnicodeString::doReplace(int32_t start, int32_t length, std::u16string_view src) { 1618| 3.85k| if (!isWritable()) { ------------------ | Branch (1618:7): [True: 0, False: 3.85k] ------------------ 1619| 0| return *this; 1620| 0| } 1621| 3.85k| if (src.length() > INT32_MAX) { ------------------ | Branch (1621:7): [True: 0, False: 3.85k] ------------------ 1622| 0| setToBogus(); 1623| 0| return *this; 1624| 0| } 1625| 3.85k| return doReplace(start, length, src.data(), 0, static_cast(src.length())); 1626| 3.85k|} _ZN6icu_7813UnicodeString8doAppendERKS0_ii: 1632| 73.2k|UnicodeString::doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength) { 1633| 73.2k| if(srcLength == 0) { ------------------ | Branch (1633:6): [True: 0, False: 73.2k] ------------------ 1634| 0| return *this; 1635| 0| } 1636| | 1637| | // pin the indices to legal values 1638| 73.2k| src.pinIndices(srcStart, srcLength); 1639| 73.2k| return doAppend(src.getArrayStart(), srcStart, srcLength); 1640| 73.2k|} _ZN6icu_7813UnicodeString8doAppendEPKDsii: 1643| 350M|UnicodeString::doAppend(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) { 1644| 350M| if(!isWritable() || srcLength == 0 || srcChars == nullptr) { ------------------ | Branch (1644:6): [True: 0, False: 350M] | Branch (1644:23): [True: 1.05k, False: 350M] | Branch (1644:41): [True: 0, False: 350M] ------------------ 1645| 1.05k| return *this; 1646| 1.05k| } 1647| | 1648| | // Perform all remaining operations relative to srcChars + srcStart. 1649| | // From this point forward, do not use srcStart. 1650| 350M| srcChars += srcStart; 1651| | 1652| 350M| if(srcLength < 0) { ------------------ | Branch (1652:6): [True: 0, False: 350M] ------------------ 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| 350M| int32_t oldLength = length(); 1660| 350M| int32_t newLength; 1661| | 1662| 350M| if (srcLength <= getCapacity() - oldLength && isBufferWritable()) { ------------------ | Branch (1662:7): [True: 349M, False: 1.51M] | Branch (1662:49): [True: 349M, False: 6.32k] ------------------ 1663| 349M| newLength = oldLength + srcLength; 1664| | // Faster than a memmove 1665| 349M| if (srcLength <= 4) { ------------------ | Branch (1665:9): [True: 349M, False: 112k] ------------------ 1666| 349M| char16_t *arr = getArrayStart(); 1667| 349M| arr[oldLength] = srcChars[0]; 1668| 349M| if (srcLength > 1) arr[oldLength+1] = srcChars[1]; ------------------ | Branch (1668:11): [True: 52.4k, False: 349M] ------------------ 1669| 349M| if (srcLength > 2) arr[oldLength+2] = srcChars[2]; ------------------ | Branch (1669:11): [True: 11.4k, False: 349M] ------------------ 1670| 349M| if (srcLength > 3) arr[oldLength+3] = srcChars[3]; ------------------ | Branch (1670:11): [True: 5.28k, False: 349M] ------------------ 1671| 349M| setLength(newLength); 1672| 349M| return *this; 1673| 349M| } 1674| 349M| } else { 1675| 1.51M| if (uprv_add32_overflow(oldLength, srcLength, &newLength)) { ------------------ | | 1394| 1.51M|#define uprv_add32_overflow U_ICU_ENTRY_POINT_RENAME(uprv_add32_overflow) | | ------------------ | | | | 123| 1.51M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.51M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.51M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1675:9): [True: 0, False: 1.51M] ------------------ 1676| 0| setToBogus(); 1677| 0| return *this; 1678| 0| } 1679| | 1680| | // Check for append onto ourself 1681| 1.51M| const char16_t* oldArray = getArrayStart(); 1682| 1.51M| if (isBufferWritable() && ------------------ | Branch (1682:9): [True: 1.51M, False: 6.32k] ------------------ 1683| 1.51M| oldArray < srcChars + srcLength && ------------------ | Branch (1683:9): [True: 261k, False: 1.24M] ------------------ 1684| 1.51M| srcChars < oldArray + oldLength) { ------------------ | Branch (1684:9): [True: 0, False: 261k] ------------------ 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| 1.51M| if (!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength))) { ------------------ | Branch (1695:9): [True: 0, False: 1.51M] ------------------ 1696| 0| return *this; 1697| 0| } 1698| 1.51M| } 1699| | 1700| 1.62M| 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| 1.62M| if(srcChars != newArray + oldLength) { ------------------ | Branch (1708:6): [True: 1.62M, False: 0] ------------------ 1709| 1.62M| us_arrayCopy(srcChars, 0, newArray, oldLength, srcLength); 1710| 1.62M| } 1711| 1.62M| setLength(newLength); 1712| | 1713| 1.62M| return *this; 1714| 350M|} _ZN6icu_7813UnicodeString18cloneArrayIfNeededEiiaPPia: 1917| 1.52M| UBool forceClone) { 1918| | // default parameters need to be static, therefore 1919| | // the defaults are -1 to have convenience defaults 1920| 1.52M| if(newCapacity == -1) { ------------------ | Branch (1920:6): [True: 0, False: 1.52M] ------------------ 1921| 0| newCapacity = getCapacity(); 1922| 0| } 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| 1.52M| if(!isWritable()) { ------------------ | Branch (1927:6): [True: 0, False: 1.52M] ------------------ 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| 1.52M| if(forceClone || ------------------ | Branch (1938:6): [True: 0, False: 1.52M] ------------------ 1939| 1.52M| fUnion.fFields.fLengthAndFlags & kBufferIsReadonly || ------------------ | Branch (1939:6): [True: 0, False: 1.52M] ------------------ 1940| 1.52M| (fUnion.fFields.fLengthAndFlags & kRefCounted && refCount() > 1) || ------------------ | Branch (1940:7): [True: 272k, False: 1.24M] | Branch (1940:55): [True: 6.96k, False: 265k] ------------------ 1941| 1.52M| newCapacity > getCapacity() ------------------ | Branch (1941:6): [True: 1.51M, False: 3.20k] ------------------ 1942| 1.52M| ) { 1943| | // check growCapacity for default value and use of the stack buffer 1944| 1.51M| if(growCapacity < 0) { ------------------ | Branch (1944:8): [True: 0, False: 1.51M] ------------------ 1945| 0| growCapacity = newCapacity; 1946| 1.51M| } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) { ------------------ | Branch (1946:15): [True: 6.96k, False: 1.51M] | Branch (1946:50): [True: 6.96k, False: 0] ------------------ 1947| 6.96k| growCapacity = US_STACKBUF_SIZE; 1948| 1.51M| } else if(newCapacity > growCapacity) { ------------------ | Branch (1948:15): [True: 0, False: 1.51M] ------------------ 1949| 0| setToBogus(); 1950| 0| return false; // bad inputs 1951| 0| } 1952| 1.51M| if(growCapacity > kMaxCapacity) { ------------------ | Branch (1952:8): [True: 0, False: 1.51M] ------------------ 1953| 0| setToBogus(); 1954| 0| return false; 1955| 0| } 1956| | 1957| | // save old values 1958| 1.51M| char16_t oldStackBuffer[US_STACKBUF_SIZE]; 1959| 1.51M| char16_t *oldArray; 1960| 1.51M| int32_t oldLength = length(); 1961| 1.51M| int16_t flags = fUnion.fFields.fLengthAndFlags; 1962| | 1963| 1.51M| if(flags&kUsingStackBuffer) { ------------------ | Branch (1963:8): [True: 1.24M, False: 272k] ------------------ 1964| 1.24M| U_ASSERT(!(flags&kRefCounted)); /* kRefCounted and kUsingStackBuffer are mutally exclusive */ ------------------ | | 35| 1.24M|# define U_ASSERT(exp) (void)0 ------------------ 1965| 1.24M| if(doCopyArray && growCapacity > US_STACKBUF_SIZE) { ------------------ | Branch (1965:10): [True: 1.24M, False: 0] | Branch (1965:25): [True: 1.24M, False: 0] ------------------ 1966| | // copy the stack buffer contents because it will be overwritten with 1967| | // fUnion.fFields values 1968| 1.24M| us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength); 1969| 1.24M| oldArray = oldStackBuffer; 1970| 1.24M| } else { 1971| 0| oldArray = nullptr; // no need to copy from the stack buffer to itself 1972| 0| } 1973| 1.24M| } else { 1974| 272k| oldArray = fUnion.fFields.fArray; 1975| 272k| U_ASSERT(oldArray!=nullptr); /* when stack buffer is not used, oldArray must have a non-nullptr reference */ ------------------ | | 35| 272k|# define U_ASSERT(exp) (void)0 ------------------ 1976| 272k| } 1977| | 1978| | // allocate a new array 1979| 1.51M| if(allocate(growCapacity) || ------------------ | Branch (1979:8): [True: 1.51M, False: 0] ------------------ 1980| 1.51M| (newCapacity < growCapacity && allocate(newCapacity)) ------------------ | Branch (1980:9): [True: 0, False: 0] | Branch (1980:39): [True: 0, False: 0] ------------------ 1981| 1.51M| ) { 1982| 1.51M| if(doCopyArray) { ------------------ | Branch (1982:10): [True: 1.51M, False: 644] ------------------ 1983| | // copy the contents 1984| | // do not copy more than what fits - it may be smaller than before 1985| 1.51M| int32_t minLength = oldLength; 1986| 1.51M| newCapacity = getCapacity(); 1987| 1.51M| if(newCapacity < minLength) { ------------------ | Branch (1987:12): [True: 0, False: 1.51M] ------------------ 1988| 0| minLength = newCapacity; 1989| 0| } 1990| 1.51M| if(oldArray != nullptr) { ------------------ | Branch (1990:12): [True: 1.51M, False: 0] ------------------ 1991| 1.51M| us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength); 1992| 1.51M| } 1993| 1.51M| setLength(minLength); 1994| 1.51M| } else { 1995| 644| setZeroLength(); 1996| 644| } 1997| | 1998| | // release the old array 1999| 1.51M| if(flags & kRefCounted) { ------------------ | Branch (1999:10): [True: 272k, False: 1.24M] ------------------ 2000| | // the array is refCounted; decrement and release if 0 2001| 272k| u_atomic_int32_t* pRefCount = reinterpret_cast(oldArray) - 1; 2002| 272k| if(umtx_atomic_dec(pRefCount) == 0) { ------------------ | Branch (2002:12): [True: 265k, False: 6.96k] ------------------ 2003| 265k| if (pBufferToDelete == nullptr) { ------------------ | Branch (2003:15): [True: 265k, False: 0] ------------------ 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| 265k| uprv_free((void *)pRefCount); ------------------ | | 1503| 265k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 265k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 265k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 265k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2008| 265k| } else { 2009| | // the caller requested to delete it himself 2010| 0| *pBufferToDelete = reinterpret_cast(pRefCount); 2011| 0| } 2012| 265k| } 2013| 272k| } 2014| 1.51M| } 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| 1.51M| } 2025| 1.52M| return true; 2026| 1.52M|} uhash_compareUnicodeString_78: 2089| 56.0M|uhash_compareUnicodeString(const UElement key1, const UElement key2) { 2090| 56.0M| const UnicodeString *str1 = (const UnicodeString*) key1.pointer; 2091| 56.0M| const UnicodeString *str2 = (const UnicodeString*) key2.pointer; 2092| 56.0M| if (str1 == str2) { ------------------ | Branch (2092:9): [True: 0, False: 56.0M] ------------------ 2093| 0| return true; 2094| 0| } 2095| 56.0M| if (str1 == nullptr || str2 == nullptr) { ------------------ | Branch (2095:9): [True: 0, False: 56.0M] | Branch (2095:28): [True: 0, False: 56.0M] ------------------ 2096| 0| return false; 2097| 0| } 2098| 56.0M| return *str1 == *str2; 2099| 56.0M|} unistr.cpp:_ZL20UnicodeString_charAtiPv: 96| 100k|UnicodeString_charAt(int32_t offset, void *context) { 97| 100k| return ((icu::UnicodeString*) context)->charAt(offset); 98| 100k|} unistr.cpp:_ZL12us_arrayCopyPKDsiPDsii: 87| 4.39M|{ 88| 4.39M| if(count>0) { ------------------ | Branch (88:6): [True: 4.33M, False: 66.5k] ------------------ 89| 4.33M| uprv_memmove(dst+dstStart, src+srcStart, (size_t)count*sizeof(*src)); ------------------ | | 51| 4.33M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.33M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 4.33M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 4.33M| _Pragma("clang diagnostic push") \ | | 54| 4.33M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 4.33M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4.33M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 4.33M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4.33M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 4.33M| _Pragma("clang diagnostic pop") \ | | 58| 4.33M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 4.33M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 4.33M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.33M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 90| 4.33M| } 91| 4.39M|} unistr.cpp:_ZN6icu_7812_GLOBAL__N_115getGrowCapacityEi: 397| 1.52M|int32_t getGrowCapacity(int32_t newLength) { 398| 1.52M| int32_t growSize = (newLength >> 2) + kGrowSize; 399| 1.52M| if(growSize <= (kMaxCapacity - newLength)) { ------------------ | Branch (399:6): [True: 1.52M, False: 0] ------------------ 400| 1.52M| return newLength + growSize; 401| 1.52M| } else { 402| 0| return kMaxCapacity; 403| 0| } 404| 1.52M|} _ZN6icu_787UMemorynwEm: 61| 658k|void * U_EXPORT2 UMemory::operator new(size_t size) noexcept { 62| 658k| return uprv_malloc(size); ------------------ | | 1524| 658k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 658k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 658k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 658k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 658k|} _ZN6icu_787UMemorydlEPv: 65| 658k|void U_EXPORT2 UMemory::operator delete(void *p) noexcept { 66| 658k| if(p!=nullptr) { ------------------ | Branch (66:8): [True: 658k, False: 0] ------------------ 67| 658k| uprv_free(p); ------------------ | | 1503| 658k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 658k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 658k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 658k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 68| 658k| } 69| 658k|} _ZN6icu_787UObjectD2Ev: 94| 3.55M|UObject::~UObject() {} uprv_deleteUObject_78: 103| 482k|uprv_deleteUObject(void *obj) { 104| 482k| delete static_cast(obj); 105| 482k|} u_hasBinaryProperty_78: 487| 152k|u_hasBinaryProperty(UChar32 c, UProperty which) { 488| | /* c is range-checked in the functions that are called from here */ 489| 152k| if(whichadd(sa->set, c); 863| 0| } 864| | // single characters 865| 0| for (UChar32 c : ID_COMPAT_MATH_START) { ------------------ | Branch (865:24): [True: 0, False: 0] ------------------ 866| 0| sa->add(sa->set, c); 867| 0| sa->add(sa->set, c + 1); 868| 0| } 869| 0| return; 870| 0| } 871| 2| if (src == UPROPS_SRC_MCM) { ------------------ | Branch (871:9): [True: 1, False: 1] ------------------ 872| | // range limits 873| 18| for (UChar32 c : MODIFIER_COMBINING_MARK) { ------------------ | Branch (873:24): [True: 18, False: 1] ------------------ 874| 18| sa->add(sa->set, c); 875| 18| } 876| 1| return; 877| 1| } 878| 1| if (!ulayout_ensureData(*pErrorCode)) { return; } ------------------ | Branch (878:9): [True: 0, False: 1] ------------------ 879| 1| const UCPTrie *trie; 880| 1| switch (src) { 881| 0| case UPROPS_SRC_INPC: ------------------ | Branch (881:5): [True: 0, False: 1] ------------------ 882| 0| trie = gInpcTrie; 883| 0| break; 884| 0| case UPROPS_SRC_INSC: ------------------ | Branch (884:5): [True: 0, False: 1] ------------------ 885| 0| trie = gInscTrie; 886| 0| break; 887| 1| case UPROPS_SRC_VO: ------------------ | Branch (887:5): [True: 1, False: 0] ------------------ 888| 1| trie = gVoTrie; 889| 1| break; 890| 0| default: ------------------ | Branch (890:5): [True: 0, False: 1] ------------------ 891| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 892| 0| return; 893| 1| } 894| | 895| 1| if (trie == nullptr) { ------------------ | Branch (895:9): [True: 0, False: 1] ------------------ 896| 0| *pErrorCode = U_MISSING_RESOURCE_ERROR; 897| 0| return; 898| 0| } 899| | 900| | // Add the start code point of each same-value range of the trie. 901| 1| UChar32 start = 0, end; 902| 265| while ((end = ucptrie_getRange(trie, start, UCPMAP_RANGE_NORMAL, 0, ------------------ | | 806| 265|#define ucptrie_getRange U_ICU_ENTRY_POINT_RENAME(ucptrie_getRange) | | ------------------ | | | | 123| 265|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 265|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 265|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (902:12): [True: 264, False: 1] ------------------ 903| 265| nullptr, nullptr, nullptr)) >= 0) { 904| 264| sa->add(sa->set, start); 905| 264| start = end + 1; 906| 264| } 907| 1|} uprops.cpp:_ZL15defaultContainsRK14BinaryPropertyi9UProperty: 168| 121k|static UBool defaultContains(const BinaryProperty &prop, UChar32 c, UProperty /*which*/) { 169| | /* systematic, directly stored properties */ 170| 121k| return (u_getUnicodeProperties(c, prop.column)&prop.mask)!=0; ------------------ | | 288| 121k|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 121k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 121k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 121k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 121k|} uprops.cpp:_ZL26caseBinaryPropertyContainsRK14BinaryPropertyi9UProperty: 173| 18.5k|static UBool caseBinaryPropertyContains(const BinaryProperty &/*prop*/, UChar32 c, UProperty which) { 174| 18.5k| return ucase_hasBinaryProperty(c, which); ------------------ | | 577| 18.5k|#define ucase_hasBinaryProperty U_ICU_ENTRY_POINT_RENAME(ucase_hasBinaryProperty) | | ------------------ | | | | 123| 18.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 18.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 18.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 175| 18.5k|} uprops.cpp:_ZL21changesWhenCasefoldedRK14BinaryPropertyi9UProperty: 221| 5.79k|static UBool changesWhenCasefolded(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 222| 5.79k| UnicodeString nfd; 223| 5.79k| UErrorCode errorCode=U_ZERO_ERROR; 224| 5.79k| const Normalizer2 *nfcNorm2=Normalizer2::getNFCInstance(errorCode); 225| 5.79k| if(U_FAILURE(errorCode)) { ------------------ | Branch (225:8): [True: 0, False: 5.79k] ------------------ 226| 0| return false; 227| 0| } 228| 5.79k| if(nfcNorm2->getDecomposition(c, nfd)) { ------------------ | Branch (228:8): [True: 2.86k, False: 2.92k] ------------------ 229| | /* c has a decomposition */ 230| 2.86k| if(nfd.length()==1) { ------------------ | Branch (230:12): [True: 894, False: 1.97k] ------------------ 231| 894| c=nfd[0]; /* single BMP code point */ 232| 1.97k| } else if(nfd.length()<=U16_MAX_LENGTH && ------------------ | | 148| 3.94k|#define U16_MAX_LENGTH 2 ------------------ | Branch (232:19): [True: 1.27k, False: 701] ------------------ 233| 1.97k| nfd.length()==U16_LENGTH(c=nfd.char32At(0)) ------------------ | | 141| 1.27k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 1.16k, False: 110] | | ------------------ ------------------ | Branch (233:19): [True: 110, False: 1.16k] ------------------ 234| 1.97k| ) { 235| | /* single supplementary code point */ 236| 1.86k| } else { 237| 1.86k| c=U_SENTINEL; ------------------ | | 469| 1.86k|#define U_SENTINEL (-1) ------------------ 238| 1.86k| } 239| 2.92k| } else if(c<0) { ------------------ | Branch (239:15): [True: 0, False: 2.92k] ------------------ 240| 0| return false; /* protect against bad input */ 241| 0| } 242| 5.79k| if(c>=0) { ------------------ | Branch (242:8): [True: 3.92k, False: 1.86k] ------------------ 243| | /* single code point */ 244| 3.92k| const char16_t *resultString; 245| 3.92k| return ucase_toFullFolding(c, &resultString, U_FOLD_CASE_DEFAULT) >= 0; ------------------ | | 580| 3.92k|#define ucase_toFullFolding U_ICU_ENTRY_POINT_RENAME(ucase_toFullFolding) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return ucase_toFullFolding(c, &resultString, U_FOLD_CASE_DEFAULT) >= 0; ------------------ | | 22| 3.92k|#define U_FOLD_CASE_DEFAULT 0 ------------------ 246| 3.92k| } else { 247| | /* guess some large but stack-friendly capacity */ 248| 1.86k| char16_t dest[2*UCASE_MAX_STRING_LENGTH]; 249| 1.86k| int32_t destLength; 250| 1.86k| destLength=u_strFoldCase(dest, UPRV_LENGTHOF(dest), ------------------ | | 363| 1.86k|#define u_strFoldCase U_ICU_ENTRY_POINT_RENAME(u_strFoldCase) | | ------------------ | | | | 123| 1.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ destLength=u_strFoldCase(dest, UPRV_LENGTHOF(dest), ------------------ | | 99| 1.86k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 251| 1.86k| nfd.getBuffer(), nfd.length(), 252| 1.86k| U_FOLD_CASE_DEFAULT, &errorCode); ------------------ | | 22| 1.86k|#define U_FOLD_CASE_DEFAULT 0 ------------------ 253| 1.86k| return U_SUCCESS(errorCode) && ------------------ | Branch (253:16): [True: 1.86k, False: 0] ------------------ 254| 1.86k| 0!=u_strCompare(nfd.getBuffer(), nfd.length(), ------------------ | | 359| 1.86k|#define u_strCompare U_ICU_ENTRY_POINT_RENAME(u_strCompare) | | ------------------ | | | | 123| 1.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (254:24): [True: 415, False: 1.44k] ------------------ 255| 1.86k| dest, destLength, false); 256| 1.86k| } 257| 5.79k|} uprops.cpp:_ZL19isRegionalIndicatorRK14BinaryPropertyi9UProperty: 322| 7.12k|static UBool isRegionalIndicator(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 323| | // Property starts are a subset of lb=RI etc. 324| 7.12k| return 0x1F1E6<=c && c<=0x1F1FF; ------------------ | Branch (324:12): [True: 368, False: 6.76k] | Branch (324:26): [True: 1, False: 367] ------------------ 325| 7.12k|} uprops.cpp:_ZL18isIDSUnaryOperatorRK14BinaryPropertyi9UProperty: 331| 2|static UBool isIDSUnaryOperator(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 332| | // New in Unicode 15.1 for just two characters. 333| 2| return 0x2FFE<=c && c<=0x2FFF; ------------------ | Branch (333:12): [True: 2, False: 0] | Branch (333:25): [True: 1, False: 1] ------------------ 334| 2|} uprops.cpp:_ZL23isModifierCombiningMarkRK14BinaryPropertyi9UProperty: 391| 18|static UBool isModifierCombiningMark(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 392| 99| for (int32_t i = 0; i < UPRV_LENGTHOF(MODIFIER_COMBINING_MARK); i += 2) { ------------------ | | 99| 99|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (392:25): [True: 98, False: 1] ------------------ 393| 98| if (c < MODIFIER_COMBINING_MARK[i]) { return false; } // below range start ------------------ | Branch (393:13): [True: 8, False: 90] ------------------ 394| 90| if (c < MODIFIER_COMBINING_MARK[i + 1]) { return true; } // below range limit ------------------ | Branch (394:13): [True: 9, False: 81] ------------------ 395| 90| } 396| 1| return false; 397| 18|} uprops.cpp:_ZL12getBiDiClassRK11IntPropertyi9UProperty: 557| 1.17M|static int32_t getBiDiClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 558| 1.17M| return static_cast(u_charDirection(c)); ------------------ | | 221| 1.17M|#define u_charDirection U_ICU_ENTRY_POINT_RENAME(u_charDirection) | | ------------------ | | | | 123| 1.17M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.17M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.17M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 559| 1.17M|} uprops.cpp:_ZL17getCombiningClassRK11IntPropertyi9UProperty: 582| 490k|static int32_t getCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 583| 490k| return u_getCombiningClass(c); ------------------ | | 270| 490k|#define u_getCombiningClass U_ICU_ENTRY_POINT_RENAME(u_getCombiningClass) | | ------------------ | | | | 123| 490k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 490k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 490k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 584| 490k|} uprops.cpp:_ZL15defaultGetValueRK11IntPropertyi9UProperty: 544| 308k|static int32_t defaultGetValue(const IntProperty &prop, UChar32 c, UProperty /*which*/) { 545| | /* systematic, directly stored properties */ 546| 308k| return static_cast(u_getUnicodeProperties(c, prop.column) & prop.mask) >> prop.shift; ------------------ | | 288| 308k|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 308k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 308k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 308k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 547| 308k|} uprops.cpp:_ZL15getJoiningGroupRK11IntPropertyi9UProperty: 591| 314k|static int32_t getJoiningGroup(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 592| 314k| return ubidi_getJoiningGroup(c); ------------------ | | 444| 314k|#define ubidi_getJoiningGroup U_ICU_ENTRY_POINT_RENAME(ubidi_getJoiningGroup) | | ------------------ | | | | 123| 314k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 314k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 314k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 593| 314k|} uprops.cpp:_ZL14getJoiningTypeRK11IntPropertyi9UProperty: 595| 769k|static int32_t getJoiningType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 596| 769k| return ubidi_getJoiningType(c); ------------------ | | 445| 769k|#define ubidi_getJoiningType U_ICU_ENTRY_POINT_RENAME(ubidi_getJoiningType) | | ------------------ | | | | 123| 769k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 769k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 769k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 597| 769k|} uprops.cpp:_ZL9getScriptRK11IntPropertyi9UProperty: 604| 3.55M|static int32_t getScript(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 605| 3.55M| UErrorCode errorCode=U_ZERO_ERROR; 606| 3.55M| return static_cast(uscript_getScript(c, &errorCode)); ------------------ | | 1706| 3.55M|#define uscript_getScript U_ICU_ENTRY_POINT_RENAME(uscript_getScript) | | ------------------ | | | | 123| 3.55M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.55M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.55M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 3.55M|} uprops.cpp:_ZL21getLeadCombiningClassRK11IntPropertyi9UProperty: 668| 474k|static int32_t getLeadCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 669| 474k| return unorm_getFCD16(c)>>8; ------------------ | | 1288| 474k|#define unorm_getFCD16 U_ICU_ENTRY_POINT_RENAME(unorm_getFCD16) | | ------------------ | | | | 123| 474k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 474k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 474k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 670| 474k|} uprops.cpp:_ZL22getTrailCombiningClassRK11IntPropertyi9UProperty: 678| 703k|static int32_t getTrailCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 679| 703k| return unorm_getFCD16(c)&0xff; ------------------ | | 1288| 703k|#define unorm_getFCD16 U_ICU_ENTRY_POINT_RENAME(unorm_getFCD16) | | ------------------ | | | | 123| 703k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 703k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 703k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 680| 703k|} uprops.cpp:_ZN12_GLOBAL__N_118ulayout_ensureDataEv: 149| 132k|UBool ulayout_ensureData() { 150| 132k| UErrorCode errorCode = U_ZERO_ERROR; 151| 132k| return ulayout_ensureData(errorCode); 152| 132k|} uprops.cpp:_ZL5getVoRK11IntPropertyi9UProperty: 691| 132k|static int32_t getVo(const IntProperty &, UChar32 c, UProperty) { 692| 132k| return ulayout_ensureData() && gVoTrie != nullptr ? ucptrie_get(gVoTrie, c) : 0; ------------------ | | 805| 132k|#define ucptrie_get U_ICU_ENTRY_POINT_RENAME(ucptrie_get) | | ------------------ | | | | 123| 132k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 132k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 132k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (692:12): [True: 132k, False: 0] | Branch (692:36): [True: 132k, False: 0] ------------------ 693| 132k|} uprops.cpp:_ZN12_GLOBAL__N_118ulayout_ensureDataER10UErrorCode: 143| 132k|UBool ulayout_ensureData(UErrorCode &errorCode) { 144| 132k| if (U_FAILURE(errorCode)) { return false; } ------------------ | Branch (144:9): [True: 0, False: 132k] ------------------ 145| 132k| umtx_initOnce(gLayoutInitOnce, &ulayout_load, errorCode); 146| 132k| return U_SUCCESS(errorCode); 147| 132k|} uprops.cpp:_ZN12_GLOBAL__N_112ulayout_loadER10UErrorCode: 97| 1|void U_CALLCONV ulayout_load(UErrorCode &errorCode) { 98| 1| gLayoutMemory = udata_openChoice( ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 99| 1| nullptr, ULAYOUT_DATA_TYPE, ULAYOUT_DATA_NAME, ------------------ | | 15| 1|#define ULAYOUT_DATA_TYPE "icu" ------------------ nullptr, ULAYOUT_DATA_TYPE, ULAYOUT_DATA_NAME, ------------------ | | 14| 1|#define ULAYOUT_DATA_NAME "ulayout" ------------------ 100| 1| ulayout_isAcceptable, nullptr, &errorCode); 101| 1| if (U_FAILURE(errorCode)) { return; } ------------------ | Branch (101:9): [True: 0, False: 1] ------------------ 102| | 103| 1| const uint8_t* inBytes = static_cast(udata_getMemory(gLayoutMemory)); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 104| 1| const int32_t* inIndexes = reinterpret_cast(inBytes); 105| 1| int32_t indexesLength = inIndexes[ULAYOUT_IX_INDEXES_LENGTH]; 106| 1| if (indexesLength < 12) { ------------------ | Branch (106:9): [True: 0, False: 1] ------------------ 107| 0| errorCode = U_INVALID_FORMAT_ERROR; // Not enough indexes. 108| 0| return; 109| 0| } 110| 1| int32_t offset = indexesLength * 4; 111| 1| int32_t top = inIndexes[ULAYOUT_IX_INPC_TRIE_TOP]; 112| 1| int32_t trieSize = top - offset; 113| 1| if (trieSize >= 16) { ------------------ | Branch (113:9): [True: 1, False: 0] ------------------ 114| 1| gInpcTrie = ucptrie_openFromBinary( ------------------ | | 813| 1|#define ucptrie_openFromBinary U_ICU_ENTRY_POINT_RENAME(ucptrie_openFromBinary) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 115| 1| UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY, 116| 1| inBytes + offset, trieSize, nullptr, &errorCode); 117| 1| } 118| 1| offset = top; 119| 1| top = inIndexes[ULAYOUT_IX_INSC_TRIE_TOP]; 120| 1| trieSize = top - offset; 121| 1| if (trieSize >= 16) { ------------------ | Branch (121:9): [True: 1, False: 0] ------------------ 122| 1| gInscTrie = ucptrie_openFromBinary( ------------------ | | 813| 1|#define ucptrie_openFromBinary U_ICU_ENTRY_POINT_RENAME(ucptrie_openFromBinary) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 123| 1| UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY, 124| 1| inBytes + offset, trieSize, nullptr, &errorCode); 125| 1| } 126| 1| offset = top; 127| 1| top = inIndexes[ULAYOUT_IX_VO_TRIE_TOP]; 128| 1| trieSize = top - offset; 129| 1| if (trieSize >= 16) { ------------------ | Branch (129:9): [True: 1, False: 0] ------------------ 130| 1| gVoTrie = ucptrie_openFromBinary( ------------------ | | 813| 1|#define ucptrie_openFromBinary U_ICU_ENTRY_POINT_RENAME(ucptrie_openFromBinary) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 131| 1| UCPTRIE_TYPE_ANY, UCPTRIE_VALUE_BITS_ANY, 132| 1| inBytes + offset, trieSize, nullptr, &errorCode); 133| 1| } 134| | 135| 1| uint32_t maxValues = inIndexes[ULAYOUT_IX_MAX_VALUES]; 136| 1| gMaxInpcValue = maxValues >> ULAYOUT_MAX_INPC_SHIFT; 137| 1| gMaxInscValue = (maxValues >> ULAYOUT_MAX_INSC_SHIFT) & 0xff; 138| 1| gMaxVoValue = (maxValues >> ULAYOUT_MAX_VO_SHIFT) & 0xff; 139| | 140| 1| ucln_common_registerCleanup(UCLN_COMMON_UPROPS, uprops_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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 141| 1|} uprops.cpp:_ZN12_GLOBAL__N_120ulayout_isAcceptableEPvPKcS2_PK9UDataInfo: 85| 1| const UDataInfo *pInfo) { 86| 1| return pInfo->size >= 20 && ------------------ | Branch (86:12): [True: 1, False: 0] ------------------ 87| 1| pInfo->isBigEndian == U_IS_BIG_ENDIAN && ------------------ | | 353| 2|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (87:9): [True: 1, False: 0] ------------------ 88| 1| pInfo->charsetFamily == U_CHARSET_FAMILY && ------------------ | | 588| 1|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 2|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (88:9): [True: 1, False: 0] ------------------ 89| 1| pInfo->dataFormat[0] == ULAYOUT_FMT_0 && ------------------ | | 18| 2|#define ULAYOUT_FMT_0 0x4c ------------------ | Branch (89:9): [True: 1, False: 0] ------------------ 90| 1| pInfo->dataFormat[1] == ULAYOUT_FMT_1 && ------------------ | | 19| 2|#define ULAYOUT_FMT_1 0x61 ------------------ | Branch (90:9): [True: 1, False: 0] ------------------ 91| 1| pInfo->dataFormat[2] == ULAYOUT_FMT_2 && ------------------ | | 20| 2|#define ULAYOUT_FMT_2 0x79 ------------------ | Branch (91:9): [True: 1, False: 0] ------------------ 92| 1| pInfo->dataFormat[3] == ULAYOUT_FMT_3 && ------------------ | | 21| 2|#define ULAYOUT_FMT_3 0x6f ------------------ | Branch (92:9): [True: 1, False: 0] ------------------ 93| 1| pInfo->formatVersion[0] == 1; ------------------ | Branch (93:9): [True: 1, False: 0] ------------------ 94| 1|} ustrcase_internalFold_78: 1302| 1.86k| UErrorCode &errorCode) { 1303| 1.86k| int32_t destIndex = toLower( 1304| 1.86k| -1, options, 1305| 1.86k| dest, destCapacity, 1306| 1.86k| src, nullptr, 0, srcLength, 1307| 1.86k| edits, errorCode); 1308| 1.86k| return checkOverflowAndEditsError(destIndex, destCapacity, edits, errorCode); 1309| 1.86k|} ustrcase_mapWithOverlap_78: 1360| 1.86k| UErrorCode &errorCode) { 1361| 1.86k| char16_t buffer[300]; 1362| 1.86k| char16_t *temp; 1363| | 1364| 1.86k| int32_t destLength; 1365| | 1366| | /* check argument values */ 1367| 1.86k| if(U_FAILURE(errorCode)) { ------------------ | Branch (1367:8): [True: 0, False: 1.86k] ------------------ 1368| 0| return 0; 1369| 0| } 1370| 1.86k| if( destCapacity<0 || ------------------ | Branch (1370:9): [True: 0, False: 1.86k] ------------------ 1371| 1.86k| (dest==nullptr && destCapacity>0) || ------------------ | Branch (1371:10): [True: 0, False: 1.86k] | Branch (1371:27): [True: 0, False: 0] ------------------ 1372| 1.86k| src==nullptr || ------------------ | Branch (1372:9): [True: 0, False: 1.86k] ------------------ 1373| 1.86k| srcLength<-1 ------------------ | Branch (1373:9): [True: 0, False: 1.86k] ------------------ 1374| 1.86k| ) { 1375| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 1376| 0| return 0; 1377| 0| } 1378| | 1379| | /* get the string length */ 1380| 1.86k| if(srcLength==-1) { ------------------ | Branch (1380:8): [True: 0, False: 1.86k] ------------------ 1381| 0| srcLength=u_strlen(src); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1382| 0| } 1383| | 1384| | /* check for overlapping source and destination */ 1385| 1.86k| if( dest!=nullptr && ------------------ | Branch (1385:9): [True: 1.86k, False: 0] ------------------ 1386| 1.86k| ((src>=dest && src<(dest+destCapacity)) || ------------------ | Branch (1386:11): [True: 798, False: 1.06k] | Branch (1386:24): [True: 0, False: 798] ------------------ 1387| 1.86k| (dest>=src && dest<(src+srcLength))) ------------------ | Branch (1387:11): [True: 1.06k, False: 798] | Branch (1387:24): [True: 0, False: 1.06k] ------------------ 1388| 1.86k| ) { 1389| | /* overlap: provide a temporary destination buffer and later copy the result */ 1390| 0| if(destCapacity<=UPRV_LENGTHOF(buffer)) { ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1390:12): [True: 0, False: 0] ------------------ 1391| | /* the stack buffer is large enough */ 1392| 0| temp=buffer; 1393| 0| } else { 1394| | /* allocate a buffer */ 1395| 0| temp=(char16_t *)uprv_malloc(destCapacity*U_SIZEOF_UCHAR); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ temp=(char16_t *)uprv_malloc(destCapacity*U_SIZEOF_UCHAR); ------------------ | | 352| 0|#define U_SIZEOF_UCHAR 2 ------------------ 1396| 0| if(temp==nullptr) { ------------------ | Branch (1396:16): [True: 0, False: 0] ------------------ 1397| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 1398| 0| return 0; 1399| 0| } 1400| 0| } 1401| 1.86k| } else { 1402| 1.86k| temp=dest; 1403| 1.86k| } 1404| | 1405| 1.86k| destLength=stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR ------------------ | | 131| 1.86k|# define UCASEMAP_BREAK_ITERATOR iter, ------------------ 1406| 1.86k| temp, destCapacity, src, srcLength, nullptr, errorCode); 1407| 1.86k| if(temp!=dest) { ------------------ | Branch (1407:8): [True: 0, False: 1.86k] ------------------ 1408| | /* copy the result string to the destination buffer */ 1409| 0| if (U_SUCCESS(errorCode) && 0 < destLength && destLength <= destCapacity) { ------------------ | Branch (1409:13): [True: 0, False: 0] | Branch (1409:37): [True: 0, False: 0] | Branch (1409:55): [True: 0, False: 0] ------------------ 1410| 0| u_memmove(dest, temp, destLength); ------------------ | | 335| 0|#define u_memmove U_ICU_ENTRY_POINT_RENAME(u_memmove) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1411| 0| } 1412| 0| if(temp!=buffer) { ------------------ | Branch (1412:12): [True: 0, False: 0] ------------------ 1413| 0| uprv_free(temp); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1414| 0| } 1415| 0| } 1416| | 1417| 1.86k| return u_terminateUChars(dest, destCapacity, destLength, &errorCode); ------------------ | | 408| 1.86k|#define u_terminateUChars U_ICU_ENTRY_POINT_RENAME(u_terminateUChars) | | ------------------ | | | | 123| 1.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1418| 1.86k|} u_strFoldCase_78: 1426| 1.86k| UErrorCode *pErrorCode) { 1427| 1.86k| return ustrcase_mapWithOverlap( ------------------ | | 1888| 1.86k|#define ustrcase_mapWithOverlap U_ICU_ENTRY_POINT_RENAME(ustrcase_mapWithOverlap) | | ------------------ | | | | 123| 1.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1428| 1.86k| UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL ------------------ | | 132| 1.86k|# define UCASEMAP_BREAK_ITERATOR_NULL NULL, ------------------ 1429| 1.86k| dest, destCapacity, 1430| 1.86k| src, srcLength, 1431| 1.86k| ustrcase_internalFold, *pErrorCode); ------------------ | | 1883| 1.86k|#define ustrcase_internalFold U_ICU_ENTRY_POINT_RENAME(ustrcase_internalFold) | | ------------------ | | | | 123| 1.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1432| 1.86k|} ustrcase.cpp:_ZN6icu_7812_GLOBAL__N_115appendUnchangedEPDsiiPKDsijPNS_5EditsE: 165| 2.30k| const char16_t *s, int32_t length, uint32_t options, icu::Edits *edits) { 166| 2.30k| if (length <= 0) { ------------------ | Branch (166:9): [True: 445, False: 1.85k] ------------------ 167| 445| return destIndex; 168| 445| } 169| 1.85k| return appendNonEmptyUnchanged(dest, destIndex, destCapacity, s, length, options, edits); 170| 2.30k|} ustrcase.cpp:_ZN6icu_7812_GLOBAL__N_123appendNonEmptyUnchangedEPDsiiPKDsijPNS_5EditsE: 147| 1.85k| const char16_t *s, int32_t length, uint32_t options, icu::Edits *edits) { 148| 1.85k| if(edits!=nullptr) { ------------------ | Branch (148:8): [True: 0, False: 1.85k] ------------------ 149| 0| edits->addUnchanged(length); 150| 0| } 151| 1.85k| if(options & U_OMIT_UNCHANGED_TEXT) { ------------------ | | 152| 1.85k|#define U_OMIT_UNCHANGED_TEXT 0x4000 ------------------ | Branch (151:8): [True: 0, False: 1.85k] ------------------ 152| 0| return destIndex; 153| 0| } 154| 1.85k| if(length>(INT32_MAX-destIndex)) { ------------------ | Branch (154:8): [True: 0, False: 1.85k] ------------------ 155| 0| return -1; // integer overflow 156| 0| } 157| 1.85k| if((destIndex+length)<=destCapacity) { ------------------ | Branch (157:8): [True: 1.85k, False: 0] ------------------ 158| 1.85k| u_memcpy(dest+destIndex, s, length); ------------------ | | 334| 1.85k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 1.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 159| 1.85k| } 160| 1.85k| return destIndex + length; 161| 1.85k|} ustrcase.cpp:_ZN6icu_7812_GLOBAL__N_112appendResultEPDsiiiPKDsijPNS_5EditsE: 65| 109| int32_t cpLength, uint32_t options, icu::Edits *edits) { 66| 109| UChar32 c; 67| 109| int32_t length; 68| | 69| | /* decode the result */ 70| 109| if(result<0) { ------------------ | Branch (70:8): [True: 0, False: 109] ------------------ 71| | /* (not) original code point */ 72| 0| if(edits!=nullptr) { ------------------ | Branch (72:12): [True: 0, False: 0] ------------------ 73| 0| edits->addUnchanged(cpLength); 74| 0| } 75| 0| if(options & U_OMIT_UNCHANGED_TEXT) { ------------------ | | 152| 0|#define U_OMIT_UNCHANGED_TEXT 0x4000 ------------------ | Branch (75:12): [True: 0, False: 0] ------------------ 76| 0| return destIndex; 77| 0| } 78| 0| c=~result; 79| 0| if(destIndex(c); 81| 0| return destIndex; 82| 0| } 83| 0| length=cpLength; 84| 109| } else { 85| 109| if(result<=UCASE_MAX_STRING_LENGTH) { ------------------ | Branch (85:12): [True: 0, False: 109] ------------------ 86| 0| c=U_SENTINEL; ------------------ | | 469| 0|#define U_SENTINEL (-1) ------------------ 87| 0| length=result; 88| 109| } else if(destIndex(result); 90| 109| if(edits!=nullptr) { ------------------ | Branch (90:16): [True: 0, False: 109] ------------------ 91| 0| edits->addReplace(cpLength, 1); 92| 0| } 93| 109| return destIndex; 94| 109| } else { 95| 0| c=result; 96| 0| length=U16_LENGTH(c); ------------------ | | 141| 0|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 0, False: 0] | | ------------------ ------------------ 97| 0| } 98| 0| if(edits!=nullptr) { ------------------ | Branch (98:12): [True: 0, False: 0] ------------------ 99| 0| edits->addReplace(cpLength, length); 100| 0| } 101| 0| } 102| 0| if(length>(INT32_MAX-destIndex)) { ------------------ | Branch (102:8): [True: 0, False: 0] ------------------ 103| 0| return -1; // integer overflow 104| 0| } 105| | 106| 0| if(destIndex=0) { ------------------ | Branch (108:12): [True: 0, False: 0] ------------------ 109| | /* code point */ 110| 0| UBool isError=false; 111| 0| U16_APPEND(dest, destIndex, destCapacity, c, isError); ------------------ | | 393| 0|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 0| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 0, False: 0] | | ------------------ | | 395| 0| (s)[(i)++]=(uint16_t)(c); \ | | 396| 0| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 0, False: 0] | | | Branch (396:42): [True: 0, False: 0] | | ------------------ | | 397| 0| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 0| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 0| } else /* c>0x10ffff or not enough space */ { \ | | 400| 0| (isError)=true; \ | | 401| 0| } \ | | 402| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 112| 0| if(isError) { ------------------ | Branch (112:16): [True: 0, False: 0] ------------------ 113| | /* overflow, nothing written */ 114| 0| destIndex+=length; 115| 0| } 116| 0| } else { 117| | /* string */ 118| 0| if((destIndex+length)<=destCapacity) { ------------------ | Branch (118:16): [True: 0, False: 0] ------------------ 119| 0| while(length>0) { ------------------ | Branch (119:23): [True: 0, False: 0] ------------------ 120| 0| dest[destIndex++]=*s++; 121| 0| --length; 122| 0| } 123| 0| } else { 124| | /* overflow */ 125| 0| destIndex+=length; 126| 0| } 127| 0| } 128| 0| } else { 129| | /* preflight */ 130| 0| destIndex+=length; 131| 0| } 132| 0| return destIndex; 133| 0|} ustrcase.cpp:_ZN6icu_7812_GLOBAL__N_17toLowerEijPDsiPKDsP12UCaseContextiiPNS_5EditsER10UErrorCode: 211| 1.86k| icu::Edits *edits, UErrorCode &errorCode) { 212| 1.86k| const int8_t *latinToLower; 213| 1.86k| if (caseLocale == UCASE_LOC_ROOT || ------------------ | Branch (213:9): [True: 0, False: 1.86k] ------------------ 214| 1.86k| (caseLocale >= 0 ? ------------------ | Branch (214:13): [True: 1.86k, False: 0] | Branch (214:14): [True: 0, False: 1.86k] ------------------ 215| 0| !(caseLocale == UCASE_LOC_TURKISH || caseLocale == UCASE_LOC_LITHUANIAN) : ------------------ | Branch (215:19): [True: 0, False: 0] | Branch (215:54): [True: 0, False: 0] ------------------ 216| 1.86k| (options & _FOLD_CASE_OPTIONS_MASK) == U_FOLD_CASE_DEFAULT)) { ------------------ | | 83| 1.86k|#define _FOLD_CASE_OPTIONS_MASK 7 ------------------ (options & _FOLD_CASE_OPTIONS_MASK) == U_FOLD_CASE_DEFAULT)) { ------------------ | | 22| 1.86k|#define U_FOLD_CASE_DEFAULT 0 ------------------ 217| 1.86k| latinToLower = LatinCase::TO_LOWER_NORMAL; 218| 1.86k| } else { 219| 0| latinToLower = LatinCase::TO_LOWER_TR_LT; 220| 0| } 221| 1.86k| const UTrie2 *trie = ucase_getTrie(); ------------------ | | 574| 1.86k|#define ucase_getTrie U_ICU_ENTRY_POINT_RENAME(ucase_getTrie) | | ------------------ | | | | 123| 1.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 222| 1.86k| int32_t destIndex = 0; 223| 1.86k| int32_t prev = srcStart; 224| 1.86k| int32_t srcIndex = srcStart; 225| 2.18k| for (;;) { 226| | // fast path for simple cases 227| 2.18k| char16_t lead = 0; 228| 6.29k| while (srcIndex < srcLimit) { ------------------ | Branch (228:16): [True: 4.42k, False: 1.86k] ------------------ 229| 4.42k| lead = src[srcIndex]; 230| 4.42k| int32_t delta; 231| 4.42k| if (lead < LatinCase::LONG_S) { ------------------ | Branch (231:17): [True: 502, False: 3.92k] ------------------ 232| 502| int8_t d = latinToLower[lead]; 233| 502| if (d == LatinCase::EXC) { break; } ------------------ | Branch (233:21): [True: 0, False: 502] ------------------ 234| 502| ++srcIndex; 235| 502| if (d == 0) { continue; } ------------------ | Branch (235:21): [True: 256, False: 246] ------------------ 236| 246| delta = d; 237| 3.92k| } else if (lead >= 0xd800) { ------------------ | Branch (237:24): [True: 103, False: 3.82k] ------------------ 238| 103| break; // surrogate or higher 239| 3.82k| } else { 240| 3.82k| uint16_t props = UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, lead); ------------------ | | 557| 3.82k|#define UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, c) _UTRIE2_GET_FROM_U16_SINGLE_LEAD((trie), index, c) | | ------------------ | | | | 859| 3.82k| (trie)->data[_UTRIE2_INDEX_FROM_U16_SINGLE_LEAD((trie)->index, c)] | | | | ------------------ | | | | | | 820| 3.82k|#define _UTRIE2_INDEX_FROM_U16_SINGLE_LEAD(trieIndex, c) _UTRIE2_INDEX_RAW(0, trieIndex, c) | | | | | | ------------------ | | | | | | | | 815| 3.82k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 3.82k| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 89|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ | Branch (243:21): [True: 3.51k, False: 89] | Branch (243:56): [True: 2, False: 87] ------------------ 244| 3.52k| continue; 245| 3.52k| } 246| 3.60k| } 247| 333| lead += static_cast(delta); 248| 333| destIndex = appendUnchanged(dest, destIndex, destCapacity, 249| 333| src + prev, srcIndex - 1 - prev, options, edits); 250| 333| if (destIndex >= 0) { ------------------ | Branch (250:17): [True: 333, False: 0] ------------------ 251| 333| destIndex = appendUChar(dest, destIndex, destCapacity, lead); 252| 333| if (edits != nullptr) { ------------------ | Branch (252:21): [True: 0, False: 333] ------------------ 253| 0| edits->addReplace(1, 1); 254| 0| } 255| 333| } 256| 333| if (destIndex < 0) { ------------------ | Branch (256:17): [True: 0, False: 333] ------------------ 257| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 258| 0| return 0; 259| 0| } 260| 333| prev = srcIndex; 261| 333| } 262| 2.18k| if (srcIndex >= srcLimit) { ------------------ | Branch (262:13): [True: 1.86k, False: 319] ------------------ 263| 1.86k| break; 264| 1.86k| } 265| | // slow path 266| 319| int32_t cpStart = srcIndex++; 267| 319| char16_t trail; 268| 319| UChar32 c; 269| 319| if (U16_IS_LEAD(lead) && srcIndex < srcLimit && U16_IS_TRAIL(trail = src[srcIndex])) { ------------------ | | 59| 638|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 103, False: 216] | | ------------------ ------------------ if (U16_IS_LEAD(lead) && srcIndex < srcLimit && U16_IS_TRAIL(trail = src[srcIndex])) { ------------------ | | 67| 103|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 103, False: 0] | | ------------------ ------------------ | Branch (269:34): [True: 103, False: 0] ------------------ 270| 103| c = U16_GET_SUPPLEMENTARY(lead, trail); ------------------ | | 113| 103| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 103|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 271| 103| ++srcIndex; 272| 216| } else { 273| 216| c = lead; 274| 216| } 275| 319| const char16_t *s = nullptr; 276| 319| if (caseLocale >= 0) { ------------------ | Branch (276:13): [True: 0, False: 319] ------------------ 277| 0| csc->cpStart = cpStart; 278| 0| csc->cpLimit = srcIndex; 279| 0| c = ucase_toFullLower(c, utf16_caseContextIterator, csc, &s, caseLocale); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 280| 319| } else { 281| 319| c = ucase_toFullFolding(c, &s, options); ------------------ | | 580| 319|#define ucase_toFullFolding U_ICU_ENTRY_POINT_RENAME(ucase_toFullFolding) | | ------------------ | | | | 123| 319|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 319|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 319|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 282| 319| } 283| 319| if (c >= 0) { ------------------ | Branch (283:13): [True: 109, False: 210] ------------------ 284| 109| destIndex = appendUnchanged(dest, destIndex, destCapacity, 285| 109| src + prev, cpStart - prev, options, edits); 286| 109| if (destIndex >= 0) { ------------------ | Branch (286:17): [True: 109, False: 0] ------------------ 287| 109| destIndex = appendResult(dest, destIndex, destCapacity, c, s, 288| 109| srcIndex - cpStart, options, edits); 289| 109| } 290| 109| if (destIndex < 0) { ------------------ | Branch (290:17): [True: 0, False: 109] ------------------ 291| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 292| 0| return 0; 293| 0| } 294| 109| prev = srcIndex; 295| 109| } 296| 319| } 297| 1.86k| destIndex = appendUnchanged(dest, destIndex, destCapacity, 298| 1.86k| src + prev, srcIndex - prev, options, edits); 299| 1.86k| if (destIndex < 0) { ------------------ | Branch (299:9): [True: 0, False: 1.86k] ------------------ 300| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 301| 0| return 0; 302| 0| } 303| 1.86k| return destIndex; 304| 1.86k|} ustrcase.cpp:_ZN6icu_7812_GLOBAL__N_126checkOverflowAndEditsErrorEiiPNS_5EditsER10UErrorCode: 50| 1.86k| Edits *edits, UErrorCode &errorCode) { 51| 1.86k| if (U_SUCCESS(errorCode)) { ------------------ | Branch (51:9): [True: 1.86k, False: 0] ------------------ 52| 1.86k| if (destIndex > destCapacity) { ------------------ | Branch (52:13): [True: 0, False: 1.86k] ------------------ 53| 0| errorCode = U_BUFFER_OVERFLOW_ERROR; 54| 1.86k| } else if (edits != nullptr) { ------------------ | Branch (54:20): [True: 0, False: 1.86k] ------------------ 55| 0| edits->copyErrorTo(errorCode); 56| 0| } 57| 1.86k| } 58| 1.86k| return destIndex; 59| 1.86k|} ustrcase.cpp:_ZN6icu_7812_GLOBAL__N_111appendUCharEPDsiiDs: 136| 333|appendUChar(char16_t *dest, int32_t destIndex, int32_t destCapacity, char16_t c) { 137| 333| if(destIndex=0 but also check for NUL */ 721| 0| if(s1==s2) { ------------------ | Branch (721:12): [True: 0, False: 0] ------------------ 722| 0| return 0; 723| 0| } 724| | 725| 0| limit1=start1+length1; 726| | 727| 0| for(;;) { 728| | /* both lengths are same, check only one limit */ 729| 0| if(s1==limit1) { ------------------ | Branch (729:16): [True: 0, False: 0] ------------------ 730| 0| return 0; 731| 0| } 732| | 733| 0| c1=*s1; 734| 0| c2=*s2; 735| 0| if(c1!=c2) { ------------------ | Branch (735:16): [True: 0, False: 0] ------------------ 736| 0| break; 737| 0| } 738| 0| if(c1==0) { ------------------ | Branch (738:16): [True: 0, False: 0] ------------------ 739| 0| return 0; 740| 0| } 741| 0| ++s1; 742| 0| ++s2; 743| 0| } 744| | 745| | /* setup for fix-up */ 746| 0| limit2=start2+length1; /* use length1 here, too, to enforce assumption */ 747| 1.86k| } else { 748| | /* memcmp/UnicodeString style, both length-specified */ 749| 1.86k| int32_t lengthResult; 750| | 751| 1.86k| if(length1<0) { ------------------ | Branch (751:12): [True: 0, False: 1.86k] ------------------ 752| 0| length1=u_strlen(s1); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 753| 0| } 754| 1.86k| if(length2<0) { ------------------ | Branch (754:12): [True: 0, False: 1.86k] ------------------ 755| 0| length2=u_strlen(s2); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 756| 0| } 757| | 758| | /* limit1=start1+min(length1, length2) */ 759| 1.86k| if(length1length2 */ { 766| 0| lengthResult=1; 767| 0| limit1=start1+length2; 768| 0| } 769| | 770| 1.86k| if(s1==s2) { ------------------ | Branch (770:12): [True: 0, False: 1.86k] ------------------ 771| 0| return lengthResult; 772| 0| } 773| | 774| 5.46k| for(;;) { 775| | /* check pseudo-limit */ 776| 5.46k| if(s1==limit1) { ------------------ | Branch (776:16): [True: 1.44k, False: 4.01k] ------------------ 777| 1.44k| return lengthResult; 778| 1.44k| } 779| | 780| 4.01k| c1=*s1; 781| 4.01k| c2=*s2; 782| 4.01k| if(c1!=c2) { ------------------ | Branch (782:16): [True: 415, False: 3.60k] ------------------ 783| 415| break; 784| 415| } 785| 3.60k| ++s1; 786| 3.60k| ++s2; 787| 3.60k| } 788| | 789| | /* setup for fix-up */ 790| 415| limit1=start1+length1; 791| 415| limit2=start2+length2; 792| 415| } 793| | 794| | /* if both values are in or above the surrogate range, fix them up */ 795| 415| if(c1>=0xd800 && c2>=0xd800 && codePointOrder) { ------------------ | Branch (795:8): [True: 0, False: 415] | Branch (795:22): [True: 0, False: 0] | Branch (795:36): [True: 0, False: 0] ------------------ 796| | /* subtract 0x2800 from BMP code points to make them smaller than supplementary ones */ 797| 0| if( 798| 0| (c1<=0xdbff && (s1+1)!=limit1 && U16_IS_TRAIL(*(s1+1))) || ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ | Branch (798:14): [True: 0, False: 0] | Branch (798:28): [True: 0, False: 0] ------------------ 799| 0| (U16_IS_TRAIL(c1) && start1!=s1 && U16_IS_LEAD(*(s1-1))) ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ (U16_IS_TRAIL(c1) && start1!=s1 && U16_IS_LEAD(*(s1-1))) ------------------ | | 59| 0|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 0, False: 0] | | ------------------ ------------------ | Branch (799:34): [True: 0, False: 0] ------------------ 800| 0| ) { 801| | /* part of a surrogate pair, leave >=d800 */ 802| 0| } else { 803| | /* BMP code point - may be surrogate code point - make =d800 */ 812| 0| } else { 813| | /* BMP code point - may be surrogate code point - make 0) { ------------------ | Branch (1118:8): [True: 18.9k, False: 0] ------------------ 1119| 18.9k| uprv_memcpy(dest, src, (size_t)count*U_SIZEOF_UCHAR); ------------------ | | 42| 18.9k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 18.9k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 18.9k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 18.9k| _Pragma("clang diagnostic push") \ | | 45| 18.9k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 18.9k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 18.9k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 18.9k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 18.9k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 18.9k| _Pragma("clang diagnostic pop") \ | | 49| 18.9k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 18.9k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 18.9k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 18.9k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1120| 18.9k| } 1121| 18.9k| return dest; 1122| 18.9k|} u_unescapeAt_78: 1216| 48.5k| void *context) { 1217| | 1218| 48.5k| int32_t start = *offset; 1219| 48.5k| UChar32 c; 1220| 48.5k| UChar32 result = 0; 1221| 48.5k| int8_t n = 0; 1222| 48.5k| int8_t minDig = 0; 1223| 48.5k| int8_t maxDig = 0; 1224| 48.5k| int8_t bitsPerDigit = 4; 1225| 48.5k| int32_t dig; 1226| 48.5k| UBool braces = false; 1227| | 1228| | /* Check that offset is in range */ 1229| 48.5k| if (*offset < 0 || *offset >= length) { ------------------ | Branch (1229:9): [True: 0, False: 48.5k] | Branch (1229:24): [True: 84, False: 48.4k] ------------------ 1230| 84| goto err; 1231| 84| } 1232| | 1233| | /* Fetch first char16_t after '\\' */ 1234| 48.4k| c = charAt((*offset)++, context); 1235| | 1236| | /* Convert hexadecimal and octal escapes */ 1237| 48.4k| switch (c) { 1238| 2.34k| case u'u': ------------------ | Branch (1238:5): [True: 2.34k, False: 46.1k] ------------------ 1239| 2.34k| minDig = maxDig = 4; 1240| 2.34k| break; 1241| 1.11k| case u'U': ------------------ | Branch (1241:5): [True: 1.11k, False: 47.3k] ------------------ 1242| 1.11k| minDig = maxDig = 8; 1243| 1.11k| break; 1244| 1.00k| case u'x': ------------------ | Branch (1244:5): [True: 1.00k, False: 47.4k] ------------------ 1245| 1.00k| minDig = 1; 1246| 1.00k| if (*offset < length && charAt(*offset, context) == u'{') { ------------------ | Branch (1246:13): [True: 994, False: 8] | Branch (1246:33): [True: 262, False: 732] ------------------ 1247| 262| ++(*offset); 1248| 262| braces = true; 1249| 262| maxDig = 8; 1250| 740| } else { 1251| 740| maxDig = 2; 1252| 740| } 1253| 1.00k| break; 1254| 44.0k| default: ------------------ | Branch (1254:5): [True: 44.0k, False: 4.46k] ------------------ 1255| 44.0k| dig = _digit8(c); 1256| 44.0k| if (dig >= 0) { ------------------ | Branch (1256:13): [True: 2.36k, False: 41.6k] ------------------ 1257| 2.36k| minDig = 1; 1258| 2.36k| maxDig = 3; 1259| 2.36k| n = 1; /* Already have first octal digit */ 1260| 2.36k| bitsPerDigit = 3; 1261| 2.36k| result = dig; 1262| 2.36k| } 1263| 44.0k| break; 1264| 48.4k| } 1265| 48.4k| if (minDig != 0) { ------------------ | Branch (1265:9): [True: 6.82k, False: 41.6k] ------------------ 1266| 27.3k| while (*offset < length && n < maxDig) { ------------------ | Branch (1266:16): [True: 26.5k, False: 822] | Branch (1266:36): [True: 22.3k, False: 4.19k] ------------------ 1267| 22.3k| c = charAt(*offset, context); 1268| 22.3k| dig = (bitsPerDigit == 3) ? _digit8(c) : _digit16(c); ------------------ | Branch (1268:19): [True: 3.72k, False: 18.6k] ------------------ 1269| 22.3k| if (dig < 0) { ------------------ | Branch (1269:17): [True: 1.80k, False: 20.5k] ------------------ 1270| 1.80k| break; 1271| 1.80k| } 1272| 20.5k| result = (result << bitsPerDigit) | dig; 1273| 20.5k| ++(*offset); 1274| 20.5k| ++n; 1275| 20.5k| } 1276| 6.82k| if (n < minDig) { ------------------ | Branch (1276:13): [True: 436, False: 6.38k] ------------------ 1277| 436| goto err; 1278| 436| } 1279| 6.38k| if (braces) { ------------------ | Branch (1279:13): [True: 258, False: 6.13k] ------------------ 1280| 258| if (c != u'}') { ------------------ | Branch (1280:17): [True: 42, False: 216] ------------------ 1281| 42| goto err; 1282| 42| } 1283| 216| ++(*offset); 1284| 216| } 1285| 6.34k| if (result < 0 || result >= 0x110000) { ------------------ | Branch (1285:13): [True: 50, False: 6.29k] | Branch (1285:27): [True: 26, False: 6.27k] ------------------ 1286| 76| goto err; 1287| 76| } 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| 6.27k| if (*offset < length && U16_IS_LEAD(result)) { ------------------ | | 59| 5.84k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 2.86k, False: 2.97k] | | ------------------ ------------------ | Branch (1292:13): [True: 5.84k, False: 430] ------------------ 1293| 2.86k| int32_t ahead = *offset + 1; 1294| 2.86k| c = charAt(*offset, context); 1295| 2.86k| if (c == u'\\' && ahead < length) { ------------------ | Branch (1295:17): [True: 2.28k, False: 578] | Branch (1295:31): [True: 1.75k, False: 534] ------------------ 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.75k| int32_t tailLimit = ahead + 11; 1300| 1.75k| if (tailLimit > length) { ------------------ | Branch (1300:21): [True: 1.75k, False: 0] ------------------ 1301| 1.75k| tailLimit = length; 1302| 1.75k| } 1303| 1.75k| c = u_unescapeAt(charAt, &ahead, tailLimit, context); ------------------ | | 416| 1.75k|#define u_unescapeAt U_ICU_ENTRY_POINT_RENAME(u_unescapeAt) | | ------------------ | | | | 123| 1.75k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.75k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.75k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1304| 1.75k| } 1305| 2.86k| if (U16_IS_TRAIL(c)) { ------------------ | | 67| 2.86k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 254, False: 2.60k] | | ------------------ ------------------ 1306| 254| *offset = ahead; 1307| 254| result = U16_GET_SUPPLEMENTARY(result, c); ------------------ | | 113| 254| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 254|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 1308| 254| } 1309| 2.86k| } 1310| 6.27k| return result; 1311| 6.34k| } 1312| | 1313| | /* Convert C-style escapes in table */ 1314| 119k| for (int32_t i=0; idestCapacity */ { \ | | 1454| 0| /* even the string itself did not fit - set an error code */ \ | | 1455| 0| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; \ | | 1456| 0| } \ | | 1457| 1.86k| } \ | | 1458| 1.86k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.86k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1471| 1.86k| return length; 1472| 1.86k|} ustring.cpp:_ZL19isMatchAtCPBoundaryPKDsS0_S0_S0_: 43| 16.7k|isMatchAtCPBoundary(const char16_t *start, const char16_t *match, const char16_t *matchLimit, const char16_t *limit) { 44| 16.7k| if(U16_IS_TRAIL(*match) && start!=match && U16_IS_LEAD(*(match-1))) { ------------------ | | 67| 33.4k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 16.7k] | | ------------------ ------------------ if(U16_IS_TRAIL(*match) && start!=match && U16_IS_LEAD(*(match-1))) { ------------------ | | 59| 0|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 0, False: 0] | | ------------------ ------------------ | Branch (44:32): [True: 0, False: 0] ------------------ 45| | /* the leading edge of the match is in the middle of a surrogate pair */ 46| 0| return false; 47| 0| } 48| 16.7k| if(U16_IS_LEAD(*(matchLimit-1)) && matchLimit!=limit && U16_IS_TRAIL(*matchLimit)) { ------------------ | | 59| 33.4k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 0, False: 16.7k] | | ------------------ ------------------ if(U16_IS_LEAD(*(matchLimit-1)) && matchLimit!=limit && U16_IS_TRAIL(*matchLimit)) { ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ | Branch (48:40): [True: 0, False: 0] ------------------ 49| | /* the trailing edge of the match is in the middle of a surrogate pair */ 50| 0| return false; 51| 0| } 52| 16.7k| return true; 53| 16.7k|} ustring.cpp:_ZL7_digit8Ds: 1188| 47.7k|static int32_t _digit8(char16_t c) { 1189| 47.7k| if (c >= u'0' && c <= u'7') { ------------------ | Branch (1189:9): [True: 46.0k, False: 1.72k] | Branch (1189:22): [True: 5.27k, False: 40.7k] ------------------ 1190| 5.27k| return c - u'0'; 1191| 5.27k| } 1192| 42.4k| return -1; 1193| 47.7k|} ustring.cpp:_ZL8_digit16Ds: 1196| 18.6k|static int32_t _digit16(char16_t c) { 1197| 18.6k| if (c >= u'0' && c <= u'9') { ------------------ | Branch (1197:9): [True: 18.1k, False: 430] | Branch (1197:22): [True: 4.43k, False: 13.7k] ------------------ 1198| 4.43k| return c - u'0'; 1199| 4.43k| } 1200| 14.1k| if (c >= u'A' && c <= u'F') { ------------------ | Branch (1200:9): [True: 13.7k, False: 438] | Branch (1200:22): [True: 2.06k, False: 11.6k] ------------------ 1201| 2.06k| return c - (u'A' - 10); 1202| 2.06k| } 1203| 12.1k| if (c >= u'a' && c <= u'f') { ------------------ | Branch (1203:9): [True: 11.6k, False: 450] | Branch (1203:22): [True: 11.1k, False: 538] ------------------ 1204| 11.1k| return c - (u'a' - 10); 1205| 11.1k| } 1206| 988| return -1; 1207| 12.1k|} _ZN6icu_7811ICU_Utility21shouldAlwaysBeEscapedEi: 72| 60.0M|UBool ICU_Utility::shouldAlwaysBeEscaped(UChar32 c) { 73| 60.0M| if (c < 0x20) { ------------------ | Branch (73:9): [True: 28.7M, False: 31.2M] ------------------ 74| 28.7M| return true; // C0 control codes 75| 31.2M| } else if (c <= 0x7e) { ------------------ | Branch (75:16): [True: 437k, False: 30.8M] ------------------ 76| 437k| return false; // printable ASCII 77| 30.8M| } else if (c <= 0x9f) { ------------------ | Branch (77:16): [True: 29.0k, False: 30.8M] ------------------ 78| 29.0k| return true; // C1 control codes 79| 30.8M| } else if (c < 0xd800) { ------------------ | Branch (79:16): [True: 6.57M, False: 24.2M] ------------------ 80| 6.57M| return false; // most of the BMP 81| 24.2M| } else if (c <= 0xdfff || (0xfdd0 <= c && c <= 0xfdef) || (c & 0xfffe) == 0xfffe) { ------------------ | Branch (81:16): [True: 21.6M, False: 2.59M] | Branch (81:32): [True: 1.94M, False: 644k] | Branch (81:47): [True: 2.09k, False: 1.94M] | Branch (81:63): [True: 1.58M, False: 1.00M] ------------------ 82| 23.2M| return true; // surrogate or noncharacter code points 83| 23.2M| } else if (c <= 0x10ffff) { ------------------ | Branch (83:16): [True: 1.00M, False: 0] ------------------ 84| 1.00M| return false; // all else 85| 1.00M| } else { 86| 0| return true; // not a code point 87| 0| } 88| 60.0M|} _ZN6icu_7811ICU_Utility6escapeERNS_13UnicodeStringEi: 98| 51.9M|UnicodeString &ICU_Utility::escape(UnicodeString& result, UChar32 c) { 99| 51.9M| result.append(BACKSLASH); 100| 51.9M| if (c & ~0xFFFF) { ------------------ | Branch (100:9): [True: 1.16M, False: 50.8M] ------------------ 101| 1.16M| result.append(UPPER_U); 102| 1.16M| result.append(DIGITS[0xF&(c>>28)]); 103| 1.16M| result.append(DIGITS[0xF&(c>>24)]); 104| 1.16M| result.append(DIGITS[0xF&(c>>20)]); 105| 1.16M| result.append(DIGITS[0xF&(c>>16)]); 106| 50.8M| } else { 107| 50.8M| result.append(LOWER_U); 108| 50.8M| } 109| 51.9M| result.append(DIGITS[0xF&(c>>12)]); 110| 51.9M| result.append(DIGITS[0xF&(c>>8)]); 111| 51.9M| result.append(DIGITS[0xF&(c>>4)]); 112| 51.9M| result.append(DIGITS[0xF&c]); 113| 51.9M| return result; 114| 51.9M|} _ZN6icu_7811ICU_Utility14skipWhitespaceERKNS_13UnicodeStringERia: 150| 33.4k| UBool advance) { 151| 33.4k| int32_t p = pos; 152| 33.4k| const char16_t* s = str.getBuffer(); 153| 33.4k| p = static_cast(PatternProps::skipWhiteSpace(s + p, str.length() - p) - s); 154| 33.4k| if (advance) { ------------------ | Branch (154:9): [True: 1.55k, False: 31.9k] ------------------ 155| 1.55k| pos = p; 156| 1.55k| } 157| 33.4k| return p; 158| 33.4k|} utrie2_enum_78: 622| 5| UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 623| 5| enumEitherTrie(trie, 0, 0x110000, enumValue, enumRange, context); 624| 5|} utrie2.cpp:_ZL14enumEitherTriePK6UTrie2iiPFjPKvjEPFaS3_iijES3_: 445| 5| UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 446| 5| const uint32_t *data32; 447| 5| const uint16_t *idx; 448| | 449| 5| uint32_t value, prevValue, initialValue; 450| 5| UChar32 c, prev, highStart; 451| 5| int32_t j, i2Block, prevI2Block, index2NullOffset, block, prevBlock, nullBlock; 452| | 453| 5| if(enumRange==nullptr) { ------------------ | Branch (453:8): [True: 0, False: 5] ------------------ 454| 0| return; 455| 0| } 456| 5| if(enumValue==nullptr) { ------------------ | Branch (456:8): [True: 5, False: 0] ------------------ 457| 5| enumValue=enumSameValue; 458| 5| } 459| | 460| 5| if(trie->newTrie==nullptr) { ------------------ | Branch (460:8): [True: 5, False: 0] ------------------ 461| | /* frozen trie */ 462| 5| idx=trie->index; 463| 5| U_ASSERT(idx!=nullptr); /* the following code assumes trie->newTrie is not nullptr when idx is nullptr */ ------------------ | | 35| 5|# define U_ASSERT(exp) (void)0 ------------------ 464| 5| data32=trie->data32; 465| | 466| 5| index2NullOffset=trie->index2NullOffset; 467| 5| nullBlock=trie->dataNullOffset; 468| 5| } else { 469| | /* unfrozen, mutable trie */ 470| 0| idx=nullptr; 471| 0| data32=trie->newTrie->data; 472| 0| U_ASSERT(data32!=nullptr); /* the following code assumes idx is not nullptr when data32 is nullptr */ ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 473| | 474| 0| index2NullOffset=trie->newTrie->index2NullOffset; 475| 0| nullBlock=trie->newTrie->dataNullOffset; 476| 0| } 477| | 478| 5| highStart=trie->highStart; 479| | 480| | /* get the enumeration value that corresponds to an initial-value trie data entry */ 481| 5| initialValue=enumValue(context, trie->initialValue); 482| | 483| | /* set variables for previous range */ 484| 5| prevI2Block=-1; 485| 5| prevBlock=-1; 486| 5| prev=start; 487| 5| prevValue=0; 488| | 489| | /* enumerate index-2 blocks */ 490| 2.54k| for(c=start; c>UTRIE2_SHIFT_2; 499| 155| } else if(U_IS_SURROGATE_LEAD(c)) { ------------------ | | 202| 10|#define U_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | ------------------ | | | Branch (202:32): [True: 5, False: 5] | | ------------------ ------------------ 500| | /* 501| | * Enumerate values for lead surrogate code points, not code units: 502| | * This special block has half the normal length. 503| | */ 504| 5| i2Block=UTRIE2_LSCP_INDEX_2_OFFSET; 505| 5| tempLimit=MIN_VALUE(0xdc00, limit); ------------------ | | 421| 5|#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) | | ------------------ | | | Branch (421:26): [True: 5, False: 0] | | ------------------ ------------------ 506| 5| } 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| 5| i2Block=0xd800>>UTRIE2_SHIFT_2; 512| 5| tempLimit=MIN_VALUE(0xe000, limit); ------------------ | | 421| 5|#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) | | ------------------ | | | Branch (421:26): [True: 5, False: 0] | | ------------------ ------------------ 513| 5| } 514| 2.37k| } else { 515| | /* supplementary code points */ 516| 2.37k| if(idx!=nullptr) { ------------------ | Branch (516:16): [True: 2.37k, False: 0] ------------------ 517| 2.37k| i2Block=idx[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ 518| 2.37k| (c>>UTRIE2_SHIFT_1)]; 519| 2.37k| } else { 520| 0| i2Block=trie->newTrie->index1[c>>UTRIE2_SHIFT_1]; 521| 0| } 522| 2.37k| if(i2Block==prevI2Block && (c-prev)>=UTRIE2_CP_PER_INDEX_1_ENTRY) { ------------------ | Branch (522:16): [True: 2.14k, False: 225] | Branch (522:40): [True: 2.14k, False: 0] ------------------ 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.14k| c+=UTRIE2_CP_PER_INDEX_1_ENTRY; 529| 2.14k| continue; 530| 2.14k| } 531| 2.37k| } 532| 390| prevI2Block=i2Block; 533| 390| if(i2Block==index2NullOffset) { ------------------ | Branch (533:12): [True: 51, False: 339] ------------------ 534| | /* this is the null index-2 block */ 535| 51| if(prevValue!=initialValue) { ------------------ | Branch (535:16): [True: 26, False: 25] ------------------ 536| 26| if(prev>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 548| 339| if((c>>UTRIE2_SHIFT_1)==(tempLimit>>UTRIE2_SHIFT_1)) { ------------------ | Branch (548:16): [True: 5, False: 334] ------------------ 549| 5| i2Limit=(tempLimit>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 550| 334| } else { 551| 334| i2Limit=UTRIE2_INDEX_2_BLOCK_LENGTH; 552| 334| } 553| 21.7k| for(; i2(idx[i2Block + i2]) << UTRIE2_INDEX_SHIFT; 556| 21.3k| } else { 557| 0| block=trie->newTrie->index2[i2Block+i2]; 558| 0| } 559| 21.3k| if(block==prevBlock && (c-prev)>=UTRIE2_DATA_BLOCK_LENGTH) { ------------------ | Branch (559:20): [True: 17.2k, False: 4.08k] | Branch (559:40): [True: 17.2k, False: 26] ------------------ 560| | /* the block is the same as the previous one, and filled with prevValue */ 561| 17.2k| c+=UTRIE2_DATA_BLOCK_LENGTH; 562| 17.2k| continue; 563| 17.2k| } 564| 4.11k| prevBlock=block; 565| 4.11k| if(block==nullBlock) { ------------------ | Branch (565:20): [True: 477, False: 3.63k] ------------------ 566| | /* this is the null data block */ 567| 477| if(prevValue!=initialValue) { ------------------ | Branch (567:24): [True: 67, False: 410] ------------------ 568| 67| if(prevlimit) { ------------------ | Branch (592:8): [True: 0, False: 5] ------------------ 593| 0| c=limit; /* could be higher if in the index2NullOffset */ 594| 5| } else if(chighValueIndex] : 601| 2| idx[trie->highValueIndex]; 602| 2| } else { 603| 0| highValue=trie->newTrie->data[trie->newTrie->dataLength-UTRIE2_DATA_GRANULARITY]; 604| 0| } 605| 2| value=enumValue(context, highValue); 606| 2| if(value!=prevValue) { ------------------ | Branch (606:12): [True: 0, False: 2] ------------------ 607| 0| if(prev static_cast(INT32_MAX / sizeof(UElement)))) { ------------------ | Branch (52:9): [True: 0, False: 32.7k] | Branch (52:34): [True: 0, False: 32.7k] ------------------ 53| 0| initialCapacity = DEFAULT_CAPACITY; 54| 0| } 55| 32.7k| elements = static_cast(uprv_malloc(sizeof(UElement) * initialCapacity)); ------------------ | | 1524| 32.7k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 32.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 32.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 32.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 56| 32.7k| if (elements == nullptr) { ------------------ | Branch (56:9): [True: 0, False: 32.7k] ------------------ 57| 0| status = U_MEMORY_ALLOCATION_ERROR; 58| 32.7k| } else { 59| 32.7k| capacity = initialCapacity; 60| 32.7k| } 61| 32.7k|} _ZN6icu_787UVectorD2Ev: 63| 32.7k|UVector::~UVector() { 64| 32.7k| removeAllElements(); 65| 32.7k| uprv_free(elements); ------------------ | | 1503| 32.7k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 32.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 32.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 32.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 66| 32.7k| elements = nullptr; 67| 32.7k|} _ZNK6icu_787UVector9elementAtEi: 185| 446k|void* UVector::elementAt(int32_t index) const { 186| 446k| return (0 <= index && index < count) ? elements[index].pointer : nullptr; ------------------ | Branch (186:13): [True: 446k, False: 0] | Branch (186:27): [True: 446k, False: 0] ------------------ 187| 446k|} _ZN6icu_787UVector9removeAllERKS0_: 211| 1.71k|UBool UVector::removeAll(const UVector& other) { 212| 1.71k| UBool changed = false; 213| 10.4k| for (int32_t i=0; i= 0) { ------------------ | Branch (215:13): [True: 1.66k, False: 7.11k] ------------------ 216| 1.66k| removeElementAt(j); 217| 1.66k| changed = true; 218| 1.66k| } 219| 8.78k| } 220| 1.71k| return changed; 221| 1.71k|} _ZN6icu_787UVector9retainAllERKS0_: 223| 954|UBool UVector::retainAll(const UVector& other) { 224| 954| UBool changed = false; 225| 5.28k| for (int32_t j=size()-1; j>=0; --j) { ------------------ | Branch (225:30): [True: 4.33k, False: 954] ------------------ 226| 4.33k| int32_t i = other.indexOf(elements[j]); 227| 4.33k| if (i < 0) { ------------------ | Branch (227:13): [True: 3.34k, False: 984] ------------------ 228| 3.34k| removeElementAt(j); 229| 3.34k| changed = true; 230| 3.34k| } 231| 4.33k| } 232| 954| return changed; 233| 954|} _ZN6icu_787UVector15removeElementAtEi: 235| 5.01k|void UVector::removeElementAt(int32_t index) { 236| 5.01k| void* e = orphanElementAt(index); 237| 5.01k| if (e != nullptr && deleter != nullptr) { ------------------ | Branch (237:9): [True: 5.01k, False: 0] | Branch (237:25): [True: 5.01k, False: 0] ------------------ 238| 5.01k| (*deleter)(e); 239| 5.01k| } 240| 5.01k|} _ZN6icu_787UVector17removeAllElementsEv: 251| 48.1k|void UVector::removeAllElements() { 252| 48.1k| if (deleter != nullptr) { ------------------ | Branch (252:9): [True: 48.1k, False: 0] ------------------ 253| 525k| for (int32_t i=0; i (INT32_MAX - 1) / 2) { // integer overflow check ------------------ | Branch (335:13): [True: 0, False: 39.5k] ------------------ 336| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 337| 0| return false; 338| 0| } 339| 39.5k| int32_t newCap = capacity * 2; 340| 39.5k| if (newCap < minimumCapacity) { ------------------ | Branch (340:13): [True: 0, False: 39.5k] ------------------ 341| 0| newCap = minimumCapacity; 342| 0| } 343| 39.5k| if (newCap > static_cast(INT32_MAX / sizeof(UElement))) { // integer overflow check ------------------ | Branch (343:13): [True: 0, False: 39.5k] ------------------ 344| | // We keep the original memory contents on bad minimumCapacity. 345| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 346| 0| return false; 347| 0| } 348| 39.5k| UElement* newElems = static_cast(uprv_realloc(elements, sizeof(UElement) * newCap)); ------------------ | | 1536| 39.5k|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 349| 39.5k| if (newElems == nullptr) { ------------------ | Branch (349:13): [True: 0, False: 39.5k] ------------------ 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| 39.5k| elements = newElems; 355| 39.5k| capacity = newCap; 356| 39.5k| } 357| 482k| return true; 358| 482k|} _ZN6icu_787UVector15orphanElementAtEi: 418| 5.01k|void* UVector::orphanElementAt(int32_t index) { 419| 5.01k| void* e = nullptr; 420| 5.01k| if (0 <= index && index < count) { ------------------ | Branch (420:9): [True: 5.01k, False: 0] | Branch (420:23): [True: 5.01k, False: 0] ------------------ 421| 5.01k| e = elements[index].pointer; 422| 12.3k| for (int32_t i=index; i 0) { ------------------ | Branch (471:13): [True: 304k, False: 2.17M] ------------------ 472| 304k| max = probe; 473| 2.17M| } else { 474| | // assert(c <= 0); 475| 2.17M| min = probe + 1; 476| 2.17M| } 477| 2.48M| } 478| 2.09M| for (int32_t i=count; i>min; --i) { ------------------ | Branch (478:27): [True: 1.60M, False: 482k] ------------------ 479| 1.60M| elements[i] = elements[i-1]; 480| 1.60M| } 481| 482k| elements[min] = e; 482| 482k| ++count; 483| 482k|} _ZNK6icu_787UVector4sizeEv: 190| 495k| inline int32_t size() const {return count;} _ZNK6icu_787UVector8containsEPv: 174| 461k| inline UBool contains(void* obj) const {return indexOf(obj) >= 0;} _ZNK6icu_787UVector7isEmptyEv: 192| 16.3k| inline UBool isEmpty() const {return count == 0;} _ZN14IcuEnvironmentC2Ev: 14| 2| IcuEnvironment() { 15| | // nothing to initialize yet; 16| 2| } LLVMFuzzerTestOneInput: 13| 5.31k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 14| 5.31k| UErrorCode status = U_ZERO_ERROR; 15| | 16| 5.31k| size_t unistr_size = size/2; 17| 5.31k| std::unique_ptr fuzzbuff(new char16_t[unistr_size]); 18| 5.31k| std::memcpy(fuzzbuff.get(), data, unistr_size * 2); 19| 5.31k| icu::UnicodeString fuzzstr(false, fuzzbuff.get(), unistr_size); 20| | 21| 5.31k| icu::LocalPointer set( 22| 5.31k| new icu::UnicodeSet(fuzzstr, status)); 23| | 24| 5.31k| status = U_ZERO_ERROR; 25| | 26| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 27| 5.31k| set->applyPattern (fuzzstr, status); 28| | 29| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 30| 5.31k| set->addAll(fuzzstr); 31| | 32| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 33| 5.31k| set->add(fuzzstr); 34| | 35| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 36| 5.31k| set->retainAll(fuzzstr); 37| | 38| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 39| 5.31k| set->complementAll(fuzzstr); 40| | 41| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 42| 5.31k| set->removeAll(fuzzstr); 43| | 44| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 45| 5.31k| set->retain(fuzzstr); 46| | 47| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 48| 5.31k| set->remove(fuzzstr); 49| | 50| 5.31k| set.adoptInstead(new icu::UnicodeSet()); 51| 5.31k| set->complement(fuzzstr); 52| | 53| 5.31k| set.adoptInstead(icu::UnicodeSet::createFrom(fuzzstr)); 54| | 55| 5.31k| set.adoptInstead(icu::UnicodeSet::createFromAll(fuzzstr)); 56| 5.31k| return 0; 57| 5.31k|}