_ZN6icu_786BMPSetC2EPKii: 30| 23| list(parentList), listLength(parentListLength) { 31| 23| uprv_memset(latin1Contains, 0, sizeof(latin1Contains)); ------------------ | | 100| 23|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 23|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 32| 23| uprv_memset(table7FF, 0, sizeof(table7FF)); ------------------ | | 100| 23|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 23|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 33| 23| uprv_memset(bmpBlockBits, 0, sizeof(bmpBlockBits)); ------------------ | | 100| 23|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 23|#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| 23| list4kStarts[0]=findCodePoint(0x800, 0, listLength-1); 43| 23| int32_t i; 44| 391| for(i=1; i<=0x10; ++i) { ------------------ | Branch (44:14): [True: 368, False: 23] ------------------ 45| 368| list4kStarts[i]=findCodePoint(i<<12, list4kStarts[i-1], listLength-1); 46| 368| } 47| 23| list4kStarts[0x11]=listLength-1; 48| 23| containsFFFD=containsSlow(0xfffd, list4kStarts[0xf], list4kStarts[0x10]); 49| | 50| 23| initBits(); 51| 23| overrideIllegal(); 52| 23|} _ZN6icu_786BMPSet8initBitsEv: 121| 23|void BMPSet::initBits() { 122| 23| UChar32 start, limit; 123| 23| int32_t listIndex=0; 124| | 125| | // Set latin1Contains[]. 126| 107| do { 127| 107| start=list[listIndex++]; 128| 107| if(listIndex=0x100) { ------------------ | Branch (133:12): [True: 18, False: 89] ------------------ 134| 18| break; 135| 18| } 136| 1.10k| do { 137| 1.10k| latin1Contains[start++]=1; 138| 1.10k| } while(start0x80) { ------------------ | Branch (150:12): [True: 23, False: 36] ------------------ 151| 23| if(start<0x80) { ------------------ | Branch (151:16): [True: 0, False: 23] ------------------ 152| 0| start=0x80; 153| 0| } 154| 23| break; 155| 23| } 156| 59| } 157| | 158| | // Set table7FF[]. 159| 1.66k| while(start<0x800) { ------------------ | Branch (159:11): [True: 1.64k, False: 21] ------------------ 160| 1.64k| set32x64Bits(table7FF, start, limit<=0x800 ? limit : 0x800); ------------------ | Branch (160:39): [True: 1.64k, False: 2] ------------------ 161| 1.64k| if(limit>0x800) { ------------------ | Branch (161:12): [True: 2, False: 1.64k] ------------------ 162| 2| start=0x800; 163| 2| break; 164| 2| } 165| | 166| 1.64k| start=list[listIndex++]; 167| 1.64k| if(listIndex0x10000) { ------------------ | Branch (177:12): [True: 0, False: 3.99k] ------------------ 178| 0| limit=0x10000; 179| 0| } 180| | 181| 3.99k| if(start>=6; 188| 457| bmpBlockBits[start&0x3f]|=0x10001<<(start>>6); 189| 457| start=(start+1)<<6; // Round up to the next block boundary. 190| 457| minStart=start; // Ignore further ranges in this block. 191| 457| } 192| 1.03k| if(start>6, limit>>6); 196| 136| } 197| | 198| 615| if(limit&0x3f) { ------------------ | Branch (198:20): [True: 597, False: 18] ------------------ 199| | // Mixed-value block of 64 code points. 200| 597| limit>>=6; 201| 597| bmpBlockBits[limit&0x3f]|=0x10001<<(limit>>6); 202| 597| limit=(limit+1)<<6; // Round up to the next block boundary. 203| 597| minStart=limit; // Ignore further ranges in this block. 204| 597| } 205| 615| } 206| 1.03k| } 207| | 208| 3.99k| if(limit==0x10000) { ------------------ | Branch (208:12): [True: 0, False: 3.99k] ------------------ 209| 0| break; 210| 0| } 211| | 212| 3.99k| start=list[listIndex++]; 213| 3.99k| if(listIndex(~(0x10001<<0xd)); // Lead byte 0xED. 245| 2| bits=1<<0xd; 246| 66| for(i=32; i<64; ++i) { // Second half of 4k block. ------------------ | Branch (246:19): [True: 64, False: 2] ------------------ 247| 64| bmpBlockBits[i]=(bmpBlockBits[i]&mask)|bits; 248| 64| } 249| 21| } else { 250| 21| mask= static_cast(~(0x10001<<0xd)); // Lead byte 0xED. 251| 693| for(i=32; i<64; ++i) { // Second half of 4k block. ------------------ | Branch (251:19): [True: 672, False: 21] ------------------ 252| 672| bmpBlockBits[i]&=mask; 253| 672| } 254| 21| } 255| 23|} _ZNK6icu_786BMPSet13findCodePointEiii: 257| 414|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| 414| if (c < list[lo]) ------------------ | Branch (270:9): [True: 283, False: 131] ------------------ 271| 283| return lo; 272| | // High runner test. c is often after the last range, so an 273| | // initial check for this condition pays off. 274| 131| if (lo >= hi || c >= list[hi-1]) ------------------ | Branch (274:9): [True: 0, False: 131] | Branch (274:21): [True: 15, False: 116] ------------------ 275| 15| return hi; 276| | // invariant: c >= list[lo] 277| | // invariant: c < list[hi] 278| 1.05k| for (;;) { 279| 1.05k| int32_t i = (lo + hi) >> 1; 280| 1.05k| if (i == lo) { ------------------ | Branch (280:13): [True: 116, False: 935] ------------------ 281| 116| break; // Found! 282| 935| } else if (c < list[i]) { ------------------ | Branch (282:20): [True: 546, False: 389] ------------------ 283| 546| hi = i; 284| 546| } else { 285| 389| lo = i; 286| 389| } 287| 1.05k| } 288| 116| return hi; 289| 131|} bmpset.cpp:_ZN6icu_78L12set32x64BitsEPjii: 70| 1.78k|static void set32x64Bits(uint32_t table[64], int32_t start, int32_t limit) { 71| 1.78k| U_ASSERT(start>6; // Named for UTF-8 2-byte lead byte with upper 5 bits. 75| 1.78k| 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.78k| uint32_t bits = static_cast(1) << lead; 79| 1.78k| if((start+1)==limit) { // Single-character shortcut. ------------------ | Branch (79:8): [True: 1.39k, False: 383] ------------------ 80| 1.39k| table[trail]|=bits; 81| 1.39k| return; 82| 1.39k| } 83| | 84| 383| int32_t limitLead=limit>>6; 85| 383| int32_t limitTrail=limit&0x3f; 86| | 87| 383| if(lead==limitLead) { ------------------ | Branch (87:8): [True: 289, False: 94] ------------------ 88| | // Partial vertical bit column. 89| 2.45k| while(trail0) { ------------------ | Branch (96:12): [True: 89, False: 5] ------------------ 97| 2.17k| do { 98| 2.17k| table[trail++]|=bits; 99| 2.17k| } while(trail<64); ------------------ | Branch (99:21): [True: 2.08k, False: 89] ------------------ 100| 89| ++lead; 101| 89| } 102| 94| if(lead(1) << lead) - 1); 104| 33| if(limitLead<0x20) { ------------------ | Branch (104:16): [True: 33, False: 0] ------------------ 105| 33| bits &= (static_cast(1) << limitLead) - 1; 106| 33| } 107| 2.14k| for(trail=0; trail<64; ++trail) { ------------------ | Branch (107:26): [True: 2.11k, False: 33] ------------------ 108| 2.11k| table[trail]|=bits; 109| 2.11k| } 110| 33| } 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: 2, False: 92] ------------------ 115| 2.22k| for(trail=0; trailkMaxBranchLinearSubNodeLength) { ------------------ | Branch (89:11): [True: 533k, False: 339k] ------------------ 90| 533k| if(inByte<*pos++) { ------------------ | Branch (90:12): [True: 290k, False: 242k] ------------------ 91| 290k| length>>=1; 92| 290k| pos=jumpByDelta(pos); 93| 290k| } else { 94| 242k| length=length-(length>>1); 95| 242k| pos=skipDelta(pos); 96| 242k| } 97| 533k| } 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| 612k| do { 102| 612k| if(inByte==*pos++) { ------------------ | Branch (102:12): [True: 237k, False: 375k] ------------------ 103| 237k| UStringTrieResult result; 104| 237k| int32_t node=*pos; 105| 237k| U_ASSERT(node>=kMinValueLead); ------------------ | | 35| 237k|# define U_ASSERT(exp) (void)0 ------------------ 106| 237k| if(node&kValueIsFinal) { ------------------ | Branch (106:16): [True: 29.8k, False: 207k] ------------------ 107| | // Leave the final value for getValue() to read. 108| 29.8k| result=USTRINGTRIE_FINAL_VALUE; 109| 207k| } else { 110| | // Use the non-final value as the jump delta. 111| 207k| ++pos; 112| | // int32_t delta=readValue(pos, node>>1); 113| 207k| node>>=1; 114| 207k| int32_t delta; 115| 207k| if(node=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (132:25): [True: 108k, False: 98.9k] ------------------ 133| 207k| } 134| 237k| pos_=pos; 135| 237k| return result; 136| 237k| } 137| 375k| --length; 138| 375k| pos=skipValue(pos); 139| 375k| } while(length>1); ------------------ | Branch (139:13): [True: 273k, False: 102k] ------------------ 140| 102k| if(inByte==*pos++) { ------------------ | Branch (140:8): [True: 57.5k, False: 44.5k] ------------------ 141| 57.5k| pos_=pos; 142| 57.5k| int32_t node=*pos; 143| 57.5k| return node>=kMinValueLead ? valueResult(node) : USTRINGTRIE_NO_VALUE; ------------------ | Branch (143:16): [True: 44.2k, False: 13.2k] ------------------ 144| 57.5k| } else { 145| 44.5k| stop(); 146| 44.5k| return USTRINGTRIE_NO_MATCH; 147| 44.5k| } 148| 102k|} _ZN6icu_789BytesTrie8nextImplEPKhi: 151| 375k|BytesTrie::nextImpl(const uint8_t *pos, int32_t inByte) { 152| 418k| for(;;) { 153| 418k| int32_t node=*pos++; 154| 418k| if(node=kMinValueLead) ? ------------------ | Branch (162:25): [True: 4.17k, False: 16.2k] | Branch (162:37): [True: 4.16k, False: 2] ------------------ 163| 16.2k| valueResult(node) : USTRINGTRIE_NO_VALUE; 164| 20.3k| } else { 165| | // No match. 166| 15.7k| break; 167| 15.7k| } 168| 43.3k| } else if(node&kValueIsFinal) { ------------------ | Branch (168:19): [True: 0, False: 43.3k] ------------------ 169| | // No further matching bytes. 170| 0| break; 171| 43.3k| } else { 172| | // Skip intermediate value. 173| 43.3k| pos=skipValue(pos, node); 174| | // The next node must not also be a value node. 175| 43.3k| U_ASSERT(*pos=0) { ------------------ | Branch (192:8): [True: 16.6k, False: 375k] ------------------ 193| | // Remaining part of a linear-match node. 194| 16.6k| if(inByte==*pos++) { ------------------ | Branch (194:12): [True: 15.2k, False: 1.39k] ------------------ 195| 15.2k| remainingMatchLength_=--length; 196| 15.2k| pos_=pos; 197| 15.2k| int32_t node; 198| 15.2k| return (length<0 && (node=*pos)>=kMinValueLead) ? ------------------ | Branch (198:21): [True: 14.2k, False: 1.05k] | Branch (198:33): [True: 7.57k, False: 6.64k] ------------------ 199| 7.69k| valueResult(node) : USTRINGTRIE_NO_VALUE; 200| 15.2k| } else { 201| 1.39k| stop(); 202| 1.39k| return USTRINGTRIE_NO_MATCH; 203| 1.39k| } 204| 16.6k| } 205| 375k| return nextImpl(pos, inByte); 206| 392k|} _ZN6icu_7819CharacterProperties24getInclusionsForPropertyE9UPropertyR10UErrorCode: 267| 130k| UProperty prop, UErrorCode &errorCode) { 268| 130k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (268:9): [True: 0, False: 130k] ------------------ 269| 130k| if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { ------------------ | Branch (269:9): [True: 130k, False: 23] | Branch (269:36): [True: 20.2k, False: 109k] ------------------ 270| 20.2k| int32_t inclIndex = UPROPS_SRC_COUNT + (prop - UCHAR_INT_START); 271| 20.2k| Inclusion &i = gInclusions[inclIndex]; 272| 20.2k| umtx_initOnce(i.fInitOnce, &initIntPropInclusion, prop, errorCode); 273| 20.2k| return i.fSet; 274| 109k| } else { 275| 109k| UPropertySource src = uprops_getSource(prop); ------------------ | | 1392| 109k|#define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource) | | ------------------ | | | | 123| 109k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 109k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 109k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 276| 109k| return getInclusionsForSource(src, errorCode); 277| 109k| } 278| 130k|} _ZN6icu_7819CharacterProperties20getBinaryPropertySetE9UPropertyR10UErrorCode: 394| 4.33k|const UnicodeSet *CharacterProperties::getBinaryPropertySet(UProperty property, UErrorCode &errorCode) { 395| 4.33k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (395:9): [True: 0, False: 4.33k] ------------------ 396| 4.33k| if (property < 0 || UCHAR_BINARY_LIMIT <= property) { ------------------ | Branch (396:9): [True: 0, False: 4.33k] | Branch (396:25): [True: 0, False: 4.33k] ------------------ 397| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 398| 0| return nullptr; 399| 0| } 400| 4.33k| Mutex m(&cpMutex); 401| 4.33k| UnicodeSet *set = sets[property]; 402| 4.33k| if (set == nullptr) { ------------------ | Branch (402:9): [True: 23, False: 4.31k] ------------------ 403| 23| sets[property] = set = makeSet(property, errorCode); 404| 23| } 405| 4.33k| return set; 406| 4.33k|} u_getBinaryPropertySet_78: 413| 4.33k|u_getBinaryPropertySet(UProperty property, UErrorCode *pErrorCode) { 414| 4.33k| const UnicodeSet *set = CharacterProperties::getBinaryPropertySet(property, *pErrorCode); 415| 4.33k| return U_SUCCESS(*pErrorCode) ? set->toUSet() : nullptr; ------------------ | Branch (415:12): [True: 4.33k, False: 0] ------------------ 416| 4.33k|} characterproperties.cpp:_ZN12_GLOBAL__N_120initIntPropInclusionE9UPropertyR10UErrorCode: 222| 7|void U_CALLCONV initIntPropInclusion(UProperty prop, UErrorCode &errorCode) { 223| | // This function is invoked only via umtx_initOnce(). 224| 7| U_ASSERT(UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT); ------------------ | | 35| 7|# define U_ASSERT(exp) (void)0 ------------------ 225| 7| int32_t inclIndex = UPROPS_SRC_COUNT + (prop - UCHAR_INT_START); 226| 7| U_ASSERT(gInclusions[inclIndex].fSet == nullptr); ------------------ | | 35| 7|# define U_ASSERT(exp) (void)0 ------------------ 227| 7| UPropertySource src = uprops_getSource(prop); ------------------ | | 1392| 7|#define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 228| 7| const UnicodeSet *incl = getInclusionsForSource(src, errorCode); 229| 7| if (U_FAILURE(errorCode)) { ------------------ | Branch (229:9): [True: 0, False: 7] ------------------ 230| 0| return; 231| 0| } 232| | 233| 7| LocalPointer intPropIncl(new UnicodeSet(0, 0)); 234| 7| if (intPropIncl.isNull()) { ------------------ | Branch (234:9): [True: 0, False: 7] ------------------ 235| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 236| 0| return; 237| 0| } 238| 7| int32_t numRanges = incl->getRangeCount(); 239| 7| int32_t prevValue = 0; 240| 11.1k| for (int32_t i = 0; i < numRanges; ++i) { ------------------ | Branch (240:25): [True: 11.0k, False: 7] ------------------ 241| 11.0k| UChar32 rangeEnd = incl->getRangeEnd(i); 242| 41.6k| for (UChar32 c = incl->getRangeStart(i); c <= rangeEnd; ++c) { ------------------ | Branch (242:50): [True: 30.5k, False: 11.0k] ------------------ 243| | // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch. 244| 30.5k| int32_t value = u_getIntPropertyValue(c, prop); ------------------ | | 280| 30.5k|#define u_getIntPropertyValue U_ICU_ENTRY_POINT_RENAME(u_getIntPropertyValue) | | ------------------ | | | | 123| 30.5k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 30.5k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 30.5k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 245| 30.5k| if (value != prevValue) { ------------------ | Branch (245:17): [True: 6.66k, False: 23.8k] ------------------ 246| 6.66k| intPropIncl->add(c); 247| 6.66k| prevValue = value; 248| 6.66k| } 249| 30.5k| } 250| 11.0k| } 251| | 252| 7| if (intPropIncl->isBogus()) { ------------------ | Branch (252:9): [True: 0, False: 7] ------------------ 253| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 254| 0| return; 255| 0| } 256| | // Compact for caching. 257| 7| intPropIncl->compact(); 258| 7| gInclusions[inclIndex].fSet = intPropIncl.orphan(); 259| 7| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); ------------------ | | 617| 7|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 260| 7|} characterproperties.cpp:_ZN12_GLOBAL__N_122getInclusionsForSourceE15UPropertySourceR10UErrorCode: 211| 109k|const UnicodeSet *getInclusionsForSource(UPropertySource src, UErrorCode &errorCode) { 212| 109k| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (212:9): [True: 0, False: 109k] ------------------ 213| 109k| if (src < 0 || UPROPS_SRC_COUNT <= src) { ------------------ | Branch (213:9): [True: 0, False: 109k] | Branch (213:20): [True: 0, False: 109k] ------------------ 214| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 215| 0| return nullptr; 216| 0| } 217| 109k| Inclusion &i = gInclusions[src]; 218| 109k| umtx_initOnce(i.fInitOnce, &initInclusion, src, errorCode); 219| 109k| return i.fSet; 220| 109k|} characterproperties.cpp:_ZN12_GLOBAL__N_113initInclusionE15UPropertySourceR10UErrorCode: 91| 7|void U_CALLCONV initInclusion(UPropertySource src, UErrorCode &errorCode) { 92| | // This function is invoked only via umtx_initOnce(). 93| 7| U_ASSERT(0 <= src && src < UPROPS_SRC_COUNT); ------------------ | | 35| 7|# define U_ASSERT(exp) (void)0 ------------------ 94| 7| if (src == UPROPS_SRC_NONE) { ------------------ | Branch (94:9): [True: 0, False: 7] ------------------ 95| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 96| 0| return; 97| 0| } 98| 7| U_ASSERT(gInclusions[src].fSet == nullptr); ------------------ | | 35| 7|# define U_ASSERT(exp) (void)0 ------------------ 99| | 100| 7| LocalPointer incl(new UnicodeSet()); 101| 7| if (incl.isNull()) { ------------------ | Branch (101:9): [True: 0, False: 7] ------------------ 102| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 103| 0| return; 104| 0| } 105| 7| USetAdder sa = { 106| 7| reinterpret_cast(incl.getAlias()), 107| 7| _set_add, 108| 7| _set_addRange, 109| 7| _set_addString, 110| 7| nullptr, // don't need remove() 111| 7| nullptr // don't need removeRange() 112| 7| }; 113| | 114| 7| switch(src) { 115| 1| case UPROPS_SRC_CHAR: ------------------ | Branch (115:5): [True: 1, False: 6] ------------------ 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: 6] ------------------ 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| 1| case UPROPS_SRC_CHAR_AND_PROPSVEC: ------------------ | Branch (121:5): [True: 1, False: 6] ------------------ 122| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 123| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 124| 1| break; 125| 0|#if !UCONFIG_NO_NORMALIZATION 126| 0| case UPROPS_SRC_CASE_AND_NORM: { ------------------ | Branch (126:5): [True: 0, False: 7] ------------------ 127| 0| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 128| 0| if(U_SUCCESS(errorCode)) { ------------------ | Branch (128:12): [True: 0, False: 0] ------------------ 129| 0| impl->addPropertyStarts(&sa, errorCode); 130| 0| } 131| 0| ucase_addPropertyStarts(&sa, &errorCode); ------------------ | | 568| 0|#define ucase_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(ucase_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 132| 0| break; 133| 0| } 134| 1| case UPROPS_SRC_NFC: { ------------------ | Branch (134:5): [True: 1, False: 6] ------------------ 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: 7] ------------------ 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: 7] ------------------ 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: 7] ------------------ 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: 6] ------------------ 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: 6] ------------------ 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: 7] ------------------ 170| 0| case UPROPS_SRC_INSC: ------------------ | Branch (170:5): [True: 0, False: 7] ------------------ 171| 0| case UPROPS_SRC_VO: ------------------ | Branch (171:5): [True: 0, False: 7] ------------------ 172| 0| uprops_addPropertyStarts(src, &sa, &errorCode); ------------------ | | 1391| 0|#define uprops_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(uprops_addPropertyStarts) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 173| 0| break; 174| 0| case UPROPS_SRC_EMOJI: { ------------------ | Branch (174:5): [True: 0, False: 7] ------------------ 175| 0| const icu::EmojiProps *ep = icu::EmojiProps::getSingleton(errorCode); 176| 0| if (U_SUCCESS(errorCode)) { ------------------ | Branch (176:13): [True: 0, False: 0] ------------------ 177| 0| ep->addPropertyStarts(&sa, errorCode); 178| 0| } 179| 0| break; 180| 0| } 181| 0| case UPROPS_SRC_IDSU: ------------------ | Branch (181:5): [True: 0, False: 7] ------------------ 182| | // New in Unicode 15.1 for just two characters. 183| 0| sa.add(sa.set, 0x2FFE); 184| 0| sa.add(sa.set, 0x2FFF + 1); 185| 0| break; 186| 0| case UPROPS_SRC_ID_COMPAT_MATH: ------------------ | Branch (186:5): [True: 0, False: 7] ------------------ 187| 1| case UPROPS_SRC_MCM: ------------------ | Branch (187:5): [True: 1, False: 6] ------------------ 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: 7] ------------------ 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: 7] ------------------ 194| 0| errorCode = U_INTERNAL_PROGRAM_ERROR; 195| 0| break; 196| 7| } 197| | 198| 7| if (U_FAILURE(errorCode)) { ------------------ | Branch (198:9): [True: 0, False: 7] ------------------ 199| 0| return; 200| 0| } 201| 7| if (incl->isBogus()) { ------------------ | Branch (201:9): [True: 0, False: 7] ------------------ 202| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 203| 0| return; 204| 0| } 205| | // Compact for caching. 206| 7| incl->compact(); 207| 7| gInclusions[src].fSet = incl.orphan(); 208| 7| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); ------------------ | | 617| 7|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 209| 7|} characterproperties.cpp:_ZN12_GLOBAL__N_18_set_addEP4USeti: 60| 36.4k|_set_add(USet *set, UChar32 c) { 61| 36.4k| reinterpret_cast(set)->add(c); 62| 36.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| 23|UnicodeSet *makeSet(UProperty property, UErrorCode &errorCode) { 285| 23| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (285:9): [True: 0, False: 23] ------------------ 286| 23| LocalPointer set(new UnicodeSet()); 287| 23| if (set.isNull()) { ------------------ | Branch (287:9): [True: 0, False: 23] ------------------ 288| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 289| 0| return nullptr; 290| 0| } 291| 23| if (UCHAR_BASIC_EMOJI <= property && property <= UCHAR_RGI_EMOJI) { ------------------ | Branch (291:9): [True: 1, False: 22] | Branch (291:42): [True: 0, False: 1] ------------------ 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| 23| const UnicodeSet *inclusions = 312| 23| icu::CharacterProperties::getInclusionsForProperty(property, errorCode); 313| 23| if (U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (313:9): [True: 0, False: 23] ------------------ 314| 23| int32_t numRanges = inclusions->getRangeCount(); 315| 23| UChar32 startHasProperty = -1; 316| | 317| 48.5k| for (int32_t i = 0; i < numRanges; ++i) { ------------------ | Branch (317:25): [True: 48.5k, False: 23] ------------------ 318| 48.5k| UChar32 rangeEnd = inclusions->getRangeEnd(i); 319| 174k| for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) { ------------------ | Branch (319:56): [True: 126k, False: 48.5k] ------------------ 320| | // TODO: Get a UCharacterProperty.BinaryProperty to avoid the property dispatch. 321| 126k| if (u_hasBinaryProperty(c, property)) { ------------------ | | 292| 126k|#define u_hasBinaryProperty U_ICU_ENTRY_POINT_RENAME(u_hasBinaryProperty) | | ------------------ | | | | 123| 126k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 126k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 126k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (321:17): [True: 31.5k, False: 94.4k] ------------------ 322| 31.5k| if (startHasProperty < 0) { ------------------ | Branch (322:21): [True: 8.00k, False: 23.5k] ------------------ 323| | // Transition from false to true. 324| 8.00k| startHasProperty = c; 325| 8.00k| } 326| 94.4k| } else if (startHasProperty >= 0) { ------------------ | Branch (326:24): [True: 8.00k, False: 86.4k] ------------------ 327| | // Transition from true to false. 328| 8.00k| set->add(startHasProperty, c - 1); 329| 8.00k| startHasProperty = -1; 330| 8.00k| } 331| 126k| } 332| 48.5k| } 333| 23| if (startHasProperty >= 0) { ------------------ | Branch (333:9): [True: 0, False: 23] ------------------ 334| 0| set->add(startHasProperty, 0x10FFFF); 335| 0| } 336| 23| set->freeze(); 337| 23| return set.orphan(); 338| 23|} _ZN6icu_7824ForwardCharacterIteratorD2Ev: 14| 11.0k|ForwardCharacterIterator::~ForwardCharacterIterator() {} _ZN6icu_7824ForwardCharacterIteratorC2Ev: 16| 11.0k|: UObject() 17| 11.0k|{} _ZN6icu_7817CharacterIteratorC2Ei: 28| 11.0k|: textLength(length), pos(0), begin(0), end(length) { 29| 11.0k| if(textLength < 0) { ------------------ | Branch (29:8): [True: 0, False: 11.0k] ------------------ 30| 0| textLength = end = 0; 31| 0| } 32| 11.0k|} _ZN6icu_7817CharacterIteratoraSERKS0_: 77| 2.63k|CharacterIterator::operator=(const CharacterIterator &that) { 78| 2.63k| ForwardCharacterIterator::operator=(that); 79| 2.63k| textLength = that.textLength; 80| 2.63k| pos = that.pos; 81| 2.63k| begin = that.begin; 82| 2.63k| end = that.end; 83| 2.63k| return *this; 84| 2.63k|} _ZN6icu_7810CharString6appendEcR10UErrorCode: 113| 2|CharString &CharString::append(char c, UErrorCode &errorCode) { 114| 2| if(ensureCapacity(len+2, 0, errorCode)) { ------------------ | Branch (114:8): [True: 2, False: 0] ------------------ 115| 2| buffer[len++]=c; 116| 2| buffer[len]=0; 117| 2| } 118| 2| return *this; 119| 2|} _ZN6icu_7810CharString6appendEPKciR10UErrorCode: 121| 9|CharString &CharString::append(const char *s, int32_t sLength, UErrorCode &errorCode) { 122| 9| if(U_FAILURE(errorCode)) { ------------------ | Branch (122:8): [True: 0, False: 9] ------------------ 123| 0| return *this; 124| 0| } 125| 9| if(sLength<-1 || (s==nullptr && sLength!=0)) { ------------------ | Branch (125:8): [True: 0, False: 9] | Branch (125:23): [True: 0, False: 9] | Branch (125:37): [True: 0, False: 0] ------------------ 126| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 127| 0| return *this; 128| 0| } 129| 9| if(sLength<0) { ------------------ | Branch (129:8): [True: 0, False: 9] ------------------ 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| 9| if(sLength>0) { ------------------ | Branch (132:8): [True: 9, False: 0] ------------------ 133| 9| if(s==(buffer.getAlias()+len)) { ------------------ | Branch (133:12): [True: 0, False: 9] ------------------ 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| 9| } else if(buffer.getAlias()<=s && s<(buffer.getAlias()+len) && ------------------ | Branch (141:19): [True: 2, False: 7] | Branch (141:43): [True: 0, False: 2] ------------------ 142| 9| sLength>=(buffer.getCapacity()-len) ------------------ | Branch (142:19): [True: 0, False: 0] ------------------ 143| 9| ) { 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| 9| } else if(ensureCapacity(len+sLength+1, 0, errorCode)) { ------------------ | Branch (147:19): [True: 9, False: 0] ------------------ 148| 9| uprv_memcpy(buffer.getAlias()+len, s, sLength); ------------------ | | 42| 9|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 9|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 9| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 9| _Pragma("clang diagnostic push") \ | | 45| 9| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 9| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 9|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 9| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 9|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 9| _Pragma("clang diagnostic pop") \ | | 49| 9| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 9|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 9|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 9|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 149| 9| buffer[len+=sLength]=0; 150| 9| } 151| 9| } 152| 9| return *this; 153| 9|} _ZN6icu_7810CharString20appendInvariantCharsERKNS_13UnicodeStringER10UErrorCode: 208| 316k|CharString &CharString::appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode) { 209| 316k| return appendInvariantChars(s.getBuffer(), s.length(), errorCode); 210| 316k|} _ZN6icu_7810CharString20appendInvariantCharsEPKDsiR10UErrorCode: 212| 316k|CharString &CharString::appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode &errorCode) { 213| 316k| if(U_FAILURE(errorCode)) { ------------------ | Branch (213:8): [True: 0, False: 316k] ------------------ 214| 0| return *this; 215| 0| } 216| 316k| if (!uprv_isInvariantUString(uchars, ucharsLen)) { ------------------ | | 1518| 316k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 316k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 316k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 316k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (216:9): [True: 0, False: 316k] ------------------ 217| 0| errorCode = U_INVARIANT_CONVERSION_ERROR; 218| 0| return *this; 219| 0| } 220| 316k| if(ensureCapacity(len+ucharsLen+1, 0, errorCode)) { ------------------ | Branch (220:8): [True: 316k, False: 0] ------------------ 221| 316k| u_UCharsToChars(uchars, buffer.getAlias()+len, ucharsLen); ------------------ | | 211| 316k|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 123| 316k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 316k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 316k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 222| 316k| len += ucharsLen; 223| 316k| buffer[len] = 0; 224| 316k| } 225| 316k| return *this; 226| 316k|} _ZN6icu_7810CharString14ensureCapacityEiiR10UErrorCode: 230| 316k| UErrorCode &errorCode) { 231| 316k| if(U_FAILURE(errorCode)) { ------------------ | Branch (231:8): [True: 0, False: 316k] ------------------ 232| 0| return false; 233| 0| } 234| 316k| if(capacity>buffer.getCapacity()) { ------------------ | Branch (234:8): [True: 1.49k, False: 314k] ------------------ 235| 1.49k| if(desiredCapacityHint==0) { ------------------ | Branch (235:12): [True: 1.49k, False: 0] ------------------ 236| 1.49k| desiredCapacityHint=capacity+buffer.getCapacity(); 237| 1.49k| } 238| 1.49k| if( (desiredCapacityHint<=capacity || buffer.resize(desiredCapacityHint, len+1)==nullptr) && ------------------ | Branch (238:14): [True: 0, False: 1.49k] | Branch (238:47): [True: 0, False: 1.49k] ------------------ 239| 1.49k| buffer.resize(capacity, len+1)==nullptr ------------------ | Branch (239:13): [True: 0, False: 0] ------------------ 240| 1.49k| ) { 241| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 242| 0| return false; 243| 0| } 244| 1.49k| } 245| 316k| return true; 246| 316k|} _ZN6icu_7810CharString4dataEv: 85| 264k| char *data() { return buffer.getAlias(); } _ZN6icu_7810CharStringD2Ev: 56| 316k| ~CharString() {} _ZN6icu_7810CharString6appendENS_11StringPieceER10UErrorCode: 131| 7| CharString &append(StringPiece s, UErrorCode &errorCode) { 132| 7| return append(s.data(), s.length(), errorCode); 133| 7| } _ZN6icu_7810CharStringC2Ev: 43| 316k| CharString() : len(0) { buffer[0]=0; } _ZNK6icu_7810CharString7isEmptyEv: 79| 1| UBool isEmpty() const { return len==0; } _ZNK6icu_7810CharString6lengthEv: 80| 3| int32_t length() const { return len; } _ZNK6icu_7810CharString4dataEv: 84| 2| const char *data() const { return buffer.getAlias(); } _ZN6icu_7810CharString6appendERKS0_R10UErrorCode: 134| 2| CharString &append(const CharString &s, UErrorCode &errorCode) { 135| 2| return append(s.data(), s.length(), errorCode); 136| 2| } uprv_malloc_78: 45| 88.2M|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| 88.2M| if (s > 0) { ------------------ | Branch (54:9): [True: 88.2M, False: 0] ------------------ 55| 88.2M| if (pAlloc) { ------------------ | Branch (55:13): [True: 0, False: 88.2M] ------------------ 56| 0| return (*pAlloc)(pContext, s); 57| 88.2M| } else { 58| 88.2M| return uprv_default_malloc(s); ------------------ | | 615| 88.2M|# define uprv_default_malloc(x) malloc(x) ------------------ 59| 88.2M| } 60| 88.2M| } else { 61| 0| return (void *)zeroMem; 62| 0| } 63| 88.2M|} uprv_realloc_78: 66| 3.23M|uprv_realloc(void * buffer, size_t size) { 67| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 68| | putchar('~'); 69| | fflush(stdout); 70| |#endif 71| 3.23M| if (buffer == zeroMem) { ------------------ | Branch (71:9): [True: 0, False: 3.23M] ------------------ 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| 3.23M| } else if (size == 0) { ------------------ | Branch (73:16): [True: 0, False: 3.23M] ------------------ 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| 3.23M| } else { 81| 3.23M| if (pRealloc) { ------------------ | Branch (81:13): [True: 0, False: 3.23M] ------------------ 82| 0| return (*pRealloc)(pContext, buffer, size); 83| 3.23M| } else { 84| 3.23M| return uprv_default_realloc(buffer, size); ------------------ | | 616| 3.23M|# define uprv_default_realloc(x,y) realloc(x,y) ------------------ 85| 3.23M| } 86| 3.23M| } 87| 3.23M|} uprv_free_78: 90| 88.9M|uprv_free(void *buffer) { 91| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 92| | putchar('<'); 93| | fflush(stdout); 94| |#endif 95| 88.9M| if (buffer != zeroMem) { ------------------ | Branch (95:9): [True: 88.9M, False: 0] ------------------ 96| 88.9M| if (pFree) { ------------------ | Branch (96:13): [True: 0, False: 88.9M] ------------------ 97| 0| (*pFree)(pContext, buffer); 98| 88.9M| } else { 99| 88.9M| uprv_default_free(buffer); ------------------ | | 617| 88.9M|# define uprv_default_free(x) free(x) ------------------ 100| 88.9M| } 101| 88.9M| } 102| 88.9M|} _ZN6icu_7815MaybeStackArrayIcLi40EEC2Ev: 344| 316k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7815MaybeStackArrayIcLi40EED2Ev: 363| 316k| ~MaybeStackArray() { releaseArray(); } _ZNK6icu_7815MaybeStackArrayIcLi40EE11getCapacityEv: 376| 317k| int32_t getCapacity() const { return capacity; } _ZNK6icu_7815MaybeStackArrayIcLi40EE8getAliasEv: 381| 581k| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayIcLi40EEixEl: 402| 632k| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EE6resizeEii: 505| 1.49k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 1.49k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 1.49k, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 1.49k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 1.49k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.49k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.49k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.49k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 1.49k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 1.49k, False: 0] ------------------ 512| 1.49k| if(length>0) { ------------------ | Branch (512:16): [True: 1.49k, False: 0] ------------------ 513| 1.49k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 1.49k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 1.49k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 1.49k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 1.49k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 1.49k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.49k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.49k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.49k| _Pragma("clang diagnostic push") \ | | 45| 1.49k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.49k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.49k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.49k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.49k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.49k| _Pragma("clang diagnostic pop") \ | | 49| 1.49k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.49k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.49k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.49k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 1.49k| } 521| 1.49k| releaseArray(); 522| 1.49k| ptr=p; 523| 1.49k| capacity=newCapacity; 524| 1.49k| needToRelease=true; 525| 1.49k| } 526| 1.49k| return p; 527| 1.49k| } else { 528| 0| return nullptr; 529| 0| } 530| 1.49k|} _ZN6icu_7815MaybeStackArrayIcLi40EE12releaseArrayEv: 458| 317k| void releaseArray() { 459| 317k| if(needToRelease) { ------------------ | Branch (459:12): [True: 1.49k, False: 316k] ------------------ 460| 1.49k| uprv_free(ptr); ------------------ | | 1503| 1.49k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.49k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.49k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.49k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1.49k| } 462| 317k| } _ZN6icu_7811LocalMemoryINS_14RBBIDataHeaderEEC2EPS1_: 195| 2.63k| explicit LocalMemory(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7811LocalMemoryINS_14RBBIDataHeaderEED2Ev: 206| 2.63k| ~LocalMemory() { 207| 2.63k| uprv_free(LocalPointerBase::ptr); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 2.63k| } _ZN6icu_7815MaybeStackArrayIPvLi16EEC2Ev: 344| 15.3M| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7815MaybeStackArrayIPvLi16EED2Ev: 363| 15.3M| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayIPvLi16EE12releaseArrayEv: 458| 19.8M| void releaseArray() { 459| 19.8M| if(needToRelease) { ------------------ | Branch (459:12): [True: 4.52M, False: 15.3M] ------------------ 460| 4.52M| uprv_free(ptr); ------------------ | | 1503| 4.52M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 4.52M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.52M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.52M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 4.52M| } 462| 19.8M| } _ZNK6icu_7815MaybeStackArrayIPvLi16EE11getCapacityEv: 376| 15.3M| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIPvLi16EE6resizeEii: 505| 4.52M|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 4.52M| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 4.52M, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 4.52M| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 4.52M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4.52M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.52M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.52M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 4.52M| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 4.52M, False: 0] ------------------ 512| 4.52M| if(length>0) { ------------------ | Branch (512:16): [True: 0, False: 4.52M] ------------------ 513| 0| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 0] ------------------ 514| 0| length=capacity; 515| 0| } 516| 0| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 0] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 0| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 520| 0| } 521| 4.52M| releaseArray(); 522| 4.52M| ptr=p; 523| 4.52M| capacity=newCapacity; 524| 4.52M| needToRelease=true; 525| 4.52M| } 526| 4.52M| return p; 527| 4.52M| } else { 528| 0| return nullptr; 529| 0| } 530| 4.52M|} _ZNK6icu_7815MaybeStackArrayIPvLi16EE8getAliasEv: 381| 15.3M| T *getAlias() const { return ptr; } 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| 24.6k|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| 24.6k| if('a'<=c && c<='z') { ------------------ | Branch (69:8): [True: 15.5k, False: 9.07k] | Branch (69:18): [True: 15.2k, False: 377] ------------------ 70| 15.2k| c=(char)(c+('A'-'a')); 71| 15.2k| } 72| 24.6k|#endif 73| 24.6k| return c; 74| 24.6k|} uprv_asciitolower_78: 103| 570k|uprv_asciitolower(char c) { 104| 570k| if(0x41<=c && c<=0x5a) { ------------------ | Branch (104:8): [True: 554k, False: 16.4k] | Branch (104:19): [True: 414k, False: 139k] ------------------ 105| 414k| c=(char)(c+0x20); 106| 414k| } 107| 570k| return c; 108| 570k|} _ZN6icu_7811LocaleBased12setLocaleIDsEPKNS_10CharStringES3_R10UErrorCode: 42| 2.63k|void LocaleBased::setLocaleIDs(const CharString* validID, const CharString* actualID, UErrorCode& status) { 43| 2.63k| setValidLocaleID(validID, status); 44| 2.63k| setActualLocaleID(actualID,status); 45| 2.63k|} _ZN6icu_7811LocaleBased11setLocaleIDEPKNS_10CharStringERPS1_R10UErrorCode: 69| 7.90k|void LocaleBased::setLocaleID(const CharString* id, CharString*& dest, UErrorCode& status) { 70| 7.90k| if (U_FAILURE(status)) { return; } ------------------ | Branch (70:9): [True: 0, False: 7.90k] ------------------ 71| 7.90k| if (id == nullptr || id->isEmpty()) { ------------------ | Branch (71:9): [True: 7.90k, False: 0] | Branch (71:26): [True: 0, False: 0] ------------------ 72| 7.90k| delete dest; 73| 7.90k| dest = nullptr; 74| 7.90k| } else { 75| 0| if (dest == nullptr) { ------------------ | Branch (75:13): [True: 0, False: 0] ------------------ 76| 0| dest = new CharString(*id, status); 77| 0| if (dest == nullptr) { ------------------ | Branch (77:17): [True: 0, False: 0] ------------------ 78| 0| status = U_MEMORY_ALLOCATION_ERROR; 79| 0| return; 80| 0| } 81| 0| } else { 82| 0| dest->copyFrom(*id, status); 83| 0| } 84| 0| } 85| 7.90k|} _ZN6icu_7811LocaleBasedC2ERPNS_10CharStringES3_: 101| 2.63k| valid(validAlias), actual(actualAlias) { 102| 2.63k|} _ZN6icu_7811LocaleBased16setValidLocaleIDEPKNS_10CharStringER10UErrorCode: 104| 2.63k|inline void LocaleBased::setValidLocaleID(const CharString* id, UErrorCode& status) { 105| 2.63k| setLocaleID(id, valid, status); 106| 2.63k|} _ZN6icu_7811LocaleBased17setActualLocaleIDEPKNS_10CharStringER10UErrorCode: 107| 2.63k|inline void LocaleBased::setActualLocaleID(const CharString* id, UErrorCode& status) { 108| 2.63k| setLocaleID(id, actual, status); 109| 2.63k|} _ZN6icu_785MutexC2EPNS_6UMutexE: 58| 4.35k| Mutex(UMutex *mutex = nullptr) : fMutex(mutex) { 59| 4.35k| umtx_lock(fMutex); ------------------ | | 1250| 4.35k|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 4.35k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.35k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.35k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 60| 4.35k| } _ZN6icu_785MutexD2Ev: 61| 4.35k| ~Mutex() { 62| 4.35k| umtx_unlock(fMutex); ------------------ | | 1251| 4.35k|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 4.35k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.35k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.35k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 4.35k| } _ZN6icu_7819Normalizer2WithImplC2ERKNS_15Normalizer2ImplE: 34| 4| Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {} _ZNK6icu_7819Normalizer2WithImpl17getCombiningClassEi: 145| 2.45M| getCombiningClass(UChar32 c) const override { 146| 2.45M| return impl.getCC(impl.getNorm16(c)); 147| 2.45M| } _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| 6.23M|Norm2AllModes::getNFCInstance(UErrorCode &errorCode) { 257| 6.23M| if(U_FAILURE(errorCode)) { return nullptr; } ------------------ | Branch (257:8): [True: 0, False: 6.23M] ------------------ 258| 6.23M| umtx_initOnce(nfcInitOnce, &initNFCSingleton, errorCode); 259| 6.23M| return nfcSingleton; 260| 6.23M|} _ZN6icu_7811Normalizer214getNFDInstanceER10UErrorCode: 269| 2.45M|Normalizer2::getNFDInstance(UErrorCode &errorCode) { 270| 2.45M| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 271| 2.45M| return allModes!=nullptr ? &allModes->decomp : nullptr; ------------------ | Branch (271:12): [True: 2.45M, False: 0] ------------------ 272| 2.45M|} _ZN6icu_7818Normalizer2Factory10getNFCImplER10UErrorCode: 285| 3.78M|Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) { 286| 3.78M| const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode); 287| 3.78M| return allModes!=nullptr ? allModes->impl : nullptr; ------------------ | Branch (287:12): [True: 3.78M, False: 0] ------------------ 288| 3.78M|} u_getCombiningClass_78: 551| 2.45M|u_getCombiningClass(UChar32 c) { 552| 2.45M| UErrorCode errorCode=U_ZERO_ERROR; 553| 2.45M| const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode); 554| 2.45M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (554:8): [True: 2.45M, False: 0] ------------------ 555| 2.45M| return nfd->getCombiningClass(c); 556| 2.45M| } else { 557| 0| return 0; 558| 0| } 559| 2.45M|} unorm_getFCD16_78: 562| 3.78M|unorm_getFCD16(UChar32 c) { 563| 3.78M| UErrorCode errorCode=U_ZERO_ERROR; 564| 3.78M| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 565| 3.78M| if(U_SUCCESS(errorCode)) { ------------------ | Branch (565:8): [True: 3.78M, False: 0] ------------------ 566| 3.78M| return impl->getFCD16(c); 567| 3.78M| } else { 568| 0| return 0; 569| 0| } 570| 3.78M|} 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| 1|Normalizer2Impl::addPropertyStarts(const USetAdder *sa, UErrorCode & /*errorCode*/) const { 482| | // Add the start code point of each same-value range of the trie. 483| 1| UChar32 start = 0, end; 484| 1| uint32_t value; 485| 4.01k| while ((end = ucptrie_getRange(normTrie, start, UCPMAP_RANGE_FIXED_LEAD_SURROGATES, INERT, ------------------ | | 806| 4.01k|#define ucptrie_getRange U_ICU_ENTRY_POINT_RENAME(ucptrie_getRange) | | ------------------ | | | | 123| 4.01k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.01k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.01k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (485:12): [True: 4.00k, False: 1] ------------------ 486| 4.01k| nullptr, nullptr, &value)) >= 0) { 487| 4.00k| sa->add(sa->set, start); 488| 4.00k| if (start != end && isAlgorithmicNoNo(static_cast(value)) && ------------------ | Branch (488:13): [True: 934, False: 3.07k] | Branch (488:29): [True: 1, False: 933] ------------------ 489| 4.00k| (value & Normalizer2Impl::DELTA_TCCC_MASK) > Normalizer2Impl::DELTA_TCCC_1) { ------------------ | Branch (489:17): [True: 0, False: 1] ------------------ 490| | // Range of code points with same-norm16-value algorithmic decompositions. 491| | // They might have different non-zero FCD16 values. 492| 0| uint16_t prevFCD16 = getFCD16(start); 493| 0| while (++start <= end) { ------------------ | Branch (493:20): [True: 0, False: 0] ------------------ 494| 0| uint16_t fcd16 = getFCD16(start); 495| 0| if (fcd16 != prevFCD16) { ------------------ | Branch (495:21): [True: 0, False: 0] ------------------ 496| 0| sa->add(sa->set, start); 497| 0| prevFCD16 = fcd16; 498| 0| } 499| 0| } 500| 0| } 501| 4.00k| start = end + 1; 502| 4.00k| } 503| | 504| | /* add Hangul LV syllables and LV+1 because of skippables */ 505| 400| for(char16_t c=Hangul::HANGUL_BASE; cadd(sa->set, c); 507| 399| sa->add(sa->set, c+1); 508| 399| } 509| 1| sa->add(sa->set, Hangul::HANGUL_LIMIT); /* add Hangul+1 to continue with other properties */ 510| 1|} _ZNK6icu_7815Normalizer2Impl20getFCD16FromNormDataEi: 2248| 3.72M|uint16_t Normalizer2Impl::getFCD16FromNormData(UChar32 c) const { 2249| 3.72M| uint16_t norm16=getNorm16(c); 2250| 3.72M| if (norm16 >= limitNoNo) { ------------------ | Branch (2250:9): [True: 2.38M, False: 1.34M] ------------------ 2251| 2.38M| if(norm16>=MIN_NORMAL_MAYBE_YES) { ------------------ | Branch (2251:12): [True: 2.38M, False: 32] ------------------ 2252| | // combining mark 2253| 2.38M| norm16=getCCFromNormalYesOrMaybe(norm16); 2254| 2.38M| return norm16|(norm16<<8); 2255| 2.38M| } 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| 2.38M| } 2267| 1.34M| if(norm16<=minYesNo || isHangulLVT(norm16)) { ------------------ | Branch (2267:8): [True: 1.18M, False: 159k] | Branch (2267:28): [True: 0, False: 159k] ------------------ 2268| | // no decomposition or Hangul syllable, all zeros 2269| 1.18M| return 0; 2270| 1.18M| } 2271| | // c decomposes, get everything from the variable-length extra data 2272| 159k| const uint16_t *mapping=getData(norm16); 2273| 159k| uint16_t firstUnit=*mapping; 2274| 159k| norm16=firstUnit>>8; // tccc 2275| 159k| if(firstUnit&MAPPING_HAS_CCC_LCCC_WORD) { ------------------ | Branch (2275:8): [True: 16.8k, False: 142k] ------------------ 2276| 16.8k| norm16|=*(mapping-1)&0xff00; // lccc 2277| 16.8k| } 2278| 159k| return norm16; 2279| 1.34M|} _ZN6icu_7815Normalizer2ImplC2Ev: 248| 1| Normalizer2Impl() : normTrie(nullptr), fCanonIterData(nullptr) {} _ZNK6icu_7815Normalizer2Impl9getNorm16Ei: 264| 6.18M| uint16_t getNorm16(UChar32 c) const { 265| 6.18M| return U_IS_LEAD(c) ? ------------------ | | 177| 6.18M|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 0, False: 6.18M] | | ------------------ ------------------ 266| 0| static_cast(INERT) : 267| 6.18M| UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); ------------------ | | 358| 6.18M|#define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c)) | | ------------------ | | | | 267| 6.18M| UCPTRIE_FAST_GET(normTrie, UCPTRIE_16, c); | | | | ------------------ | | | | | | 326| 19.4M|#define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i]) | | | | | | ------------------ | | | | | | | Branch (326:49): [True: 0, False: 1.76M] | | | | | | | Branch (326:49): [True: 1.76M, False: 0] | | | | | | | Branch (326:49): [True: 4.42M, False: 1.76M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 268| 6.18M| } _ZNK6icu_7815Normalizer2Impl17isAlgorithmicNoNoEt: 280| 934| UBool isAlgorithmicNoNo(uint16_t norm16) const { return limitNoNo<=norm16 && norm16=MIN_NORMAL_MAYBE_YES) { ------------------ | Branch (285:12): [True: 1.63M, False: 817k] ------------------ 286| 1.63M| return getCCFromNormalYesOrMaybe(norm16); 287| 1.63M| } 288| 817k| if(norm16(norm16 >> OFFSET_SHIFT); 295| 4.02M| } _ZNK6icu_7815Normalizer2Impl8getFCD16Ei: 309| 3.78M| uint16_t getFCD16(UChar32 c) const { 310| 3.78M| if(c>8]; 366| 2.72M| if(bits==0) { return false; } ------------------ | Branch (366:12): [True: 8.60k, False: 2.71M] ------------------ 367| 2.71M| return (bits >> ((lead >> 5) & 7)) & 1; 368| 2.72M| } _ZNK6icu_7815Normalizer2Impl9hangulLVTEv: 568| 159k| uint16_t hangulLVT() const { return minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER; } _ZNK6icu_7815Normalizer2Impl11isHangulLVTEt: 570| 159k| UBool isHangulLVT(uint16_t norm16) const { 571| 159k| return norm16==hangulLVT(); 572| 159k| } _ZNK6icu_7815Normalizer2Impl13getCCFromNoNoEt: 603| 17.7k| uint8_t getCCFromNoNo(uint16_t norm16) const { 604| 17.7k| const uint16_t *mapping=getDataForYesOrNo(norm16); 605| 17.7k| if(*mapping&MAPPING_HAS_CCC_LCCC_WORD) { ------------------ | Branch (605:12): [True: 12.4k, False: 5.25k] ------------------ 606| 12.4k| return static_cast(*(mapping - 1)); 607| 12.4k| } else { 608| 5.25k| return 0; 609| 5.25k| } 610| 17.7k| } _ZNK6icu_7815Normalizer2Impl17getDataForYesOrNoEt: 631| 17.7k| const uint16_t *getDataForYesOrNo(uint16_t norm16) const { 632| 17.7k| return extraData+(norm16>>OFFSET_SHIFT); 633| 17.7k| } _ZNK6icu_7815Normalizer2Impl7getDataEt: 637| 159k| const uint16_t *getData(uint16_t norm16) const { 638| 159k| if(norm16>=minMaybeNo) { ------------------ | Branch (638:12): [True: 24, False: 159k] ------------------ 639| 24| norm16=norm16-minMaybeNo+limitNoNo; 640| 24| } 641| 159k| return extraData+(norm16>>OFFSET_SHIFT); 642| 159k| } _ZN6icu_7813ParsePositionD2Ev: 16| 212k|ParsePosition::~ParsePosition() {} _ZN6icu_7812PatternProps12isWhiteSpaceEi: 155| 198M|PatternProps::isWhiteSpace(UChar32 c) { 156| 198M| if(c<0) { ------------------ | Branch (156:8): [True: 34.7k, False: 198M] ------------------ 157| 34.7k| return false; 158| 198M| } else if(c<=0xff) { ------------------ | Branch (158:15): [True: 73.2M, False: 125M] ------------------ 159| 73.2M| return (latin1[c] >> 2) & 1; 160| 125M| } else if(0x200e<=c && c<=0x2029) { ------------------ | Branch (160:15): [True: 92.5M, False: 32.9M] | Branch (160:28): [True: 5.66k, False: 92.5M] ------------------ 161| 5.66k| return c<=0x200f || 0x2028<=c; ------------------ | Branch (161:16): [True: 1.10k, False: 4.55k] | Branch (161:29): [True: 2.50k, False: 2.05k] ------------------ 162| 125M| } else { 163| 125M| return false; 164| 125M| } 165| 198M|} _ZN6icu_7812PatternProps14skipWhiteSpaceEPKDsi: 168| 192k|PatternProps::skipWhiteSpace(const char16_t *s, int32_t length) { 169| 193k| while(length>0 && isWhiteSpace(*s)) { ------------------ | Branch (169:11): [True: 159k, False: 33.6k] | Branch (169:23): [True: 1.19k, False: 158k] ------------------ 170| 1.19k| ++s; 171| 1.19k| --length; 172| 1.19k| } 173| 192k| return s; 174| 192k|} uprv_compareASCIIPropertyNames_78: 93| 15.8k|uprv_compareASCIIPropertyNames(const char *name1, const char *name2) { 94| 15.8k| int32_t rc, r1, r2; 95| | 96| 62.1k| for(;;) { 97| 62.1k| r1=getASCIIPropertyNameChar(name1); 98| 62.1k| r2=getASCIIPropertyNameChar(name2); 99| | 100| | /* If we reach the ends of both strings then they match */ 101| 62.1k| if(((r1|r2)&0xff)==0) { ------------------ | Branch (101:12): [True: 14.8k, False: 47.2k] ------------------ 102| 14.8k| return 0; 103| 14.8k| } 104| | 105| | /* Compare the lowercased characters */ 106| 47.2k| if(r1!=r2) { ------------------ | Branch (106:12): [True: 1.25k, False: 46.0k] ------------------ 107| 1.25k| rc=(r1&0xff)-(r2&0xff); 108| 1.25k| if(rc!=0) { ------------------ | Branch (108:16): [True: 990, False: 264] ------------------ 109| 990| return rc; 110| 990| } 111| 1.25k| } 112| | 113| 46.2k| name1+=r1>>8; 114| 46.2k| name2+=r2>>8; 115| 46.2k| } 116| 15.8k|} _ZN6icu_7812PropNameData12findPropertyEi: 148| 171k|int32_t PropNameData::findProperty(int32_t property) { 149| 171k| int32_t i=1; // valueMaps index, initially after numRanges 150| 468k| for(int32_t numRanges=valueMaps[0]; numRanges>0; --numRanges) { ------------------ | Branch (150:41): [True: 468k, False: 0] ------------------ 151| | // Read and skip the start and limit of this range. 152| 468k| int32_t start=valueMaps[i]; 153| 468k| int32_t limit=valueMaps[i+1]; 154| 468k| i+=2; 155| 468k| if(property(c)); 235| 392k| } 236| 181k| return USTRINGTRIE_HAS_VALUE(result); ------------------ | | 86| 181k|#define USTRINGTRIE_HAS_VALUE(result) ((result)>=USTRINGTRIE_FINAL_VALUE) ------------------ 237| 223k|} _ZN6icu_7812PropNameData22getPropertyOrValueEnumEiPKc: 259| 223k|int32_t PropNameData::getPropertyOrValueEnum(int32_t bytesTrieOffset, const char *alias) { 260| 223k| BytesTrie trie(bytesTries+bytesTrieOffset); 261| 223k| if(containsName(trie, alias)) { ------------------ | Branch (261:8): [True: 151k, False: 72.7k] ------------------ 262| 151k| return trie.getValue(); 263| 151k| } else { 264| 72.7k| return UCHAR_INVALID_CODE; 265| 72.7k| } 266| 223k|} _ZN6icu_7812PropNameData15getPropertyEnumEPKc: 268| 52.2k|int32_t PropNameData::getPropertyEnum(const char *alias) { 269| 52.2k| return getPropertyOrValueEnum(0, alias); 270| 52.2k|} _ZN6icu_7812PropNameData20getPropertyValueEnumEiPKc: 272| 171k|int32_t PropNameData::getPropertyValueEnum(int32_t property, const char *alias) { 273| 171k| int32_t valueMapIndex=findProperty(property); 274| 171k| if(valueMapIndex==0) { ------------------ | Branch (274:8): [True: 0, False: 171k] ------------------ 275| 0| return UCHAR_INVALID_CODE; // Not a known property. 276| 0| } 277| 171k| valueMapIndex=valueMaps[valueMapIndex+1]; 278| 171k| if(valueMapIndex==0) { ------------------ | Branch (278:8): [True: 0, False: 171k] ------------------ 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| 171k| return getPropertyOrValueEnum(valueMaps[valueMapIndex], alias); 284| 171k|} u_getPropertyEnum_78: 301| 52.2k|u_getPropertyEnum(const char* alias) { 302| 52.2k| U_NAMESPACE_USE ------------------ | | 112| 52.2k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 303| 52.2k| return (UProperty)PropNameData::getPropertyEnum(alias); 304| 52.2k|} u_getPropertyValueEnum_78: 319| 171k| const char* alias) { 320| 171k| U_NAMESPACE_USE ------------------ | | 112| 171k|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 321| 171k| return PropNameData::getPropertyValueEnum(property, alias); 322| 171k|} propname.cpp:_ZL24getASCIIPropertyNameCharPKc: 35| 124k|getASCIIPropertyNameChar(const char *name) { 36| 124k| int32_t i; 37| 124k| char c; 38| | 39| | /* Ignore delimiters '-', '_', and ASCII White_Space */ 40| 124k| for(i=0; 41| 135k| (c=name[i++])==0x2d || c==0x5f || ------------------ | Branch (41:9): [True: 9.50k, False: 125k] | Branch (41:32): [True: 702, False: 124k] ------------------ 42| 135k| c==0x20 || (0x09<=c && c<=0x0d); ------------------ | Branch (42:9): [True: 243, False: 124k] | Branch (42:21): [True: 94.7k, False: 29.8k] | Branch (42:32): [True: 320, False: 94.4k] ------------------ 43| 124k| ) {} 44| | 45| 124k| if(c!=0) { ------------------ | Branch (45:8): [True: 94.4k, False: 29.8k] ------------------ 46| 94.4k| return (i << 8) | static_cast(uprv_asciitolower(c)); ------------------ | | 1397| 94.4k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | ------------------ | | | | 123| 94.4k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 94.4k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 94.4k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 47| 94.4k| } else { 48| 29.8k| return i<<8; 49| 29.8k| } 50| 124k|} uprv_add32_overflow_78: 524| 286k|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| 286k| auto a64 = static_cast(a); 528| 286k| auto b64 = static_cast(b); 529| 286k| int64_t res64 = a64 + b64; 530| 286k| *res = static_cast(res64); 531| 286k| return res64 != *res; 532| 286k|} 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| 1|u_getDataDirectory() { 1500| 1| umtx_initOnce(gDataDirInitOnce, &dataDirectoryInitFn); 1501| 1| return gDataDirectory; 1502| 1|} 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_7822RuleBasedBreakIteratorC2EPNS_14RBBIDataHeaderER10UErrorCode: 66| 2.63k| : RuleBasedBreakIterator(&status) 67| 2.63k|{ 68| 2.63k| fData = new RBBIDataWrapper(data, status); // status checked in constructor 69| 2.63k| if (U_FAILURE(status)) {return;} ------------------ | Branch (69:9): [True: 0, False: 2.63k] ------------------ 70| 2.63k| if(fData == nullptr) { ------------------ | Branch (70:8): [True: 0, False: 2.63k] ------------------ 71| 0| status = U_MEMORY_ALLOCATION_ERROR; 72| 0| return; 73| 0| } 74| 2.63k| if (fData->fForwardTable->fLookAheadResultsSize > 0) { ------------------ | Branch (74:9): [True: 240, False: 2.39k] ------------------ 75| 240| fLookAheadMatches = static_cast( 76| 240| uprv_malloc(fData->fForwardTable->fLookAheadResultsSize * sizeof(int32_t))); ------------------ | | 1524| 240|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 240|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 240|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 240|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 77| 240| if (fLookAheadMatches == nullptr) { ------------------ | Branch (77:13): [True: 0, False: 240] ------------------ 78| 0| status = U_MEMORY_ALLOCATION_ERROR; 79| 0| return; 80| 0| } 81| 240| } 82| 2.63k|} _ZN6icu_7822RuleBasedBreakIteratorC2ERKNS_13UnicodeStringER11UParseErrorR10UErrorCode: 170| 8.41k| : RuleBasedBreakIterator(&status) 171| 8.41k|{ 172| 8.41k| if (U_FAILURE(status)) {return;} ------------------ | Branch (172:9): [True: 0, False: 8.41k] ------------------ 173| 8.41k| RuleBasedBreakIterator *bi = (RuleBasedBreakIterator *) 174| 8.41k| RBBIRuleBuilder::createRuleBasedBreakIterator(rules, &parseError, status); 175| | // Note: This is a bit awkward. The RBBI ruleBuilder has a factory method that 176| | // creates and returns a complete RBBI. From here, in a constructor, we 177| | // can't just return the object created by the builder factory, hence 178| | // the assignment of the factory created object to "this". 179| 8.41k| if (U_SUCCESS(status)) { ------------------ | Branch (179:9): [True: 2.63k, False: 5.77k] ------------------ 180| 2.63k| *this = *bi; 181| 2.63k| delete bi; 182| 2.63k| } 183| 8.41k|} _ZN6icu_7822RuleBasedBreakIteratorC2EP10UErrorCode: 201| 11.0k|RuleBasedBreakIterator::RuleBasedBreakIterator(UErrorCode *status) { 202| 11.0k| UErrorCode ec = U_ZERO_ERROR; 203| 11.0k| if (status == nullptr) { ------------------ | Branch (203:9): [True: 0, False: 11.0k] ------------------ 204| 0| status = &ec; 205| 0| } 206| 11.0k| utext_openUChars(&fText, nullptr, 0, status); ------------------ | | 1909| 11.0k|#define utext_openUChars U_ICU_ENTRY_POINT_RENAME(utext_openUChars) | | ------------------ | | | | 123| 11.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 207| 11.0k| LocalPointer lpDictionaryCache(new DictionaryCache(this, *status), *status); 208| 11.0k| LocalPointer lpBreakCache(new BreakCache(this, *status), *status); 209| 11.0k| if (U_FAILURE(*status)) { ------------------ | Branch (209:9): [True: 0, False: 11.0k] ------------------ 210| 0| fErrorCode = *status; 211| 0| return; 212| 0| } 213| 11.0k| fDictionaryCache = lpDictionaryCache.orphan(); 214| 11.0k| fBreakCache = lpBreakCache.orphan(); 215| | 216| |#ifdef RBBI_DEBUG 217| | static UBool debugInitDone = false; 218| | if (debugInitDone == false) { 219| | char *debugEnv = getenv("U_RBBIDEBUG"); 220| | if (debugEnv && uprv_strstr(debugEnv, "trace")) { 221| | gTrace = true; 222| | } 223| | debugInitDone = true; 224| | } 225| |#endif 226| 11.0k|} _ZN6icu_7822RuleBasedBreakIteratorD2Ev: 245| 11.0k|RuleBasedBreakIterator::~RuleBasedBreakIterator() { 246| 11.0k| if (fCharIter != &fSCharIter) { ------------------ | Branch (246:9): [True: 0, False: 11.0k] ------------------ 247| | // fCharIter was adopted from the outside. 248| 0| delete fCharIter; 249| 0| } 250| 11.0k| fCharIter = nullptr; 251| | 252| 11.0k| utext_close(&fText); ------------------ | | 1891| 11.0k|#define utext_close U_ICU_ENTRY_POINT_RENAME(utext_close) | | ------------------ | | | | 123| 11.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 253| | 254| 11.0k| if (fData != nullptr) { ------------------ | Branch (254:9): [True: 5.27k, False: 5.77k] ------------------ 255| 5.27k| fData->removeReference(); 256| 5.27k| fData = nullptr; 257| 5.27k| } 258| 11.0k| delete fBreakCache; 259| 11.0k| fBreakCache = nullptr; 260| | 261| 11.0k| delete fDictionaryCache; 262| 11.0k| fDictionaryCache = nullptr; 263| | 264| 11.0k| delete fLanguageBreakEngines; 265| 11.0k| fLanguageBreakEngines = nullptr; 266| | 267| 11.0k| delete fUnhandledBreakEngine; 268| 11.0k| fUnhandledBreakEngine = nullptr; 269| | 270| 11.0k| uprv_free(fLookAheadMatches); ------------------ | | 1503| 11.0k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 11.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 271| 11.0k| fLookAheadMatches = nullptr; 272| 11.0k|} _ZN6icu_7822RuleBasedBreakIteratoraSERKS0_: 280| 2.63k|RuleBasedBreakIterator::operator=(const RuleBasedBreakIterator& that) { 281| 2.63k| if (this == &that) { ------------------ | Branch (281:9): [True: 0, False: 2.63k] ------------------ 282| 0| return *this; 283| 0| } 284| 2.63k| BreakIterator::operator=(that); 285| | 286| 2.63k| if (fLanguageBreakEngines != nullptr) { ------------------ | Branch (286:9): [True: 0, False: 2.63k] ------------------ 287| 0| delete fLanguageBreakEngines; 288| 0| fLanguageBreakEngines = nullptr; // Just rebuild for now 289| 0| } 290| | // TODO: clone fLanguageBreakEngines from "that" 291| 2.63k| UErrorCode status = U_ZERO_ERROR; 292| 2.63k| utext_clone(&fText, &that.fText, false, true, &status); ------------------ | | 1890| 2.63k|#define utext_clone U_ICU_ENTRY_POINT_RENAME(utext_clone) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 293| | 294| 2.63k| if (fCharIter != &fSCharIter) { ------------------ | Branch (294:9): [True: 0, False: 2.63k] ------------------ 295| 0| delete fCharIter; 296| 0| } 297| 2.63k| fCharIter = &fSCharIter; 298| | 299| 2.63k| if (that.fCharIter != nullptr && that.fCharIter != &that.fSCharIter) { ------------------ | Branch (299:9): [True: 2.63k, False: 0] | Branch (299:38): [True: 0, False: 2.63k] ------------------ 300| | // This is a little bit tricky - it will initially appear that 301| | // this->fCharIter is adopted, even if that->fCharIter was 302| | // not adopted. That's ok. 303| 0| fCharIter = that.fCharIter->clone(); 304| 0| } 305| 2.63k| fSCharIter = that.fSCharIter; 306| 2.63k| if (fCharIter == nullptr) { ------------------ | Branch (306:9): [True: 0, False: 2.63k] ------------------ 307| 0| fCharIter = &fSCharIter; 308| 0| } 309| | 310| 2.63k| if (fData != nullptr) { ------------------ | Branch (310:9): [True: 0, False: 2.63k] ------------------ 311| 0| fData->removeReference(); 312| 0| fData = nullptr; 313| 0| } 314| 2.63k| if (that.fData != nullptr) { ------------------ | Branch (314:9): [True: 2.63k, False: 0] ------------------ 315| 2.63k| fData = that.fData->addReference(); 316| 2.63k| } 317| | 318| 2.63k| uprv_free(fLookAheadMatches); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 319| 2.63k| fLookAheadMatches = nullptr; 320| 2.63k| if (fData && fData->fForwardTable->fLookAheadResultsSize > 0) { ------------------ | Branch (320:9): [True: 2.63k, False: 0] | Branch (320:18): [True: 240, False: 2.39k] ------------------ 321| 240| fLookAheadMatches = static_cast( 322| 240| uprv_malloc(fData->fForwardTable->fLookAheadResultsSize * sizeof(int32_t))); ------------------ | | 1524| 240|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 240|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 240|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 240|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 240| } 324| | 325| | 326| 2.63k| fPosition = that.fPosition; 327| 2.63k| fRuleStatusIndex = that.fRuleStatusIndex; 328| 2.63k| fDone = that.fDone; 329| | 330| | // TODO: both the dictionary and the main cache need to be copied. 331| | // Current position could be within a dictionary range. Trying to continue 332| | // the iteration without the caches present would go to the rules, with 333| | // the assumption that the current position is on a rule boundary. 334| 2.63k| fBreakCache->reset(fPosition, fRuleStatusIndex); 335| 2.63k| fDictionaryCache->reset(); 336| | 337| 2.63k| return *this; 338| 2.63k|} _ZN6icu_7822RuleBasedBreakIterator15DictionaryCacheC2EPS0_R10UErrorCode: 29| 11.0k| fBI(bi), fBreaks(status), fPositionInCache(-1), 30| 11.0k| fStart(0), fLimit(0), fFirstRuleStatusIndex(0), fOtherRuleStatusIndex(0) { 31| 11.0k|} _ZN6icu_7822RuleBasedBreakIterator15DictionaryCacheD2Ev: 33| 11.0k|RuleBasedBreakIterator::DictionaryCache::~DictionaryCache() { 34| 11.0k|} _ZN6icu_7822RuleBasedBreakIterator15DictionaryCache5resetEv: 36| 2.63k|void RuleBasedBreakIterator::DictionaryCache::reset() { 37| 2.63k| fPositionInCache = -1; 38| 2.63k| fStart = 0; 39| 2.63k| fLimit = 0; 40| 2.63k| fFirstRuleStatusIndex = 0; 41| 2.63k| fOtherRuleStatusIndex = 0; 42| 2.63k| fBreaks.removeAllElements(); 43| 2.63k|} _ZN6icu_7822RuleBasedBreakIterator10BreakCacheC2EPS0_R10UErrorCode: 209| 11.0k| fBI(bi), fSideBuffer(status) { 210| 11.0k| reset(); 211| 11.0k|} _ZN6icu_7822RuleBasedBreakIterator10BreakCacheD2Ev: 214| 11.0k|RuleBasedBreakIterator::BreakCache::~BreakCache() { 215| 11.0k|} _ZN6icu_7822RuleBasedBreakIterator10BreakCache5resetEii: 218| 13.6k|void RuleBasedBreakIterator::BreakCache::reset(int32_t pos, int32_t ruleStatus) { 219| 13.6k| fStartBufIdx = 0; 220| 13.6k| fEndBufIdx = 0; 221| 13.6k| fTextIdx = pos; 222| 13.6k| fBufIdx = 0; 223| 13.6k| fBoundaries[0] = pos; 224| 13.6k| fStatuses[0] = static_cast(ruleStatus); 225| 13.6k|} _ZN6icu_7815RBBIDataWrapperC2EPKNS_14RBBIDataHeaderER10UErrorCode: 33| 2.63k|RBBIDataWrapper::RBBIDataWrapper(const RBBIDataHeader *data, UErrorCode &status) { 34| 2.63k| init0(); 35| 2.63k| init(data, status); 36| 2.63k|} _ZN6icu_7815RBBIDataWrapper23isDataVersionAcceptableEPKh: 69| 2.63k|UBool RBBIDataWrapper::isDataVersionAcceptable(const UVersionInfo version) { 70| 2.63k| return RBBI_DATA_FORMAT_VERSION[0] == version[0]; 71| 2.63k|} _ZN6icu_7815RBBIDataWrapper5init0Ev: 80| 2.63k|void RBBIDataWrapper::init0() { 81| 2.63k| fHeader = nullptr; 82| 2.63k| fForwardTable = nullptr; 83| 2.63k| fReverseTable = nullptr; 84| 2.63k| fRuleSource = nullptr; 85| 2.63k| fRuleStatusTable = nullptr; 86| 2.63k| fTrie = nullptr; 87| 2.63k| fUDataMem = nullptr; 88| 2.63k| fRefCount = 0; 89| 2.63k| fDontFreeData = true; 90| 2.63k|} _ZN6icu_7815RBBIDataWrapper4initEPKNS_14RBBIDataHeaderER10UErrorCode: 92| 2.63k|void RBBIDataWrapper::init(const RBBIDataHeader *data, UErrorCode &status) { 93| 2.63k| if (U_FAILURE(status)) { ------------------ | Branch (93:9): [True: 0, False: 2.63k] ------------------ 94| 0| return; 95| 0| } 96| 2.63k| fHeader = data; 97| 2.63k| if (fHeader->fMagic != 0xb1a0 || !isDataVersionAcceptable(fHeader->fFormatVersion)) { ------------------ | Branch (97:9): [True: 0, False: 2.63k] | Branch (97:38): [True: 0, False: 2.63k] ------------------ 98| 0| status = U_INVALID_FORMAT_ERROR; 99| 0| return; 100| 0| } 101| | // Note: in ICU version 3.2 and earlier, there was a formatVersion 1 102| | // that is no longer supported. At that time fFormatVersion was 103| | // an int32_t field, rather than an array of 4 bytes. 104| | 105| 2.63k| fDontFreeData = false; 106| 2.63k| if (data->fFTableLen != 0) { ------------------ | Branch (106:9): [True: 2.63k, False: 0] ------------------ 107| 2.63k| fForwardTable = reinterpret_cast(reinterpret_cast(data) + fHeader->fFTable); 108| 2.63k| } 109| 2.63k| if (data->fRTableLen != 0) { ------------------ | Branch (109:9): [True: 2.63k, False: 0] ------------------ 110| 2.63k| fReverseTable = reinterpret_cast(reinterpret_cast(data) + fHeader->fRTable); 111| 2.63k| } 112| | 113| 2.63k| fTrie = ucptrie_openFromBinary(UCPTRIE_TYPE_FAST, ------------------ | | 813| 2.63k|#define ucptrie_openFromBinary U_ICU_ENTRY_POINT_RENAME(ucptrie_openFromBinary) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 114| 2.63k| UCPTRIE_VALUE_BITS_ANY, 115| 2.63k| (uint8_t *)data + fHeader->fTrie, 116| 2.63k| fHeader->fTrieLen, 117| 2.63k| nullptr, // *actual length 118| 2.63k| &status); 119| 2.63k| if (U_FAILURE(status)) { ------------------ | Branch (119:9): [True: 0, False: 2.63k] ------------------ 120| 0| return; 121| 0| } 122| | 123| 2.63k| UCPTrieValueWidth width = ucptrie_getValueWidth(fTrie); ------------------ | | 808| 2.63k|#define ucptrie_getValueWidth U_ICU_ENTRY_POINT_RENAME(ucptrie_getValueWidth) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 124| 2.63k| if (!(width == UCPTRIE_VALUE_BITS_8 || width == UCPTRIE_VALUE_BITS_16)) { ------------------ | Branch (124:11): [True: 2.56k, False: 66] | Branch (124:44): [True: 66, False: 0] ------------------ 125| 0| status = U_INVALID_FORMAT_ERROR; 126| 0| return; 127| 0| } 128| | 129| 2.63k| fRuleSource = ((char *)data + fHeader->fRuleSource); 130| 2.63k| fRuleString = UnicodeString::fromUTF8(StringPiece(fRuleSource, fHeader->fRuleSourceLen)); 131| 2.63k| U_ASSERT(data->fRuleSourceLen > 0); ------------------ | | 35| 2.63k|# define U_ASSERT(exp) (void)0 ------------------ 132| | 133| 2.63k| fRuleStatusTable = reinterpret_cast(reinterpret_cast(data) + fHeader->fStatusTable); 134| 2.63k| fStatusMaxIdx = data->fStatusTableLen / sizeof(int32_t); 135| | 136| 2.63k| fRefCount = 1; 137| | 138| |#ifdef RBBI_DEBUG 139| | char *debugEnv = getenv("U_RBBIDEBUG"); 140| | if (debugEnv && uprv_strstr(debugEnv, "data")) {this->printData();} 141| |#endif 142| 2.63k|} _ZN6icu_7815RBBIDataWrapperD2Ev: 150| 2.63k|RBBIDataWrapper::~RBBIDataWrapper() { 151| 2.63k| U_ASSERT(fRefCount == 0); ------------------ | | 35| 2.63k|# define U_ASSERT(exp) (void)0 ------------------ 152| 2.63k| ucptrie_close(fTrie); ------------------ | | 804| 2.63k|#define ucptrie_close U_ICU_ENTRY_POINT_RENAME(ucptrie_close) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 153| 2.63k| fTrie = nullptr; 154| 2.63k| if (fUDataMem) { ------------------ | Branch (154:9): [True: 0, False: 2.63k] ------------------ 155| 0| udata_close(fUDataMem); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 156| 2.63k| } else if (!fDontFreeData) { ------------------ | Branch (156:16): [True: 2.63k, False: 0] ------------------ 157| 2.63k| uprv_free((void *)fHeader); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 158| 2.63k| } 159| 2.63k|} _ZN6icu_7815RBBIDataWrapper15removeReferenceEv: 199| 5.27k|void RBBIDataWrapper::removeReference() { 200| 5.27k| if (umtx_atomic_dec(&fRefCount) == 0) { ------------------ | Branch (200:9): [True: 2.63k, False: 2.63k] ------------------ 201| 2.63k| delete this; 202| 2.63k| } 203| 5.27k|} _ZN6icu_7815RBBIDataWrapper12addReferenceEv: 206| 2.63k|RBBIDataWrapper *RBBIDataWrapper::addReference() { 207| 2.63k| umtx_atomic_inc(&fRefCount); 208| 2.63k| return this; 209| 2.63k|} _ZN6icu_788RBBINodeC2ENS0_8NodeTypeER10UErrorCode: 50| 9.83M|RBBINode::RBBINode(NodeType t, UErrorCode& status) : UMemory() { 51| 9.83M| if (U_FAILURE(status)) { ------------------ | Branch (51:9): [True: 0, False: 9.83M] ------------------ 52| 0| return; 53| 0| } 54| |#ifdef RBBI_DEBUG 55| | fSerialNum = ++gLastSerial; 56| |#endif 57| 9.83M| fType = t; 58| 9.83M| fParent = nullptr; 59| 9.83M| fLeftChild = nullptr; 60| 9.83M| fRightChild = nullptr; 61| 9.83M| fInputSet = nullptr; 62| 9.83M| fFirstPos = 0; 63| 9.83M| fLastPos = 0; 64| 9.83M| fNullable = false; 65| 9.83M| fLookAheadEnd = false; 66| 9.83M| fRuleRoot = false; 67| 9.83M| fChainIn = false; 68| 9.83M| fVal = 0; 69| 9.83M| fPrecedence = precZero; 70| | 71| 9.83M| fFirstPosSet = new UVector(status); 72| 9.83M| fLastPosSet = new UVector(status); 73| 9.83M| fFollowPos = new UVector(status); 74| 9.83M| if (U_SUCCESS(status) && ------------------ | Branch (74:9): [True: 9.83M, False: 0] ------------------ 75| 9.83M| (fFirstPosSet == nullptr || fLastPosSet == nullptr || fFollowPos == nullptr)) { ------------------ | Branch (75:10): [True: 0, False: 9.83M] | Branch (75:37): [True: 0, False: 9.83M] | Branch (75:63): [True: 0, False: 9.83M] ------------------ 76| 0| status = U_MEMORY_ALLOCATION_ERROR; 77| 0| } 78| 9.83M| if (t==opCat) {fPrecedence = precOpCat;} ------------------ | Branch (78:14): [True: 4.59M, False: 5.23M] ------------------ 79| 5.23M| else if (t==opOr) {fPrecedence = precOpOr;} ------------------ | Branch (79:14): [True: 146k, False: 5.09M] ------------------ 80| 5.09M| else if (t==opStart) {fPrecedence = precStart;} ------------------ | Branch (80:14): [True: 48.9k, False: 5.04M] ------------------ 81| 5.04M| else if (t==opLParen) {fPrecedence = precLParen;} ------------------ | Branch (81:14): [True: 1.48k, False: 5.04M] ------------------ 82| | 83| 9.83M|} _ZN6icu_788RBBINodeC2ERKS0_R10UErrorCode: 86| 1.07M|RBBINode::RBBINode(const RBBINode &other, UErrorCode& status) : UMemory(other) { 87| 1.07M| if (U_FAILURE(status)) { ------------------ | Branch (87:9): [True: 0, False: 1.07M] ------------------ 88| 0| return; 89| 0| } 90| |#ifdef RBBI_DEBUG 91| | fSerialNum = ++gLastSerial; 92| |#endif 93| 1.07M| fType = other.fType; 94| 1.07M| fParent = nullptr; 95| 1.07M| fLeftChild = nullptr; 96| 1.07M| fRightChild = nullptr; 97| 1.07M| fInputSet = other.fInputSet; 98| 1.07M| fPrecedence = other.fPrecedence; 99| 1.07M| fText = other.fText; 100| 1.07M| fFirstPos = other.fFirstPos; 101| 1.07M| fLastPos = other.fLastPos; 102| 1.07M| fNullable = other.fNullable; 103| 1.07M| fVal = other.fVal; 104| 1.07M| fRuleRoot = false; 105| 1.07M| fChainIn = other.fChainIn; 106| 1.07M| fFirstPosSet = new UVector(status); // TODO - get a real status from somewhere 107| 1.07M| fLastPosSet = new UVector(status); 108| 1.07M| fFollowPos = new UVector(status); 109| 1.07M| if (U_SUCCESS(status) && ------------------ | Branch (109:9): [True: 1.07M, False: 0] ------------------ 110| 1.07M| (fFirstPosSet == nullptr || fLastPosSet == nullptr || fFollowPos == nullptr)) { ------------------ | Branch (110:10): [True: 0, False: 1.07M] | Branch (110:37): [True: 0, False: 1.07M] | Branch (110:63): [True: 0, False: 1.07M] ------------------ 111| 0| status = U_MEMORY_ALLOCATION_ERROR; 112| 0| } 113| 1.07M|} _ZN6icu_788RBBINodeD2Ev: 125| 10.9M|RBBINode::~RBBINode() { 126| | // printf("deleting node %8x serial %4d\n", this, this->fSerialNum); 127| 10.9M| delete fInputSet; 128| 10.9M| fInputSet = nullptr; 129| | 130| 10.9M| switch (this->fType) { 131| 2.06k| case varRef: ------------------ | Branch (131:5): [True: 2.06k, False: 10.9M] ------------------ 132| 4.63M| case setRef: ------------------ | Branch (132:5): [True: 4.63M, False: 6.27M] ------------------ 133| | // for these node types, multiple instances point to the same "children" 134| | // Storage ownership of children handled elsewhere. Don't delete here. 135| 4.63M| break; 136| | 137| 6.27M| default: ------------------ | Branch (137:5): [True: 6.27M, False: 4.63M] ------------------ 138| | // Avoid using a recursive implementation because of stack overflow problems. 139| | // See bug ICU-22584. 140| | // delete fLeftChild; 141| 6.27M| NRDeleteNode(fLeftChild); 142| 6.27M| fLeftChild = nullptr; 143| | // delete fRightChild; 144| 6.27M| NRDeleteNode(fRightChild); 145| 6.27M| fRightChild = nullptr; 146| 10.9M| } 147| | 148| 10.9M| delete fFirstPosSet; 149| 10.9M| delete fLastPosSet; 150| 10.9M| delete fFollowPos; 151| 10.9M|} _ZN6icu_788RBBINode12NRDeleteNodeEPS0_: 158| 12.5M|void RBBINode::NRDeleteNode(RBBINode *node) { 159| 12.5M| if (node == nullptr) { ------------------ | Branch (159:9): [True: 12.4M, False: 121k] ------------------ 160| 12.4M| return; 161| 12.4M| } 162| | 163| 121k| RBBINode *stopNode = node->fParent; 164| 121k| RBBINode *nextNode = node; 165| 20.8M| while (nextNode != stopNode && nextNode != nullptr) { ------------------ | Branch (165:12): [True: 20.7M, False: 121k] | Branch (165:36): [True: 20.7M, False: 0] ------------------ 166| 20.7M| RBBINode *currentNode = nextNode; 167| | 168| 20.7M| if ((currentNode->fLeftChild == nullptr && currentNode->fRightChild == nullptr) || ------------------ | Branch (168:14): [True: 11.1M, False: 9.58M] | Branch (168:52): [True: 6.01M, False: 5.15M] ------------------ 169| 20.7M| currentNode->fType == varRef || // varRef and setRef nodes do not ------------------ | Branch (169:17): [True: 354, False: 14.7M] ------------------ 170| 20.7M| currentNode->fType == setRef) { // own their children nodes. ------------------ | Branch (170:17): [True: 4.42M, False: 10.3M] ------------------ 171| | // CurrentNode is effectively a leaf node; it's safe to go ahead and delete it. 172| 10.4M| nextNode = currentNode->fParent; 173| 10.4M| if (nextNode) { ------------------ | Branch (173:17): [True: 10.4M, False: 20] ------------------ 174| 10.4M| if (nextNode->fLeftChild == currentNode) { ------------------ | Branch (174:21): [True: 5.27M, False: 5.16M] ------------------ 175| 5.27M| nextNode->fLeftChild = nullptr; 176| 5.27M| } else if (nextNode->fRightChild == currentNode) { ------------------ | Branch (176:28): [True: 5.16M, False: 0] ------------------ 177| 5.16M| nextNode->fRightChild = nullptr; 178| 5.16M| } 179| 10.4M| } 180| 10.4M| delete currentNode; 181| 10.4M| } else if (currentNode->fLeftChild) { ------------------ | Branch (181:20): [True: 5.16M, False: 5.15M] ------------------ 182| 5.16M| nextNode = currentNode->fLeftChild; 183| 5.16M| if (nextNode->fParent == nullptr) { ------------------ | Branch (183:17): [True: 335, False: 5.16M] ------------------ 184| 335| nextNode->fParent = currentNode; 185| | // fParent isn't always set; do it now if not. 186| 335| } 187| 5.16M| U_ASSERT(nextNode->fParent == currentNode); ------------------ | | 35| 5.16M|# define U_ASSERT(exp) (void)0 ------------------ 188| 5.16M| } else if (currentNode->fRightChild) { ------------------ | Branch (188:20): [True: 5.15M, False: 0] ------------------ 189| 5.15M| nextNode = currentNode->fRightChild; 190| 5.15M| if (nextNode->fParent == nullptr) { ------------------ | Branch (190:17): [True: 404, False: 5.15M] ------------------ 191| 404| nextNode->fParent = currentNode; 192| | // fParent isn't always set; do it now if not. 193| 404| } 194| 5.15M| U_ASSERT(nextNode->fParent == currentNode); ------------------ | | 35| 5.15M|# define U_ASSERT(exp) (void)0 ------------------ 195| 5.15M| } 196| 20.7M| } 197| 121k|} _ZN6icu_788RBBINode9cloneTreeER10UErrorCodei: 209| 1.09M|RBBINode *RBBINode::cloneTree(UErrorCode &status, int depth) { 210| 1.09M| if (U_FAILURE(status)) { ------------------ | Branch (210:9): [True: 0, False: 1.09M] ------------------ 211| 0| return nullptr; 212| 0| } 213| | // If the depth of the stack is too deep, we return U_INPUT_TOO_LONG_ERROR 214| | // to avoid stack overflow crash. 215| 1.09M| if (depth > kRecursiveDepthLimit) { ------------------ | Branch (215:9): [True: 18, False: 1.09M] ------------------ 216| 18| status = U_INPUT_TOO_LONG_ERROR; 217| 18| return nullptr; 218| 18| } 219| 1.09M| RBBINode *n; 220| | 221| 1.09M| if (fType == RBBINode::varRef) { ------------------ | Branch (221:9): [True: 371, False: 1.08M] ------------------ 222| | // If the current node is a variable reference, skip over it 223| | // and clone the definition of the variable instead. 224| 371| n = fLeftChild->cloneTree(status, depth+1); 225| 371| if (U_FAILURE(status)) { ------------------ | Branch (225:13): [True: 18, False: 353] ------------------ 226| 18| return nullptr; 227| 18| } 228| 1.08M| } else if (fType == RBBINode::uset) { ------------------ | Branch (228:16): [True: 11.5k, False: 1.07M] ------------------ 229| 11.5k| n = this; 230| 1.07M| } else { 231| 1.07M| n = new RBBINode(*this, status); 232| 1.07M| if (U_FAILURE(status)) { ------------------ | Branch (232:13): [True: 0, False: 1.07M] ------------------ 233| 0| delete n; 234| 0| return nullptr; 235| 0| } 236| | // Check for null pointer. 237| 1.07M| if (n == nullptr) { ------------------ | Branch (237:13): [True: 0, False: 1.07M] ------------------ 238| 0| status = U_MEMORY_ALLOCATION_ERROR; 239| 0| return nullptr; 240| 0| } 241| 1.07M| if (fLeftChild != nullptr) { ------------------ | Branch (241:13): [True: 459k, False: 618k] ------------------ 242| 459k| n->fLeftChild = fLeftChild->cloneTree(status, depth+1); 243| 459k| if (U_FAILURE(status)) { ------------------ | Branch (243:17): [True: 28.8k, False: 430k] ------------------ 244| 28.8k| delete n; 245| 28.8k| return nullptr; 246| 28.8k| } 247| 430k| n->fLeftChild->fParent = n; 248| 430k| } 249| 1.04M| if (fRightChild != nullptr) { ------------------ | Branch (249:13): [True: 419k, False: 630k] ------------------ 250| 419k| n->fRightChild = fRightChild->cloneTree(status, depth+1); 251| 419k| if (U_FAILURE(status)) { ------------------ | Branch (251:17): [True: 35, False: 419k] ------------------ 252| 35| delete n; 253| 35| return nullptr; 254| 35| } 255| 419k| n->fRightChild->fParent = n; 256| 419k| } 257| 1.04M| } 258| 1.06M| return n; 259| 1.09M|} _ZN6icu_788RBBINode16flattenVariablesER10UErrorCodei: 281| 1.81M|RBBINode *RBBINode::flattenVariables(UErrorCode& status, int depth) { 282| 1.81M| if (U_FAILURE(status)) { ------------------ | Branch (282:9): [True: 0, False: 1.81M] ------------------ 283| 0| return this; 284| 0| } 285| | // If the depth of the stack is too deep, we return U_INPUT_TOO_LONG_ERROR 286| | // to avoid stack overflow crash. 287| 1.81M| if (depth > kRecursiveDepthLimit) { ------------------ | Branch (287:9): [True: 23, False: 1.81M] ------------------ 288| 23| status = U_INPUT_TOO_LONG_ERROR; 289| 23| return this; 290| 23| } 291| 1.81M| if (fType == varRef) { ------------------ | Branch (291:9): [True: 371, False: 1.81M] ------------------ 292| 371| RBBINode *retNode = fLeftChild->cloneTree(status, depth+1); 293| 371| if (U_FAILURE(status)) { ------------------ | Branch (293:13): [True: 18, False: 353] ------------------ 294| 18| return this; 295| 18| } 296| 353| retNode->fRuleRoot = this->fRuleRoot; 297| 353| retNode->fChainIn = this->fChainIn; 298| 353| delete this; // TODO: undefined behavior. Fix. 299| 353| return retNode; 300| 371| } 301| | 302| 1.81M| if (fLeftChild != nullptr) { ------------------ | Branch (302:9): [True: 1.17M, False: 641k] ------------------ 303| 1.17M| fLeftChild = fLeftChild->flattenVariables(status, depth+1); 304| 1.17M| if (fLeftChild == nullptr) { ------------------ | Branch (304:13): [True: 0, False: 1.17M] ------------------ 305| 0| status = U_MEMORY_ALLOCATION_ERROR; 306| 0| } 307| 1.17M| if (U_FAILURE(status)) { ------------------ | Branch (307:13): [True: 114k, False: 1.05M] ------------------ 308| 114k| return this; 309| 114k| } 310| 1.05M| fLeftChild->fParent = this; 311| 1.05M| } 312| 1.69M| if (fRightChild != nullptr) { ------------------ | Branch (312:9): [True: 639k, False: 1.05M] ------------------ 313| 639k| fRightChild = fRightChild->flattenVariables(status, depth+1); 314| 639k| if (fRightChild == nullptr) { ------------------ | Branch (314:13): [True: 0, False: 639k] ------------------ 315| 0| status = U_MEMORY_ALLOCATION_ERROR; 316| 0| } 317| 639k| if (U_FAILURE(status)) { ------------------ | Branch (317:13): [True: 85, False: 639k] ------------------ 318| 85| return this; 319| 85| } 320| 639k| fRightChild->fParent = this; 321| 639k| } 322| 1.69M| return this; 323| 1.69M|} _ZN6icu_788RBBINode11flattenSetsER10UErrorCodei: 334| 268k|void RBBINode::flattenSets(UErrorCode &status, int depth) { 335| 268k| if (U_FAILURE(status)) { ------------------ | Branch (335:9): [True: 0, False: 268k] ------------------ 336| 0| return; 337| 0| } 338| | // If the depth of the stack is too deep, we return U_INPUT_TOO_LONG_ERROR 339| | // to avoid stack overflow crash. 340| 268k| if (depth > kRecursiveDepthLimit) { ------------------ | Branch (340:9): [True: 0, False: 268k] ------------------ 341| 0| status = U_INPUT_TOO_LONG_ERROR; 342| 0| return; 343| 0| } 344| 268k| U_ASSERT(fType != setRef); ------------------ | | 35| 268k|# define U_ASSERT(exp) (void)0 ------------------ 345| | 346| 268k| if (fLeftChild != nullptr) { ------------------ | Branch (346:9): [True: 239k, False: 28.5k] ------------------ 347| 239k| if (fLeftChild->fType==setRef) { ------------------ | Branch (347:13): [True: 29.9k, False: 209k] ------------------ 348| 29.9k| RBBINode *setRefNode = fLeftChild; 349| 29.9k| RBBINode *usetNode = setRefNode->fLeftChild; 350| 29.9k| RBBINode *replTree = usetNode->fLeftChild; 351| 29.9k| fLeftChild = replTree->cloneTree(status, depth+1); 352| 29.9k| if (U_FAILURE(status)) { ------------------ | Branch (352:17): [True: 0, False: 29.9k] ------------------ 353| 0| delete setRefNode; 354| 0| return; 355| 0| } 356| 29.9k| fLeftChild->fParent = this; 357| 29.9k| delete setRefNode; 358| 209k| } else { 359| 209k| fLeftChild->flattenSets(status, depth+1); 360| 209k| } 361| 239k| } 362| | 363| 268k| if (fRightChild != nullptr) { ------------------ | Branch (363:9): [True: 236k, False: 31.5k] ------------------ 364| 236k| if (fRightChild->fType==setRef) { ------------------ | Branch (364:13): [True: 180k, False: 55.9k] ------------------ 365| 180k| RBBINode *setRefNode = fRightChild; 366| 180k| RBBINode *usetNode = setRefNode->fLeftChild; 367| 180k| RBBINode *replTree = usetNode->fLeftChild; 368| 180k| fRightChild = replTree->cloneTree(status, depth+1); 369| 180k| if (U_FAILURE(status)) { ------------------ | Branch (369:17): [True: 0, False: 180k] ------------------ 370| 0| delete setRefNode; 371| 0| return; 372| 0| } 373| 180k| fRightChild->fParent = this; 374| 180k| delete setRefNode; 375| 180k| } else { 376| 55.9k| fRightChild->flattenSets(status, depth+1); 377| 55.9k| } 378| 236k| } 379| 268k|} _ZN6icu_788RBBINode9findNodesEPNS_7UVectorENS0_8NodeTypeER10UErrorCode: 389| 4.07M|void RBBINode::findNodes(UVector *dest, RBBINode::NodeType kind, UErrorCode &status) { 390| | /* test for buffer overflows */ 391| 4.07M| if (U_FAILURE(status)) { ------------------ | Branch (391:9): [True: 0, False: 4.07M] ------------------ 392| 0| return; 393| 0| } 394| 4.07M| U_ASSERT(!dest->hasDeleter()); ------------------ | | 35| 4.07M|# define U_ASSERT(exp) (void)0 ------------------ 395| 4.07M| if (fType == kind) { ------------------ | Branch (395:9): [True: 123k, False: 3.95M] ------------------ 396| 123k| dest->addElement(this, status); 397| 123k| } 398| 4.07M| if (fLeftChild != nullptr) { ------------------ | Branch (398:9): [True: 2.03M, False: 2.03M] ------------------ 399| 2.03M| fLeftChild->findNodes(dest, kind, status); 400| 2.03M| } 401| 4.07M| if (fRightChild != nullptr) { ------------------ | Branch (401:9): [True: 2.02M, False: 2.04M] ------------------ 402| 2.02M| fRightChild->findNodes(dest, kind, status); 403| 2.02M| } 404| 4.07M|} _ZN6icu_7815RBBIRuleBuilderC2ERKNS_13UnicodeStringEP11UParseErrorR10UErrorCode: 51| 8.41k| : fRules(rules), fStrippedRules(rules) 52| 8.41k|{ 53| 8.41k| fStatus = &status; // status is checked below 54| 8.41k| fParseError = parseErr; 55| 8.41k| fDebugEnv = nullptr; 56| |#ifdef RBBI_DEBUG 57| | fDebugEnv = getenv("U_RBBIDEBUG"); 58| |#endif 59| | 60| | 61| 8.41k| fForwardTree = nullptr; 62| 8.41k| fReverseTree = nullptr; 63| 8.41k| fSafeFwdTree = nullptr; 64| 8.41k| fSafeRevTree = nullptr; 65| 8.41k| fDefaultTree = &fForwardTree; 66| 8.41k| fForwardTable = nullptr; 67| 8.41k| fRuleStatusVals = nullptr; 68| 8.41k| fChainRules = false; 69| 8.41k| fLookAheadHardBreak = false; 70| 8.41k| fUSetNodes = nullptr; 71| 8.41k| fRuleStatusVals = nullptr; 72| 8.41k| fScanner = nullptr; 73| 8.41k| fSetBuilder = nullptr; 74| 8.41k| if (parseErr) { ------------------ | Branch (74:9): [True: 8.41k, False: 0] ------------------ 75| 8.41k| uprv_memset(parseErr, 0, sizeof(UParseError)); ------------------ | | 100| 8.41k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 8.41k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 76| 8.41k| } 77| | 78| 8.41k| if (U_FAILURE(status)) { ------------------ | Branch (78:9): [True: 0, False: 8.41k] ------------------ 79| 0| return; 80| 0| } 81| | 82| 8.41k| fUSetNodes = new UVector(status); // bcos status gets overwritten here 83| 8.41k| fRuleStatusVals = new UVector(status); 84| 8.41k| fScanner = new RBBIRuleScanner(this); 85| 8.41k| fSetBuilder = new RBBISetBuilder(this); 86| 8.41k| if (U_FAILURE(status)) { ------------------ | Branch (86:9): [True: 0, False: 8.41k] ------------------ 87| 0| return; 88| 0| } 89| 8.41k| if (fSetBuilder == nullptr || fScanner == nullptr || ------------------ | Branch (89:9): [True: 0, False: 8.41k] | Branch (89:35): [True: 0, False: 8.41k] ------------------ 90| 8.41k| fUSetNodes == nullptr || fRuleStatusVals == nullptr) { ------------------ | Branch (90:9): [True: 0, False: 8.41k] | Branch (90:34): [True: 0, False: 8.41k] ------------------ 91| 0| status = U_MEMORY_ALLOCATION_ERROR; 92| 0| } 93| 8.41k|} _ZN6icu_7815RBBIRuleBuilderD2Ev: 102| 8.41k|RBBIRuleBuilder::~RBBIRuleBuilder() { 103| | 104| 8.41k| int i; 105| 182k| for (i=0; ; i++) { 106| 182k| RBBINode* n = static_cast(fUSetNodes->elementAt(i)); 107| 182k| if (n==nullptr) { ------------------ | Branch (107:13): [True: 8.41k, False: 174k] ------------------ 108| 8.41k| break; 109| 8.41k| } 110| 174k| delete n; 111| 174k| } 112| | 113| 8.41k| delete fUSetNodes; 114| 8.41k| delete fSetBuilder; 115| 8.41k| delete fForwardTable; 116| 8.41k| delete fForwardTree; 117| 8.41k| delete fReverseTree; 118| 8.41k| delete fSafeFwdTree; 119| 8.41k| delete fSafeRevTree; 120| 8.41k| delete fScanner; 121| 8.41k| delete fRuleStatusVals; 122| 8.41k|} _ZN6icu_7815RBBIRuleBuilder11flattenDataEv: 137| 2.67k|RBBIDataHeader *RBBIRuleBuilder::flattenData() { 138| 2.67k| int32_t i; 139| | 140| 2.67k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (140:9): [True: 41, False: 2.63k] ------------------ 141| 41| return nullptr; 142| 41| } 143| | 144| | // Remove whitespace from the rules to make it smaller. 145| | // The rule parser has already removed comments. 146| 2.63k| fStrippedRules = fScanner->stripRules(fStrippedRules); 147| | 148| | // Calculate the size of each section in the data. 149| | // Sizes here are padded up to a multiple of 8 for better memory alignment. 150| | // Sections sizes actually stored in the header are for the actual data 151| | // without the padding. 152| | // 153| 2.63k| int32_t headerSize = align8(sizeof(RBBIDataHeader)); 154| 2.63k| int32_t forwardTableSize = align8(fForwardTable->getTableSize()); 155| 2.63k| int32_t reverseTableSize = align8(fForwardTable->getSafeTableSize()); 156| 2.63k| int32_t trieSize = align8(fSetBuilder->getTrieSize()); 157| 2.63k| int32_t statusTableSize = align8(fRuleStatusVals->size() * sizeof(int32_t)); 158| | 159| 2.63k| int32_t rulesLengthInUTF8 = 0; 160| 2.63k| u_strToUTF8WithSub(nullptr, 0, &rulesLengthInUTF8, ------------------ | | 380| 2.63k|#define u_strToUTF8WithSub U_ICU_ENTRY_POINT_RENAME(u_strToUTF8WithSub) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 161| 2.63k| fStrippedRules.getBuffer(), fStrippedRules.length(), 162| 2.63k| 0xfffd, nullptr, fStatus); 163| 2.63k| *fStatus = U_ZERO_ERROR; 164| | 165| 2.63k| int32_t rulesSize = align8((rulesLengthInUTF8+1)); 166| | 167| 2.63k| int32_t totalSize = headerSize 168| 2.63k| + forwardTableSize 169| 2.63k| + reverseTableSize 170| 2.63k| + statusTableSize + trieSize + rulesSize; 171| | 172| |#ifdef RBBI_DEBUG 173| | if (fDebugEnv && uprv_strstr(fDebugEnv, "size")) { 174| | RBBIDebugPrintf("Header Size: %8d\n", headerSize); 175| | RBBIDebugPrintf("Forward Table Size: %8d\n", forwardTableSize); 176| | RBBIDebugPrintf("Reverse Table Size: %8d\n", reverseTableSize); 177| | RBBIDebugPrintf("Trie Size: %8d\n", trieSize); 178| | RBBIDebugPrintf("Status Table Size: %8d\n", statusTableSize); 179| | RBBIDebugPrintf("Rules Size: %8d\n", rulesSize); 180| | RBBIDebugPrintf("-----------------------------\n"); 181| | RBBIDebugPrintf("Total Size: %8d\n", totalSize); 182| | } 183| |#endif 184| | 185| 2.63k| LocalMemory data(static_cast(uprv_malloc(totalSize))); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 186| 2.63k| if (data.isNull()) { ------------------ | Branch (186:9): [True: 0, False: 2.63k] ------------------ 187| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 188| 0| return nullptr; 189| 0| } 190| 2.63k| uprv_memset(data.getAlias(), 0, totalSize); ------------------ | | 100| 2.63k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 191| | 192| | 193| 2.63k| data->fMagic = 0xb1a0; 194| 2.63k| data->fFormatVersion[0] = RBBI_DATA_FORMAT_VERSION[0]; 195| 2.63k| data->fFormatVersion[1] = RBBI_DATA_FORMAT_VERSION[1]; 196| 2.63k| data->fFormatVersion[2] = RBBI_DATA_FORMAT_VERSION[2]; 197| 2.63k| data->fFormatVersion[3] = RBBI_DATA_FORMAT_VERSION[3]; 198| 2.63k| data->fLength = totalSize; 199| 2.63k| data->fCatCount = fSetBuilder->getNumCharCategories(); 200| | 201| 2.63k| data->fFTable = headerSize; 202| 2.63k| data->fFTableLen = forwardTableSize; 203| | 204| 2.63k| data->fRTable = data->fFTable + data->fFTableLen; 205| 2.63k| data->fRTableLen = reverseTableSize; 206| | 207| 2.63k| data->fTrie = data->fRTable + data->fRTableLen; 208| 2.63k| data->fTrieLen = trieSize; 209| 2.63k| data->fStatusTable = data->fTrie + data->fTrieLen; 210| 2.63k| data->fStatusTableLen= statusTableSize; 211| 2.63k| data->fRuleSource = data->fStatusTable + statusTableSize; 212| 2.63k| data->fRuleSourceLen = rulesLengthInUTF8; 213| | 214| 2.63k| uprv_memset(data->fReserved, 0, sizeof(data->fReserved)); ------------------ | | 100| 2.63k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 215| | 216| 2.63k| fForwardTable->exportTable(reinterpret_cast(data.getAlias()) + data->fFTable); 217| 2.63k| fForwardTable->exportSafeTable(reinterpret_cast(data.getAlias()) + data->fRTable); 218| 2.63k| fSetBuilder->serializeTrie(reinterpret_cast(data.getAlias()) + data->fTrie); 219| | 220| 2.63k| int32_t* ruleStatusTable = reinterpret_cast(reinterpret_cast(data.getAlias()) + data->fStatusTable); 221| 16.4k| for (i=0; isize(); i++) { ------------------ | Branch (221:15): [True: 13.8k, False: 2.63k] ------------------ 222| 13.8k| ruleStatusTable[i] = fRuleStatusVals->elementAti(i); 223| 13.8k| } 224| | 225| 2.63k| u_strToUTF8WithSub(reinterpret_cast(data.getAlias()) + data->fRuleSource, rulesSize, &rulesLengthInUTF8, ------------------ | | 380| 2.63k|#define u_strToUTF8WithSub U_ICU_ENTRY_POINT_RENAME(u_strToUTF8WithSub) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 226| 2.63k| fStrippedRules.getBuffer(), fStrippedRules.length(), 227| 2.63k| 0xfffd, nullptr, fStatus); 228| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (228:9): [True: 0, False: 2.63k] ------------------ 229| 0| return nullptr; 230| 0| } 231| | 232| 2.63k| return data.orphan(); 233| 2.63k|} _ZN6icu_7815RBBIRuleBuilder28createRuleBasedBreakIteratorERKNS_13UnicodeStringEP11UParseErrorR10UErrorCode: 246| 8.41k|{ 247| | // 248| | // Read the input rules, generate a parse tree, symbol table, 249| | // and list of all Unicode Sets referenced by the rules. 250| | // 251| 8.41k| RBBIRuleBuilder builder(rules, parseError, status); 252| 8.41k| if (U_FAILURE(status)) { // status checked here bcos build below doesn't ------------------ | Branch (252:9): [True: 0, False: 8.41k] ------------------ 253| 0| return nullptr; 254| 0| } 255| | 256| 8.41k| RBBIDataHeader *data = builder.build(status); 257| | 258| 8.41k| if (U_FAILURE(status)) { ------------------ | Branch (258:9): [True: 5.77k, False: 2.63k] ------------------ 259| 5.77k| return nullptr; 260| 5.77k| } 261| | 262| | // 263| | // Create a break iterator from the compiled rules. 264| | // (Identical to creation from stored pre-compiled rules) 265| | // 266| | // status is checked after init in construction. 267| 2.63k| RuleBasedBreakIterator *This = new RuleBasedBreakIterator(data, status); 268| 2.63k| if (U_FAILURE(status)) { ------------------ | Branch (268:9): [True: 0, False: 2.63k] ------------------ 269| 0| delete This; 270| 0| This = nullptr; 271| 0| } 272| 2.63k| else if(This == nullptr) { // test for nullptr ------------------ | Branch (272:13): [True: 0, False: 2.63k] ------------------ 273| 0| status = U_MEMORY_ALLOCATION_ERROR; 274| 0| } 275| 2.63k| return This; 276| 8.41k|} _ZN6icu_7815RBBIRuleBuilder5buildER10UErrorCode: 278| 8.41k|RBBIDataHeader *RBBIRuleBuilder::build(UErrorCode &status) { 279| 8.41k| if (U_FAILURE(status)) { ------------------ | Branch (279:9): [True: 0, False: 8.41k] ------------------ 280| 0| return nullptr; 281| 0| } 282| | 283| 8.41k| fScanner->parse(); 284| 8.41k| if (U_FAILURE(status)) { ------------------ | Branch (284:9): [True: 5.73k, False: 2.67k] ------------------ 285| 5.73k| return nullptr; 286| 5.73k| } 287| | 288| | // 289| | // UnicodeSet processing. 290| | // Munge the Unicode Sets to create an initial set of character categories. 291| | // 292| 2.67k| fSetBuilder->buildRanges(); 293| | 294| | // 295| | // Generate the DFA state transition table. 296| | // 297| 2.67k| fForwardTable = new RBBITableBuilder(this, &fForwardTree, status); 298| 2.67k| if (fForwardTable == nullptr) { ------------------ | Branch (298:9): [True: 0, False: 2.67k] ------------------ 299| 0| status = U_MEMORY_ALLOCATION_ERROR; 300| 0| return nullptr; 301| 0| } 302| | 303| 2.67k| fForwardTable->buildForwardTable(); 304| | 305| | // State table and character category optimization. 306| | // Merge equivalent rows and columns. 307| | // Note that this process alters the initial set of character categories, 308| | // causing the representation of UnicodeSets in the parse tree to become invalid. 309| | 310| 2.67k| optimizeTables(); 311| 2.67k| fForwardTable->buildSafeReverseTable(status); 312| | 313| | 314| |#ifdef RBBI_DEBUG 315| | if (fDebugEnv && uprv_strstr(fDebugEnv, "states")) { 316| | fForwardTable->printStates(); 317| | fForwardTable->printRuleStatusTable(); 318| | fForwardTable->printReverseTable(); 319| | } 320| |#endif 321| | 322| | // Generate the mapping tables (TRIE) from input code points to 323| | // the character categories. 324| | // 325| 2.67k| fSetBuilder->buildTrie(); 326| | 327| | // 328| | // Package up the compiled data into a memory image 329| | // in the run-time format. 330| | // 331| 2.67k| RBBIDataHeader *data = flattenData(); // returns nullptr if error 332| 2.67k| if (U_FAILURE(status)) { ------------------ | Branch (332:9): [True: 41, False: 2.63k] ------------------ 333| 41| return nullptr; 334| 41| } 335| 2.63k| return data; 336| 2.67k|} _ZN6icu_7815RBBIRuleBuilder14optimizeTablesEv: 338| 2.67k|void RBBIRuleBuilder::optimizeTables() { 339| 2.67k| bool didSomething; 340| 3.26k| do { 341| 3.26k| didSomething = false; 342| | 343| | // Begin looking for duplicates with char class 3. 344| | // Classes 0, 1 and 2 are special; they are unused, {bof} and {eof} respectively, 345| | // and should not have other categories merged into them. 346| 3.26k| IntPair duplPair = {3, 0}; 347| 15.7k| while (fForwardTable->findDuplCharClassFrom(&duplPair)) { ------------------ | Branch (347:16): [True: 12.4k, False: 3.26k] ------------------ 348| 12.4k| fSetBuilder->mergeCategories(duplPair); 349| 12.4k| fForwardTable->removeColumn(duplPair.second); 350| 12.4k| didSomething = true; 351| 12.4k| } 352| | 353| 4.95k| while (fForwardTable->removeDuplicateStates() > 0) { ------------------ | Branch (353:16): [True: 1.68k, False: 3.26k] ------------------ 354| 1.68k| didSomething = true; 355| 1.68k| } 356| 3.26k| } while (didSomething); ------------------ | Branch (356:14): [True: 590, False: 2.67k] ------------------ 357| 2.67k|} rbbirb.cpp:_ZN6icu_78L6align8Ei: 135| 15.8k|static int32_t align8(int32_t i) {return (i+7) & 0xfffffff8;} _ZN6icu_7815RBBIRuleScannerC2EPNS_15RBBIRuleBuilderE: 91| 8.41k|{ 92| 8.41k| fRB = rb; 93| 8.41k| fScanIndex = 0; 94| 8.41k| fNextIndex = 0; 95| 8.41k| fQuoteMode = false; 96| 8.41k| fLineNum = 1; 97| 8.41k| fCharNum = 0; 98| 8.41k| fLastChar = 0; 99| | 100| 8.41k| fStateTable = nullptr; 101| 8.41k| fStack[0] = 0; 102| 8.41k| fStackPtr = 0; 103| 8.41k| fNodeStack[0] = nullptr; 104| 8.41k| fNodeStackPtr = 0; 105| | 106| 8.41k| fReverseRule = false; 107| 8.41k| fLookAheadRule = false; 108| 8.41k| fNoChainInRule = false; 109| | 110| 8.41k| fSymbolTable = nullptr; 111| 8.41k| fSetTable = nullptr; 112| 8.41k| fRuleNum = 0; 113| 8.41k| fOptionStart = 0; 114| | 115| | // Do not check status until after all critical fields are sufficiently initialized 116| | // that the destructor can run cleanly. 117| 8.41k| if (U_FAILURE(*rb->fStatus)) { ------------------ | Branch (117:9): [True: 0, False: 8.41k] ------------------ 118| 0| return; 119| 0| } 120| | 121| | // 122| | // Set up the constant Unicode Sets. 123| | // Note: These could be made static, lazily initialized, and shared among 124| | // all instances of RBBIRuleScanners. BUT this is quite a bit simpler, 125| | // and the time to build these few sets should be small compared to a 126| | // full break iterator build. 127| 8.41k| fRuleSets[kRuleSet_rule_char-128] 128| 8.41k| = UnicodeSet(UnicodeString(gRuleSet_rule_char_pattern), *rb->fStatus); 129| | // fRuleSets[kRuleSet_white_space-128] = [:Pattern_White_Space:] 130| 8.41k| fRuleSets[kRuleSet_white_space-128]. 131| 8.41k| add(9, 0xd).add(0x20).add(0x85).add(0x200e, 0x200f).add(0x2028, 0x2029); 132| 8.41k| fRuleSets[kRuleSet_name_char-128] 133| 8.41k| = UnicodeSet(UnicodeString(gRuleSet_name_char_pattern), *rb->fStatus); 134| 8.41k| fRuleSets[kRuleSet_name_start_char-128] 135| 8.41k| = UnicodeSet(UnicodeString(gRuleSet_name_start_char_pattern), *rb->fStatus); 136| 8.41k| fRuleSets[kRuleSet_digit_char-128] 137| 8.41k| = UnicodeSet(UnicodeString(gRuleSet_digit_char_pattern), *rb->fStatus); 138| 8.41k| if (*rb->fStatus == U_ILLEGAL_ARGUMENT_ERROR) { ------------------ | Branch (138:9): [True: 0, False: 8.41k] ------------------ 139| | // This case happens if ICU's data is missing. UnicodeSet tries to look up property 140| | // names from the init string, can't find them, and claims an illegal argument. 141| | // Change the error so that the actual problem will be clearer to users. 142| 0| *rb->fStatus = U_BRK_INIT_ERROR; 143| 0| } 144| 8.41k| if (U_FAILURE(*rb->fStatus)) { ------------------ | Branch (144:9): [True: 0, False: 8.41k] ------------------ 145| 0| return; 146| 0| } 147| | 148| 8.41k| fSymbolTable = new RBBISymbolTable(this, rb->fRules, *rb->fStatus); 149| 8.41k| if (fSymbolTable == nullptr) { ------------------ | Branch (149:9): [True: 0, False: 8.41k] ------------------ 150| 0| *rb->fStatus = U_MEMORY_ALLOCATION_ERROR; 151| 0| return; 152| 0| } 153| 8.41k| fSetTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, rb->fStatus); ------------------ | | 1030| 8.41k|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ fSetTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, rb->fStatus); ------------------ | | 1017| 8.41k|#define uhash_hashUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hashUnicodeString) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ fSetTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, rb->fStatus); ------------------ | | 999| 8.41k|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 154| 8.41k| if (U_FAILURE(*rb->fStatus)) { ------------------ | Branch (154:9): [True: 0, False: 8.41k] ------------------ 155| 0| return; 156| 0| } 157| 8.41k| uhash_setValueDeleter(fSetTable, RBBISetTable_deleter); ------------------ | | 1044| 8.41k|#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDeleter) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 158| 8.41k|} _ZN6icu_7815RBBIRuleScannerD2Ev: 167| 8.41k|RBBIRuleScanner::~RBBIRuleScanner() { 168| 8.41k| delete fSymbolTable; 169| 8.41k| if (fSetTable != nullptr) { ------------------ | Branch (169:9): [True: 8.41k, False: 0] ------------------ 170| 8.41k| uhash_close(fSetTable); ------------------ | | 991| 8.41k|#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 8.41k| fSetTable = nullptr; 172| | 173| 8.41k| } 174| | 175| | 176| | // Node Stack. 177| | // Normally has one entry, which is the entire parse tree for the rules. 178| | // If errors occurred, there may be additional subtrees left on the stack. 179| 18.9k| while (fNodeStackPtr > 0) { ------------------ | Branch (179:12): [True: 10.5k, False: 8.41k] ------------------ 180| 10.5k| delete fNodeStack[fNodeStackPtr]; 181| 10.5k| fNodeStackPtr--; 182| 10.5k| } 183| | 184| 8.41k|} _ZN6icu_7815RBBIRuleScanner14doParseActionsEi: 201| 14.5M|{ 202| 14.5M| RBBINode *n = nullptr; 203| | 204| 14.5M| UBool returnVal = true; 205| | 206| 14.5M| switch (action) { 207| | 208| 47.6k| case doExprStart: ------------------ | Branch (208:5): [True: 47.6k, False: 14.4M] ------------------ 209| 47.6k| pushNewNode(RBBINode::opStart); 210| 47.6k| fRuleNum++; 211| 47.6k| break; 212| | 213| | 214| 253| case doNoChain: ------------------ | Branch (214:5): [True: 253, False: 14.5M] ------------------ 215| | // Scanned a '^' while on the rule start state. 216| 253| fNoChainInRule = true; 217| 253| break; 218| | 219| | 220| 14.6k| case doExprOrOperator: ------------------ | Branch (220:5): [True: 14.6k, False: 14.5M] ------------------ 221| 14.6k| { 222| 14.6k| fixOpStack(RBBINode::precOpCat); 223| 14.6k| RBBINode *operandNode = fNodeStack[fNodeStackPtr--]; 224| 14.6k| RBBINode *orNode = pushNewNode(RBBINode::opOr); 225| 14.6k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (225:17): [True: 0, False: 14.6k] ------------------ 226| 0| break; 227| 0| } 228| 14.6k| orNode->fLeftChild = operandNode; 229| 14.6k| operandNode->fParent = orNode; 230| 14.6k| } 231| 0| break; 232| | 233| 4.58M| case doExprCatOperator: ------------------ | Branch (233:5): [True: 4.58M, False: 9.95M] ------------------ 234| | // concatenation operator. 235| | // For the implicit concatenation of adjacent terms in an expression that are 236| | // not separated by any other operator. Action is invoked between the 237| | // actions for the two terms. 238| 4.58M| { 239| 4.58M| fixOpStack(RBBINode::precOpCat); 240| 4.58M| RBBINode *operandNode = fNodeStack[fNodeStackPtr--]; 241| 4.58M| RBBINode *catNode = pushNewNode(RBBINode::opCat); 242| 4.58M| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (242:17): [True: 0, False: 4.58M] ------------------ 243| 0| break; 244| 0| } 245| 4.58M| catNode->fLeftChild = operandNode; 246| 4.58M| operandNode->fParent = catNode; 247| 4.58M| } 248| 0| break; 249| | 250| 1.48k| case doLParen: ------------------ | Branch (250:5): [True: 1.48k, False: 14.5M] ------------------ 251| | // Open Paren. 252| | // The openParen node is a dummy operation type with a low precedence, 253| | // which has the affect of ensuring that any real binary op that 254| | // follows within the parens binds more tightly to the operands than 255| | // stuff outside of the parens. 256| 1.48k| pushNewNode(RBBINode::opLParen); 257| 1.48k| break; 258| | 259| 387| case doExprRParen: ------------------ | Branch (259:5): [True: 387, False: 14.5M] ------------------ 260| 387| fixOpStack(RBBINode::precLParen); 261| 387| break; 262| | 263| 5.14M| case doNOP: ------------------ | Branch (263:5): [True: 5.14M, False: 9.39M] ------------------ 264| 5.14M| break; 265| | 266| 1.31k| case doStartAssign: ------------------ | Branch (266:5): [True: 1.31k, False: 14.5M] ------------------ 267| | // We've just scanned "$variable = " 268| | // The top of the node stack has the $variable ref node. 269| | 270| | // Save the start position of the RHS text in the StartExpression node 271| | // that precedes the $variableReference node on the stack. 272| | // This will eventually be used when saving the full $variable replacement 273| | // text as a string. 274| 1.31k| n = fNodeStack[fNodeStackPtr-1]; 275| 1.31k| n->fFirstPos = fNextIndex; // move past the '=' 276| | 277| | // Push a new start-of-expression node; needed to keep parse of the 278| | // RHS expression happy. 279| 1.31k| pushNewNode(RBBINode::opStart); 280| 1.31k| break; 281| | 282| | 283| | 284| | 285| 1.25k| case doEndAssign: ------------------ | Branch (285:5): [True: 1.25k, False: 14.5M] ------------------ 286| 1.25k| { 287| | // We have reached the end of an assignment statement. 288| | // Current scan char is the ';' that terminates the assignment. 289| | 290| | // Terminate expression, leaves expression parse tree rooted in TOS node. 291| 1.25k| fixOpStack(RBBINode::precStart); 292| 1.25k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (292:17): [True: 2, False: 1.25k] ------------------ 293| 2| break; 294| 2| } 295| | 296| 1.25k| RBBINode *startExprNode = fNodeStack[fNodeStackPtr-2]; 297| 1.25k| RBBINode *varRefNode = fNodeStack[fNodeStackPtr-1]; 298| 1.25k| RBBINode *RHSExprNode = fNodeStack[fNodeStackPtr]; 299| | 300| | // Save original text of right side of assignment, excluding the terminating ';' 301| | // in the root of the node for the right-hand-side expression. 302| 1.25k| RHSExprNode->fFirstPos = startExprNode->fFirstPos; 303| 1.25k| RHSExprNode->fLastPos = fScanIndex; 304| 1.25k| fRB->fRules.extractBetween(RHSExprNode->fFirstPos, RHSExprNode->fLastPos, RHSExprNode->fText); 305| | 306| | // Expression parse tree becomes l. child of the $variable reference node. 307| 1.25k| varRefNode->fLeftChild = RHSExprNode; 308| 1.25k| RHSExprNode->fParent = varRefNode; 309| | 310| | // Make a symbol table entry for the $variableRef node. 311| 1.25k| fSymbolTable->addEntry(varRefNode->fText, varRefNode, *fRB->fStatus); 312| 1.25k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (312:17): [True: 7, False: 1.24k] ------------------ 313| | // This is a round-about way to get the parse position set 314| | // so that duplicate symbols error messages include a line number. 315| 7| UErrorCode t = *fRB->fStatus; 316| 7| *fRB->fStatus = U_ZERO_ERROR; 317| 7| error(t); 318| | // When adding $variableRef to the symbol table fail, Delete 319| | // both nodes because deleting varRefNode will not delete 320| | // RHSExprNode internally. 321| 7| delete RHSExprNode; 322| 7| delete varRefNode; 323| 7| } 324| | 325| | // Clean up the stack. 326| 1.25k| delete startExprNode; 327| 1.25k| fNodeStackPtr-=3; 328| 1.25k| break; 329| 1.25k| } 330| | 331| 41.0k| case doEndOfRule: ------------------ | Branch (331:5): [True: 41.0k, False: 14.4M] ------------------ 332| 41.0k| { 333| 41.0k| fixOpStack(RBBINode::precStart); // Terminate expression, leaves expression 334| 41.0k| if (U_FAILURE(*fRB->fStatus)) { // parse tree rooted in TOS node. ------------------ | Branch (334:13): [True: 1, False: 41.0k] ------------------ 335| 1| break; 336| 1| } 337| |#ifdef RBBI_DEBUG 338| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "rtree")) {printNodeStack("end of rule");} 339| |#endif 340| 41.0k| U_ASSERT(fNodeStackPtr == 1); ------------------ | | 35| 41.0k|# define U_ASSERT(exp) (void)0 ------------------ 341| 41.0k| RBBINode *thisRule = fNodeStack[fNodeStackPtr]; 342| | 343| | // If this rule includes a look-ahead '/', add a endMark node to the 344| | // expression tree. 345| 41.0k| if (fLookAheadRule) { ------------------ | Branch (345:13): [True: 12.4k, False: 28.5k] ------------------ 346| 12.4k| RBBINode *endNode = pushNewNode(RBBINode::endMark); 347| 12.4k| RBBINode *catNode = pushNewNode(RBBINode::opCat); 348| 12.4k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (348:17): [True: 0, False: 12.4k] ------------------ 349| 0| break; 350| 0| } 351| 12.4k| fNodeStackPtr -= 2; 352| 12.4k| catNode->fLeftChild = thisRule; 353| 12.4k| catNode->fRightChild = endNode; 354| 12.4k| fNodeStack[fNodeStackPtr] = catNode; 355| 12.4k| endNode->fVal = fRuleNum; 356| 12.4k| endNode->fLookAheadEnd = true; 357| 12.4k| thisRule = catNode; 358| | 359| | // TODO: Disable chaining out of look-ahead (hard break) rules. 360| | // The break on rule match is forced, so there is no point in building up 361| | // the state table to chain into another rule for a longer match. 362| 12.4k| } 363| | 364| | // Mark this node as being the root of a rule. 365| 41.0k| thisRule->fRuleRoot = true; 366| | 367| | // Flag if chaining into this rule is wanted. 368| | // 369| 41.0k| if (fRB->fChainRules && // If rule chaining is enabled globally via !!chain ------------------ | Branch (369:13): [True: 3.77k, False: 37.2k] ------------------ 370| 41.0k| !fNoChainInRule) { // and no '^' chain-in inhibit was on this rule ------------------ | Branch (370:17): [True: 3.56k, False: 211] ------------------ 371| 3.56k| thisRule->fChainIn = true; 372| 3.56k| } 373| | 374| | 375| | // All rule expressions are ORed together. 376| | // The ';' that terminates an expression really just functions as a '|' with 377| | // a low operator prededence. 378| | // 379| | // Each of the four sets of rules are collected separately. 380| | // (forward, reverse, safe_forward, safe_reverse) 381| | // OR this rule into the appropriate group of them. 382| | // 383| 41.0k| RBBINode **destRules = (fReverseRule? &fRB->fSafeRevTree : fRB->fDefaultTree); ------------------ | Branch (383:33): [True: 324, False: 40.6k] ------------------ 384| | 385| 41.0k| if (*destRules != nullptr) { ------------------ | Branch (385:13): [True: 37.9k, False: 3.05k] ------------------ 386| | // This is not the first rule encountered. 387| | // OR previous stuff (from *destRules) 388| | // with the current rule expression (on the Node Stack) 389| | // with the resulting OR expression going to *destRules 390| | // 391| 37.9k| thisRule = fNodeStack[fNodeStackPtr]; 392| 37.9k| RBBINode *prevRules = *destRules; 393| 37.9k| RBBINode *orNode = pushNewNode(RBBINode::opOr); 394| 37.9k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (394:17): [True: 0, False: 37.9k] ------------------ 395| 0| break; 396| 0| } 397| 37.9k| orNode->fLeftChild = prevRules; 398| 37.9k| prevRules->fParent = orNode; 399| 37.9k| orNode->fRightChild = thisRule; 400| 37.9k| thisRule->fParent = orNode; 401| 37.9k| *destRules = orNode; 402| 37.9k| } 403| 3.05k| else 404| 3.05k| { 405| | // This is the first rule encountered (for this direction). 406| | // Just move its parse tree from the stack to *destRules. 407| 3.05k| *destRules = fNodeStack[fNodeStackPtr]; 408| 3.05k| } 409| 41.0k| fReverseRule = false; // in preparation for the next rule. 410| 41.0k| fLookAheadRule = false; 411| 41.0k| fNoChainInRule = false; 412| 41.0k| fNodeStackPtr = 0; 413| 41.0k| } 414| 0| break; 415| | 416| | 417| 1.09k| case doRuleError: ------------------ | Branch (417:5): [True: 1.09k, False: 14.5M] ------------------ 418| 1.09k| error(U_BRK_RULE_SYNTAX); 419| 1.09k| returnVal = false; 420| 1.09k| break; 421| | 422| | 423| 15| case doVariableNameExpectedErr: ------------------ | Branch (423:5): [True: 15, False: 14.5M] ------------------ 424| 15| error(U_BRK_RULE_SYNTAX); 425| 15| break; 426| | 427| | 428| | // 429| | // Unary operands + ? * 430| | // These all appear after the operand to which they apply. 431| | // When we hit one, the operand (may be a whole sub expression) 432| | // will be on the top of the stack. 433| | // Unary Operator becomes TOS, with the old TOS as its one child. 434| 898| case doUnaryOpPlus: ------------------ | Branch (434:5): [True: 898, False: 14.5M] ------------------ 435| 898| { 436| 898| RBBINode *operandNode = fNodeStack[fNodeStackPtr--]; 437| 898| RBBINode *plusNode = pushNewNode(RBBINode::opPlus); 438| 898| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (438:17): [True: 0, False: 898] ------------------ 439| 0| break; 440| 0| } 441| 898| plusNode->fLeftChild = operandNode; 442| 898| operandNode->fParent = plusNode; 443| 898| } 444| 0| break; 445| | 446| 335| case doUnaryOpQuestion: ------------------ | Branch (446:5): [True: 335, False: 14.5M] ------------------ 447| 335| { 448| 335| RBBINode *operandNode = fNodeStack[fNodeStackPtr--]; 449| 335| RBBINode *qNode = pushNewNode(RBBINode::opQuestion); 450| 335| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (450:17): [True: 0, False: 335] ------------------ 451| 0| break; 452| 0| } 453| 335| qNode->fLeftChild = operandNode; 454| 335| operandNode->fParent = qNode; 455| 335| } 456| 0| break; 457| | 458| 2.50k| case doUnaryOpStar: ------------------ | Branch (458:5): [True: 2.50k, False: 14.5M] ------------------ 459| 2.50k| { 460| 2.50k| RBBINode *operandNode = fNodeStack[fNodeStackPtr--]; 461| 2.50k| RBBINode *starNode = pushNewNode(RBBINode::opStar); 462| 2.50k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (462:17): [True: 0, False: 2.50k] ------------------ 463| 0| break; 464| 0| } 465| 2.50k| starNode->fLeftChild = operandNode; 466| 2.50k| operandNode->fParent = starNode; 467| 2.50k| } 468| 0| break; 469| | 470| 4.60M| case doRuleChar: ------------------ | Branch (470:5): [True: 4.60M, False: 9.93M] ------------------ 471| | // A "Rule Character" is any single character that is a literal part 472| | // of the regular expression. Like a, b and c in the expression "(abc*) | [:L:]" 473| | // These are pretty uncommon in break rules; the terms are more commonly 474| | // sets. To keep things uniform, treat these characters like as 475| | // sets that just happen to contain only one character. 476| 4.60M| { 477| 4.60M| n = pushNewNode(RBBINode::setRef); 478| 4.60M| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (478:17): [True: 1, False: 4.60M] ------------------ 479| 1| break; 480| 1| } 481| 4.60M| findSetFor(UnicodeString(fC.fChar), n); 482| 4.60M| n->fFirstPos = fScanIndex; 483| 4.60M| n->fLastPos = fNextIndex; 484| 4.60M| fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText); 485| 4.60M| break; 486| 4.60M| } 487| | 488| 6.77k| case doDotAny: ------------------ | Branch (488:5): [True: 6.77k, False: 14.5M] ------------------ 489| | // scanned a ".", meaning match any single character. 490| 6.77k| { 491| 6.77k| n = pushNewNode(RBBINode::setRef); 492| 6.77k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (492:17): [True: 1, False: 6.77k] ------------------ 493| 1| break; 494| 1| } 495| 6.77k| findSetFor(UnicodeString(true, kAny, 3), n); 496| 6.77k| n->fFirstPos = fScanIndex; 497| 6.77k| n->fLastPos = fNextIndex; 498| 6.77k| fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText); 499| 6.77k| break; 500| 6.77k| } 501| | 502| 14.8k| case doSlash: ------------------ | Branch (502:5): [True: 14.8k, False: 14.5M] ------------------ 503| | // Scanned a '/', which identifies a look-ahead break position in a rule. 504| 14.8k| n = pushNewNode(RBBINode::lookAhead); 505| 14.8k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (505:13): [True: 1, False: 14.8k] ------------------ 506| 1| break; 507| 1| } 508| 14.8k| n->fVal = fRuleNum; 509| 14.8k| n->fFirstPos = fScanIndex; 510| 14.8k| n->fLastPos = fNextIndex; 511| 14.8k| fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText); 512| 14.8k| fLookAheadRule = true; 513| 14.8k| break; 514| | 515| | 516| 1.00k| case doStartTagValue: ------------------ | Branch (516:5): [True: 1.00k, False: 14.5M] ------------------ 517| | // Scanned a '{', the opening delimiter for a tag value within a rule. 518| 1.00k| n = pushNewNode(RBBINode::tag); 519| 1.00k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (519:13): [True: 1, False: 1.00k] ------------------ 520| 1| break; 521| 1| } 522| 1.00k| n->fVal = 0; 523| 1.00k| n->fFirstPos = fScanIndex; 524| 1.00k| n->fLastPos = fNextIndex; 525| 1.00k| break; 526| | 527| 1.61k| case doTagDigit: ------------------ | Branch (527:5): [True: 1.61k, False: 14.5M] ------------------ 528| | // Just scanned a decimal digit that's part of a tag value 529| 1.61k| { 530| 1.61k| n = fNodeStack[fNodeStackPtr]; 531| 1.61k| uint32_t v = u_charDigitValue(fC.fChar); ------------------ | | 220| 1.61k|#define u_charDigitValue U_ICU_ENTRY_POINT_RENAME(u_charDigitValue) | | ------------------ | | | | 123| 1.61k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.61k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.61k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 532| 1.61k| U_ASSERT(v < 10); ------------------ | | 35| 1.61k|# define U_ASSERT(exp) (void)0 ------------------ 533| 1.61k| int64_t updated = static_cast(n->fVal)*10 + v; 534| | // Avoid overflow n->fVal 535| 1.61k| if (updated > INT32_MAX) { ------------------ | Branch (535:17): [True: 3, False: 1.61k] ------------------ 536| 3| error(U_BRK_RULE_SYNTAX); 537| 3| break; 538| 3| } 539| 1.61k| n->fVal = static_cast(updated); 540| 1.61k| break; 541| 1.61k| } 542| | 543| 977| case doTagValue: ------------------ | Branch (543:5): [True: 977, False: 14.5M] ------------------ 544| 977| n = fNodeStack[fNodeStackPtr]; 545| 977| n->fLastPos = fNextIndex; 546| 977| fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText); 547| 977| break; 548| | 549| 30| case doTagExpectedError: ------------------ | Branch (549:5): [True: 30, False: 14.5M] ------------------ 550| 30| error(U_BRK_MALFORMED_RULE_TAG); 551| 30| returnVal = false; 552| 30| break; 553| | 554| 2.35k| case doOptionStart: ------------------ | Branch (554:5): [True: 2.35k, False: 14.5M] ------------------ 555| | // Scanning a !!option. At the start of string. 556| 2.35k| fOptionStart = fScanIndex; 557| 2.35k| break; 558| | 559| 2.35k| case doOptionEnd: ------------------ | Branch (559:5): [True: 2.35k, False: 14.5M] ------------------ 560| 2.35k| { 561| 2.35k| UnicodeString opt(fRB->fRules, fOptionStart, fScanIndex-fOptionStart); 562| 2.35k| if (opt == UNICODE_STRING("chain", 5)) { ------------------ | | 121| 2.35k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (562:17): [True: 348, False: 2.01k] ------------------ 563| 348| fRB->fChainRules = true; 564| 2.01k| } else if (opt == UNICODE_STRING("forward", 7)) { ------------------ | | 121| 2.01k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (564:24): [True: 364, False: 1.64k] ------------------ 565| 364| fRB->fDefaultTree = &fRB->fForwardTree; 566| 1.64k| } else if (opt == UNICODE_STRING("reverse", 7)) { ------------------ | | 121| 1.64k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (566:24): [True: 613, False: 1.03k] ------------------ 567| 613| fRB->fDefaultTree = &fRB->fReverseTree; 568| 1.03k| } else if (opt == UNICODE_STRING("safe_forward", 12)) { ------------------ | | 121| 1.03k|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (568:24): [True: 757, False: 277] ------------------ 569| 757| fRB->fDefaultTree = &fRB->fSafeFwdTree; 570| 757| } else if (opt == UNICODE_STRING("safe_reverse", 12)) { ------------------ | | 121| 277|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (570:24): [True: 79, False: 198] ------------------ 571| 79| fRB->fDefaultTree = &fRB->fSafeRevTree; 572| 198| } else if (opt == UNICODE_STRING("lookAheadHardBreak", 18)) { ------------------ | | 121| 198|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (572:24): [True: 37, False: 161] ------------------ 573| 37| fRB->fLookAheadHardBreak = true; 574| 161| } else if (opt == UNICODE_STRING("quoted_literals_only", 20)) { ------------------ | | 121| 161|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (574:24): [True: 2, False: 159] ------------------ 575| 2| fRuleSets[kRuleSet_rule_char-128].clear(); 576| 159| } else if (opt == UNICODE_STRING("unquoted_literals", 17)) { ------------------ | | 121| 159|# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length) ------------------ | Branch (576:24): [True: 1, False: 158] ------------------ 577| 1| fRuleSets[kRuleSet_rule_char-128].applyPattern(UnicodeString(gRuleSet_rule_char_pattern), *fRB->fStatus); 578| 158| } else { 579| 158| error(U_BRK_UNRECOGNIZED_OPTION); 580| 158| } 581| 2.35k| } 582| 2.35k| break; 583| | 584| 348| case doReverseDir: ------------------ | Branch (584:5): [True: 348, False: 14.5M] ------------------ 585| 348| fReverseRule = true; 586| 348| break; 587| | 588| 2.06k| case doStartVariableName: ------------------ | Branch (588:5): [True: 2.06k, False: 14.5M] ------------------ 589| 2.06k| n = pushNewNode(RBBINode::varRef); 590| 2.06k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (590:13): [True: 1, False: 2.06k] ------------------ 591| 1| break; 592| 1| } 593| 2.06k| n->fFirstPos = fScanIndex; 594| 2.06k| break; 595| | 596| 2.04k| case doEndVariableName: ------------------ | Branch (596:5): [True: 2.04k, False: 14.5M] ------------------ 597| 2.04k| n = fNodeStack[fNodeStackPtr]; 598| 2.04k| if (n==nullptr || n->fType != RBBINode::varRef) { ------------------ | Branch (598:13): [True: 0, False: 2.04k] | Branch (598:27): [True: 0, False: 2.04k] ------------------ 599| 0| error(U_BRK_INTERNAL_ERROR); 600| 0| break; 601| 0| } 602| 2.04k| n->fLastPos = fScanIndex; 603| 2.04k| fRB->fRules.extractBetween(n->fFirstPos+1, n->fLastPos, n->fText); 604| | // Look the newly scanned name up in the symbol table 605| | // If there's an entry, set the l. child of the var ref to the replacement expression. 606| | // (We also pass through here when scanning assignments, but no harm is done, other 607| | // than a slight wasted effort that seems hard to avoid. Lookup will be null) 608| 2.04k| n->fLeftChild = fSymbolTable->lookupNode(n->fText); 609| 2.04k| break; 610| | 611| 725| case doCheckVarDef: ------------------ | Branch (611:5): [True: 725, False: 14.5M] ------------------ 612| 725| n = fNodeStack[fNodeStackPtr]; 613| 725| if (n->fLeftChild == nullptr) { ------------------ | Branch (613:13): [True: 12, False: 713] ------------------ 614| 12| error(U_BRK_UNDEFINED_VARIABLE); 615| 12| returnVal = false; 616| 12| } 617| 725| break; 618| | 619| 43.6k| case doExprFinished: ------------------ | Branch (619:5): [True: 43.6k, False: 14.4M] ------------------ 620| 43.6k| break; 621| | 622| 4| case doRuleErrorAssignExpr: ------------------ | Branch (622:5): [True: 4, False: 14.5M] ------------------ 623| 4| error(U_BRK_ASSIGN_ERROR); 624| 4| returnVal = false; 625| 4| break; 626| | 627| 0| case doExit: ------------------ | Branch (627:5): [True: 0, False: 14.5M] ------------------ 628| 0| returnVal = false; 629| 0| break; 630| | 631| 20.2k| case doScanUnicodeSet: ------------------ | Branch (631:5): [True: 20.2k, False: 14.5M] ------------------ 632| 20.2k| scanSet(); 633| 20.2k| break; 634| | 635| 0| default: ------------------ | Branch (635:5): [True: 0, False: 14.5M] ------------------ 636| 0| error(U_BRK_INTERNAL_ERROR); 637| 0| returnVal = false; 638| 0| break; 639| 14.5M| } 640| 14.5M| return returnVal && U_SUCCESS(*fRB->fStatus); ------------------ | Branch (640:12): [True: 14.5M, False: 1.13k] | Branch (640:25): [True: 14.5M, False: 4.34k] ------------------ 641| 14.5M|} _ZN6icu_7815RBBIRuleScanner5errorE10UErrorCode: 652| 5.73k|void RBBIRuleScanner::error(UErrorCode e) { 653| 5.73k| if (U_SUCCESS(*fRB->fStatus)) { ------------------ | Branch (653:9): [True: 5.73k, False: 0] ------------------ 654| 5.73k| *fRB->fStatus = e; 655| 5.73k| if (fRB->fParseError) { ------------------ | Branch (655:13): [True: 5.73k, False: 0] ------------------ 656| 5.73k| fRB->fParseError->line = fLineNum; 657| 5.73k| fRB->fParseError->offset = fCharNum; 658| 5.73k| fRB->fParseError->preContext[0] = 0; 659| 5.73k| fRB->fParseError->postContext[0] = 0; 660| 5.73k| } 661| 5.73k| } 662| 5.73k|} _ZN6icu_7815RBBIRuleScanner10fixOpStackENS_8RBBINode12OpPrecedenceE: 682| 4.64M|void RBBIRuleScanner::fixOpStack(RBBINode::OpPrecedence p) { 683| 4.64M| RBBINode *n; 684| | // printNodeStack("entering fixOpStack()"); 685| 9.23M| for (;;) { 686| 9.23M| n = fNodeStack[fNodeStackPtr-1]; // an operator node 687| 9.23M| if (n->fPrecedence == 0) { ------------------ | Branch (687:13): [True: 0, False: 9.23M] ------------------ 688| 0| RBBIDebugPuts("RBBIRuleScanner::fixOpStack, bad operator node"); 689| 0| error(U_BRK_INTERNAL_ERROR); 690| 0| return; 691| 0| } 692| | 693| 9.23M| if (n->fPrecedence < p || n->fPrecedence <= RBBINode::precLParen) { ------------------ | Branch (693:13): [True: 4.59M, False: 4.63M] | Branch (693:35): [True: 42.6k, False: 4.59M] ------------------ 694| | // The most recent operand goes with the current operator, 695| | // not with the previously stacked one. 696| 4.64M| break; 697| 4.64M| } 698| | // Stack operator is a binary op ( '|' or concatenation) 699| | // TOS operand becomes right child of this operator. 700| | // Resulting subexpression becomes the TOS operand. 701| 4.59M| n->fRightChild = fNodeStack[fNodeStackPtr]; 702| 4.59M| fNodeStack[fNodeStackPtr]->fParent = n; 703| 4.59M| fNodeStackPtr--; 704| | // printNodeStack("looping in fixOpStack() "); 705| 4.59M| } 706| | 707| 4.64M| if (p <= RBBINode::precLParen) { ------------------ | Branch (707:9): [True: 42.6k, False: 4.59M] ------------------ 708| | // Scan is at a right paren or end of expression. 709| | // The scanned item must match the stack, or else there was an error. 710| | // Discard the left paren (or start expr) node from the stack, 711| | // leaving the completed (sub)expression as TOS. 712| 42.6k| if (n->fPrecedence != p) { ------------------ | Branch (712:17): [True: 7, False: 42.6k] ------------------ 713| | // Right paren encountered matched start of expression node, or 714| | // end of expression matched with a left paren node. 715| 7| error(U_BRK_MISMATCHED_PAREN); 716| 7| } 717| 42.6k| fNodeStack[fNodeStackPtr-1] = fNodeStack[fNodeStackPtr]; 718| 42.6k| fNodeStackPtr--; 719| | // Delete the now-discarded LParen or Start node. 720| 42.6k| delete n; 721| 42.6k| } 722| | // printNodeStack("leaving fixOpStack()"); 723| 4.64M|} _ZN6icu_7815RBBIRuleScanner10findSetForERKNS_13UnicodeStringEPNS_8RBBINodeEPNS_10UnicodeSetE: 744| 4.62M|void RBBIRuleScanner::findSetFor(const UnicodeString &s, RBBINode *node, UnicodeSet *setToAdopt) { 745| | 746| 4.62M| RBBISetTableEl *el; 747| | 748| | // First check whether we've already cached a set for this string. 749| | // If so, just use the cached set in the new node. 750| | // delete any set provided by the caller, since we own it. 751| 4.62M| el = static_cast(uhash_get(fSetTable, &s)); ------------------ | | 1007| 4.62M|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 4.62M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.62M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.62M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 4.62M| if (el != nullptr) { ------------------ | Branch (752:9): [True: 4.45M, False: 174k] ------------------ 753| 4.45M| delete setToAdopt; 754| 4.45M| node->fLeftChild = el->val; 755| 4.45M| U_ASSERT(node->fLeftChild->fType == RBBINode::uset); ------------------ | | 35| 4.45M|# define U_ASSERT(exp) (void)0 ------------------ 756| 4.45M| return; 757| 4.45M| } 758| | 759| | // Haven't seen this set before. 760| | // If the caller didn't provide us with a prebuilt set, 761| | // create a new UnicodeSet now. 762| 174k| if (setToAdopt == nullptr) { ------------------ | Branch (762:9): [True: 168k, False: 5.52k] ------------------ 763| 168k| if (s.compare(kAny, -1) == 0) { ------------------ | Branch (763:13): [True: 955, False: 167k] ------------------ 764| 955| setToAdopt = new UnicodeSet(0x000000, 0x10ffff); 765| 167k| } else { 766| 167k| UChar32 c; 767| 167k| c = s.char32At(0); 768| 167k| setToAdopt = new UnicodeSet(c, c); 769| 167k| } 770| 168k| if (setToAdopt == nullptr) { ------------------ | Branch (770:13): [True: 0, False: 168k] ------------------ 771| 0| error(U_MEMORY_ALLOCATION_ERROR); 772| 0| return; 773| 0| } 774| 168k| } 775| | 776| | // 777| | // Make a new uset node to refer to this UnicodeSet 778| | // This new uset node becomes the child of the caller's setReference node. 779| | // 780| 174k| UErrorCode localStatus = U_ZERO_ERROR; 781| 174k| RBBINode *usetNode = new RBBINode(RBBINode::uset, localStatus); 782| 174k| if (usetNode == nullptr) { ------------------ | Branch (782:9): [True: 0, False: 174k] ------------------ 783| 0| localStatus = U_MEMORY_ALLOCATION_ERROR; 784| 0| } 785| 174k| if (U_FAILURE(localStatus)) { ------------------ | Branch (785:9): [True: 0, False: 174k] ------------------ 786| 0| delete usetNode; 787| 0| error(localStatus); 788| 0| delete setToAdopt; 789| 0| return; 790| 0| } 791| 174k| usetNode->fInputSet = setToAdopt; 792| 174k| usetNode->fParent = node; 793| 174k| node->fLeftChild = usetNode; 794| 174k| usetNode->fText = s; 795| | 796| | 797| | // 798| | // Add the new uset node to the list of all uset nodes. 799| | // 800| 174k| fRB->fUSetNodes->addElement(usetNode, *fRB->fStatus); 801| | 802| | 803| | // 804| | // Add the new set to the set hash table. 805| | // 806| 174k| el = static_cast(uprv_malloc(sizeof(RBBISetTableEl))); ------------------ | | 1524| 174k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 174k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 174k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 174k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 807| 174k| UnicodeString *tkey = new UnicodeString(s); 808| 174k| if (tkey == nullptr || el == nullptr || setToAdopt == nullptr) { ------------------ | Branch (808:9): [True: 0, False: 174k] | Branch (808:28): [True: 0, False: 174k] | Branch (808:45): [True: 0, False: 174k] ------------------ 809| | // Delete to avoid memory leak 810| 0| delete tkey; 811| 0| tkey = nullptr; 812| 0| uprv_free(el); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 813| 0| el = nullptr; 814| 0| delete setToAdopt; 815| 0| setToAdopt = nullptr; 816| | 817| 0| error(U_MEMORY_ALLOCATION_ERROR); 818| 0| return; 819| 0| } 820| 174k| el->key = tkey; 821| 174k| el->val = usetNode; 822| 174k| uhash_put(fSetTable, el->key, el, fRB->fStatus); ------------------ | | 1032| 174k|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 174k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 174k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 174k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 823| 174k|} _ZN6icu_7815RBBIRuleScanner10stripRulesERKNS_13UnicodeStringE: 849| 2.63k|UnicodeString RBBIRuleScanner::stripRules(const UnicodeString &rules) { 850| 2.63k| UnicodeString strippedRules; 851| 2.63k| int32_t rulesLength = rules.length(); 852| | 853| 7.92M| for (int32_t idx=0; idx= fRB->fRules.length()) { ------------------ | Branch (875:9): [True: 3.95k, False: 16.1M] ------------------ 876| 3.95k| return static_cast(-1); 877| 3.95k| } 878| 16.1M| ch = fRB->fRules.char32At(fNextIndex); 879| 16.1M| if (U_IS_SURROGATE(ch)) { ------------------ | | 193| 16.1M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ | | | Branch (193:27): [True: 203, False: 16.1M] | | ------------------ ------------------ 880| 203| error(U_ILLEGAL_CHAR_FOUND); 881| 203| return U_SENTINEL; ------------------ | | 469| 203|#define U_SENTINEL (-1) ------------------ 882| 203| } 883| 16.1M| fNextIndex = fRB->fRules.moveIndex32(fNextIndex, 1); 884| | 885| 16.1M| if (ch == chCR || ------------------ | Branch (885:9): [True: 1.16k, False: 16.1M] ------------------ 886| 16.1M| ch == chNEL || ------------------ | Branch (886:9): [True: 1.26k, False: 16.1M] ------------------ 887| 16.1M| ch == chLS || ------------------ | Branch (887:9): [True: 522, False: 16.1M] ------------------ 888| 16.1M| (ch == chLF && fLastChar != chCR)) { ------------------ | Branch (888:10): [True: 65.6k, False: 16.0M] | Branch (888:24): [True: 65.4k, False: 205] ------------------ 889| | // Character is starting a new line. Bump up the line number, and 890| | // reset the column to 0. 891| 68.4k| fLineNum++; 892| 68.4k| fCharNum=0; 893| 68.4k| if (fQuoteMode) { ------------------ | Branch (893:13): [True: 1, False: 68.4k] ------------------ 894| 1| error(U_BRK_NEW_LINE_IN_QUOTED_STRING); 895| 1| fQuoteMode = false; 896| 1| } 897| 68.4k| } 898| 16.0M| else { 899| | // Character is not starting a new line. Except in the case of a 900| | // LF following a CR, increment the column position. 901| 16.0M| if (ch != chLF) { ------------------ | Branch (901:13): [True: 16.0M, False: 205] ------------------ 902| 16.0M| fCharNum++; 903| 16.0M| } 904| 16.0M| } 905| 16.1M| fLastChar = ch; 906| 16.1M| return ch; 907| 16.1M|} _ZN6icu_7815RBBIRuleScanner8nextCharERNS0_12RBBIRuleCharE: 917| 5.21M|void RBBIRuleScanner::nextChar(RBBIRuleChar &c) { 918| | 919| | // Unicode Character constants needed for the processing done by nextChar(), 920| | // in hex because literals wont work on EBCDIC machines. 921| | 922| 5.21M| fScanIndex = fNextIndex; 923| 5.21M| c.fChar = nextCharLL(); 924| 5.21M| c.fEscaped = false; 925| | 926| | // 927| | // check for '' sequence. 928| | // These are recognized in all contexts, whether in quoted text or not. 929| | // 930| 5.21M| if (c.fChar == chApos) { ------------------ | Branch (930:9): [True: 1.00k, False: 5.21M] ------------------ 931| 1.00k| if (fRB->fRules.char32At(fNextIndex) == chApos) { ------------------ | Branch (931:13): [True: 198, False: 810] ------------------ 932| 198| c.fChar = nextCharLL(); // get nextChar officially so character counts 933| 198| c.fEscaped = true; // stay correct. 934| 198| } 935| 810| else 936| 810| { 937| | // Single quote, by itself. 938| | // Toggle quoting mode. 939| | // Return either '(' or ')', because quotes cause a grouping of the quoted text. 940| 810| fQuoteMode = !fQuoteMode; 941| 810| if (fQuoteMode) { ------------------ | Branch (941:17): [True: 427, False: 383] ------------------ 942| 427| c.fChar = chLParen; 943| 427| } else { 944| 383| c.fChar = chRParen; 945| 383| } 946| 810| c.fEscaped = false; // The paren that we return is not escaped. 947| 810| return; 948| 810| } 949| 1.00k| } 950| | 951| 5.21M| if (c.fChar == static_cast(-1)) { ------------------ | Branch (951:9): [True: 3.91k, False: 5.20M] ------------------ 952| 3.91k| return; 953| 3.91k| } 954| 5.20M| if (fQuoteMode) { ------------------ | Branch (954:9): [True: 1.52k, False: 5.20M] ------------------ 955| 1.52k| c.fEscaped = true; 956| 1.52k| } 957| 5.20M| else 958| 5.20M| { 959| | // We are not in a 'quoted region' of the source. 960| | // 961| 5.20M| if (c.fChar == chPound) { ------------------ | Branch (961:13): [True: 1.56k, False: 5.20M] ------------------ 962| | // Start of a comment. Consume the rest of it. 963| | // The new-line char that terminates the comment is always returned. 964| | // It will be treated as white-space, and serves to break up anything 965| | // that might otherwise incorrectly clump together with a comment in 966| | // the middle (a variable name, for example.) 967| 1.56k| int32_t commentStart = fScanIndex; 968| 278k| for (;;) { 969| 278k| c.fChar = nextCharLL(); 970| 278k| if (c.fChar == static_cast(-1) || // EOF ------------------ | Branch (970:21): [True: 72, False: 278k] ------------------ 971| 278k| c.fChar == chCR || ------------------ | Branch (971:21): [True: 223, False: 278k] ------------------ 972| 278k| c.fChar == chLF || ------------------ | Branch (972:21): [True: 1.18k, False: 277k] ------------------ 973| 278k| c.fChar == chNEL || ------------------ | Branch (973:21): [True: 20, False: 277k] ------------------ 974| 278k| c.fChar == chLS) {break;} ------------------ | Branch (974:21): [True: 63, False: 277k] ------------------ 975| 278k| } 976| 281k| for (int32_t i=commentStart; ifStrippedRules.setCharAt(i, u' '); 978| 279k| } 979| 1.56k| } 980| 5.20M| if (c.fChar == static_cast(-1)) { ------------------ | Branch (980:13): [True: 72, False: 5.20M] ------------------ 981| 72| return; 982| 72| } 983| | 984| | // 985| | // check for backslash escaped characters. 986| | // Use UnicodeString::unescapeAt() to handle them. 987| | // 988| 5.20M| if (c.fChar == chBackSlash) { ------------------ | Branch (988:13): [True: 78.9k, False: 5.12M] ------------------ 989| 78.9k| c.fEscaped = true; 990| 78.9k| int32_t startX = fNextIndex; 991| 78.9k| c.fChar = fRB->fRules.unescapeAt(fNextIndex); 992| 78.9k| if (fNextIndex == startX) { ------------------ | Branch (992:17): [True: 109, False: 78.8k] ------------------ 993| 109| error(U_BRK_HEX_DIGITS_EXPECTED); 994| 109| } 995| 78.9k| fCharNum += fNextIndex-startX; 996| 78.9k| } 997| 5.20M| } 998| | // putc(c.fChar, stdout); 999| 5.20M|} _ZN6icu_7815RBBIRuleScanner5parseEv: 1009| 8.41k|void RBBIRuleScanner::parse() { 1010| 8.41k| uint16_t state; 1011| 8.41k| const RBBIRuleTableEl *tableEl; 1012| | 1013| 8.41k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (1013:9): [True: 0, False: 8.41k] ------------------ 1014| 0| return; 1015| 0| } 1016| | 1017| 8.41k| state = 1; 1018| 8.41k| nextChar(fC); 1019| | // 1020| | // Main loop for the rule parsing state machine. 1021| | // Runs once per state transition. 1022| | // Each time through optionally performs, depending on the state table, 1023| | // - an advance to the the next input char 1024| | // - an action to be performed. 1025| | // - pushing or popping a state to/from the local state return stack. 1026| | // 1027| 14.5M| for (;;) { 1028| | // Bail out if anything has gone wrong. 1029| | // RBBI rule file parsing stops on the first error encountered. 1030| 14.5M| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (1030:13): [True: 144, False: 14.5M] ------------------ 1031| 144| break; 1032| 144| } 1033| | 1034| | // Quit if state == 0. This is the normal way to exit the state machine. 1035| | // 1036| 14.5M| if (state == 0) { ------------------ | Branch (1036:13): [True: 2.79k, False: 14.5M] ------------------ 1037| 2.79k| break; 1038| 2.79k| } 1039| | 1040| | // Find the state table element that matches the input char from the rule, or the 1041| | // class of the input character. Start with the first table row for this 1042| | // state, then linearly scan forward until we find a row that matches the 1043| | // character. The last row for each state always matches all characters, so 1044| | // the search will stop there, if not before. 1045| | // 1046| 14.5M| tableEl = &gRuleParseStateTable[state]; 1047| | #ifdef RBBI_DEBUG 1048| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "scan")) { 1049| | RBBIDebugPrintf("char, line, col = (\'%c\', %d, %d) state=%s ", 1050| | fC.fChar, fLineNum, fCharNum, RBBIRuleStateNames[state]); 1051| | } 1052| | #endif 1053| | 1054| 52.3M| for (;;) { 1055| | #ifdef RBBI_DEBUG 1056| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "scan")) { RBBIDebugPrintf("."); fflush(stdout);} 1057| | #endif 1058| 52.3M| if (tableEl->fCharClass < 127 && fC.fEscaped == false && tableEl->fCharClass == fC.fChar) { ------------------ | Branch (1058:17): [True: 14.7M, False: 37.5M] | Branch (1058:46): [True: 14.5M, False: 200k] | Branch (1058:72): [True: 180k, False: 14.3M] ------------------ 1059| | // Table row specified an individual character, not a set, and 1060| | // the input character is not escaped, and 1061| | // the input character matched it. 1062| 180k| break; 1063| 180k| } 1064| 52.1M| if (tableEl->fCharClass == 255) { ------------------ | Branch (1064:17): [True: 4.71M, False: 47.4M] ------------------ 1065| | // Table row specified default, match anything character class. 1066| 4.71M| break; 1067| 4.71M| } 1068| 47.4M| if (tableEl->fCharClass == 254 && fC.fEscaped) { ------------------ | Branch (1068:17): [True: 9.33M, False: 38.0M] | Branch (1068:47): [True: 148k, False: 9.18M] ------------------ 1069| | // Table row specified "escaped" and the char was escaped. 1070| 148k| break; 1071| 148k| } 1072| 47.2M| if (tableEl->fCharClass == 253 && fC.fEscaped && ------------------ | Branch (1072:17): [True: 0, False: 47.2M] | Branch (1072:47): [True: 0, False: 0] ------------------ 1073| 47.2M| (fC.fChar == 0x50 || fC.fChar == 0x70 )) { ------------------ | Branch (1073:18): [True: 0, False: 0] | Branch (1073:38): [True: 0, False: 0] ------------------ 1074| | // Table row specified "escaped P" and the char is either 'p' or 'P'. 1075| 0| break; 1076| 0| } 1077| 47.2M| if (tableEl->fCharClass == 252 && fC.fChar == static_cast(-1)) { ------------------ | Branch (1077:17): [True: 47.7k, False: 47.2M] | Branch (1077:47): [True: 2.79k, False: 44.9k] ------------------ 1078| | // Table row specified eof and we hit eof on the input. 1079| 2.79k| break; 1080| 2.79k| } 1081| | 1082| 47.2M| if (tableEl->fCharClass >= 128 && tableEl->fCharClass < 240 && // Table specs a char class && ------------------ | Branch (1082:17): [True: 32.6M, False: 14.5M] | Branch (1082:47): [True: 23.4M, False: 9.22M] ------------------ 1083| 47.2M| fC.fEscaped == false && // char is not escaped && ------------------ | Branch (1083:17): [True: 23.3M, False: 66.7k] ------------------ 1084| 47.2M| fC.fChar != static_cast(-1)) { // char is not EOF ------------------ | Branch (1084:17): [True: 23.3M, False: 8.01k] ------------------ 1085| 23.3M| U_ASSERT((tableEl->fCharClass-128) < UPRV_LENGTHOF(fRuleSets)); ------------------ | | 35| 23.3M|# define U_ASSERT(exp) (void)0 ------------------ 1086| 23.3M| if (fRuleSets[tableEl->fCharClass-128].contains(fC.fChar)) { ------------------ | Branch (1086:21): [True: 9.48M, False: 13.8M] ------------------ 1087| | // Table row specified a character class, or set of characters, 1088| | // and the current char matches it. 1089| 9.48M| break; 1090| 9.48M| } 1091| 23.3M| } 1092| | 1093| | // No match on this row, advance to the next row for this state, 1094| 37.7M| tableEl++; 1095| 37.7M| } 1096| 14.5M| if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "scan")) { RBBIDebugPuts("");} ------------------ | | 41| 0|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (41:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1096:13): [True: 0, False: 14.5M] ------------------ 1097| | 1098| | // 1099| | // We've found the row of the state table that matches the current input 1100| | // character from the rules string. 1101| | // Perform any action specified by this row in the state table. 1102| 14.5M| if (doParseActions(static_cast(tableEl->fAction)) == false) { ------------------ | Branch (1102:13): [True: 5.47k, False: 14.5M] ------------------ 1103| | // Break out of the state machine loop if the 1104| | // the action signalled some kind of error, or 1105| | // the action was to exit, occurs on normal end-of-rules-input. 1106| 5.47k| break; 1107| 5.47k| } 1108| | 1109| 14.5M| if (tableEl->fPushState != 0) { ------------------ | Branch (1109:13): [True: 71.7k, False: 14.4M] ------------------ 1110| 71.7k| fStackPtr++; 1111| 71.7k| if (fStackPtr >= kStackSize) { ------------------ | Branch (1111:17): [True: 1, False: 71.7k] ------------------ 1112| 1| error(U_BRK_INTERNAL_ERROR); 1113| 1| RBBIDebugPuts("RBBIRuleScanner::parse() - state stack overflow."); 1114| 1| fStackPtr--; 1115| 1| } 1116| 71.7k| fStack[fStackPtr] = tableEl->fPushState; 1117| 71.7k| } 1118| | 1119| 14.5M| if (tableEl->fNextChar) { ------------------ | Branch (1119:13): [True: 5.20M, False: 9.32M] ------------------ 1120| 5.20M| nextChar(fC); 1121| 5.20M| } 1122| | 1123| | // Get the next state from the table entry, or from the 1124| | // state stack if the next state was specified as "pop". 1125| 14.5M| if (tableEl->fNextState != 255) { ------------------ | Branch (1125:13): [True: 14.4M, False: 62.2k] ------------------ 1126| 14.4M| state = tableEl->fNextState; 1127| 14.4M| } else { 1128| 62.2k| state = fStack[fStackPtr]; 1129| 62.2k| fStackPtr--; 1130| 62.2k| if (fStackPtr < 0) { ------------------ | Branch (1130:17): [True: 0, False: 62.2k] ------------------ 1131| 0| error(U_BRK_INTERNAL_ERROR); 1132| 0| RBBIDebugPuts("RBBIRuleScanner::parse() - state stack underflow."); 1133| 0| fStackPtr++; 1134| 0| } 1135| 62.2k| } 1136| | 1137| 14.5M| } 1138| | 1139| 8.41k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (1139:9): [True: 5.62k, False: 2.79k] ------------------ 1140| 5.62k| return; 1141| 5.62k| } 1142| | 1143| | // If there are no forward rules set an error. 1144| | // 1145| 2.79k| if (fRB->fForwardTree == nullptr) { ------------------ | Branch (1145:9): [True: 115, False: 2.67k] ------------------ 1146| 115| error(U_BRK_RULE_SYNTAX); 1147| 115| return; 1148| 115| } 1149| | 1150| | // 1151| | // Parsing of the input RBBI rules is complete. 1152| | // We now have a parse tree for the rule expressions 1153| | // and a list of all UnicodeSets that are referenced. 1154| | // 1155| |#ifdef RBBI_DEBUG 1156| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "symbols")) {fSymbolTable->rbbiSymtablePrint();} 1157| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "ptree")) { 1158| | RBBIDebugPrintf("Completed Forward Rules Parse Tree...\n"); 1159| | RBBINode::printTree(fRB->fForwardTree, true); 1160| | RBBIDebugPrintf("\nCompleted Reverse Rules Parse Tree...\n"); 1161| | RBBINode::printTree(fRB->fReverseTree, true); 1162| | RBBIDebugPrintf("\nCompleted Safe Point Forward Rules Parse Tree...\n"); 1163| | RBBINode::printTree(fRB->fSafeFwdTree, true); 1164| | RBBIDebugPrintf("\nCompleted Safe Point Reverse Rules Parse Tree...\n"); 1165| | RBBINode::printTree(fRB->fSafeRevTree, true); 1166| | } 1167| |#endif 1168| 2.79k|} _ZN6icu_7815RBBIRuleScanner11pushNewNodeENS_8RBBINode8NodeTypeE: 1193| 9.35M|RBBINode *RBBIRuleScanner::pushNewNode(RBBINode::NodeType t) { 1194| 9.35M| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (1194:9): [True: 0, False: 9.35M] ------------------ 1195| 0| return nullptr; 1196| 0| } 1197| 9.35M| if (fNodeStackPtr >= kStackSize - 1) { ------------------ | Branch (1197:9): [True: 6, False: 9.35M] ------------------ 1198| 6| error(U_BRK_RULE_SYNTAX); 1199| 6| RBBIDebugPuts("RBBIRuleScanner::pushNewNode - stack overflow."); 1200| 6| return nullptr; 1201| 6| } 1202| 9.35M| fNodeStackPtr++; 1203| 9.35M| fNodeStack[fNodeStackPtr] = new RBBINode(t, *fRB->fStatus); 1204| 9.35M| if (fNodeStack[fNodeStackPtr] == nullptr) { ------------------ | Branch (1204:9): [True: 0, False: 9.35M] ------------------ 1205| 0| *fRB->fStatus = U_MEMORY_ALLOCATION_ERROR; 1206| 0| } 1207| 9.35M| return fNodeStack[fNodeStackPtr]; 1208| 9.35M|} _ZN6icu_7815RBBIRuleScanner7scanSetEv: 1226| 20.2k|void RBBIRuleScanner::scanSet() { 1227| 20.2k| ParsePosition pos; 1228| 20.2k| int startPos; 1229| 20.2k| int i; 1230| | 1231| 20.2k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (1231:9): [True: 0, False: 20.2k] ------------------ 1232| 0| return; 1233| 0| } 1234| | 1235| 20.2k| pos.setIndex(fScanIndex); 1236| 20.2k| startPos = fScanIndex; 1237| 20.2k| UErrorCode localStatus = U_ZERO_ERROR; 1238| 20.2k| LocalPointer uset(new UnicodeSet(), localStatus); 1239| 20.2k| if (U_FAILURE(localStatus)) { ------------------ | Branch (1239:9): [True: 0, False: 20.2k] ------------------ 1240| 0| error(localStatus); 1241| 0| return; 1242| 0| } 1243| 20.2k| uset->applyPatternIgnoreSpace(fRB->fRules, pos, fSymbolTable, localStatus); 1244| 20.2k| if (U_FAILURE(localStatus)) { ------------------ | Branch (1244:9): [True: 3.93k, False: 16.3k] ------------------ 1245| | // TODO: Get more accurate position of the error from UnicodeSet's return info. 1246| | // UnicodeSet appears to not be reporting correctly at this time. 1247| | #ifdef RBBI_DEBUG 1248| | RBBIDebugPrintf("UnicodeSet parse position.ErrorIndex = %d\n", pos.getIndex()); 1249| | #endif 1250| 3.93k| error(localStatus); 1251| 3.93k| return; 1252| 3.93k| } 1253| | 1254| | // Verify that the set contains at least one code point. 1255| | // 1256| 16.3k| U_ASSERT(uset.isValid()); ------------------ | | 35| 16.3k|# define U_ASSERT(exp) (void)0 ------------------ 1257| 16.3k| UnicodeSet tempSet(*uset); 1258| | // Use tempSet to handle the case that the UnicodeSet contains 1259| | // only string element, such as [{ab}] and treat it as empty set. 1260| 16.3k| tempSet.removeAllStrings(); 1261| 16.3k| if (tempSet.isEmpty()) { ------------------ | Branch (1261:9): [True: 44, False: 16.3k] ------------------ 1262| | // This set is empty. 1263| | // Make it an error, because it almost certainly is not what the user wanted. 1264| | // Also, avoids having to think about corner cases in the tree manipulation code 1265| | // that occurs later on. 1266| 44| error(U_BRK_RULE_EMPTY_SET); 1267| 44| return; 1268| 44| } 1269| | 1270| | 1271| | // Advance the RBBI parse position over the UnicodeSet pattern. 1272| | // Don't just set fScanIndex because the line/char positions maintained 1273| | // for error reporting would be thrown off. 1274| 16.3k| i = pos.getIndex(); 1275| 10.6M| for (;U_SUCCESS(*fRB->fStatus);) { ------------------ | Branch (1275:11): [True: 10.6M, False: 170] ------------------ 1276| 10.6M| if (fNextIndex >= i) { ------------------ | Branch (1276:13): [True: 16.1k, False: 10.6M] ------------------ 1277| 16.1k| break; 1278| 16.1k| } 1279| 10.6M| nextCharLL(); 1280| 10.6M| } 1281| | 1282| 16.3k| if (U_SUCCESS(*fRB->fStatus)) { ------------------ | Branch (1282:9): [True: 16.1k, False: 170] ------------------ 1283| 16.1k| RBBINode *n; 1284| | 1285| 16.1k| n = pushNewNode(RBBINode::setRef); 1286| 16.1k| if (U_FAILURE(*fRB->fStatus)) { ------------------ | Branch (1286:13): [True: 1, False: 16.1k] ------------------ 1287| 1| return; 1288| 1| } 1289| 16.1k| n->fFirstPos = startPos; 1290| 16.1k| n->fLastPos = fNextIndex; 1291| 16.1k| fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText); 1292| | // findSetFor() serves several purposes here: 1293| | // - Adopts storage for the UnicodeSet, will be responsible for deleting. 1294| | // - Maintains collection of all sets in use, needed later for establishing 1295| | // character categories for run time engine. 1296| | // - Eliminates mulitiple instances of the same set. 1297| | // - Creates a new uset node if necessary (if this isn't a duplicate.) 1298| 16.1k| findSetFor(n->fText, n, uset.orphan()); 1299| 16.1k| } 1300| | 1301| 16.3k|} _ZN6icu_7815RBBIRuleScanner8numRulesEv: 1303| 5.27k|int32_t RBBIRuleScanner::numRules() { 1304| 5.27k| return fRuleNum; 1305| 5.27k|} rbbiscan.cpp:_ZL20RBBISetTable_deleterPv: 74| 174k|static void U_CALLCONV RBBISetTable_deleter(void *p) { 75| 174k| icu::RBBISetTableEl *px = (icu::RBBISetTableEl *)p; 76| 174k| delete px->key; 77| | // Note: px->val is owned by the linked list "fSetsListHead" in scanner. 78| | // Don't delete the value nodes here. 79| 174k| uprv_free(px); ------------------ | | 1503| 174k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 174k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 174k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 174k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 80| 174k|} _ZN6icu_7815RBBIRuleScanner12RBBIRuleCharC2Ev: 57| 8.41k| RBBIRuleChar() : fChar(0), fEscaped(false) {} _ZN6icu_7814RBBISetBuilderC2EPNS_15RBBIRuleBuilderE: 55| 8.41k|{ 56| 8.41k| fRB = rb; 57| 8.41k| fStatus = rb->fStatus; 58| 8.41k| fRangeList = nullptr; 59| 8.41k| fMutableTrie = nullptr; 60| 8.41k| fTrie = nullptr; 61| 8.41k| fTrieSize = 0; 62| 8.41k| fGroupCount = 0; 63| 8.41k| fSawBOF = false; 64| 8.41k|} _ZN6icu_7814RBBISetBuilderD2Ev: 73| 8.41k|{ 74| 8.41k| RangeDescriptor *nextRangeDesc; 75| | 76| | // Walk through & delete the linked list of RangeDescriptors 77| 881k| for (nextRangeDesc = fRangeList; nextRangeDesc!=nullptr;) { ------------------ | Branch (77:38): [True: 872k, False: 8.41k] ------------------ 78| 872k| RangeDescriptor *r = nextRangeDesc; 79| 872k| nextRangeDesc = r->fNext; 80| 872k| delete r; 81| 872k| } 82| | 83| 8.41k| ucptrie_close(fTrie); ------------------ | | 804| 8.41k|#define ucptrie_close U_ICU_ENTRY_POINT_RENAME(ucptrie_close) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 84| 8.41k| umutablecptrie_close(fMutableTrie); ------------------ | | 1254| 8.41k|#define umutablecptrie_close U_ICU_ENTRY_POINT_RENAME(umutablecptrie_close) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 85| 8.41k|} _ZN6icu_7814RBBISetBuilder11buildRangesEv: 96| 2.67k|void RBBISetBuilder::buildRanges() { 97| 2.67k| RBBINode *usetNode; 98| 2.67k| RangeDescriptor *rlRange; 99| | 100| 2.67k| if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "usets")) {printSets();} ------------------ | | 41| 0|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (41:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (100:9): [True: 0, False: 2.67k] ------------------ 101| | 102| | // 103| | // Initialize the process by creating a single range encompassing all characters 104| | // that is in no sets. 105| | // 106| 2.67k| fRangeList = new RangeDescriptor(*fStatus); // will check for status here 107| 2.67k| if (fRangeList == nullptr) { ------------------ | Branch (107:9): [True: 0, False: 2.67k] ------------------ 108| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 109| 0| return; 110| 0| } 111| 2.67k| fRangeList->fStartChar = 0; 112| 2.67k| fRangeList->fEndChar = 0x10ffff; 113| | 114| 2.67k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (114:9): [True: 0, False: 2.67k] ------------------ 115| 0| return; 116| 0| } 117| | 118| | // 119| | // Find the set of non-overlapping ranges of characters 120| | // 121| 2.67k| int ni; 122| 113k| for (ni=0; ; ni++) { // Loop over each of the UnicodeSets encountered in the input rules 123| 113k| usetNode = static_cast(this->fRB->fUSetNodes->elementAt(ni)); 124| 113k| if (usetNode==nullptr) { ------------------ | Branch (124:13): [True: 2.67k, False: 110k] ------------------ 125| 2.67k| break; 126| 2.67k| } 127| | 128| 110k| UnicodeSet *inputSet = usetNode->fInputSet; 129| 110k| int32_t inputSetRangeCount = inputSet->getRangeCount(); 130| 110k| int inputSetRangeIndex = 0; 131| 110k| rlRange = fRangeList; 132| | 133| 1.15M| for (;;) { 134| 1.15M| if (inputSetRangeIndex >= inputSetRangeCount) { ------------------ | Branch (134:17): [True: 110k, False: 1.04M] ------------------ 135| 110k| break; 136| 110k| } 137| 1.04M| UChar32 inputSetRangeBegin = inputSet->getRangeStart(inputSetRangeIndex); 138| 1.04M| UChar32 inputSetRangeEnd = inputSet->getRangeEnd(inputSetRangeIndex); 139| | 140| | // skip over ranges from the range list that are completely 141| | // below the current range from the input unicode set. 142| 100M| while (rlRange->fEndChar < inputSetRangeBegin) { ------------------ | Branch (142:20): [True: 99.8M, False: 1.04M] ------------------ 143| 99.8M| rlRange = rlRange->fNext; 144| 99.8M| } 145| | 146| | // If the start of the range from the range list is before with 147| | // the start of the range from the unicode set, split the range list range 148| | // in two, with one part being before (wholly outside of) the unicode set 149| | // and the other containing the rest. 150| | // Then continue the loop; the post-split current range will then be skipped 151| | // over 152| 1.04M| if (rlRange->fStartChar < inputSetRangeBegin) { ------------------ | Branch (152:17): [True: 428k, False: 619k] ------------------ 153| 428k| rlRange->split(inputSetRangeBegin, *fStatus); 154| 428k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (154:21): [True: 0, False: 428k] ------------------ 155| 0| return; 156| 0| } 157| 428k| continue; 158| 428k| } 159| | 160| | // Same thing at the end of the ranges... 161| | // If the end of the range from the range list doesn't coincide with 162| | // the end of the range from the unicode set, split the range list 163| | // range in two. The first part of the split range will be 164| | // wholly inside the Unicode set. 165| 619k| if (rlRange->fEndChar > inputSetRangeEnd) { ------------------ | Branch (165:17): [True: 441k, False: 177k] ------------------ 166| 441k| rlRange->split(inputSetRangeEnd+1, *fStatus); 167| 441k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (167:21): [True: 0, False: 441k] ------------------ 168| 0| return; 169| 0| } 170| 441k| } 171| | 172| | // The current rlRange is now entirely within the UnicodeSet range. 173| | // Add this unicode set to the list of sets for this rlRange 174| 619k| if (rlRange->fIncludesSets->indexOf(usetNode) == -1) { ------------------ | Branch (174:17): [True: 619k, False: 0] ------------------ 175| 619k| rlRange->fIncludesSets->addElement(usetNode, *fStatus); 176| 619k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (176:21): [True: 0, False: 619k] ------------------ 177| 0| return; 178| 0| } 179| 619k| } 180| | 181| | // Advance over ranges that we are finished with. 182| 619k| if (inputSetRangeEnd == rlRange->fEndChar) { ------------------ | Branch (182:17): [True: 502k, False: 116k] ------------------ 183| 502k| inputSetRangeIndex++; 184| 502k| } 185| 619k| rlRange = rlRange->fNext; 186| 619k| } 187| 110k| } 188| | 189| 2.67k| if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "range")) { printRanges();} ------------------ | | 41| 0|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (41:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (189:9): [True: 0, False: 2.67k] ------------------ 190| | 191| | // 192| | // Group the above ranges, with each group consisting of one or more 193| | // ranges that are in exactly the same set of original UnicodeSets. 194| | // The groups are numbered, and these group numbers are the set of 195| | // input symbols recognized by the run-time state machine. 196| | // 197| | // Numbering: # 0 (state table column 0) is unused. 198| | // # 1 is reserved - table column 1 is for end-of-input 199| | // # 2 is reserved - table column 2 is for beginning-of-input 200| | // # 3 is the first range list. 201| | // 202| 2.67k| RangeDescriptor *rlSearchRange; 203| 2.67k| int32_t dictGroupCount = 0; 204| | 205| 875k| for (rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) { ------------------ | Branch (205:32): [True: 872k, False: 2.67k] ------------------ 206| 158M| for (rlSearchRange=fRangeList; rlSearchRange != rlRange; rlSearchRange=rlSearchRange->fNext) { ------------------ | Branch (206:40): [True: 158M, False: 113k] ------------------ 207| 158M| if (rlRange->fIncludesSets->equals(*rlSearchRange->fIncludesSets)) { ------------------ | Branch (207:17): [True: 759k, False: 157M] ------------------ 208| 759k| rlRange->fNum = rlSearchRange->fNum; 209| 759k| rlRange->fIncludesDict = rlSearchRange->fIncludesDict; 210| 759k| break; 211| 759k| } 212| 158M| } 213| 872k| if (rlRange->fNum == 0) { ------------------ | Branch (213:13): [True: 113k, False: 759k] ------------------ 214| 113k| rlRange->fFirstInGroup = true; 215| 113k| if (rlRange->isDictionaryRange()) { ------------------ | Branch (215:17): [True: 0, False: 113k] ------------------ 216| 0| rlRange->fNum = ++dictGroupCount; 217| 0| rlRange->fIncludesDict = true; 218| 113k| } else { 219| 113k| fGroupCount++; 220| 113k| rlRange->fNum = fGroupCount+2; 221| 113k| addValToSets(rlRange->fIncludesSets, rlRange->fNum); 222| 113k| } 223| 113k| } 224| 872k| } 225| | 226| | // Move the character category numbers for any dictionary ranges up, so that they 227| | // immediately follow the non-dictionary ranges. 228| | 229| 2.67k| fDictCategoriesStart = fGroupCount + 3; 230| 875k| for (rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) { ------------------ | Branch (230:32): [True: 872k, False: 2.67k] ------------------ 231| 872k| if (rlRange->fIncludesDict) { ------------------ | Branch (231:13): [True: 0, False: 872k] ------------------ 232| 0| rlRange->fNum += fDictCategoriesStart - 1; 233| 0| if (rlRange->fFirstInGroup) { ------------------ | Branch (233:17): [True: 0, False: 0] ------------------ 234| 0| addValToSets(rlRange->fIncludesSets, rlRange->fNum); 235| 0| } 236| 0| } 237| 872k| } 238| 2.67k| fGroupCount += dictGroupCount; 239| | 240| | 241| | // Handle input sets that contain the special string {eof}. 242| | // Column 1 of the state table is reserved for EOF on input. 243| | // Column 2 is reserved for before-the-start-input. 244| | // (This column can be optimized away later if there are no rule 245| | // references to {bof}.) 246| | // Add this column value (1 or 2) to the equivalent expression 247| | // subtree for each UnicodeSet that contains the string {eof} 248| | // Because {bof} and {eof} are not characters in the normal sense, 249| | // they don't affect the computation of the ranges or TRIE. 250| | 251| 2.67k| UnicodeString eofString(u"eof"); 252| 2.67k| UnicodeString bofString(u"bof"); 253| 113k| for (ni=0; ; ni++) { // Loop over each of the UnicodeSets encountered in the input rules 254| 113k| usetNode = static_cast(this->fRB->fUSetNodes->elementAt(ni)); 255| 113k| if (usetNode==nullptr) { ------------------ | Branch (255:13): [True: 2.67k, False: 110k] ------------------ 256| 2.67k| break; 257| 2.67k| } 258| 110k| UnicodeSet *inputSet = usetNode->fInputSet; 259| 110k| if (inputSet->contains(eofString)) { ------------------ | Branch (259:13): [True: 40, False: 110k] ------------------ 260| 40| addValToSet(usetNode, 1); 261| 40| } 262| 110k| if (inputSet->contains(bofString)) { ------------------ | Branch (262:13): [True: 611, False: 109k] ------------------ 263| 611| addValToSet(usetNode, 2); 264| 611| fSawBOF = true; 265| 611| } 266| 110k| } 267| | 268| | 269| 2.67k| if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "rgroup")) {printRangeGroups();} ------------------ | | 41| 0|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (41:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (269:9): [True: 0, False: 2.67k] ------------------ 270| 2.67k| if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "esets")) {printSets();} ------------------ | | 41| 0|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (41:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (270:9): [True: 0, False: 2.67k] ------------------ 271| 2.67k|} _ZN6icu_7814RBBISetBuilder9buildTrieEv: 278| 2.67k|void RBBISetBuilder::buildTrie() { 279| 2.67k| fMutableTrie = umutablecptrie_open( ------------------ | | 1259| 2.67k|#define umutablecptrie_open U_ICU_ENTRY_POINT_RENAME(umutablecptrie_open) | | ------------------ | | | | 123| 2.67k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.67k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.67k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 280| 2.67k| 0, // Initial value for all code points. 281| 2.67k| 0, // Error value for out-of-range input. 282| 2.67k| fStatus); 283| | 284| 820k| for (RangeDescriptor *range = fRangeList; range!=nullptr && U_SUCCESS(*fStatus); range=range->fNext) { ------------------ | Branch (284:47): [True: 817k, False: 2.63k] | Branch (284:65): [True: 817k, False: 41] ------------------ 285| 817k| umutablecptrie_setRange(fMutableTrie, ------------------ | | 1261| 817k|#define umutablecptrie_setRange U_ICU_ENTRY_POINT_RENAME(umutablecptrie_setRange) | | ------------------ | | | | 123| 817k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 817k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 817k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 286| 817k| range->fStartChar, // Range start 287| 817k| range->fEndChar, // Range end (inclusive) 288| 817k| range->fNum, // value for range 289| 817k| fStatus); 290| 817k| } 291| 2.67k|} _ZN6icu_7814RBBISetBuilder15mergeCategoriesENSt3__14pairIiiEE: 294| 12.4k|void RBBISetBuilder::mergeCategories(IntPair categories) { 295| 12.4k| U_ASSERT(categories.first >= 1); ------------------ | | 35| 12.4k|# define U_ASSERT(exp) (void)0 ------------------ 296| 12.4k| U_ASSERT(categories.second > categories.first); ------------------ | | 35| 12.4k|# define U_ASSERT(exp) (void)0 ------------------ 297| 12.4k| U_ASSERT((categories.first < fDictCategoriesStart && categories.second < fDictCategoriesStart) || ------------------ | | 35| 12.4k|# define U_ASSERT(exp) (void)0 ------------------ 298| 12.4k| (categories.first >= fDictCategoriesStart && categories.second >= fDictCategoriesStart)); 299| | 300| 20.8M| for (RangeDescriptor *rd = fRangeList; rd != nullptr; rd = rd->fNext) { ------------------ | Branch (300:44): [True: 20.8M, False: 12.4k] ------------------ 301| 20.8M| int32_t rangeNum = rd->fNum; 302| 20.8M| if (rangeNum == categories.second) { ------------------ | Branch (302:13): [True: 38.3k, False: 20.8M] ------------------ 303| 38.3k| rd->fNum = categories.first; 304| 20.8M| } else if (rangeNum > categories.second) { ------------------ | Branch (304:20): [True: 5.28M, False: 15.5M] ------------------ 305| 5.28M| rd->fNum--; 306| 5.28M| } 307| 20.8M| } 308| 12.4k| --fGroupCount; 309| 12.4k| if (categories.second <= fDictCategoriesStart) { ------------------ | Branch (309:9): [True: 12.4k, False: 0] ------------------ 310| 12.4k| --fDictCategoriesStart; 311| 12.4k| } 312| 12.4k|} _ZN6icu_7814RBBISetBuilder11getTrieSizeEv: 320| 2.63k|int32_t RBBISetBuilder::getTrieSize() { 321| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (321:9): [True: 0, False: 2.63k] ------------------ 322| 0| return 0; 323| 0| } 324| 2.63k| if (fTrie == nullptr) { ------------------ | Branch (324:9): [True: 2.63k, False: 0] ------------------ 325| 2.63k| bool use8Bits = getNumCharCategories() <= kMaxCharCategoriesFor8BitsTrie; 326| 2.63k| fTrie = umutablecptrie_buildImmutable( ------------------ | | 1252| 2.63k|#define umutablecptrie_buildImmutable U_ICU_ENTRY_POINT_RENAME(umutablecptrie_buildImmutable) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 327| 2.63k| fMutableTrie, 328| 2.63k| UCPTRIE_TYPE_FAST, 329| 2.63k| use8Bits ? UCPTRIE_VALUE_BITS_8 : UCPTRIE_VALUE_BITS_16, ------------------ | Branch (329:13): [True: 2.56k, False: 66] ------------------ 330| 2.63k| fStatus); 331| 2.63k| UErrorCode bufferStatus = *fStatus; 332| 2.63k| fTrieSize = ucptrie_toBinary(fTrie, nullptr, 0, &bufferStatus); ------------------ | | 815| 2.63k|#define ucptrie_toBinary U_ICU_ENTRY_POINT_RENAME(ucptrie_toBinary) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 333| 2.63k| if (bufferStatus != U_BUFFER_OVERFLOW_ERROR && U_FAILURE(bufferStatus)) { ------------------ | Branch (333:13): [True: 0, False: 2.63k] | Branch (333:56): [True: 0, False: 0] ------------------ 334| 0| *fStatus = bufferStatus; 335| 0| } 336| 2.63k| } 337| 2.63k| return fTrieSize; 338| 2.63k|} _ZN6icu_7814RBBISetBuilder13serializeTrieEPh: 348| 2.63k|void RBBISetBuilder::serializeTrie(uint8_t *where) { 349| 2.63k| ucptrie_toBinary(fTrie, ------------------ | | 815| 2.63k|#define ucptrie_toBinary U_ICU_ENTRY_POINT_RENAME(ucptrie_toBinary) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 350| 2.63k| where, // Buffer 351| 2.63k| fTrieSize, // Capacity 352| 2.63k| fStatus); 353| 2.63k|} _ZN6icu_7814RBBISetBuilder12addValToSetsEPNS_7UVectorEj: 369| 113k|void RBBISetBuilder::addValToSets(UVector *sets, uint32_t val) { 370| 113k| int32_t ix; 371| | 372| 317k| for (ix=0; ixsize(); ix++) { ------------------ | Branch (372:16): [True: 203k, False: 113k] ------------------ 373| 203k| RBBINode* usetNode = static_cast(sets->elementAt(ix)); 374| 203k| addValToSet(usetNode, val); 375| 203k| } 376| 113k|} _ZN6icu_7814RBBISetBuilder11addValToSetEPNS_8RBBINodeEj: 378| 204k|void RBBISetBuilder::addValToSet(RBBINode *usetNode, uint32_t val) { 379| 204k| RBBINode *leafNode = new RBBINode(RBBINode::leafChar, *fStatus); 380| 204k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (380:9): [True: 0, False: 204k] ------------------ 381| 0| delete leafNode; 382| 0| return; 383| 0| } 384| 204k| if (leafNode == nullptr) { ------------------ | Branch (384:9): [True: 0, False: 204k] ------------------ 385| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 386| 0| return; 387| 0| } 388| 204k| leafNode->fVal = static_cast(val); 389| 204k| if (usetNode->fLeftChild == nullptr) { ------------------ | Branch (389:9): [True: 110k, False: 93.8k] ------------------ 390| 110k| usetNode->fLeftChild = leafNode; 391| 110k| leafNode->fParent = usetNode; 392| 110k| } else { 393| | // There are already input symbols present for this set. 394| | // Set up an OR node, with the previous stuff as the left child 395| | // and the new value as the right child. 396| 93.8k| RBBINode *orNode = new RBBINode(RBBINode::opOr, *fStatus); 397| 93.8k| if (orNode == nullptr) { ------------------ | Branch (397:13): [True: 0, False: 93.8k] ------------------ 398| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 399| 0| } 400| 93.8k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (400:13): [True: 0, False: 93.8k] ------------------ 401| 0| delete orNode; 402| 0| delete leafNode; 403| 0| return; 404| 0| } 405| 93.8k| orNode->fLeftChild = usetNode->fLeftChild; 406| 93.8k| orNode->fRightChild = leafNode; 407| 93.8k| orNode->fLeftChild->fParent = orNode; 408| 93.8k| orNode->fRightChild->fParent = orNode; 409| 93.8k| usetNode->fLeftChild = orNode; 410| 93.8k| orNode->fParent = usetNode; 411| 93.8k| } 412| 204k|} _ZNK6icu_7814RBBISetBuilder20getNumCharCategoriesEv: 420| 69.9k|int32_t RBBISetBuilder::getNumCharCategories() const { 421| 69.9k| return fGroupCount + 3; 422| 69.9k|} _ZNK6icu_7814RBBISetBuilder22getDictCategoriesStartEv: 430| 255k|int32_t RBBISetBuilder::getDictCategoriesStart() const { 431| 255k| return fDictCategoriesStart; 432| 255k|} _ZNK6icu_7814RBBISetBuilder6sawBOFEv: 440| 7.90k|UBool RBBISetBuilder::sawBOF() const { 441| 7.90k| return fSawBOF; 442| 7.90k|} _ZN6icu_7815RangeDescriptorC2ERKS0_R10UErrorCode: 597| 870k| fStartChar(other.fStartChar), fEndChar {other.fEndChar}, fNum {other.fNum}, 598| 870k| fIncludesDict{other.fIncludesDict}, fFirstInGroup{other.fFirstInGroup} { 599| | 600| 870k| if (U_FAILURE(status)) { ------------------ | Branch (600:9): [True: 0, False: 870k] ------------------ 601| 0| return; 602| 0| } 603| 870k| fIncludesSets = new UVector(status); 604| 870k| if (this->fIncludesSets == nullptr) { ------------------ | Branch (604:9): [True: 0, False: 870k] ------------------ 605| 0| status = U_MEMORY_ALLOCATION_ERROR; 606| 0| } 607| 870k| if (U_FAILURE(status)) { ------------------ | Branch (607:9): [True: 0, False: 870k] ------------------ 608| 0| return; 609| 0| } 610| | 611| 1.16M| for (int32_t i=0; isize(); i++) { ------------------ | Branch (611:23): [True: 298k, False: 870k] ------------------ 612| 298k| this->fIncludesSets->addElement(other.fIncludesSets->elementAt(i), status); 613| 298k| } 614| 870k|} _ZN6icu_7815RangeDescriptorC2ER10UErrorCode: 622| 2.67k|RangeDescriptor::RangeDescriptor(UErrorCode &status) { 623| 2.67k| if (U_FAILURE(status)) { ------------------ | Branch (623:9): [True: 0, False: 2.67k] ------------------ 624| 0| return; 625| 0| } 626| 2.67k| fIncludesSets = new UVector(status); 627| 2.67k| if (fIncludesSets == nullptr) { ------------------ | Branch (627:9): [True: 0, False: 2.67k] ------------------ 628| 0| status = U_MEMORY_ALLOCATION_ERROR; 629| 0| } 630| 2.67k|} _ZN6icu_7815RangeDescriptorD2Ev: 638| 872k|RangeDescriptor::~RangeDescriptor() { 639| 872k| delete fIncludesSets; 640| 872k| fIncludesSets = nullptr; 641| 872k|} _ZN6icu_7815RangeDescriptor5splitEiR10UErrorCode: 648| 870k|void RangeDescriptor::split(UChar32 where, UErrorCode &status) { 649| 870k| U_ASSERT(where>fStartChar && where<=fEndChar); ------------------ | | 35| 870k|# define U_ASSERT(exp) (void)0 ------------------ 650| 870k| RangeDescriptor *nr = new RangeDescriptor(*this, status); 651| 870k| if(nr == nullptr) { ------------------ | Branch (651:8): [True: 0, False: 870k] ------------------ 652| 0| status = U_MEMORY_ALLOCATION_ERROR; 653| 0| return; 654| 0| } 655| 870k| if (U_FAILURE(status)) { ------------------ | Branch (655:9): [True: 0, False: 870k] ------------------ 656| 0| delete nr; 657| 0| return; 658| 0| } 659| | // RangeDescriptor copy constructor copies all fields. 660| | // Only need to update those that are different after the split. 661| 870k| nr->fStartChar = where; 662| 870k| this->fEndChar = where-1; 663| 870k| nr->fNext = this->fNext; 664| 870k| this->fNext = nr; 665| 870k|} _ZN6icu_7815RangeDescriptor17isDictionaryRangeEv: 683| 113k|bool RangeDescriptor::isDictionaryRange() { 684| 113k| static const char16_t *dictionary = u"dictionary"; 685| 317k| for (int32_t i=0; isize(); i++) { ------------------ | Branch (685:23): [True: 203k, False: 113k] ------------------ 686| 203k| RBBINode* usetNode = static_cast(fIncludesSets->elementAt(i)); 687| 203k| RBBINode *setRef = usetNode->fParent; 688| 203k| if (setRef != nullptr) { ------------------ | Branch (688:13): [True: 203k, False: 0] ------------------ 689| 203k| RBBINode *varRef = setRef->fParent; 690| 203k| if (varRef && varRef->fType == RBBINode::varRef) { ------------------ | Branch (690:17): [True: 203k, False: 644] | Branch (690:27): [True: 337, False: 202k] ------------------ 691| 337| const UnicodeString *setName = &varRef->fText; 692| 337| if (setName->compare(dictionary, -1) == 0) { ------------------ | Branch (692:21): [True: 0, False: 337] ------------------ 693| 0| return true; 694| 0| } 695| 337| } 696| 203k| } 697| 203k| } 698| 113k| return false; 699| 113k|} _ZN6icu_7815RBBISymbolTableC2EPNS_15RBBIRuleScannerERKNS_13UnicodeStringER10UErrorCode: 44| 8.41k| : fRules(rules), fRuleScanner(rs), ffffString(static_cast(0xffff)) 45| 8.41k|{ 46| 8.41k| fHashTable = nullptr; 47| 8.41k| fCachedSetLookup = nullptr; 48| | 49| 8.41k| fHashTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, &status); ------------------ | | 1030| 8.41k|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ fHashTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, &status); ------------------ | | 1017| 8.41k|#define uhash_hashUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hashUnicodeString) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ fHashTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, &status); ------------------ | | 999| 8.41k|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 50| | // uhash_open checks status 51| 8.41k| if (U_FAILURE(status)) { ------------------ | Branch (51:9): [True: 0, False: 8.41k] ------------------ 52| 0| return; 53| 0| } 54| 8.41k| uhash_setValueDeleter(fHashTable, RBBISymbolTableEntry_deleter); ------------------ | | 1044| 8.41k|#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDeleter) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 55| 8.41k|} _ZN6icu_7815RBBISymbolTableD2Ev: 60| 8.41k|{ 61| 8.41k| uhash_close(fHashTable); ------------------ | | 991| 8.41k|#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close) | | ------------------ | | | | 123| 8.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 62| 8.41k|} _ZNK6icu_7815RBBISymbolTable6lookupERKNS_13UnicodeStringE: 73| 55.7k|{ 74| 55.7k| RBBISymbolTableEntry *el; 75| 55.7k| RBBINode *varRefNode; 76| 55.7k| RBBINode *exprNode; 77| 55.7k| RBBINode *usetNode; 78| 55.7k| const UnicodeString *retString; 79| 55.7k| RBBISymbolTable *This = const_cast(this); // cast off const 80| | 81| 55.7k| el = static_cast(uhash_get(fHashTable, &s)); ------------------ | | 1007| 55.7k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 55.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 55.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 55.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 82| 55.7k| if (el == nullptr) { ------------------ | Branch (82:9): [True: 2.79k, False: 53.0k] ------------------ 83| 2.79k| return nullptr; 84| 2.79k| } 85| | 86| 53.0k| varRefNode = el->val; 87| 53.0k| exprNode = varRefNode->fLeftChild; // Root node of expression for variable 88| 53.0k| if (exprNode->fType == RBBINode::setRef) { ------------------ | Branch (88:9): [True: 1.35k, False: 51.6k] ------------------ 89| | // The $variable refers to a single UnicodeSet 90| | // return the ffffString, which will subsequently be interpreted as a 91| | // stand-in character for the set by RBBISymbolTable::lookupMatcher() 92| 1.35k| usetNode = exprNode->fLeftChild; 93| 1.35k| This->fCachedSetLookup = usetNode->fInputSet; 94| 1.35k| retString = &ffffString; 95| 1.35k| } 96| 51.6k| else 97| 51.6k| { 98| | // The variable refers to something other than just a set. 99| | // return the original source string for the expression 100| 51.6k| retString = &exprNode->fText; 101| 51.6k| This->fCachedSetLookup = nullptr; 102| 51.6k| } 103| 53.0k| return retString; 104| 55.7k|} _ZNK6icu_7815RBBISymbolTable13lookupMatcherEi: 120| 22.8M|{ 121| 22.8M| UnicodeSet *retVal = nullptr; 122| 22.8M| RBBISymbolTable *This = const_cast(this); // cast off const 123| 22.8M| if (ch == 0xffff) { ------------------ | Branch (123:9): [True: 776k, False: 22.1M] ------------------ 124| 776k| retVal = fCachedSetLookup; 125| 776k| This->fCachedSetLookup = nullptr; 126| 776k| } 127| 22.8M| return retVal; 128| 22.8M|} _ZNK6icu_7815RBBISymbolTable14parseReferenceERKNS_13UnicodeStringERNS_13ParsePositionEi: 142| 74.2k|{ 143| 74.2k| int32_t start = pos.getIndex(); 144| 74.2k| int32_t i = start; 145| 74.2k| UnicodeString result; 146| 3.69M| while (i < limit) { ------------------ | Branch (146:12): [True: 3.69M, False: 1.12k] ------------------ 147| 3.69M| char16_t c = text.charAt(i); 148| 3.69M| if ((i==start && !u_isIDStart(c)) || !u_isIDPart(c)) { ------------------ | | 297| 74.0k|#define u_isIDStart U_ICU_ENTRY_POINT_RENAME(u_isIDStart) | | ------------------ | | | | 123| 74.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 74.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 74.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((i==start && !u_isIDStart(c)) || !u_isIDPart(c)) { ------------------ | | 296| 3.67M|#define u_isIDPart U_ICU_ENTRY_POINT_RENAME(u_isIDPart) | | ------------------ | | | | 123| 3.67M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.67M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.67M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (148:14): [True: 74.0k, False: 3.62M] | Branch (148:26): [True: 18.2k, False: 55.7k] | Branch (148:46): [True: 54.8k, False: 3.62M] ------------------ 149| 73.1k| break; 150| 73.1k| } 151| 3.62M| ++i; 152| 3.62M| } 153| 74.2k| if (i == start) { // No valid name chars ------------------ | Branch (153:9): [True: 18.4k, False: 55.7k] ------------------ 154| 18.4k| return result; // Indicate failure with empty string 155| 18.4k| } 156| 55.7k| pos.setIndex(i); 157| 55.7k| text.extractBetween(start, i, result); 158| 55.7k| return result; 159| 74.2k|} _ZNK6icu_7815RBBISymbolTable10lookupNodeERKNS_13UnicodeStringE: 168| 2.04k|RBBINode *RBBISymbolTable::lookupNode(const UnicodeString &key) const{ 169| | 170| 2.04k| RBBINode *retNode = nullptr; 171| 2.04k| RBBISymbolTableEntry *el; 172| | 173| 2.04k| el = static_cast(uhash_get(fHashTable, &key)); ------------------ | | 1007| 2.04k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 2.04k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.04k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.04k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 174| 2.04k| if (el != nullptr) { ------------------ | Branch (174:9): [True: 722, False: 1.32k] ------------------ 175| 722| retNode = el->val; 176| 722| } 177| 2.04k| return retNode; 178| 2.04k|} _ZN6icu_7815RBBISymbolTable8addEntryERKNS_13UnicodeStringEPNS_8RBBINodeER10UErrorCode: 187| 1.25k|void RBBISymbolTable::addEntry (const UnicodeString &key, RBBINode *val, UErrorCode &err) { 188| 1.25k| RBBISymbolTableEntry *e; 189| | /* test for buffer overflows */ 190| 1.25k| if (U_FAILURE(err)) { ------------------ | Branch (190:9): [True: 0, False: 1.25k] ------------------ 191| 0| return; 192| 0| } 193| 1.25k| e = static_cast(uhash_get(fHashTable, &key)); ------------------ | | 1007| 1.25k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 1.25k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.25k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.25k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 194| 1.25k| if (e != nullptr) { ------------------ | Branch (194:9): [True: 7, False: 1.24k] ------------------ 195| 7| err = U_BRK_VARIABLE_REDFINITION; 196| 7| return; 197| 7| } 198| | 199| 1.24k| e = new RBBISymbolTableEntry; 200| 1.24k| if (e == nullptr) { ------------------ | Branch (200:9): [True: 0, False: 1.24k] ------------------ 201| 0| err = U_MEMORY_ALLOCATION_ERROR; 202| 0| return; 203| 0| } 204| 1.24k| e->key = key; 205| 1.24k| e->val = val; 206| 1.24k| uhash_put( fHashTable, &e->key, e, &err); ------------------ | | 1032| 1.24k|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 1.24k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.24k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.24k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 207| 1.24k|} _ZN6icu_7820RBBISymbolTableEntryC2Ev: 210| 1.24k|RBBISymbolTableEntry::RBBISymbolTableEntry() : UMemory(), key(), val(nullptr) {} _ZN6icu_7820RBBISymbolTableEntryD2Ev: 212| 1.24k|RBBISymbolTableEntry::~RBBISymbolTableEntry() { 213| | // The "val" of a symbol table entry is a variable reference node. 214| | // The l. child of the val is the rhs expression from the assignment. 215| | // Unlike other node types, children of variable reference nodes are not 216| | // automatically recursively deleted. We do it manually here. 217| 1.24k| delete val->fLeftChild; 218| 1.24k| val->fLeftChild = nullptr; 219| | 220| 1.24k| delete val; 221| | 222| | // Note: the key UnicodeString is destructed by virtue of being in the object by value. 223| 1.24k|} rbbistbl.cpp:_ZL28RBBISymbolTableEntry_deleterPv: 33| 1.24k|static void U_CALLCONV RBBISymbolTableEntry_deleter(void *p) { 34| 1.24k| icu::RBBISymbolTableEntry *px = (icu::RBBISymbolTableEntry *)p; 35| 1.24k| delete px; 36| 1.24k|} _ZN6icu_7816RBBITableBuilderC2EPNS_15RBBIRuleBuilderEPPNS_8RBBINodeER10UErrorCode: 34| 2.67k| fRB(rb), 35| 2.67k| fTree(*rootNode), 36| 2.67k| fStatus(&status), 37| 2.67k| fDStates(nullptr), 38| 2.67k| fSafeTable(nullptr) { 39| 2.67k| if (U_FAILURE(status)) { ------------------ | Branch (39:9): [True: 0, False: 2.67k] ------------------ 40| 0| return; 41| 0| } 42| | // fDStates is UVector 43| 2.67k| fDStates = new UVector(status); 44| 2.67k| if (U_SUCCESS(status) && fDStates == nullptr ) { ------------------ | Branch (44:9): [True: 2.67k, False: 0] | Branch (44:30): [True: 0, False: 2.67k] ------------------ 45| 0| status = U_MEMORY_ALLOCATION_ERROR; 46| 0| } 47| 2.67k|} _ZN6icu_7816RBBITableBuilderD2Ev: 51| 2.67k|RBBITableBuilder::~RBBITableBuilder() { 52| 2.67k| int i; 53| 238k| for (i=0; isize(); i++) { ------------------ | Branch (53:15): [True: 236k, False: 2.67k] ------------------ 54| 236k| delete static_cast(fDStates->elementAt(i)); 55| 236k| } 56| 2.67k| delete fDStates; 57| 2.67k| delete fSafeTable; 58| 2.67k| delete fLookAheadRuleMap; 59| 2.67k|} _ZN6icu_7816RBBITableBuilder17buildForwardTableEv: 68| 2.67k|void RBBITableBuilder::buildForwardTable() { 69| | 70| 2.67k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (70:9): [True: 0, False: 2.67k] ------------------ 71| 0| return; 72| 0| } 73| | 74| | // If there were no rules, just return. This situation can easily arise 75| | // for the reverse rules. 76| 2.67k| if (fTree==nullptr) { ------------------ | Branch (76:9): [True: 0, False: 2.67k] ------------------ 77| 0| return; 78| 0| } 79| | 80| | // 81| | // Walk through the tree, replacing any references to $variables with a copy of the 82| | // parse tree for the substitution expression. 83| | // 84| 2.67k| fTree = fTree->flattenVariables(*fStatus, 0); 85| 2.67k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (85:9): [True: 41, False: 2.63k] ------------------ 86| 41| return; 87| 41| } 88| |#ifdef RBBI_DEBUG 89| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "ftree")) { 90| | RBBIDebugPuts("\nParse tree after flattening variable references."); 91| | RBBINode::printTree(fTree, true); 92| | } 93| |#endif 94| | 95| | // 96| | // If the rules contained any references to {bof} 97| | // add a {bof} to the 98| | // tree. Means that all matches must start out with the 99| | // {bof} fake character. 100| | // 101| 2.63k| if (fRB->fSetBuilder->sawBOF()) { ------------------ | Branch (101:9): [True: 71, False: 2.56k] ------------------ 102| 71| RBBINode *bofTop = new RBBINode(RBBINode::opCat, *fStatus); 103| 71| if (bofTop == nullptr) { ------------------ | Branch (103:13): [True: 0, False: 71] ------------------ 104| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 105| 0| } 106| 71| if (U_FAILURE(*fStatus)) { ------------------ | Branch (106:13): [True: 0, False: 71] ------------------ 107| 0| delete bofTop; 108| 0| return; 109| 0| } 110| 71| RBBINode *bofLeaf = new RBBINode(RBBINode::leafChar, *fStatus); 111| | // Delete and exit if memory allocation failed. 112| 71| if (bofLeaf == nullptr) { ------------------ | Branch (112:13): [True: 0, False: 71] ------------------ 113| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 114| 0| } 115| 71| if (U_FAILURE(*fStatus)) { ------------------ | Branch (115:13): [True: 0, False: 71] ------------------ 116| 0| delete bofLeaf; 117| 0| delete bofTop; 118| 0| return; 119| 0| } 120| 71| bofTop->fLeftChild = bofLeaf; 121| 71| bofTop->fRightChild = fTree; 122| 71| bofLeaf->fParent = bofTop; 123| 71| bofLeaf->fVal = 2; // Reserved value for {bof}. 124| 71| fTree = bofTop; 125| 71| } 126| | 127| | // 128| | // Add a unique right-end marker to the expression. 129| | // Appears as a cat-node, left child being the original tree, 130| | // right child being the end marker. 131| | // 132| 2.63k| RBBINode *cn = new RBBINode(RBBINode::opCat, *fStatus); 133| | // Exit if memory allocation failed. 134| 2.63k| if (cn == nullptr) { ------------------ | Branch (134:9): [True: 0, False: 2.63k] ------------------ 135| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 136| 0| } 137| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (137:9): [True: 0, False: 2.63k] ------------------ 138| 0| delete cn; 139| 0| return; 140| 0| } 141| 2.63k| cn->fLeftChild = fTree; 142| 2.63k| fTree->fParent = cn; 143| 2.63k| RBBINode *endMarkerNode = cn->fRightChild = new RBBINode(RBBINode::endMark, *fStatus); 144| | // Delete and exit if memory allocation failed. 145| 2.63k| if (cn->fRightChild == nullptr) { ------------------ | Branch (145:9): [True: 0, False: 2.63k] ------------------ 146| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 147| 0| } 148| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (148:9): [True: 0, False: 2.63k] ------------------ 149| 0| delete cn; 150| 0| return; 151| 0| } 152| 2.63k| cn->fRightChild->fParent = cn; 153| 2.63k| fTree = cn; 154| | 155| | // 156| | // Replace all references to UnicodeSets with the tree for the equivalent 157| | // expression. 158| | // 159| 2.63k| fTree->flattenSets(*fStatus, 0); 160| |#ifdef RBBI_DEBUG 161| | if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "stree")) { 162| | RBBIDebugPuts("\nParse tree after flattening Unicode Set references."); 163| | RBBINode::printTree(fTree, true); 164| | } 165| |#endif 166| | 167| | 168| | // 169| | // calculate the functions nullable, firstpos, lastpos and followpos on 170| | // nodes in the parse tree. 171| | // See the algorithm description in Aho. 172| | // Understanding how this works by looking at the code alone will be 173| | // nearly impossible. 174| | // 175| 2.63k| calcNullable(fTree); 176| 2.63k| calcFirstPos(fTree); 177| 2.63k| calcLastPos(fTree); 178| 2.63k| calcFollowPos(fTree); 179| 2.63k| if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "pos")) { ------------------ | | 41| 0|#define uprv_strstr(s, c) U_STANDARD_CPP_NAMESPACE strstr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | | Branch (41:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (179:9): [True: 0, False: 2.63k] ------------------ 180| 0| RBBIDebugPuts("\n"); 181| 0| printPosSets(fTree); 182| 0| } 183| | 184| | // 185| | // For "chained" rules, modify the followPos sets 186| | // 187| 2.63k| if (fRB->fChainRules) { ------------------ | Branch (187:9): [True: 112, False: 2.52k] ------------------ 188| 112| calcChainedFollowPos(fTree, endMarkerNode); 189| 112| } 190| | 191| | // 192| | // BOF (start of input) test fixup. 193| | // 194| 2.63k| if (fRB->fSetBuilder->sawBOF()) { ------------------ | Branch (194:9): [True: 71, False: 2.56k] ------------------ 195| 71| bofFixup(); 196| 71| } 197| | 198| | // 199| | // Build the DFA state transition tables. 200| | // 201| 2.63k| buildStateTable(); 202| 2.63k| mapLookAheadRules(); 203| 2.63k| flagAcceptingStates(); 204| 2.63k| flagLookAheadStates(); 205| 2.63k| flagTaggedStates(); 206| | 207| | // 208| | // Update the global table of rule status {tag} values 209| | // The rule builder has a global vector of status values that are common 210| | // for all tables. Merge the ones from this table into the global set. 211| | // 212| 2.63k| mergeRuleStatusVals(); 213| 2.63k|} _ZN6icu_7816RBBITableBuilder12calcNullableEPNS_8RBBINodeE: 222| 2.53M|void RBBITableBuilder::calcNullable(RBBINode *n) { 223| 2.53M| if (n == nullptr) { ------------------ | Branch (223:9): [True: 1.24M, False: 1.29M] ------------------ 224| 1.24M| return; 225| 1.24M| } 226| 1.29M| if (n->fType == RBBINode::setRef || ------------------ | Branch (226:9): [True: 0, False: 1.29M] ------------------ 227| 1.29M| n->fType == RBBINode::endMark ) { ------------------ | Branch (227:9): [True: 14.7k, False: 1.28M] ------------------ 228| | // These are non-empty leaf node types. 229| 14.7k| n->fNullable = false; 230| 14.7k| return; 231| 14.7k| } 232| | 233| 1.28M| if (n->fType == RBBINode::lookAhead || n->fType == RBBINode::tag) { ------------------ | Branch (233:9): [True: 12.8k, False: 1.26M] | Branch (233:44): [True: 902, False: 1.26M] ------------------ 234| | // Lookahead marker node. It's a leaf, so no recursion on children. 235| | // It's nullable because it does not match any literal text from the input stream. 236| 13.7k| n->fNullable = true; 237| 13.7k| return; 238| 13.7k| } 239| | 240| | 241| | // The node is not a leaf. 242| | // Calculate nullable on its children. 243| 1.26M| calcNullable(n->fLeftChild); 244| 1.26M| calcNullable(n->fRightChild); 245| | 246| | // Apply functions from table 3.40 in Aho 247| 1.26M| if (n->fType == RBBINode::opOr) { ------------------ | Branch (247:9): [True: 440k, False: 825k] ------------------ 248| 440k| n->fNullable = n->fLeftChild->fNullable || n->fRightChild->fNullable; ------------------ | Branch (248:24): [True: 745, False: 439k] | Branch (248:52): [True: 21, False: 439k] ------------------ 249| 440k| } 250| 825k| else if (n->fType == RBBINode::opCat) { ------------------ | Branch (250:14): [True: 203k, False: 621k] ------------------ 251| 203k| n->fNullable = n->fLeftChild->fNullable && n->fRightChild->fNullable; ------------------ | Branch (251:24): [True: 1.10k, False: 202k] | Branch (251:52): [True: 625, False: 480] ------------------ 252| 203k| } 253| 621k| else if (n->fType == RBBINode::opStar || n->fType == RBBINode::opQuestion) { ------------------ | Branch (253:14): [True: 2.20k, False: 619k] | Branch (253:46): [True: 323, False: 619k] ------------------ 254| 2.52k| n->fNullable = true; 255| 2.52k| } 256| 619k| else { 257| 619k| n->fNullable = false; 258| 619k| } 259| 1.26M|} _ZN6icu_7816RBBITableBuilder12calcFirstPosEPNS_8RBBINodeE: 269| 1.29M|void RBBITableBuilder::calcFirstPos(RBBINode *n) { 270| 1.29M| if (n == nullptr) { ------------------ | Branch (270:9): [True: 2.99k, False: 1.29M] ------------------ 271| 2.99k| return; 272| 2.99k| } 273| 1.29M| if (n->fType == RBBINode::leafChar || ------------------ | Branch (273:9): [True: 618k, False: 676k] ------------------ 274| 1.29M| n->fType == RBBINode::endMark || ------------------ | Branch (274:9): [True: 14.7k, False: 661k] ------------------ 275| 1.29M| n->fType == RBBINode::lookAhead || ------------------ | Branch (275:9): [True: 12.8k, False: 648k] ------------------ 276| 1.29M| n->fType == RBBINode::tag) { ------------------ | Branch (276:9): [True: 902, False: 647k] ------------------ 277| | // These are non-empty leaf node types. 278| | // Note: In order to maintain the sort invariant on the set, 279| | // this function should only be called on a node whose set is 280| | // empty to start with. 281| 647k| n->fFirstPosSet->addElement(n, *fStatus); 282| 647k| return; 283| 647k| } 284| | 285| | // The node is not a leaf. 286| | // Calculate firstPos on its children. 287| 647k| calcFirstPos(n->fLeftChild); 288| 647k| calcFirstPos(n->fRightChild); 289| | 290| | // Apply functions from table 3.40 in Aho 291| 647k| if (n->fType == RBBINode::opOr) { ------------------ | Branch (291:9): [True: 440k, False: 206k] ------------------ 292| 440k| setAdd(n->fFirstPosSet, n->fLeftChild->fFirstPosSet); 293| 440k| setAdd(n->fFirstPosSet, n->fRightChild->fFirstPosSet); 294| 440k| } 295| 206k| else if (n->fType == RBBINode::opCat) { ------------------ | Branch (295:14): [True: 203k, False: 2.99k] ------------------ 296| 203k| setAdd(n->fFirstPosSet, n->fLeftChild->fFirstPosSet); 297| 203k| if (n->fLeftChild->fNullable) { ------------------ | Branch (297:13): [True: 1.10k, False: 202k] ------------------ 298| 1.10k| setAdd(n->fFirstPosSet, n->fRightChild->fFirstPosSet); 299| 1.10k| } 300| 203k| } 301| 2.99k| else if (n->fType == RBBINode::opStar || ------------------ | Branch (301:14): [True: 2.20k, False: 788] ------------------ 302| 2.99k| n->fType == RBBINode::opQuestion || ------------------ | Branch (302:14): [True: 323, False: 465] ------------------ 303| 2.99k| n->fType == RBBINode::opPlus) { ------------------ | Branch (303:14): [True: 465, False: 0] ------------------ 304| 2.99k| setAdd(n->fFirstPosSet, n->fLeftChild->fFirstPosSet); 305| 2.99k| } 306| 647k|} _ZN6icu_7816RBBITableBuilder11calcLastPosEPNS_8RBBINodeE: 315| 1.29M|void RBBITableBuilder::calcLastPos(RBBINode *n) { 316| 1.29M| if (n == nullptr) { ------------------ | Branch (316:9): [True: 2.99k, False: 1.29M] ------------------ 317| 2.99k| return; 318| 2.99k| } 319| 1.29M| if (n->fType == RBBINode::leafChar || ------------------ | Branch (319:9): [True: 618k, False: 676k] ------------------ 320| 1.29M| n->fType == RBBINode::endMark || ------------------ | Branch (320:9): [True: 14.7k, False: 661k] ------------------ 321| 1.29M| n->fType == RBBINode::lookAhead || ------------------ | Branch (321:9): [True: 12.8k, False: 648k] ------------------ 322| 1.29M| n->fType == RBBINode::tag) { ------------------ | Branch (322:9): [True: 902, False: 647k] ------------------ 323| | // These are non-empty leaf node types. 324| | // Note: In order to maintain the sort invariant on the set, 325| | // this function should only be called on a node whose set is 326| | // empty to start with. 327| 647k| n->fLastPosSet->addElement(n, *fStatus); 328| 647k| return; 329| 647k| } 330| | 331| | // The node is not a leaf. 332| | // Calculate lastPos on its children. 333| 647k| calcLastPos(n->fLeftChild); 334| 647k| calcLastPos(n->fRightChild); 335| | 336| | // Apply functions from table 3.40 in Aho 337| 647k| if (n->fType == RBBINode::opOr) { ------------------ | Branch (337:9): [True: 440k, False: 206k] ------------------ 338| 440k| setAdd(n->fLastPosSet, n->fLeftChild->fLastPosSet); 339| 440k| setAdd(n->fLastPosSet, n->fRightChild->fLastPosSet); 340| 440k| } 341| 206k| else if (n->fType == RBBINode::opCat) { ------------------ | Branch (341:14): [True: 203k, False: 2.99k] ------------------ 342| 203k| setAdd(n->fLastPosSet, n->fRightChild->fLastPosSet); 343| 203k| if (n->fRightChild->fNullable) { ------------------ | Branch (343:13): [True: 15.4k, False: 188k] ------------------ 344| 15.4k| setAdd(n->fLastPosSet, n->fLeftChild->fLastPosSet); 345| 15.4k| } 346| 203k| } 347| 2.99k| else if (n->fType == RBBINode::opStar || ------------------ | Branch (347:14): [True: 2.20k, False: 788] ------------------ 348| 2.99k| n->fType == RBBINode::opQuestion || ------------------ | Branch (348:14): [True: 323, False: 465] ------------------ 349| 2.99k| n->fType == RBBINode::opPlus) { ------------------ | Branch (349:14): [True: 465, False: 0] ------------------ 350| 2.99k| setAdd(n->fLastPosSet, n->fLeftChild->fLastPosSet); 351| 2.99k| } 352| 647k|} _ZN6icu_7816RBBITableBuilder13calcFollowPosEPNS_8RBBINodeE: 361| 1.32M|void RBBITableBuilder::calcFollowPos(RBBINode *n) { 362| 1.32M| if (n == nullptr || ------------------ | Branch (362:9): [True: 30.4k, False: 1.29M] ------------------ 363| 1.32M| n->fType == RBBINode::leafChar || ------------------ | Branch (363:9): [True: 618k, False: 676k] ------------------ 364| 1.32M| n->fType == RBBINode::endMark) { ------------------ | Branch (364:9): [True: 14.7k, False: 661k] ------------------ 365| 663k| return; 366| 663k| } 367| | 368| 661k| calcFollowPos(n->fLeftChild); 369| 661k| calcFollowPos(n->fRightChild); 370| | 371| | // Aho rule #1 372| 661k| if (n->fType == RBBINode::opCat) { ------------------ | Branch (372:9): [True: 203k, False: 457k] ------------------ 373| 203k| RBBINode *i; // is 'i' in Aho's description 374| 203k| uint32_t ix; 375| | 376| 203k| UVector *LastPosOfLeftChild = n->fLeftChild->fLastPosSet; 377| | 378| 947k| for (ix = 0; ix < static_cast(LastPosOfLeftChild->size()); ix++) { ------------------ | Branch (378:22): [True: 743k, False: 203k] ------------------ 379| 743k| i = static_cast(LastPosOfLeftChild->elementAt(ix)); 380| 743k| setAdd(i->fFollowPos, n->fRightChild->fFirstPosSet); 381| 743k| } 382| 203k| } 383| | 384| | // Aho rule #2 385| 661k| if (n->fType == RBBINode::opStar || ------------------ | Branch (385:9): [True: 2.20k, False: 659k] ------------------ 386| 661k| n->fType == RBBINode::opPlus) { ------------------ | Branch (386:9): [True: 465, False: 658k] ------------------ 387| 2.66k| RBBINode *i; // again, n and i are the names from Aho's description. 388| 2.66k| uint32_t ix; 389| | 390| 16.7k| for (ix = 0; ix < static_cast(n->fLastPosSet->size()); ix++) { ------------------ | Branch (390:22): [True: 14.0k, False: 2.66k] ------------------ 391| 14.0k| i = static_cast(n->fLastPosSet->elementAt(ix)); 392| 14.0k| setAdd(i->fFollowPos, n->fFirstPosSet); 393| 14.0k| } 394| 2.66k| } 395| | 396| | 397| | 398| 661k|} _ZN6icu_7816RBBITableBuilder16addRuleRootNodesEPNS_7UVectorEPNS_8RBBINodeE: 406| 43.3k|void RBBITableBuilder::addRuleRootNodes(UVector *dest, RBBINode *node) { 407| 43.3k| if (node == nullptr || U_FAILURE(*fStatus)) { ------------------ | Branch (407:9): [True: 19.7k, False: 23.5k] | Branch (407:28): [True: 0, False: 23.5k] ------------------ 408| 19.7k| return; 409| 19.7k| } 410| 23.5k| U_ASSERT(!dest->hasDeleter()); ------------------ | | 35| 23.5k|# define U_ASSERT(exp) (void)0 ------------------ 411| 23.5k| if (node->fRuleRoot) { ------------------ | Branch (411:9): [True: 1.97k, False: 21.6k] ------------------ 412| 1.97k| dest->addElement(node, *fStatus); 413| | // Note: rules cannot nest. If we found a rule start node, 414| | // no child node can also be a start node. 415| 1.97k| return; 416| 1.97k| } 417| 21.6k| addRuleRootNodes(dest, node->fLeftChild); 418| 21.6k| addRuleRootNodes(dest, node->fRightChild); 419| 21.6k|} _ZN6icu_7816RBBITableBuilder20calcChainedFollowPosEPNS_8RBBINodeES2_: 427| 112|void RBBITableBuilder::calcChainedFollowPos(RBBINode *tree, RBBINode *endMarkNode) { 428| | 429| 112| UVector leafNodes(*fStatus); 430| 112| if (U_FAILURE(*fStatus)) { ------------------ | Branch (430:9): [True: 0, False: 112] ------------------ 431| 0| return; 432| 0| } 433| | 434| | // get a list all leaf nodes 435| 112| tree->findNodes(&leafNodes, RBBINode::leafChar, *fStatus); 436| 112| if (U_FAILURE(*fStatus)) { ------------------ | Branch (436:9): [True: 0, False: 112] ------------------ 437| 0| return; 438| 0| } 439| | 440| | // Collect all leaf nodes that can start matches for rules 441| | // with inbound chaining enabled, which is the union of the 442| | // firstPosition sets from each of the rule root nodes. 443| | 444| 112| UVector ruleRootNodes(*fStatus); 445| 112| addRuleRootNodes(&ruleRootNodes, tree); 446| | 447| 112| UVector matchStartNodes(*fStatus); 448| 2.08k| for (int j=0; j(ruleRootNodes.elementAt(j)); 450| 1.97k| if (node->fChainIn) { ------------------ | Branch (450:13): [True: 1.51k, False: 456] ------------------ 451| 1.51k| setAdd(&matchStartNodes, node->fFirstPosSet); 452| 1.51k| } 453| 1.97k| } 454| 112| if (U_FAILURE(*fStatus)) { ------------------ | Branch (454:9): [True: 0, False: 112] ------------------ 455| 0| return; 456| 0| } 457| | 458| 112| int32_t endNodeIx; 459| 112| int32_t startNodeIx; 460| | 461| 94.9k| for (endNodeIx=0; endNodeIx(leafNodes.elementAt(endNodeIx)); 463| | 464| | // Identify leaf nodes that correspond to overall rule match positions. 465| | // These include the endMarkNode in their followPos sets. 466| | // 467| | // Note: do not consider other end marker nodes, those that are added to 468| | // look-ahead rules. These can't chain; a match immediately stops 469| | // further matching. This leaves exactly one end marker node, the one 470| | // at the end of the complete tree. 471| | 472| 94.8k| if (!endNode->fFollowPos->contains(endMarkNode)) { ------------------ | Branch (472:13): [True: 27.0k, False: 67.7k] ------------------ 473| 27.0k| continue; 474| 27.0k| } 475| | 476| | // We've got a node that can end a match. 477| | 478| | // Now iterate over the nodes that can start a match, looking for ones 479| | // with the same char class as our ending node. 480| 67.7k| RBBINode *startNode; 481| 14.3M| for (startNodeIx = 0; startNodeIx(matchStartNodes.elementAt(startNodeIx)); 483| 14.2M| if (startNode->fType != RBBINode::leafChar) { ------------------ | Branch (483:17): [True: 3.66k, False: 14.2M] ------------------ 484| 3.66k| continue; 485| 3.66k| } 486| | 487| 14.2M| if (endNode->fVal == startNode->fVal) { ------------------ | Branch (487:17): [True: 151k, False: 14.1M] ------------------ 488| | // The end val (character class) of one possible match is the 489| | // same as the start of another. 490| | 491| | // Add all nodes from the followPos of the start node to the 492| | // followPos set of the end node, which will have the effect of 493| | // letting matches transition from a match state at endNode 494| | // to the second char of a match starting with startNode. 495| 151k| setAdd(endNode->fFollowPos, startNode->fFollowPos); 496| 151k| } 497| 14.2M| } 498| 67.7k| } 499| 112|} _ZN6icu_7816RBBITableBuilder8bofFixupEv: 512| 71|void RBBITableBuilder::bofFixup() { 513| | 514| 71| if (U_FAILURE(*fStatus)) { ------------------ | Branch (514:9): [True: 0, False: 71] ------------------ 515| 0| return; 516| 0| } 517| | 518| | // The parse tree looks like this ... 519| | // fTree root ---> 520| | // / \ . 521| | // <#end node> 522| | // / \ . 523| | // rest 524| | // of tree 525| | // 526| | // We will be adding things to the followPos set of the 527| | // 528| 71| RBBINode *bofNode = fTree->fLeftChild->fLeftChild; 529| 71| U_ASSERT(bofNode->fType == RBBINode::leafChar); ------------------ | | 35| 71|# define U_ASSERT(exp) (void)0 ------------------ 530| 71| U_ASSERT(bofNode->fVal == 2); ------------------ | | 35| 71|# define U_ASSERT(exp) (void)0 ------------------ 531| | 532| | // Get all nodes that can be the start a match of the user-written rules 533| | // (excluding the fake bofNode) 534| | // We want the nodes that can start a match in the 535| | // part labeled "rest of tree" 536| | // 537| 71| UVector *matchStartNodes = fTree->fLeftChild->fRightChild->fFirstPosSet; 538| | 539| 71| RBBINode *startNode; 540| 71| int startNodeIx; 541| 93.6k| for (startNodeIx = 0; startNodeIxsize(); startNodeIx++) { ------------------ | Branch (541:27): [True: 93.6k, False: 71] ------------------ 542| 93.6k| startNode = static_cast(matchStartNodes->elementAt(startNodeIx)); 543| 93.6k| if (startNode->fType != RBBINode::leafChar) { ------------------ | Branch (543:13): [True: 283, False: 93.3k] ------------------ 544| 283| continue; 545| 283| } 546| | 547| 93.3k| if (startNode->fVal == bofNode->fVal) { ------------------ | Branch (547:13): [True: 1.02k, False: 92.2k] ------------------ 548| | // We found a leaf node corresponding to a {bof} that was 549| | // explicitly written into a rule. 550| | // Add everything from the followPos set of this node to the 551| | // followPos set of the fake bofNode at the start of the tree. 552| | // 553| 1.02k| setAdd(bofNode->fFollowPos, startNode->fFollowPos); 554| 1.02k| } 555| 93.3k| } 556| 71|} _ZN6icu_7816RBBITableBuilder15buildStateTableEv: 567| 2.63k|void RBBITableBuilder::buildStateTable() { 568| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (568:9): [True: 0, False: 2.63k] ------------------ 569| 0| return; 570| 0| } 571| 2.63k| RBBIStateDescriptor *failState; 572| | // Set it to nullptr to avoid uninitialized warning 573| 2.63k| RBBIStateDescriptor *initialState = nullptr; 574| | // 575| | // Add a dummy state 0 - the stop state. Not from Aho. 576| 2.63k| int lastInputSymbol = fRB->fSetBuilder->getNumCharCategories() - 1; 577| 2.63k| failState = new RBBIStateDescriptor(lastInputSymbol, fStatus); 578| 2.63k| if (failState == nullptr) { ------------------ | Branch (578:9): [True: 0, False: 2.63k] ------------------ 579| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 580| 0| goto ExitBuildSTdeleteall; 581| 0| } 582| 2.63k| failState->fPositions = new UVector(*fStatus); 583| 2.63k| if (failState->fPositions == nullptr) { ------------------ | Branch (583:9): [True: 0, False: 2.63k] ------------------ 584| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 585| 0| } 586| 2.63k| if (failState->fPositions == nullptr || U_FAILURE(*fStatus)) { ------------------ | Branch (586:9): [True: 0, False: 2.63k] | Branch (586:45): [True: 0, False: 2.63k] ------------------ 587| 0| goto ExitBuildSTdeleteall; 588| 0| } 589| 2.63k| fDStates->addElement(failState, *fStatus); 590| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (590:9): [True: 0, False: 2.63k] ------------------ 591| 0| goto ExitBuildSTdeleteall; 592| 0| } 593| | 594| | // initially, the only unmarked state in Dstates is firstpos(root), 595| | // where toot is the root of the syntax tree for (r)#; 596| 2.63k| initialState = new RBBIStateDescriptor(lastInputSymbol, fStatus); 597| 2.63k| if (initialState == nullptr) { ------------------ | Branch (597:9): [True: 0, False: 2.63k] ------------------ 598| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 599| 0| } 600| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (600:9): [True: 0, False: 2.63k] ------------------ 601| 0| goto ExitBuildSTdeleteall; 602| 0| } 603| 2.63k| initialState->fPositions = new UVector(*fStatus); 604| 2.63k| if (initialState->fPositions == nullptr) { ------------------ | Branch (604:9): [True: 0, False: 2.63k] ------------------ 605| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 606| 0| } 607| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (607:9): [True: 0, False: 2.63k] ------------------ 608| 0| goto ExitBuildSTdeleteall; 609| 0| } 610| 2.63k| setAdd(initialState->fPositions, fTree->fFirstPosSet); 611| 2.63k| fDStates->addElement(initialState, *fStatus); 612| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (612:9): [True: 0, False: 2.63k] ------------------ 613| 0| goto ExitBuildSTdeleteall; 614| 0| } 615| | 616| | // while there is an unmarked state T in Dstates do begin 617| 250k| for (;;) { 618| 250k| RBBIStateDescriptor *T = nullptr; 619| 250k| int32_t tx; 620| 169M| for (tx=1; txsize(); tx++) { ------------------ | Branch (620:20): [True: 169M, False: 2.63k] ------------------ 621| 169M| RBBIStateDescriptor *temp; 622| 169M| temp = static_cast(fDStates->elementAt(tx)); 623| 169M| if (temp->fMarked == false) { ------------------ | Branch (623:17): [True: 247k, False: 169M] ------------------ 624| 247k| T = temp; 625| 247k| break; 626| 247k| } 627| 169M| } 628| 250k| if (T == nullptr) { ------------------ | Branch (628:13): [True: 2.63k, False: 247k] ------------------ 629| 2.63k| break; 630| 2.63k| } 631| | 632| | // mark T; 633| 247k| T->fMarked = true; 634| | 635| | // for each input symbol a do begin 636| 247k| int32_t a; 637| 17.8M| for (a = 1; a<=lastInputSymbol; a++) { ------------------ | Branch (637:21): [True: 17.6M, False: 247k] ------------------ 638| | // let U be the set of positions that are in followpos(p) 639| | // for some position p in T 640| | // such that the symbol at position p is a; 641| 17.6M| UVector *U = nullptr; 642| 17.6M| RBBINode *p; 643| 17.6M| int32_t px; 644| 206M| for (px=0; pxfPositions->size(); px++) { ------------------ | Branch (644:24): [True: 188M, False: 17.6M] ------------------ 645| 188M| p = static_cast(T->fPositions->elementAt(px)); 646| 188M| if ((p->fType == RBBINode::leafChar) && (p->fVal == a)) { ------------------ | Branch (646:21): [True: 185M, False: 2.94M] | Branch (646:58): [True: 4.54M, False: 181M] ------------------ 647| 4.54M| if (U == nullptr) { ------------------ | Branch (647:25): [True: 1.02M, False: 3.52M] ------------------ 648| 1.02M| U = new UVector(*fStatus); 649| 1.02M| if (U == nullptr) { ------------------ | Branch (649:29): [True: 0, False: 1.02M] ------------------ 650| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 651| 0| goto ExitBuildSTdeleteall; 652| 0| } 653| 1.02M| } 654| 4.54M| setAdd(U, p->fFollowPos); 655| 4.54M| } 656| 188M| } 657| | 658| | // if U is not empty and not in DStates then 659| 17.6M| int32_t ux = 0; 660| 17.6M| UBool UinDstates = false; 661| 17.6M| if (U != nullptr) { ------------------ | Branch (661:17): [True: 1.02M, False: 16.5M] ------------------ 662| 1.02M| U_ASSERT(U->size() > 0); ------------------ | | 35| 1.02M|# define U_ASSERT(exp) (void)0 ------------------ 663| 1.02M| int ix; 664| 449M| for (ix=0; ixsize(); ix++) { ------------------ | Branch (664:28): [True: 449M, False: 245k] ------------------ 665| 449M| RBBIStateDescriptor *temp2; 666| 449M| temp2 = static_cast(fDStates->elementAt(ix)); 667| 449M| if (setEquals(U, temp2->fPositions)) { ------------------ | Branch (667:25): [True: 780k, False: 448M] ------------------ 668| 780k| delete U; 669| 780k| U = temp2->fPositions; 670| 780k| ux = ix; 671| 780k| UinDstates = true; 672| 780k| break; 673| 780k| } 674| 449M| } 675| | 676| | // Add U as an unmarked state to Dstates 677| 1.02M| if (!UinDstates) ------------------ | Branch (677:21): [True: 245k, False: 780k] ------------------ 678| 245k| { 679| 245k| RBBIStateDescriptor *newState = new RBBIStateDescriptor(lastInputSymbol, fStatus); 680| 245k| if (newState == nullptr) { ------------------ | Branch (680:25): [True: 0, False: 245k] ------------------ 681| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 682| 0| } 683| 245k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (683:25): [True: 0, False: 245k] ------------------ 684| 0| goto ExitBuildSTdeleteall; 685| 0| } 686| 245k| newState->fPositions = U; 687| 245k| fDStates->addElement(newState, *fStatus); 688| 245k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (688:25): [True: 0, False: 245k] ------------------ 689| 0| return; 690| 0| } 691| 245k| ux = fDStates->size()-1; 692| 245k| } 693| | 694| | // Dtran[T, a] := U; 695| 1.02M| T->fDtran->setElementAt(ux, a); 696| 1.02M| } 697| 17.6M| } 698| 247k| } 699| 2.63k| return; 700| | // delete local pointers only if error occurred. 701| 2.63k|ExitBuildSTdeleteall: 702| 0| delete initialState; 703| 0| delete failState; 704| 0|} _ZN6icu_7816RBBITableBuilder17mapLookAheadRulesEv: 711| 2.63k|void RBBITableBuilder::mapLookAheadRules() { 712| 2.63k| fLookAheadRuleMap = new UVector32(fRB->fScanner->numRules() + 1, *fStatus); 713| 2.63k| if (fLookAheadRuleMap == nullptr) { ------------------ | Branch (713:9): [True: 0, False: 2.63k] ------------------ 714| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 715| 0| } 716| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (716:9): [True: 0, False: 2.63k] ------------------ 717| 0| return; 718| 0| } 719| 2.63k| fLookAheadRuleMap->setSize(fRB->fScanner->numRules() + 1); 720| | 721| 252k| for (int32_t n=0; nsize(); n++) { ------------------ | Branch (721:23): [True: 250k, False: 2.63k] ------------------ 722| 250k| RBBIStateDescriptor* sd = static_cast(fDStates->elementAt(n)); 723| 250k| int32_t laSlotForState = 0; 724| | 725| | // Establish the look-ahead slot for this state, if the state covers 726| | // any look-ahead nodes - corresponding to the '/' in look-ahead rules. 727| | 728| | // If any of the look-ahead nodes already have a slot assigned, use it, 729| | // otherwise assign a new one. 730| | 731| 250k| bool sawLookAheadNode = false; 732| 4.96M| for (int32_t ipos=0; iposfPositions->size(); ++ipos) { ------------------ | Branch (732:30): [True: 4.71M, False: 250k] ------------------ 733| 4.71M| RBBINode *node = static_cast(sd->fPositions->elementAt(ipos)); 734| 4.71M| if (node->fType != RBBINode::NodeType::lookAhead) { ------------------ | Branch (734:17): [True: 4.69M, False: 21.0k] ------------------ 735| 4.69M| continue; 736| 4.69M| } 737| 21.0k| sawLookAheadNode = true; 738| 21.0k| int32_t ruleNum = node->fVal; // Set when rule was originally parsed. 739| 21.0k| U_ASSERT(ruleNum < fLookAheadRuleMap->size()); ------------------ | | 35| 21.0k|# define U_ASSERT(exp) (void)0 ------------------ 740| 21.0k| U_ASSERT(ruleNum > 0); ------------------ | | 35| 21.0k|# define U_ASSERT(exp) (void)0 ------------------ 741| 21.0k| int32_t laSlot = fLookAheadRuleMap->elementAti(ruleNum); 742| 21.0k| if (laSlot != 0) { ------------------ | Branch (742:17): [True: 8.84k, False: 12.1k] ------------------ 743| 8.84k| if (laSlotForState == 0) { ------------------ | Branch (743:21): [True: 7.16k, False: 1.68k] ------------------ 744| 7.16k| laSlotForState = laSlot; 745| 7.16k| } else { 746| | // TODO: figure out if this can fail, change to setting an error code if so. 747| 1.68k| U_ASSERT(laSlot == laSlotForState); ------------------ | | 35| 1.68k|# define U_ASSERT(exp) (void)0 ------------------ 748| 1.68k| } 749| 8.84k| } 750| 21.0k| } 751| 250k| if (!sawLookAheadNode) { ------------------ | Branch (751:13): [True: 242k, False: 7.77k] ------------------ 752| 242k| continue; 753| 242k| } 754| | 755| 7.77k| if (laSlotForState == 0) { ------------------ | Branch (755:13): [True: 613, False: 7.16k] ------------------ 756| 613| laSlotForState = ++fLASlotsInUse; 757| 613| } 758| | 759| | // For each look ahead node covered by this state, 760| | // set the mapping from the node's rule number to the look ahead slot. 761| | // There can be multiple nodes/rule numbers going to the same la slot. 762| | 763| 239k| for (int32_t ipos=0; iposfPositions->size(); ++ipos) { ------------------ | Branch (763:30): [True: 232k, False: 7.77k] ------------------ 764| 232k| RBBINode *node = static_cast(sd->fPositions->elementAt(ipos)); 765| 232k| if (node->fType != RBBINode::NodeType::lookAhead) { ------------------ | Branch (765:17): [True: 211k, False: 21.0k] ------------------ 766| 211k| continue; 767| 211k| } 768| 21.0k| int32_t ruleNum = node->fVal; // Set when rule was originally parsed. 769| 21.0k| int32_t existingVal = fLookAheadRuleMap->elementAti(ruleNum); 770| 21.0k| (void)existingVal; 771| 21.0k| U_ASSERT(existingVal == 0 || existingVal == laSlotForState); ------------------ | | 35| 21.0k|# define U_ASSERT(exp) (void)0 ------------------ 772| 21.0k| fLookAheadRuleMap->setElementAt(laSlotForState, ruleNum); 773| 21.0k| } 774| 7.77k| } 775| | 776| 2.63k|} _ZN6icu_7816RBBITableBuilder19flagAcceptingStatesEv: 787| 2.63k|void RBBITableBuilder::flagAcceptingStates() { 788| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (788:9): [True: 0, False: 2.63k] ------------------ 789| 0| return; 790| 0| } 791| 2.63k| UVector endMarkerNodes(*fStatus); 792| 2.63k| RBBINode *endMarker; 793| 2.63k| int32_t i; 794| 2.63k| int32_t n; 795| | 796| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (796:9): [True: 0, False: 2.63k] ------------------ 797| 0| return; 798| 0| } 799| | 800| 2.63k| fTree->findNodes(&endMarkerNodes, RBBINode::endMark, *fStatus); 801| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (801:9): [True: 0, False: 2.63k] ------------------ 802| 0| return; 803| 0| } 804| | 805| 17.4k| for (i=0; i(endMarkerNodes.elementAt(i)); 807| 1.62M| for (n=0; nsize(); n++) { ------------------ | Branch (807:19): [True: 1.61M, False: 14.7k] ------------------ 808| 1.61M| RBBIStateDescriptor* sd = static_cast(fDStates->elementAt(n)); 809| 1.61M| if (sd->fPositions->indexOf(endMarker) >= 0) { ------------------ | Branch (809:17): [True: 39.7k, False: 1.57M] ------------------ 810| | // Any non-zero value for fAccepting means this is an accepting node. 811| | // The value is what will be returned to the user as the break status. 812| | // If no other value was specified, force it to ACCEPTING_UNCONDITIONAL (1). 813| | 814| 39.7k| if (sd->fAccepting==0) { ------------------ | Branch (814:21): [True: 27.4k, False: 12.2k] ------------------ 815| | // State hasn't been marked as accepting yet. Do it now. 816| 27.4k| sd->fAccepting = fLookAheadRuleMap->elementAti(endMarker->fVal); 817| 27.4k| if (sd->fAccepting == 0) { ------------------ | Branch (817:25): [True: 22.2k, False: 5.22k] ------------------ 818| 22.2k| sd->fAccepting = ACCEPTING_UNCONDITIONAL; 819| 22.2k| } 820| 27.4k| } 821| 39.7k| if (sd->fAccepting==ACCEPTING_UNCONDITIONAL && endMarker->fVal != 0) { ------------------ | Branch (821:21): [True: 22.2k, False: 17.5k] | Branch (821:64): [True: 289, False: 21.9k] ------------------ 822| | // Both lookahead and non-lookahead accepting for this state. 823| | // Favor the look-ahead, because a look-ahead match needs to 824| | // immediately stop the run-time engine. First match, not longest. 825| 289| sd->fAccepting = fLookAheadRuleMap->elementAti(endMarker->fVal); 826| 289| } 827| | // implicit else: 828| | // if sd->fAccepting already had a value other than 0 or 1, leave it be. 829| 39.7k| } 830| 1.61M| } 831| 14.7k| } 832| 2.63k|} _ZN6icu_7816RBBITableBuilder19flagLookAheadStatesEv: 840| 2.63k|void RBBITableBuilder::flagLookAheadStates() { 841| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (841:9): [True: 0, False: 2.63k] ------------------ 842| 0| return; 843| 0| } 844| 2.63k| UVector lookAheadNodes(*fStatus); 845| 2.63k| RBBINode *lookAheadNode; 846| 2.63k| int32_t i; 847| 2.63k| int32_t n; 848| | 849| 2.63k| fTree->findNodes(&lookAheadNodes, RBBINode::lookAhead, *fStatus); 850| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (850:9): [True: 0, False: 2.63k] ------------------ 851| 0| return; 852| 0| } 853| 15.4k| for (i=0; i(lookAheadNodes.elementAt(i)); 855| 12.8k| U_ASSERT(lookAheadNode->fType == RBBINode::NodeType::lookAhead); ------------------ | | 35| 12.8k|# define U_ASSERT(exp) (void)0 ------------------ 856| | 857| 1.52M| for (n=0; nsize(); n++) { ------------------ | Branch (857:19): [True: 1.51M, False: 12.8k] ------------------ 858| 1.51M| RBBIStateDescriptor* sd = static_cast(fDStates->elementAt(n)); 859| 1.51M| int32_t positionsIdx = sd->fPositions->indexOf(lookAheadNode); 860| 1.51M| if (positionsIdx >= 0) { ------------------ | Branch (860:17): [True: 21.0k, False: 1.49M] ------------------ 861| 21.0k| U_ASSERT(lookAheadNode == sd->fPositions->elementAt(positionsIdx)); ------------------ | | 35| 21.0k|# define U_ASSERT(exp) (void)0 ------------------ 862| 21.0k| uint32_t lookaheadSlot = fLookAheadRuleMap->elementAti(lookAheadNode->fVal); 863| 21.0k| U_ASSERT(sd->fLookAhead == 0 || sd->fLookAhead == lookaheadSlot); ------------------ | | 35| 21.0k|# define U_ASSERT(exp) (void)0 ------------------ 864| | // if (sd->fLookAhead != 0 && sd->fLookAhead != lookaheadSlot) { 865| | // printf("%s:%d Bingo. sd->fLookAhead:%d lookaheadSlot:%d\n", 866| | // __FILE__, __LINE__, sd->fLookAhead, lookaheadSlot); 867| | // } 868| 21.0k| sd->fLookAhead = lookaheadSlot; 869| 21.0k| } 870| 1.51M| } 871| 12.8k| } 872| 2.63k|} _ZN6icu_7816RBBITableBuilder16flagTaggedStatesEv: 882| 2.63k|void RBBITableBuilder::flagTaggedStates() { 883| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (883:9): [True: 0, False: 2.63k] ------------------ 884| 0| return; 885| 0| } 886| 2.63k| UVector tagNodes(*fStatus); 887| 2.63k| RBBINode *tagNode; 888| 2.63k| int32_t i; 889| 2.63k| int32_t n; 890| | 891| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (891:9): [True: 0, False: 2.63k] ------------------ 892| 0| return; 893| 0| } 894| 2.63k| fTree->findNodes(&tagNodes, RBBINode::tag, *fStatus); 895| 2.63k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (895:9): [True: 0, False: 2.63k] ------------------ 896| 0| return; 897| 0| } 898| 3.53k| for (i=0; i(tagNodes.elementAt(i)); 900| | 901| 264k| for (n=0; nsize(); n++) { // For each state s (row in the state table) ------------------ | Branch (901:19): [True: 263k, False: 902] ------------------ 902| 263k| RBBIStateDescriptor* sd = static_cast(fDStates->elementAt(n)); 903| 263k| if (sd->fPositions->indexOf(tagNode) >= 0) { // if s include the tag node t ------------------ | Branch (903:17): [True: 107k, False: 155k] ------------------ 904| 107k| sortedAdd(&sd->fTagVals, tagNode->fVal); 905| 107k| } 906| 263k| } 907| 902| } 908| 2.63k|} _ZN6icu_7816RBBITableBuilder19mergeRuleStatusValsEv: 922| 2.63k|void RBBITableBuilder::mergeRuleStatusVals() { 923| | // 924| | // The basic outline of what happens here is this... 925| | // 926| | // for each state in this state table 927| | // if the status tag list for this state is in the global statuses list 928| | // record where and 929| | // continue with the next state 930| | // else 931| | // add the tag list for this state to the global list. 932| | // 933| 2.63k| int i; 934| 2.63k| int n; 935| | 936| | // Pre-set a single tag of {0} into the table. 937| | // We will need this as a default, for rule sets with no explicit tagging. 938| 2.63k| if (fRB->fRuleStatusVals->size() == 0) { ------------------ | Branch (938:9): [True: 2.63k, False: 0] ------------------ 939| 2.63k| fRB->fRuleStatusVals->addElement(1, *fStatus); // Num of statuses in group 940| 2.63k| fRB->fRuleStatusVals->addElement(static_cast(0), *fStatus); // and our single status of zero 941| 2.63k| } 942| | 943| | // For each state 944| 252k| for (n=0; nsize(); n++) { ------------------ | Branch (944:15): [True: 250k, False: 2.63k] ------------------ 945| 250k| RBBIStateDescriptor* sd = static_cast(fDStates->elementAt(n)); 946| 250k| UVector *thisStatesTagValues = sd->fTagVals; 947| 250k| if (thisStatesTagValues == nullptr) { ------------------ | Branch (947:13): [True: 227k, False: 23.2k] ------------------ 948| | // No tag values are explicitly associated with this state. 949| | // Set the default tag value. 950| 227k| sd->fTagsIdx = 0; 951| 227k| continue; 952| 227k| } 953| | 954| | // There are tag(s) associated with this state. 955| | // fTagsIdx will be the index into the global tag list for this state's tag values. 956| | // Initial value of -1 flags that we haven't got it set yet. 957| 23.2k| sd->fTagsIdx = -1; 958| 23.2k| int32_t thisTagGroupStart = 0; // indexes into the global rule status vals list 959| 23.2k| int32_t nextTagGroupStart = 0; 960| | 961| | // Loop runs once per group of tags in the global list 962| 752k| while (nextTagGroupStart < fRB->fRuleStatusVals->size()) { ------------------ | Branch (962:16): [True: 750k, False: 1.86k] ------------------ 963| 750k| thisTagGroupStart = nextTagGroupStart; 964| 750k| nextTagGroupStart += fRB->fRuleStatusVals->elementAti(thisTagGroupStart) + 1; 965| 750k| if (thisStatesTagValues->size() != fRB->fRuleStatusVals->elementAti(thisTagGroupStart)) { ------------------ | Branch (965:17): [True: 595k, False: 155k] ------------------ 966| | // The number of tags for this state is different from 967| | // the number of tags in this group from the global list. 968| | // Continue with the next group from the global list. 969| 595k| continue; 970| 595k| } 971| | // The lengths match, go ahead and compare the actual tag values 972| | // between this state and the group from the global list. 973| 313k| for (i=0; isize(); i++) { ------------------ | Branch (973:23): [True: 291k, False: 21.3k] ------------------ 974| 291k| if (thisStatesTagValues->elementAti(i) != ------------------ | Branch (974:21): [True: 133k, False: 158k] ------------------ 975| 291k| fRB->fRuleStatusVals->elementAti(thisTagGroupStart + 1 + i) ) { 976| | // Mismatch. 977| 133k| break; 978| 133k| } 979| 291k| } 980| | 981| 155k| if (i == thisStatesTagValues->size()) { ------------------ | Branch (981:17): [True: 21.3k, False: 133k] ------------------ 982| | // We found a set of tag values in the global list that match 983| | // those for this state. Use them. 984| 21.3k| sd->fTagsIdx = thisTagGroupStart; 985| 21.3k| break; 986| 21.3k| } 987| 155k| } 988| | 989| 23.2k| if (sd->fTagsIdx == -1) { ------------------ | Branch (989:13): [True: 1.86k, False: 21.3k] ------------------ 990| | // No suitable entry in the global tag list already. Add one 991| 1.86k| sd->fTagsIdx = fRB->fRuleStatusVals->size(); 992| 1.86k| fRB->fRuleStatusVals->addElement(thisStatesTagValues->size(), *fStatus); 993| 8.54k| for (i=0; isize(); i++) { ------------------ | Branch (993:23): [True: 6.68k, False: 1.86k] ------------------ 994| 6.68k| fRB->fRuleStatusVals->addElement(thisStatesTagValues->elementAti(i), *fStatus); 995| 6.68k| } 996| 1.86k| } 997| 23.2k| } 998| 2.63k|} _ZN6icu_7816RBBITableBuilder9sortedAddEPPNS_7UVectorEi: 1014| 107k|void RBBITableBuilder::sortedAdd(UVector **vector, int32_t val) { 1015| 107k| int32_t i; 1016| | 1017| 107k| if (*vector == nullptr) { ------------------ | Branch (1017:9): [True: 23.2k, False: 84.5k] ------------------ 1018| 23.2k| *vector = new UVector(*fStatus); 1019| 23.2k| } 1020| 107k| if (*vector == nullptr || U_FAILURE(*fStatus)) { ------------------ | Branch (1020:9): [True: 0, False: 107k] | Branch (1020:31): [True: 0, False: 107k] ------------------ 1021| 0| return; 1022| 0| } 1023| 107k| UVector *vec = *vector; 1024| 107k| int32_t vSize = vec->size(); 1025| 224k| for (i=0; ielementAti(i); 1027| 179k| if (valAtI == val) { ------------------ | Branch (1027:13): [True: 11.4k, False: 168k] ------------------ 1028| | // The value is already in the vector. Don't add it again. 1029| 11.4k| return; 1030| 11.4k| } 1031| 168k| if (valAtI > val) { ------------------ | Branch (1031:13): [True: 51.2k, False: 116k] ------------------ 1032| 51.2k| break; 1033| 51.2k| } 1034| 168k| } 1035| 96.3k| vec->insertElementAt(val, i, *fStatus); 1036| 96.3k|} _ZN6icu_7816RBBITableBuilder6setAddEPNS_7UVectorES2_: 1047| 7.65M|void RBBITableBuilder::setAdd(UVector *dest, UVector *source) { 1048| 7.65M| U_ASSERT(!dest->hasDeleter()); ------------------ | | 35| 7.65M|# define U_ASSERT(exp) (void)0 ------------------ 1049| 7.65M| U_ASSERT(!source->hasDeleter()); ------------------ | | 35| 7.65M|# define U_ASSERT(exp) (void)0 ------------------ 1050| 7.65M| int32_t destOriginalSize = dest->size(); 1051| 7.65M| int32_t sourceSize = source->size(); 1052| 7.65M| int32_t di = 0; 1053| 7.65M| MaybeStackArray destArray, sourceArray; // Handle small cases without malloc 1054| 7.65M| void **destPtr, **sourcePtr; 1055| 7.65M| void **destLim, **sourceLim; 1056| | 1057| 7.65M| if (destOriginalSize > destArray.getCapacity()) { ------------------ | Branch (1057:9): [True: 2.86M, False: 4.78M] ------------------ 1058| 2.86M| if (destArray.resize(destOriginalSize) == nullptr) { ------------------ | Branch (1058:13): [True: 0, False: 2.86M] ------------------ 1059| 0| return; 1060| 0| } 1061| 2.86M| } 1062| 7.65M| destPtr = destArray.getAlias(); 1063| 7.65M| destLim = destPtr + destOriginalSize; // destArray.getArrayLimit()? 1064| | 1065| 7.65M| if (sourceSize > sourceArray.getCapacity()) { ------------------ | Branch (1065:9): [True: 1.66M, False: 5.98M] ------------------ 1066| 1.66M| if (sourceArray.resize(sourceSize) == nullptr) { ------------------ | Branch (1066:13): [True: 0, False: 1.66M] ------------------ 1067| 0| return; 1068| 0| } 1069| 1.66M| } 1070| 7.65M| sourcePtr = sourceArray.getAlias(); 1071| 7.65M| sourceLim = sourcePtr + sourceSize; // sourceArray.getArrayLimit()? 1072| | 1073| | // Avoid multiple "get element" calls by getting the contents into arrays 1074| 7.65M| (void) dest->toArray(destPtr); 1075| 7.65M| (void) source->toArray(sourcePtr); 1076| | 1077| 7.65M| dest->setSize(sourceSize+destOriginalSize, *fStatus); 1078| 7.65M| if (U_FAILURE(*fStatus)) { ------------------ | Branch (1078:9): [True: 0, False: 7.65M] ------------------ 1079| 0| return; 1080| 0| } 1081| | 1082| 445M| while (sourcePtr < sourceLim && destPtr < destLim) { ------------------ | Branch (1082:12): [True: 441M, False: 3.78M] | Branch (1082:37): [True: 437M, False: 3.86M] ------------------ 1083| 437M| if (*destPtr == *sourcePtr) { ------------------ | Branch (1083:13): [True: 100M, False: 337M] ------------------ 1084| 100M| dest->setElementAt(*sourcePtr++, di++); 1085| 100M| destPtr++; 1086| 100M| } 1087| | // This check is required for machines with segmented memory, like i5/OS. 1088| | // Direct pointer comparison is not recommended. 1089| 337M| else if (uprv_memcmp(destPtr, sourcePtr, sizeof(void *)) < 0) { ------------------ | | 101| 337M|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 337M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1089:18): [True: 307M, False: 30.0M] ------------------ 1090| 307M| dest->setElementAt(*destPtr++, di++); 1091| 307M| } 1092| 30.0M| else { /* *sourcePtr < *destPtr */ 1093| 30.0M| dest->setElementAt(*sourcePtr++, di++); 1094| 30.0M| } 1095| 437M| } 1096| | 1097| | // At most one of these two cleanup loops will execute 1098| 100M| while (destPtr < destLim) { ------------------ | Branch (1098:12): [True: 92.9M, False: 7.65M] ------------------ 1099| 92.9M| dest->setElementAt(*destPtr++, di++); 1100| 92.9M| } 1101| 172M| while (sourcePtr < sourceLim) { ------------------ | Branch (1101:12): [True: 165M, False: 7.65M] ------------------ 1102| 165M| dest->setElementAt(*sourcePtr++, di++); 1103| 165M| } 1104| | 1105| 7.65M| dest->setSize(di, *fStatus); 1106| 7.65M|} _ZN6icu_7816RBBITableBuilder9setEqualsEPNS_7UVectorES2_: 1117| 449M|UBool RBBITableBuilder::setEquals(UVector *a, UVector *b) { 1118| 449M| return a->equals(*b); 1119| 449M|} _ZN6icu_7816RBBITableBuilder21findDuplCharClassFromEPNSt3__14pairIiiEE: 1155| 15.7k|bool RBBITableBuilder::findDuplCharClassFrom(IntPair *categories) { 1156| 15.7k| int32_t numStates = fDStates->size(); 1157| 15.7k| int32_t numCols = fRB->fSetBuilder->getNumCharCategories(); 1158| | 1159| 129k| for (; categories->first < numCols-1; categories->first++) { ------------------ | Branch (1159:12): [True: 126k, False: 3.26k] ------------------ 1160| | // Note: dictionary & non-dictionary columns cannot be merged. 1161| | // The limitSecond value prevents considering mixed pairs. 1162| | // Dictionary categories are >= DictCategoriesStart. 1163| | // Non dict categories are < DictCategoriesStart. 1164| 126k| int limitSecond = categories->first < fRB->fSetBuilder->getDictCategoriesStart() ? ------------------ | Branch (1164:27): [True: 126k, False: 0] ------------------ 1165| 126k| fRB->fSetBuilder->getDictCategoriesStart() : numCols; 1166| 88.9M| for (categories->second=categories->first+1; categories->second < limitSecond; categories->second++) { ------------------ | Branch (1166:54): [True: 88.8M, False: 113k] ------------------ 1167| | // Initialized to different values to prevent returning true if numStates = 0 (implies no duplicates). 1168| 88.8M| uint16_t table_base = 0; 1169| 88.8M| uint16_t table_dupl = 1; 1170| 572M| for (int32_t state=0; state(fDStates->elementAt(state)); 1172| 488M| table_base = static_cast(sd->fDtran->elementAti(categories->first)); 1173| 488M| table_dupl = static_cast(sd->fDtran->elementAti(categories->second)); 1174| 488M| if (table_base != table_dupl) { ------------------ | Branch (1174:21): [True: 5.60M, False: 483M] ------------------ 1175| 5.60M| break; 1176| 5.60M| } 1177| 488M| } 1178| 88.8M| if (table_base == table_dupl) { ------------------ | Branch (1178:17): [True: 12.4k, False: 88.8M] ------------------ 1179| 12.4k| return true; 1180| 12.4k| } 1181| 88.8M| } 1182| 126k| } 1183| 3.26k| return false; 1184| 15.7k|} _ZN6icu_7816RBBITableBuilder12removeColumnEi: 1190| 12.4k|void RBBITableBuilder::removeColumn(int32_t column) { 1191| 12.4k| int32_t numStates = fDStates->size(); 1192| 496k| for (int32_t state=0; state(fDStates->elementAt(state)); 1194| 483k| U_ASSERT(column < sd->fDtran->size()); ------------------ | | 35| 483k|# define U_ASSERT(exp) (void)0 ------------------ 1195| 483k| sd->fDtran->removeElementAt(column); 1196| 483k| } 1197| 12.4k|} _ZN6icu_7816RBBITableBuilder18findDuplicateStateEPNSt3__14pairIiiEE: 1202| 19.0k|bool RBBITableBuilder::findDuplicateState(IntPair *states) { 1203| 19.0k| int32_t numStates = fDStates->size(); 1204| 19.0k| int32_t numCols = fRB->fSetBuilder->getNumCharCategories(); 1205| | 1206| 669k| for (; states->firstfirst++) { ------------------ | Branch (1206:12): [True: 664k, False: 4.95k] ------------------ 1207| 664k| RBBIStateDescriptor* firstSD = static_cast(fDStates->elementAt(states->first)); 1208| 283M| for (states->second=states->first+1; states->secondsecond++) { ------------------ | Branch (1208:46): [True: 282M, False: 650k] ------------------ 1209| 282M| RBBIStateDescriptor* duplSD = static_cast(fDStates->elementAt(states->second)); 1210| 282M| if (firstSD->fAccepting != duplSD->fAccepting || ------------------ | Branch (1210:17): [True: 51.9M, False: 230M] ------------------ 1211| 282M| firstSD->fLookAhead != duplSD->fLookAhead || ------------------ | Branch (1211:17): [True: 4.23M, False: 226M] ------------------ 1212| 282M| firstSD->fTagsIdx != duplSD->fTagsIdx) { ------------------ | Branch (1212:17): [True: 19.3M, False: 207M] ------------------ 1213| 75.4M| continue; 1214| 75.4M| } 1215| 207M| bool rowsMatch = true; 1216| 3.30G| for (int32_t col=0; col < numCols; ++col) { ------------------ | Branch (1216:33): [True: 3.30G, False: 14.0k] ------------------ 1217| 3.30G| int32_t firstVal = firstSD->fDtran->elementAti(col); 1218| 3.30G| int32_t duplVal = duplSD->fDtran->elementAti(col); 1219| 3.30G| if (!((firstVal == duplVal) || ------------------ | Branch (1219:23): [True: 3.09G, False: 207M] ------------------ 1220| 3.30G| ((firstVal == states->first || firstVal == states->second) && ------------------ | Branch (1220:27): [True: 213k, False: 207M] | Branch (1220:56): [True: 411k, False: 206M] ------------------ 1221| 207M| (duplVal == states->first || duplVal == states->second)))) { ------------------ | Branch (1221:26): [True: 69, False: 625k] | Branch (1221:55): [True: 1.99k, False: 623k] ------------------ 1222| 207M| rowsMatch = false; 1223| 207M| break; 1224| 207M| } 1225| 3.30G| } 1226| 207M| if (rowsMatch) { ------------------ | Branch (1226:17): [True: 14.0k, False: 207M] ------------------ 1227| 14.0k| return true; 1228| 14.0k| } 1229| 207M| } 1230| 664k| } 1231| 4.95k| return false; 1232| 19.0k|} _ZN6icu_7816RBBITableBuilder22findDuplicateSafeStateEPNSt3__14pairIiiEE: 1235| 26.8k|bool RBBITableBuilder::findDuplicateSafeState(IntPair *states) { 1236| 26.8k| int32_t numStates = fSafeTable->size(); 1237| | 1238| 76.0k| for (; states->firstfirst++) { ------------------ | Branch (1238:12): [True: 73.3k, False: 2.63k] ------------------ 1239| 73.3k| UnicodeString *firstRow = static_cast(fSafeTable->elementAt(states->first)); 1240| 3.71M| for (states->second=states->first+1; states->secondsecond++) { ------------------ | Branch (1240:46): [True: 3.66M, False: 49.1k] ------------------ 1241| 3.66M| UnicodeString *duplRow = static_cast(fSafeTable->elementAt(states->second)); 1242| 3.66M| bool rowsMatch = true; 1243| 3.66M| int32_t numCols = firstRow->length(); 1244| 257M| for (int32_t col=0; col < numCols; ++col) { ------------------ | Branch (1244:33): [True: 257M, False: 24.2k] ------------------ 1245| 257M| int32_t firstVal = firstRow->charAt(col); 1246| 257M| int32_t duplVal = duplRow->charAt(col); 1247| 257M| if (!((firstVal == duplVal) || ------------------ | Branch (1247:23): [True: 253M, False: 3.63M] ------------------ 1248| 257M| ((firstVal == states->first || firstVal == states->second) && ------------------ | Branch (1248:27): [True: 34.2k, False: 3.60M] | Branch (1248:56): [True: 9.12k, False: 3.59M] ------------------ 1249| 3.63M| (duplVal == states->first || duplVal == states->second)))) { ------------------ | Branch (1249:26): [True: 0, False: 43.3k] | Branch (1249:55): [True: 0, False: 43.3k] ------------------ 1250| 3.63M| rowsMatch = false; 1251| 3.63M| break; 1252| 3.63M| } 1253| 257M| } 1254| 3.66M| if (rowsMatch) { ------------------ | Branch (1254:17): [True: 24.2k, False: 3.63M] ------------------ 1255| 24.2k| return true; 1256| 24.2k| } 1257| 3.66M| } 1258| 73.3k| } 1259| 2.63k| return false; 1260| 26.8k|} _ZN6icu_7816RBBITableBuilder11removeStateENSt3__14pairIiiEE: 1263| 14.0k|void RBBITableBuilder::removeState(IntPair duplStates) { 1264| 14.0k| const int32_t keepState = duplStates.first; 1265| 14.0k| const int32_t duplState = duplStates.second; 1266| 14.0k| U_ASSERT(keepState < duplState); ------------------ | | 35| 14.0k|# define U_ASSERT(exp) (void)0 ------------------ 1267| 14.0k| U_ASSERT(duplState < fDStates->size()); ------------------ | | 35| 14.0k|# define U_ASSERT(exp) (void)0 ------------------ 1268| | 1269| 14.0k| RBBIStateDescriptor* duplSD = static_cast(fDStates->elementAt(duplState)); 1270| 14.0k| fDStates->removeElementAt(duplState); 1271| 14.0k| delete duplSD; 1272| | 1273| 14.0k| int32_t numStates = fDStates->size(); 1274| 14.0k| int32_t numCols = fRB->fSetBuilder->getNumCharCategories(); 1275| 12.7M| for (int32_t state=0; state(fDStates->elementAt(state)); 1277| 178M| for (int32_t col=0; colfDtran->elementAti(col); 1279| 165M| int32_t newVal = existingVal; 1280| 165M| if (existingVal == duplState) { ------------------ | Branch (1280:17): [True: 62.3k, False: 165M] ------------------ 1281| 62.3k| newVal = keepState; 1282| 165M| } else if (existingVal > duplState) { ------------------ | Branch (1282:24): [True: 13.3M, False: 152M] ------------------ 1283| 13.3M| newVal = existingVal - 1; 1284| 13.3M| } 1285| 165M| sd->fDtran->setElementAt(newVal, col); 1286| 165M| } 1287| 12.7M| } 1288| 14.0k|} _ZN6icu_7816RBBITableBuilder15removeSafeStateENSt3__14pairIiiEE: 1290| 24.2k|void RBBITableBuilder::removeSafeState(IntPair duplStates) { 1291| 24.2k| const int32_t keepState = duplStates.first; 1292| 24.2k| const int32_t duplState = duplStates.second; 1293| 24.2k| U_ASSERT(keepState < duplState); ------------------ | | 35| 24.2k|# define U_ASSERT(exp) (void)0 ------------------ 1294| 24.2k| U_ASSERT(duplState < fSafeTable->size()); ------------------ | | 35| 24.2k|# define U_ASSERT(exp) (void)0 ------------------ 1295| | 1296| 24.2k| fSafeTable->removeElementAt(duplState); // Note that fSafeTable has a deleter function 1297| | // and will auto-delete the removed element. 1298| 24.2k| int32_t numStates = fSafeTable->size(); 1299| 1.49M| for (int32_t state=0; state(fSafeTable->elementAt(state)); 1301| 1.46M| int32_t numCols = sd->length(); 1302| 317M| for (int32_t col=0; colcharAt(col); 1304| 315M| int32_t newVal = existingVal; 1305| 315M| if (existingVal == duplState) { ------------------ | Branch (1305:17): [True: 866k, False: 314M] ------------------ 1306| 866k| newVal = keepState; 1307| 314M| } else if (existingVal > duplState) { ------------------ | Branch (1307:24): [True: 137M, False: 177M] ------------------ 1308| 137M| newVal = existingVal - 1; 1309| 137M| } 1310| 315M| sd->setCharAt(col, static_cast(newVal)); 1311| 315M| } 1312| 1.46M| } 1313| 24.2k|} _ZN6icu_7816RBBITableBuilder21removeDuplicateStatesEv: 1319| 4.95k|int32_t RBBITableBuilder::removeDuplicateStates() { 1320| 4.95k| IntPair dupls = {3, 0}; 1321| 4.95k| int32_t numStatesRemoved = 0; 1322| | 1323| 19.0k| while (findDuplicateState(&dupls)) { ------------------ | Branch (1323:12): [True: 14.0k, False: 4.95k] ------------------ 1324| | // printf("Removing duplicate states (%d, %d)\n", dupls.first, dupls.second); 1325| 14.0k| removeState(dupls); 1326| 14.0k| ++numStatesRemoved; 1327| 14.0k| } 1328| 4.95k| return numStatesRemoved; 1329| 4.95k|} _ZNK6icu_7816RBBITableBuilder12getTableSizeEv: 1338| 2.63k|int32_t RBBITableBuilder::getTableSize() const { 1339| 2.63k| int32_t size = 0; 1340| 2.63k| int32_t numRows; 1341| 2.63k| int32_t numCols; 1342| 2.63k| int32_t rowSize; 1343| | 1344| 2.63k| if (fTree == nullptr) { ------------------ | Branch (1344:9): [True: 0, False: 2.63k] ------------------ 1345| 0| return 0; 1346| 0| } 1347| | 1348| 2.63k| size = offsetof(RBBIStateTable, fTableData); // The header, with no rows to the table. 1349| | 1350| 2.63k| numRows = fDStates->size(); 1351| 2.63k| numCols = fRB->fSetBuilder->getNumCharCategories(); 1352| | 1353| 2.63k| if (use8BitsForTable()) { ------------------ | Branch (1353:9): [True: 2.43k, False: 203] ------------------ 1354| 2.43k| rowSize = offsetof(RBBIStateTableRow8, fNextState) + sizeof(int8_t)*numCols; 1355| 2.43k| } else { 1356| 203| rowSize = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t)*numCols; 1357| 203| } 1358| 2.63k| size += numRows * rowSize; 1359| 2.63k| return size; 1360| 2.63k|} _ZNK6icu_7816RBBITableBuilder16use8BitsForTableEv: 1362| 241k|bool RBBITableBuilder::use8BitsForTable() const { 1363| 241k| return fDStates->size() <= kMaxStateFor8BitsTable; 1364| 241k|} _ZN6icu_7816RBBITableBuilder11exportTableEPv: 1373| 2.63k|void RBBITableBuilder::exportTable(void *where) { 1374| 2.63k| RBBIStateTable* table = static_cast(where); 1375| 2.63k| uint32_t state; 1376| 2.63k| int col; 1377| | 1378| 2.63k| if (U_FAILURE(*fStatus) || fTree == nullptr) { ------------------ | Branch (1378:9): [True: 0, False: 2.63k] | Branch (1378:32): [True: 0, False: 2.63k] ------------------ 1379| 0| return; 1380| 0| } 1381| | 1382| 2.63k| int32_t catCount = fRB->fSetBuilder->getNumCharCategories(); 1383| 2.63k| if (catCount > 0x7fff || ------------------ | Branch (1383:9): [True: 0, False: 2.63k] ------------------ 1384| 2.63k| fDStates->size() > 0x7fff) { ------------------ | Branch (1384:9): [True: 0, False: 2.63k] ------------------ 1385| 0| *fStatus = U_BRK_INTERNAL_ERROR; 1386| 0| return; 1387| 0| } 1388| | 1389| 2.63k| table->fNumStates = fDStates->size(); 1390| 2.63k| table->fDictCategoriesStart = fRB->fSetBuilder->getDictCategoriesStart(); 1391| 2.63k| table->fLookAheadResultsSize = fLASlotsInUse == ACCEPTING_UNCONDITIONAL ? 0 : fLASlotsInUse + 1; ------------------ | Branch (1391:36): [True: 2.39k, False: 240] ------------------ 1392| 2.63k| table->fFlags = 0; 1393| 2.63k| if (use8BitsForTable()) { ------------------ | Branch (1393:9): [True: 2.43k, False: 203] ------------------ 1394| 2.43k| table->fRowLen = offsetof(RBBIStateTableRow8, fNextState) + sizeof(uint8_t) * catCount; 1395| 2.43k| table->fFlags |= RBBI_8BITS_ROWS; 1396| 2.43k| } else { 1397| 203| table->fRowLen = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t) * catCount; 1398| 203| } 1399| 2.63k| if (fRB->fLookAheadHardBreak) { ------------------ | Branch (1399:9): [True: 2, False: 2.63k] ------------------ 1400| 2| table->fFlags |= RBBI_LOOKAHEAD_HARD_BREAK; 1401| 2| } 1402| 2.63k| if (fRB->fSetBuilder->sawBOF()) { ------------------ | Branch (1402:9): [True: 71, False: 2.56k] ------------------ 1403| 71| table->fFlags |= RBBI_BOF_REQUIRED; 1404| 71| } 1405| | 1406| 238k| for (state=0; statefNumStates; state++) { ------------------ | Branch (1406:19): [True: 236k, False: 2.63k] ------------------ 1407| 236k| RBBIStateDescriptor* sd = static_cast(fDStates->elementAt(state)); 1408| 236k| RBBIStateTableRow* row = reinterpret_cast(table->fTableData + state * table->fRowLen); 1409| 236k| if (use8BitsForTable()) { ------------------ | Branch (1409:13): [True: 67.6k, False: 168k] ------------------ 1410| 67.6k| U_ASSERT (sd->fAccepting <= 255); ------------------ | | 35| 67.6k|# define U_ASSERT(exp) (void)0 ------------------ 1411| 67.6k| U_ASSERT (sd->fLookAhead <= 255); ------------------ | | 35| 67.6k|# define U_ASSERT(exp) (void)0 ------------------ 1412| 67.6k| U_ASSERT (0 <= sd->fTagsIdx && sd->fTagsIdx <= 255); ------------------ | | 35| 67.6k|# define U_ASSERT(exp) (void)0 ------------------ 1413| 67.6k| RBBIStateTableRow8* r8 = reinterpret_cast(row); 1414| 67.6k| r8->fAccepting = sd->fAccepting; 1415| 67.6k| r8->fLookAhead = sd->fLookAhead; 1416| 67.6k| r8->fTagsIdx = sd->fTagsIdx; 1417| 4.37M| for (col=0; colfDtran->elementAti(col) <= kMaxStateFor8BitsTable); ------------------ | | 35| 4.30M|# define U_ASSERT(exp) (void)0 ------------------ 1419| 4.30M| r8->fNextState[col] = sd->fDtran->elementAti(col); 1420| 4.30M| } 1421| 168k| } else { 1422| 168k| U_ASSERT (sd->fAccepting <= 0xffff); ------------------ | | 35| 168k|# define U_ASSERT(exp) (void)0 ------------------ 1423| 168k| U_ASSERT (sd->fLookAhead <= 0xffff); ------------------ | | 35| 168k|# define U_ASSERT(exp) (void)0 ------------------ 1424| 168k| U_ASSERT (0 <= sd->fTagsIdx && sd->fTagsIdx <= 0xffff); ------------------ | | 35| 168k|# define U_ASSERT(exp) (void)0 ------------------ 1425| 168k| row->r16.fAccepting = sd->fAccepting; 1426| 168k| row->r16.fLookAhead = sd->fLookAhead; 1427| 168k| row->r16.fTagsIdx = sd->fTagsIdx; 1428| 12.9M| for (col=0; colr16.fNextState[col] = sd->fDtran->elementAti(col); 1430| 12.7M| } 1431| 168k| } 1432| 236k| } 1433| 2.63k|} _ZN6icu_7816RBBITableBuilder21buildSafeReverseTableER10UErrorCode: 1439| 2.67k|void RBBITableBuilder::buildSafeReverseTable(UErrorCode &status) { 1440| | // The safe table creation has three steps: 1441| | 1442| | // 1. Identify pairs of character classes that are "safe." Safe means that boundaries 1443| | // following the pair do not depend on context or state before the pair. To test 1444| | // whether a pair is safe, run it through the main forward state table, starting 1445| | // from each state. If the the final state is the same, no matter what the starting state, 1446| | // the pair is safe. 1447| | // 1448| | // 2. Build a state table that recognizes the safe pairs. It's similar to their 1449| | // forward table, with a column for each input character [class], and a row for 1450| | // each state. Row 1 is the start state, and row 0 is the stop state. Initially 1451| | // create an additional state for each input character category; being in 1452| | // one of these states means that the character has been seen, and is potentially 1453| | // the first of a pair. In each of these rows, the entry for the second character 1454| | // of a safe pair is set to the stop state (0), indicating that a match was found. 1455| | // All other table entries are set to the state corresponding the current input 1456| | // character, allowing that character to be the of a start following pair. 1457| | // 1458| | // Because the safe rules are to be run in reverse, moving backwards in the text, 1459| | // the first and second pair categories are swapped when building the table. 1460| | // 1461| | // 3. Compress the table. There are typically many rows (states) that are 1462| | // equivalent - that have zeroes (match completed) in the same columns - 1463| | // and can be folded together. 1464| | 1465| | // Each safe pair is stored as two UChars in the safePair string. 1466| 2.67k| UnicodeString safePairs; 1467| | 1468| 2.67k| int32_t numCharClasses = fRB->fSetBuilder->getNumCharCategories(); 1469| 2.67k| int32_t numStates = fDStates->size(); 1470| | 1471| 112k| for (int32_t c1=0; c1(fDStates->elementAt(startState)); 1477| 2.11G| int32_t s2 = startStateD->fDtran->elementAti(c1); 1478| 2.11G| RBBIStateDescriptor *s2StateD = static_cast(fDStates->elementAt(s2)); 1479| 2.11G| endState = s2StateD->fDtran->elementAti(c2); 1480| 2.11G| if (wantedEndState < 0) { ------------------ | Branch (1480:21): [True: 9.62M, False: 2.10G] ------------------ 1481| 9.62M| wantedEndState = endState; 1482| 2.10G| } else { 1483| 2.10G| if (wantedEndState != endState) { ------------------ | Branch (1483:25): [True: 1.81M, False: 2.10G] ------------------ 1484| 1.81M| break; 1485| 1.81M| } 1486| 2.10G| } 1487| 2.11G| } 1488| 176M| if (wantedEndState == endState) { ------------------ | Branch (1488:17): [True: 7.81M, False: 168M] ------------------ 1489| 7.81M| safePairs.append(static_cast(c1)); 1490| 7.81M| safePairs.append(static_cast(c2)); 1491| | // printf("(%d, %d) ", c1, c2); 1492| 7.81M| } 1493| 176M| } 1494| | // printf("\n"); 1495| 109k| } 1496| | 1497| | // Populate the initial safe table. 1498| | // The table as a whole is UVector 1499| | // Each row is represented by a UnicodeString, being used as a Vector. 1500| | // Row 0 is the stop state. 1501| | // Row 1 is the start state. 1502| | // Row 2 and beyond are other states, initially one per char class, but 1503| | // after initial construction, many of the states will be combined, compacting the table. 1504| | // The String holds the nextState data only. The four leading fields of a row, fAccepting, 1505| | // fLookAhead, etc. are not needed for the safe table, and are omitted at this stage of building. 1506| | 1507| 2.67k| U_ASSERT(fSafeTable == nullptr); ------------------ | | 35| 2.67k|# define U_ASSERT(exp) (void)0 ------------------ 1508| 2.67k| LocalPointer lpSafeTable( 1509| 2.67k| new UVector(uprv_deleteUObject, uhash_compareUnicodeString, numCharClasses + 2, status), status); ------------------ | | 1489| 2.67k|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 2.67k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.67k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.67k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ new UVector(uprv_deleteUObject, uhash_compareUnicodeString, numCharClasses + 2, status), status); ------------------ | | 999| 2.67k|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 2.67k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.67k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.67k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1510| 2.67k| if (U_FAILURE(status)) { ------------------ | Branch (1510:9): [True: 41, False: 2.63k] ------------------ 1511| 41| return; 1512| 41| } 1513| 2.63k| fSafeTable = lpSafeTable.orphan(); 1514| 81.2k| for (int32_t row=0; row lpString(new UnicodeString(numCharClasses, 0, numCharClasses+4), status); 1516| 78.6k| fSafeTable->adoptElement(lpString.orphan(), status); 1517| 78.6k| } 1518| 2.63k| if (U_FAILURE(status)) { ------------------ | Branch (1518:9): [True: 0, False: 2.63k] ------------------ 1519| 0| return; 1520| 0| } 1521| | 1522| | // From the start state, each input char class transitions to the state for that input. 1523| 2.63k| UnicodeString &startState = *static_cast(fSafeTable->elementAt(1)); 1524| 76.0k| for (int32_t charClass=0; charClass < numCharClasses; ++charClass) { ------------------ | Branch (1524:31): [True: 73.3k, False: 2.63k] ------------------ 1525| | // Note: +2 for the start & stop state. 1526| 73.3k| startState.setCharAt(charClass, static_cast(charClass+2)); 1527| 73.3k| } 1528| | 1529| | // Initially make every other state table row look like the start state row, 1530| 76.0k| for (int32_t row=2; row(fSafeTable->elementAt(row)); 1532| 73.3k| rowState = startState; // UnicodeString assignment, copies contents. 1533| 73.3k| } 1534| | 1535| | // Run through the safe pairs, set the next state to zero when pair has been seen. 1536| | // Zero being the stop state, meaning we found a safe point. 1537| 7.82M| for (int32_t pairIdx=0; pairIdx(fSafeTable->elementAt(c2 + 2)); 1542| 7.81M| rowState.setCharAt(c1, 0); 1543| 7.81M| } 1544| | 1545| | // Remove duplicate or redundant rows from the table. 1546| 2.63k| IntPair states = {1, 0}; 1547| 26.8k| while (findDuplicateSafeState(&states)) { ------------------ | Branch (1547:12): [True: 24.2k, False: 2.63k] ------------------ 1548| | // printf("Removing duplicate safe states (%d, %d)\n", states.first, states.second); 1549| 24.2k| removeSafeState(states); 1550| 24.2k| } 1551| 2.63k|} _ZNK6icu_7816RBBITableBuilder16getSafeTableSizeEv: 1560| 2.63k|int32_t RBBITableBuilder::getSafeTableSize() const { 1561| 2.63k| int32_t size = 0; 1562| 2.63k| int32_t numRows; 1563| 2.63k| int32_t numCols; 1564| 2.63k| int32_t rowSize; 1565| | 1566| 2.63k| if (fSafeTable == nullptr) { ------------------ | Branch (1566:9): [True: 0, False: 2.63k] ------------------ 1567| 0| return 0; 1568| 0| } 1569| | 1570| 2.63k| size = offsetof(RBBIStateTable, fTableData); // The header, with no rows to the table. 1571| | 1572| 2.63k| numRows = fSafeTable->size(); 1573| 2.63k| numCols = fRB->fSetBuilder->getNumCharCategories(); 1574| | 1575| 2.63k| if (use8BitsForSafeTable()) { ------------------ | Branch (1575:9): [True: 2.60k, False: 32] ------------------ 1576| 2.60k| rowSize = offsetof(RBBIStateTableRow8, fNextState) + sizeof(int8_t)*numCols; 1577| 2.60k| } else { 1578| 32| rowSize = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t)*numCols; 1579| 32| } 1580| 2.63k| size += numRows * rowSize; 1581| 2.63k| return size; 1582| 2.63k|} _ZNK6icu_7816RBBITableBuilder20use8BitsForSafeTableEv: 1584| 59.6k|bool RBBITableBuilder::use8BitsForSafeTable() const { 1585| 59.6k| return fSafeTable->size() <= kMaxStateFor8BitsTable; 1586| 59.6k|} _ZN6icu_7816RBBITableBuilder15exportSafeTableEPv: 1595| 2.63k|void RBBITableBuilder::exportSafeTable(void *where) { 1596| 2.63k| RBBIStateTable* table = static_cast(where); 1597| 2.63k| uint32_t state; 1598| 2.63k| int col; 1599| | 1600| 2.63k| if (U_FAILURE(*fStatus) || fSafeTable == nullptr) { ------------------ | Branch (1600:9): [True: 0, False: 2.63k] | Branch (1600:32): [True: 0, False: 2.63k] ------------------ 1601| 0| return; 1602| 0| } 1603| | 1604| 2.63k| int32_t catCount = fRB->fSetBuilder->getNumCharCategories(); 1605| 2.63k| if (catCount > 0x7fff || ------------------ | Branch (1605:9): [True: 0, False: 2.63k] ------------------ 1606| 2.63k| fSafeTable->size() > 0x7fff) { ------------------ | Branch (1606:13): [True: 0, False: 2.63k] ------------------ 1607| 0| *fStatus = U_BRK_INTERNAL_ERROR; 1608| 0| return; 1609| 0| } 1610| | 1611| 2.63k| table->fNumStates = fSafeTable->size(); 1612| 2.63k| table->fFlags = 0; 1613| 2.63k| if (use8BitsForSafeTable()) { ------------------ | Branch (1613:9): [True: 2.60k, False: 32] ------------------ 1614| 2.60k| table->fRowLen = offsetof(RBBIStateTableRow8, fNextState) + sizeof(uint8_t) * catCount; 1615| 2.60k| table->fFlags |= RBBI_8BITS_ROWS; 1616| 2.60k| } else { 1617| 32| table->fRowLen = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t) * catCount; 1618| 32| } 1619| | 1620| 57.0k| for (state=0; statefNumStates; state++) { ------------------ | Branch (1620:19): [True: 54.4k, False: 2.63k] ------------------ 1621| 54.4k| UnicodeString* rowString = static_cast(fSafeTable->elementAt(state)); 1622| 54.4k| RBBIStateTableRow* row = reinterpret_cast(table->fTableData + state * table->fRowLen); 1623| 54.4k| if (use8BitsForSafeTable()) { ------------------ | Branch (1623:13): [True: 45.6k, False: 8.72k] ------------------ 1624| 45.6k| RBBIStateTableRow8* r8 = reinterpret_cast(row); 1625| 45.6k| r8->fAccepting = 0; 1626| 45.6k| r8->fLookAhead = 0; 1627| 45.6k| r8->fTagsIdx = 0; 1628| 4.98M| for (col=0; colcharAt(col) <= kMaxStateFor8BitsTable); ------------------ | | 35| 4.94M|# define U_ASSERT(exp) (void)0 ------------------ 1630| 4.94M| r8->fNextState[col] = static_cast(rowString->charAt(col)); 1631| 4.94M| } 1632| 45.6k| } else { 1633| 8.72k| row->r16.fAccepting = 0; 1634| 8.72k| row->r16.fLookAhead = 0; 1635| 8.72k| row->r16.fTagsIdx = 0; 1636| 2.50M| for (col=0; colr16.fNextState[col] = rowString->charAt(col); 1638| 2.50M| } 1639| 8.72k| } 1640| 54.4k| } 1641| 2.63k|} _ZN6icu_7819RBBIStateDescriptorC2EiP10UErrorCode: 1777| 250k|RBBIStateDescriptor::RBBIStateDescriptor(int lastInputSymbol, UErrorCode *fStatus) { 1778| 250k| fMarked = false; 1779| 250k| fAccepting = 0; 1780| 250k| fLookAhead = 0; 1781| 250k| fTagsIdx = 0; 1782| 250k| fTagVals = nullptr; 1783| 250k| fPositions = nullptr; 1784| 250k| fDtran = nullptr; 1785| | 1786| 250k| fDtran = new UVector32(lastInputSymbol+1, *fStatus); 1787| 250k| if (U_FAILURE(*fStatus)) { ------------------ | Branch (1787:9): [True: 0, False: 250k] ------------------ 1788| 0| return; 1789| 0| } 1790| 250k| if (fDtran == nullptr) { ------------------ | Branch (1790:9): [True: 0, False: 250k] ------------------ 1791| 0| *fStatus = U_MEMORY_ALLOCATION_ERROR; 1792| 0| return; 1793| 0| } 1794| 250k| fDtran->setSize(lastInputSymbol+1); // fDtran needs to be pre-sized. 1795| | // It is indexed by input symbols, and will 1796| | // hold the next state number for each 1797| | // symbol. 1798| 250k|} _ZN6icu_7819RBBIStateDescriptorD2Ev: 1801| 250k|RBBIStateDescriptor::~RBBIStateDescriptor() { 1802| 250k| delete fPositions; 1803| 250k| delete fDtran; 1804| 250k| delete fTagVals; 1805| 250k| fPositions = nullptr; 1806| 250k| fDtran = nullptr; 1807| 250k| fTagVals = nullptr; 1808| 250k|} _ZN6icu_7810FileTracer9traceOpenEPKcS2_S2_: 140| 1| static void traceOpen(const char*, const char*, const char*) {} _ZN6icu_7821RuleCharacterIteratorC2ERKNS_13UnicodeStringEPKNS_11SymbolTableERNS_13ParsePositionE: 27| 53.9k| text(theText), 28| 53.9k| pos(thePos), 29| 53.9k| sym(theSym), 30| 53.9k| buf(nullptr), 31| 53.9k| bufPos(0) 32| 53.9k|{} _ZNK6icu_7821RuleCharacterIterator5atEndEv: 34| 113M|UBool RuleCharacterIterator::atEnd() const { 35| 113M| return buf == nullptr && pos.getIndex() == text.length(); ------------------ | Branch (35:12): [True: 15.5M, False: 98.1M] | Branch (35:30): [True: 12.7k, False: 15.5M] ------------------ 36| 113M|} _ZN6icu_7821RuleCharacterIterator4nextEiRaR10UErrorCode: 38| 137M|UChar32 RuleCharacterIterator::next(int32_t options, UBool& isEscaped, UErrorCode& ec) { 39| 137M| if (U_FAILURE(ec)) return DONE; ------------------ | Branch (39:9): [True: 3.18k, False: 137M] ------------------ 40| | 41| 137M| UChar32 c = DONE; 42| 137M| isEscaped = false; 43| | 44| 138M| for (;;) { 45| 138M| c = _current(); 46| 138M| _advance(U16_LENGTH(c)); ------------------ | | 141| 138M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 138M, False: 52.5k] | | ------------------ ------------------ 47| | 48| 138M| if (c == SymbolTable::SYMBOL_REF && buf == nullptr && ------------------ | Branch (48:13): [True: 214k, False: 138M] | Branch (48:45): [True: 74.2k, False: 140k] ------------------ 49| 138M| (options & PARSE_VARIABLES) != 0 && sym != nullptr) { ------------------ | Branch (49:13): [True: 74.2k, False: 0] | Branch (49:49): [True: 74.2k, False: 0] ------------------ 50| 74.2k| 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| 74.2k| if (name.length() == 0) { ------------------ | Branch (53:17): [True: 18.4k, False: 55.7k] ------------------ 54| 18.4k| break; 55| 18.4k| } 56| 55.7k| bufPos = 0; 57| 55.7k| buf = sym->lookup(name); 58| 55.7k| if (buf == nullptr) { ------------------ | Branch (58:17): [True: 2.79k, False: 53.0k] ------------------ 59| 2.79k| ec = U_UNDEFINED_VARIABLE; 60| 2.79k| return DONE; 61| 2.79k| } 62| | // Handle empty variable value 63| 53.0k| if (buf->length() == 0) { ------------------ | Branch (63:17): [True: 0, False: 53.0k] ------------------ 64| 0| buf = nullptr; 65| 0| } 66| 53.0k| continue; 67| 55.7k| } 68| | 69| 138M| if ((options & SKIP_WHITESPACE) != 0 && PatternProps::isWhiteSpace(c)) { ------------------ | Branch (69:13): [True: 138M, False: 541k] | Branch (69:49): [True: 779k, False: 137M] ------------------ 70| 779k| continue; 71| 779k| } 72| | 73| 137M| if (c == 0x5C /*'\\'*/ && (options & PARSE_ESCAPES) != 0) { ------------------ | Branch (73:13): [True: 574k, False: 137M] | Branch (73:35): [True: 324k, False: 249k] ------------------ 74| 324k| UnicodeString tempEscape; 75| 324k| int32_t offset = 0; 76| 324k| c = lookahead(tempEscape, MAX_U_NOTATION_LEN).unescapeAt(offset); ------------------ | | 21| 324k|#define MAX_U_NOTATION_LEN 12 ------------------ 77| 324k| jumpahead(offset); 78| 324k| isEscaped = true; 79| 324k| if (c < 0) { ------------------ | Branch (79:17): [True: 53, False: 324k] ------------------ 80| 53| ec = U_MALFORMED_UNICODE_ESCAPE; 81| 53| return DONE; 82| 53| } 83| 324k| } 84| | 85| 137M| break; 86| 137M| } 87| | 88| 137M| return c; 89| 137M|} _ZNK6icu_7821RuleCharacterIterator6getPosERNS0_3PosE: 91| 47.0M|void RuleCharacterIterator::getPos(RuleCharacterIterator::Pos& p) const { 92| 47.0M| p.buf = buf; 93| 47.0M| p.pos = pos.getIndex(); 94| 47.0M| p.bufPos = bufPos; 95| 47.0M|} _ZN6icu_7821RuleCharacterIterator6setPosERKNS0_3PosE: 97| 23.7M|void RuleCharacterIterator::setPos(const RuleCharacterIterator::Pos& p) { 98| 23.7M| buf = p.buf; 99| 23.7M| pos.setIndex(p.pos); 100| 23.7M| bufPos = p.bufPos; 101| 23.7M|} _ZN6icu_7821RuleCharacterIterator11skipIgnoredEi: 103| 320k|void RuleCharacterIterator::skipIgnored(int32_t options) { 104| 320k| if ((options & SKIP_WHITESPACE) != 0) { ------------------ | Branch (104:9): [True: 320k, False: 0] ------------------ 105| 331k| for (;;) { 106| 331k| UChar32 a = _current(); 107| 331k| if (!PatternProps::isWhiteSpace(a)) break; ------------------ | Branch (107:17): [True: 320k, False: 11.0k] ------------------ 108| 11.0k| _advance(U16_LENGTH(a)); ------------------ | | 141| 11.0k|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 11.0k, False: 0] | | ------------------ ------------------ 109| 11.0k| } 110| 320k| } 111| 320k|} _ZNK6icu_7821RuleCharacterIterator9lookaheadERNS_13UnicodeStringEi: 113| 483k|UnicodeString& RuleCharacterIterator::lookahead(UnicodeString& result, int32_t maxLookAhead) const { 114| 483k| if (maxLookAhead < 0) { ------------------ | Branch (114:9): [True: 158k, False: 324k] ------------------ 115| 158k| maxLookAhead = 0x7FFFFFFF; 116| 158k| } 117| 483k| if (buf != nullptr) { ------------------ | Branch (117:9): [True: 296k, False: 187k] ------------------ 118| 296k| buf->extract(bufPos, maxLookAhead, result); 119| 296k| } else { 120| 187k| text.extract(pos.getIndex(), maxLookAhead, result); 121| 187k| } 122| 483k| return result; 123| 483k|} _ZN6icu_7821RuleCharacterIterator9jumpaheadEi: 125| 482k|void RuleCharacterIterator::jumpahead(int32_t count) { 126| 482k| _advance(count); 127| 482k|} _ZNK6icu_7821RuleCharacterIterator8_currentEv: 137| 138M|UChar32 RuleCharacterIterator::_current() const { 138| 138M| if (buf != nullptr) { ------------------ | Branch (138:9): [True: 108M, False: 30.1M] ------------------ 139| 108M| return buf->char32At(bufPos); 140| 108M| } else { 141| 30.1M| int i = pos.getIndex(); 142| 30.1M| return (i < text.length()) ? text.char32At(i) : static_cast(DONE); ------------------ | Branch (142:16): [True: 30.0M, False: 36.5k] ------------------ 143| 30.1M| } 144| 138M|} _ZN6icu_7821RuleCharacterIterator8_advanceEi: 146| 139M|void RuleCharacterIterator::_advance(int32_t count) { 147| 139M| if (buf != nullptr) { ------------------ | Branch (147:9): [True: 108M, False: 30.1M] ------------------ 148| 108M| bufPos += count; 149| 108M| if (bufPos == buf->length()) { ------------------ | Branch (149:13): [True: 38.7k, False: 108M] ------------------ 150| 38.7k| buf = nullptr; 151| 38.7k| } 152| 108M| } else { 153| 30.1M| pos.setIndex(pos.getIndex() + count); 154| 30.1M| if (pos.getIndex() > text.length()) { ------------------ | Branch (154:13): [True: 2.28k, False: 30.1M] ------------------ 155| 2.28k| pos.setIndex(text.length()); 156| 2.28k| } 157| 30.1M| } 158| 139M|} _ZNK6icu_7821RuleCharacterIterator10inVariableEv: 226| 50.0k|inline UBool RuleCharacterIterator::inVariable() const { 227| 50.0k| return buf != nullptr; 228| 50.0k|} _ZN6icu_7811StringPieceC2EPKc: 19| 7| : ptr_(str), length_((str == nullptr) ? 0 : static_cast(uprv_strlen(str))) { } ------------------ | | 37| 7|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 7|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (19:26): [True: 0, False: 7] ------------------ 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| 806k|ubidi_getClass(UChar32 c) { 135| 806k| uint16_t props=UTRIE2_GET16(&ubidi_props_singleton.trie, c); ------------------ | | 360| 806k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 806k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 806k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 456k, False: 349k] | | | | | | ------------------ | | | | | | 846| 806k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 456k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 456k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 39.0k] | | | | | | | | ------------------ | | | | | | | | 816| 39.0k| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 349k| (trie)->index, c) : \ | | | | | | 851| 349k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 310k] | | | | | | ------------------ | | | | | | 852| 310k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 310k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 310k] | | | | | | ------------------ | | | | | | 854| 310k| (trie)->highValueIndex : \ | | | | | | 855| 310k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 310k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 310k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 310k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 310k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 310k| <indexLength, (c)) | | ------------------ | | | | 871| 109k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 109k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 64.5k, False: 45.2k] | | | | | | ------------------ | | | | | | 846| 109k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 64.5k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 64.5k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 1.26k] | | | | | | | | ------------------ | | | | | | | | 816| 1.26k| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 45.2k| (trie)->index, c) : \ | | | | | | 851| 45.2k| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 44.0k] | | | | | | ------------------ | | | | | | 852| 44.0k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 44.0k| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 44.0k] | | | | | | ------------------ | | | | | | 854| 44.0k| (trie)->highValueIndex : \ | | | | | | 855| 44.0k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 44.0k| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 44.0k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 44.0k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 44.0k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 44.0k| <>UBIDI_JT_SHIFT); ------------------ | | 114| 109k|#define UBIDI_JT_MASK 0x000000e0 ------------------ 199| 109k|} u_charDirection_78: 237| 806k|u_charDirection(UChar32 c) { 238| 806k| return ubidi_getClass(c); ------------------ | | 440| 806k|#define ubidi_getClass U_ICU_ENTRY_POINT_RENAME(ubidi_getClass) | | ------------------ | | | | 123| 806k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 806k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 806k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 239| 806k|} ubidi_props.cpp:_ZL24_enumPropertyStartsRangePKviij: 50| 1.98k|_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 end, uint32_t value) { 51| 1.98k| (void)end; 52| 1.98k| (void)value; 53| | /* add the start code point to the USet */ 54| 1.98k| const USetAdder* sa = static_cast(context); 55| 1.98k| sa->add(sa->set, start); 56| 1.98k| return true; 57| 1.98k|} ucase_addPropertyStarts_78: 47| 1|ucase_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 48| 1| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (48:8): [True: 0, False: 1] ------------------ 49| 0| return; 50| 0| } 51| | 52| | /* add the start code point of each same-value range of the trie */ 53| 1| utrie2_enum(&ucase_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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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| 1|} ucase_getType_78: 673| 6.19k|ucase_getType(UChar32 c) { 674| 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| <indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <= 0); ------------------ | | 35| 3.09k|# define U_ASSERT(exp) (void)0 ------------------ 1156| 3.09k| UChar32 result=c; 1157| | // Reset the output pointer in case it was uninitialized. 1158| 3.09k| *pString=nullptr; 1159| 3.09k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 3.09k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <>UCASE_DELTA_SHIFT) | | ------------------ | | | | 391| 680|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1163| 680| } 1164| 2.71k| } else { 1165| 388| const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props), *pe2; ------------------ | | 79| 388|#define GET_EXCEPTIONS(csp, props) ((csp)->exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 388|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 1166| 388| uint16_t excWord=*pe++; 1167| 388| int32_t full; 1168| | 1169| 388| pe2=pe; 1170| | 1171| 388| if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) { ------------------ | | 444| 388|#define UCASE_EXC_CONDITIONAL_SPECIAL 0x4000 ------------------ | Branch (1171:12): [True: 10, False: 378] ------------------ 1172| | /* use hardcoded conditions and mappings */ 1173| | 1174| | /* 1175| | * Test for conditional mappings first 1176| | * (otherwise the unconditional default mappings are always taken), 1177| | * then test for characters that have unconditional mappings in SpecialCasing.txt, 1178| | * then get the UnicodeData.txt mappings. 1179| | */ 1180| 10| if( loc==UCASE_LOC_LITHUANIAN && ------------------ | Branch (1180:17): [True: 0, False: 10] ------------------ 1181| | /* base characters, find accents above */ 1182| 10| (((c==0x49 || c==0x4a || c==0x12e) && ------------------ | Branch (1182:24): [True: 0, False: 0] | Branch (1182:35): [True: 0, False: 0] | Branch (1182:46): [True: 0, False: 0] ------------------ 1183| 0| isFollowedByMoreAbove(iter, context)) || ------------------ | Branch (1183:25): [True: 0, False: 0] ------------------ 1184| | /* precomposed with accent above, no need to find one */ 1185| 0| (c==0xcc || c==0xcd || c==0x128)) ------------------ | Branch (1185:22): [True: 0, False: 0] | Branch (1185:33): [True: 0, False: 0] | Branch (1185:44): [True: 0, False: 0] ------------------ 1186| 10| ) { 1187| | /* 1188| | # Lithuanian 1189| | 1190| | # Lithuanian retains the dot in a lowercase i when followed by accents. 1191| | 1192| | # Introduce an explicit dot above when lowercasing capital I's and J's 1193| | # whenever there are more accents above. 1194| | # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek) 1195| | 1196| | 0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I 1197| | 004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J 1198| | 012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK 1199| | 00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE 1200| | 00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE 1201| | 0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE 1202| | */ 1203| 0| switch(c) { 1204| 0| case 0x49: /* LATIN CAPITAL LETTER I */ ------------------ | Branch (1204:17): [True: 0, False: 0] ------------------ 1205| 0| *pString=iDot; 1206| 0| return 2; 1207| 0| case 0x4a: /* LATIN CAPITAL LETTER J */ ------------------ | Branch (1207:17): [True: 0, False: 0] ------------------ 1208| 0| *pString=jDot; 1209| 0| return 2; 1210| 0| case 0x12e: /* LATIN CAPITAL LETTER I WITH OGONEK */ ------------------ | Branch (1210:17): [True: 0, False: 0] ------------------ 1211| 0| *pString=iOgonekDot; 1212| 0| return 2; 1213| 0| case 0xcc: /* LATIN CAPITAL LETTER I WITH GRAVE */ ------------------ | Branch (1213:17): [True: 0, False: 0] ------------------ 1214| 0| *pString=iDotGrave; 1215| 0| return 3; 1216| 0| case 0xcd: /* LATIN CAPITAL LETTER I WITH ACUTE */ ------------------ | Branch (1216:17): [True: 0, False: 0] ------------------ 1217| 0| *pString=iDotAcute; 1218| 0| return 3; 1219| 0| case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */ ------------------ | Branch (1219:17): [True: 0, False: 0] ------------------ 1220| 0| *pString=iDotTilde; 1221| 0| return 3; 1222| 0| default: ------------------ | Branch (1222:17): [True: 0, False: 0] ------------------ 1223| 0| return 0; /* will not occur */ 1224| 0| } 1225| | /* # Turkish and Azeri */ 1226| 10| } else if(loc==UCASE_LOC_TURKISH && c==0x130) { ------------------ | Branch (1226:23): [True: 0, False: 10] | Branch (1226:49): [True: 0, False: 0] ------------------ 1227| | /* 1228| | # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri 1229| | # The following rules handle those cases. 1230| | 1231| | 0130; 0069; 0130; 0130; tr # LATIN CAPITAL LETTER I WITH DOT ABOVE 1232| | 0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE 1233| | */ 1234| 0| return 0x69; 1235| 10| } else if(loc==UCASE_LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, context)) { ------------------ | Branch (1235:23): [True: 0, False: 10] | Branch (1235:49): [True: 0, False: 0] | Branch (1235:61): [True: 0, False: 0] ------------------ 1236| | /* 1237| | # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i. 1238| | # This matches the behavior of the canonically equivalent I-dot_above 1239| | 1240| | 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE 1241| | 0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE 1242| | */ 1243| 0| return 0; /* remove the dot (continue without output) */ 1244| 10| } else if(loc==UCASE_LOC_TURKISH && c==0x49 && !isFollowedByDotAbove(iter, context)) { ------------------ | Branch (1244:23): [True: 0, False: 10] | Branch (1244:49): [True: 0, False: 0] | Branch (1244:60): [True: 0, False: 0] ------------------ 1245| | /* 1246| | # When lowercasing, unless an I is before a dot_above, it turns into a dotless i. 1247| | 1248| | 0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I 1249| | 0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I 1250| | */ 1251| 0| return 0x131; 1252| 10| } else if(c==0x130) { ------------------ | Branch (1252:23): [True: 1, False: 9] ------------------ 1253| | /* 1254| | # Preserve canonical equivalence for I with dot. Turkic is handled below. 1255| | 1256| | 0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE 1257| | */ 1258| 1| *pString=iDot; 1259| 1| return 2; 1260| 9| } else if( c==0x3a3 && ------------------ | Branch (1260:25): [True: 1, False: 8] ------------------ 1261| 9| !isFollowedByCasedLetter(iter, context, 1) && ------------------ | Branch (1261:25): [True: 1, False: 0] ------------------ 1262| 9| isFollowedByCasedLetter(iter, context, -1) /* -1=preceded */ ------------------ | Branch (1262:25): [True: 0, False: 1] ------------------ 1263| 9| ) { 1264| | /* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */ 1265| | /* 1266| | # Special case for final form of sigma 1267| | 1268| | 03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA 1269| | */ 1270| 0| return 0x3c2; /* greek small final sigma */ 1271| 9| } else { 1272| | /* no known conditional special case mapping, use a normal mapping */ 1273| 9| } 1274| 378| } else if(HAS_SLOT(excWord, UCASE_EXC_FULL_MAPPINGS)) { ------------------ | | 101| 378|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 102, False: 276] | | ------------------ ------------------ 1275| 102| GET_SLOT_VALUE(excWord, UCASE_EXC_FULL_MAPPINGS, pe, full); ------------------ | | 113| 102|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 102|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 102| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 102|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 102, False: 0] | | ------------------ | | 115| 102| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 102|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 102| (value)=*pExc16; \ | | 117| 102| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 102|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 102|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1276| 102| full&=UCASE_FULL_LOWER; ------------------ | | 448| 102|#define UCASE_FULL_LOWER 0xf ------------------ 1277| 102| if(full!=0) { ------------------ | Branch (1277:16): [True: 0, False: 102] ------------------ 1278| | /* set the output pointer to the lowercase mapping */ 1279| 0| *pString=reinterpret_cast(pe+1); 1280| | 1281| | /* return the string length */ 1282| 0| return full; 1283| 0| } 1284| 102| } 1285| | 1286| 387| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 101| 774|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 125, False: 262] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) { ------------------ | | 374| 125|#define UCASE_IS_UPPER_OR_TITLE(props) ((props)&2) | | ------------------ | | | Branch (374:40): [True: 69, False: 56] | | ------------------ ------------------ 1287| 69| int32_t delta; 1288| 69| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 69|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 69|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 69| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 69|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 69, False: 0] | | ------------------ | | 115| 69| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 69|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 69| (value)=*pExc16; \ | | 117| 69| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 69|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 69|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1289| 69| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1289:20): [True: 14, False: 55] ------------------ 1290| 69| } 1291| 318| if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) { ------------------ | | 101| 318|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 31, False: 287] | | ------------------ ------------------ 1292| 31| GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result); ------------------ | | 113| 31|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 31|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 31| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 31|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 31, False: 0] | | ------------------ | | 115| 31| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 31|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 31| (value)=*pExc16; \ | | 117| 31| } else { \ | | 118| 0| (pExc16)+=2*SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 0|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 119| 0| (value)=*pExc16++; \ | | 120| 0| (value)=((value)<<16)|*pExc16; \ | | 121| 0| } \ | | 122| 31|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 31|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1293| 31| } 1294| 318| } 1295| | 1296| 3.02k| return (result==c) ? ~result : result; ------------------ | Branch (1296:12): [True: 2.36k, False: 663] ------------------ 1297| 3.09k|} ucase_toFullUpper_78: 1415| 3.09k| int32_t caseLocale) { 1416| 3.09k| return toUpperOrTitle(c, iter, context, pString, caseLocale, true); 1417| 3.09k|} ucase_toFullTitle_78: 1423| 3.09k| int32_t caseLocale) { 1424| 3.09k| return toUpperOrTitle(c, iter, context, pString, caseLocale, false); 1425| 3.09k|} ucase_hasBinaryProperty_78: 1659| 21.6k|ucase_hasBinaryProperty(UChar32 c, UProperty which) { 1660| | /* case mapping properties */ 1661| 21.6k| const char16_t *resultString; 1662| 21.6k| switch(which) { 1663| 3.09k| case UCHAR_LOWERCASE: ------------------ | Branch (1663:5): [True: 3.09k, False: 18.5k] ------------------ 1664| 3.09k| return (UBool)(UCASE_LOWER==ucase_getType(c)); ------------------ | | 575| 3.09k|#define ucase_getType U_ICU_ENTRY_POINT_RENAME(ucase_getType) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1665| 3.09k| case UCHAR_UPPERCASE: ------------------ | Branch (1665:5): [True: 3.09k, False: 18.5k] ------------------ 1666| 3.09k| return (UBool)(UCASE_UPPER==ucase_getType(c)); ------------------ | | 575| 3.09k|#define ucase_getType U_ICU_ENTRY_POINT_RENAME(ucase_getType) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1667| 3.09k| case UCHAR_SOFT_DOTTED: ------------------ | Branch (1667:5): [True: 3.09k, False: 18.5k] ------------------ 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: 21.6k] ------------------ 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: 21.6k] ------------------ 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: 18.5k] ------------------ 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: 18.5k] ------------------ 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: 18.5k] ------------------ 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: 18.5k] ------------------ 1692| 3.09k| return (UBool)(ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 582| 3.09k|#define ucase_toFullTitle U_ICU_ENTRY_POINT_RENAME(ucase_toFullTitle) | | ------------------ | | | | 123| 3.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1693| | /* case UCHAR_CHANGES_WHEN_CASEFOLDED: -- in uprops.c */ 1694| 0| case UCHAR_CHANGES_WHEN_CASEMAPPED: ------------------ | Branch (1694:5): [True: 0, False: 21.6k] ------------------ 1695| 0| return (UBool)( 1696| 0| ucase_toFullLower(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 || ------------------ | | 581| 0|#define ucase_toFullLower U_ICU_ENTRY_POINT_RENAME(ucase_toFullLower) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1696:13): [True: 0, False: 0] ------------------ 1697| 0| ucase_toFullUpper(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0 || ------------------ | | 583| 0|#define ucase_toFullUpper U_ICU_ENTRY_POINT_RENAME(ucase_toFullUpper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1697:13): [True: 0, False: 0] ------------------ 1698| 0| ucase_toFullTitle(c, nullptr, nullptr, &resultString, UCASE_LOC_ROOT)>=0); ------------------ | | 582| 0|#define ucase_toFullTitle U_ICU_ENTRY_POINT_RENAME(ucase_toFullTitle) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1698:13): [True: 0, False: 0] ------------------ 1699| 0| default: ------------------ | Branch (1699:5): [True: 0, False: 21.6k] ------------------ 1700| 0| return false; 1701| 21.6k| } 1702| 21.6k|} ucase.cpp:_ZL24_enumPropertyStartsRangePKviij: 39| 3.09k|_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 /*end*/, uint32_t /*value*/) { 40| | /* add the start code point to the USet */ 41| 3.09k| const USetAdder* sa = static_cast(context); 42| 3.09k| sa->add(sa->set, start); 43| 3.09k| return true; 44| 3.09k|} ucase.cpp:_ZL10getDotTypei: 687| 3.09k|getDotType(UChar32 c) { 688| 3.09k| uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c); ------------------ | | 360| 3.09k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 3.09k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 3.09k| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 2.49k, False: 600] | | | | | | ------------------ | | | | | | 846| 3.09k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 2.49k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 2.49k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 0, False: 53] | | | | | | | | ------------------ | | | | | | | | 816| 53| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 600| (trie)->index, c) : \ | | | | | | 851| 600| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 852| 547| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 547| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 854| 547| (trie)->highValueIndex : \ | | | | | | 855| 547| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 547| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 547| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 547| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 547| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 547| <exceptions+((props)>>UCASE_EXC_SHIFT)) | | ------------------ | | | | 403| 388|#define UCASE_EXC_SHIFT 4 | | ------------------ ------------------ 693| 388| return (*pe>>UCASE_EXC_DOT_SHIFT)&UCASE_DOT_MASK; ------------------ | | 432| 388|#define UCASE_EXC_DOT_SHIFT 7 ------------------ return (*pe>>UCASE_EXC_DOT_SHIFT)&UCASE_DOT_MASK; ------------------ | | 382| 388|#define UCASE_DOT_MASK 0x60 ------------------ 694| 388| } 695| 3.09k|} ucase.cpp:_ZL23isFollowedByCasedLetterPFiPvaES_a: 1000| 2|isFollowedByCasedLetter(UCaseContextIterator *iter, void *context, int8_t dir) { 1001| 2| UChar32 c; 1002| | 1003| 2| if(iter==nullptr) { ------------------ | Branch (1003:8): [True: 2, False: 0] ------------------ 1004| 2| return false; 1005| 2| } 1006| | 1007| 0| for(/* dir!=0 sets direction */; (c=iter(context, dir))>=0; dir=0) { ------------------ | Branch (1007:38): [True: 0, False: 0] ------------------ 1008| 0| int32_t type=ucase_getTypeOrIgnorable(c); ------------------ | | 576| 0|#define ucase_getTypeOrIgnorable U_ICU_ENTRY_POINT_RENAME(ucase_getTypeOrIgnorable) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1009| 0| if(type&4) { ------------------ | Branch (1009:12): [True: 0, False: 0] ------------------ 1010| | /* case-ignorable, continue with the loop */ 1011| 0| } else if(type!=UCASE_NONE) { ------------------ | Branch (1011:19): [True: 0, False: 0] ------------------ 1012| 0| return true; /* followed by cased letter */ 1013| 0| } else { 1014| 0| return false; /* uncased and not case-ignorable */ 1015| 0| } 1016| 0| } 1017| | 1018| 0| return false; /* not followed by cased letter */ 1019| 0|} ucase.cpp:_ZL14toUpperOrTitleiPFiPvaES_PPKDsia: 1305| 6.19k| UBool upperNotTitle) { 1306| | // The sign of the result has meaning, input must be non-negative so that it can be returned as is. 1307| 6.19k| U_ASSERT(c >= 0); ------------------ | | 35| 6.19k|# define U_ASSERT(exp) (void)0 ------------------ 1308| 6.19k| UChar32 result=c; 1309| | // Reset the output pointer in case it was uninitialized. 1310| 6.19k| *pString=nullptr; 1311| 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.58k|#define UCASE_DELTA_SHIFT 7 | | ------------------ ------------------ 1315| 1.58k| } 1316| 5.42k| } else { 1317| 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 | | ------------------ ------------------ 1318| 776| uint16_t excWord=*pe++; 1319| 776| int32_t full, idx; 1320| | 1321| 776| pe2=pe; 1322| | 1323| 776| if(excWord&UCASE_EXC_CONDITIONAL_SPECIAL) { ------------------ | | 444| 776|#define UCASE_EXC_CONDITIONAL_SPECIAL 0x4000 ------------------ | Branch (1323:12): [True: 20, False: 756] ------------------ 1324| | /* use hardcoded conditions and mappings */ 1325| 20| if(loc==UCASE_LOC_TURKISH && c==0x69) { ------------------ | Branch (1325:16): [True: 0, False: 20] | 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| 20| } else if(loc==UCASE_LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, context)) { ------------------ | Branch (1338:23): [True: 0, False: 20] | 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| 20| } else if(c==0x0587) { ------------------ | Branch (1349:23): [True: 2, False: 18] ------------------ 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| 2| if(loc==UCASE_LOC_ARMENIAN) { ------------------ | Branch (1354:20): [True: 0, False: 2] ------------------ 1355| 0| *pString=upperNotTitle ? u"ԵՎ" : u"Եվ"; ------------------ | Branch (1355:30): [True: 0, False: 0] ------------------ 1356| 2| } else { 1357| 2| *pString=upperNotTitle ? u"ԵՒ" : u"Եւ"; ------------------ | Branch (1357:30): [True: 1, False: 1] ------------------ 1358| 2| } 1359| 2| return 2; 1360| 18| } else { 1361| | /* no known conditional special case mapping, use a normal mapping */ 1362| 18| } 1363| 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] | | ------------------ ------------------ 1364| 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] | | | | ------------------ | | ------------------ ------------------ 1365| | 1366| | /* start of full case mapping strings */ 1367| 204| ++pe; 1368| | 1369| | /* skip the lowercase and case-folding result strings */ 1370| 204| pe+=full&UCASE_FULL_LOWER; ------------------ | | 448| 204|#define UCASE_FULL_LOWER 0xf ------------------ 1371| 204| full>>=4; 1372| 204| pe+=full&0xf; 1373| 204| full>>=4; 1374| | 1375| 204| if(upperNotTitle) { ------------------ | Branch (1375:16): [True: 102, False: 102] ------------------ 1376| 102| full&=0xf; 1377| 102| } else { 1378| | /* skip the uppercase result string */ 1379| 102| pe+=full&0xf; 1380| 102| full=(full>>4)&0xf; 1381| 102| } 1382| | 1383| 204| if(full!=0) { ------------------ | Branch (1383:16): [True: 148, False: 56] ------------------ 1384| | /* set the output pointer to the result string */ 1385| 148| *pString=reinterpret_cast(pe); 1386| | 1387| | /* return the string length */ 1388| 148| return full; 1389| 148| } 1390| 204| } 1391| | 1392| 626| if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) { ------------------ | | 101| 1.25k|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 198, False: 428] | | ------------------ ------------------ if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) { ------------------ | | 371| 198|#define UCASE_GET_TYPE(props) ((props)&UCASE_TYPE_MASK) | | ------------------ | | | | 363| 198|#define UCASE_TYPE_MASK 3 | | ------------------ ------------------ | Branch (1392:50): [True: 85, False: 113] ------------------ 1393| 85| int32_t delta; 1394| 85| GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe2, delta); ------------------ | | 113| 85|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 85|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 85| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 85|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 85, False: 0] | | ------------------ | | 115| 85| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 85|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 85| (value)=*pExc16; \ | | 117| 85| } 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| 85|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 85|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1395| 85| return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta; ------------------ | Branch (1395:20): [True: 71, False: 14] ------------------ 1396| 85| } 1397| 541| if(!upperNotTitle && HAS_SLOT(excWord, UCASE_EXC_TITLE)) { ------------------ | | 101| 284|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 58, False: 226] | | ------------------ ------------------ | Branch (1397:12): [True: 284, False: 257] ------------------ 1398| 58| idx=UCASE_EXC_TITLE; 1399| 483| } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) { ------------------ | | 101| 483|#define HAS_SLOT(flags, idx) ((flags)&(1<<(idx))) | | ------------------ | | | Branch (101:30): [True: 318, False: 165] | | ------------------ ------------------ 1400| | /* here, titlecase is same as uppercase */ 1401| 318| idx=UCASE_EXC_UPPER; 1402| 318| } else { 1403| 165| return ~c; 1404| 165| } 1405| 541| GET_SLOT_VALUE(excWord, idx, pe2, result); ------------------ | | 113| 376|#define GET_SLOT_VALUE(excWord, idx, pExc16, value) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 376|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 114| 376| if(((excWord)&UCASE_EXC_DOUBLE_SLOTS)==0) { \ | | ------------------ | | | | 423| 376|#define UCASE_EXC_DOUBLE_SLOTS 0x100 | | ------------------ | | | Branch (114:8): [True: 376, False: 0] | | ------------------ | | 115| 376| (pExc16)+=SLOT_OFFSET(excWord, idx); \ | | ------------------ | | | | 102| 376|#define SLOT_OFFSET(flags, idx) flagsOffset[(flags)&((1<<(idx))-1)] | | ------------------ | | 116| 376| (value)=*pExc16; \ | | 117| 376| } 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| 541|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 541|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1406| 376| } 1407| | 1408| 5.79k| return (result==c) ? ~result : result; ------------------ | Branch (1408:12): [True: 4.19k, False: 1.60k] ------------------ 1409| 6.19k|} u_charType_78: 50| 582M|u_charType(UChar32 c) { 51| 582M| uint32_t props; 52| 582M| GET_PROPS(c, props); ------------------ | | 44| 582M|#define GET_PROPS(c, result) ((result)=UTRIE2_GET16(&propsTrie, c)) | | ------------------ | | | | 360| 582M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | | | ------------------ | | | | | | 871| 582M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 582M| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 342M, False: 239M] | | | | | | | | ------------------ | | | | | | | | 846| 582M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 342M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 342M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 97.0k, False: 17.4M] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 17.5M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 239M| (trie)->index, c) : \ | | | | | | | | 851| 239M| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 222M] | | | | | | | | ------------------ | | | | | | | | 852| 222M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 222M| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 222M] | | | | | | | | ------------------ | | | | | | | | 854| 222M| (trie)->highValueIndex : \ | | | | | | | | 855| 222M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 222M| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 222M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 222M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 222M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 222M| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 4.43k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 4.43k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 2.25k, False: 2.18k] | | | | | | | | ------------------ | | | | | | | | 846| 4.43k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 2.25k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 2.25k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 1, False: 171] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 172| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 2.18k| (trie)->index, c) : \ | | | | | | | | 851| 2.18k| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 2.01k] | | | | | | | | ------------------ | | | | | | | | 852| 2.01k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 2.01k| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 2.01k] | | | | | | | | ------------------ | | | | | | | | 854| 2.01k| (trie)->highValueIndex : \ | | | | | | | | 855| 2.01k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 2.01k| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 2.01k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 2.01k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 2.01k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 2.01k| <=0x41 && (c<=0x46 || c>=0x61)) || ------------------ | Branch (127:10): [True: 38, False: 5.96k] | Branch (127:21): [True: 9, False: 29] | Branch (127:33): [True: 1, False: 8] | Branch (127:44): [True: 1, False: 7] ------------------ 128| 6.00k| (c>=0xff21 && c<=0xff46 && (c<=0xff26 || c>=0xff41)) ------------------ | Branch (128:10): [True: 2.33k, False: 3.66k] | Branch (128:23): [True: 9, False: 2.32k] | Branch (128:37): [True: 1, False: 8] | Branch (128:50): [True: 1, False: 7] ------------------ 129| 6.00k| ) { 130| 4| return true; 131| 4| } 132| | 133| 6.00k| GET_PROPS(c, props); ------------------ | | 44| 6.00k|#define GET_PROPS(c, result) ((result)=UTRIE2_GET16(&propsTrie, c)) | | ------------------ | | | | 360| 6.00k|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | | | ------------------ | | | | | | 871| 6.00k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 6.00k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 3.53k, False: 2.46k] | | | | | | | | ------------------ | | | | | | | | 846| 6.00k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 3.53k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 3.53k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 1, False: 178] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 179| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 2.46k| (trie)->index, c) : \ | | | | | | | | 851| 2.46k| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 2.29k] | | | | | | | | ------------------ | | | | | | | | 852| 2.29k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 2.29k| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 2.29k] | | | | | | | | ------------------ | | | | | | | | 854| 2.29k| (trie)->highValueIndex : \ | | | | | | | | 855| 2.29k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 2.29k| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 2.29k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 2.29k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 2.29k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 2.29k| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 5.95k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 5.95k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 3.48k, False: 2.47k] | | | | | | | | ------------------ | | | | | | | | 846| 5.95k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 3.48k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 3.48k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 1, False: 180] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 181| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 2.47k| (trie)->index, c) : \ | | | | | | | | 851| 2.47k| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 2.29k] | | | | | | | | ------------------ | | | | | | | | 852| 2.29k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 2.29k| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 2.29k] | | | | | | | | ------------------ | | | | | | | | 854| 2.29k| (trie)->highValueIndex : \ | | | | | | | | 855| 2.29k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 2.29k| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 2.29k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 2.29k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 2.29k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 2.29k| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 6.00k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 6.00k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 3.53k, False: 2.47k] | | | | | | | | ------------------ | | | | | | | | 846| 6.00k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 3.53k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 3.53k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 1, False: 180] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 181| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 2.47k| (trie)->index, c) : \ | | | | | | | | 851| 2.47k| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 2.29k] | | | | | | | | ------------------ | | | | | | | | 852| 2.29k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 2.29k| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 2.29k] | | | | | | | | ------------------ | | | | | | | | 854| 2.29k| (trie)->highValueIndex : \ | | | | | | | | 855| 2.29k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 2.29k| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 2.29k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 2.29k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 2.29k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 2.29k| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 11.9k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 11.9k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 7.05k, False: 4.94k] | | | | | | | | ------------------ | | | | | | | | 846| 11.9k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 7.05k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 7.05k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 2, False: 360] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 362| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 4.94k| (trie)->index, c) : \ | | | | | | | | 851| 4.94k| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 4.58k] | | | | | | | | ------------------ | | | | | | | | 852| 4.58k| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 4.58k| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 4.58k] | | | | | | | | ------------------ | | | | | | | | 854| 4.58k| (trie)->highValueIndex : \ | | | | | | | | 855| 4.58k| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 4.58k| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 4.58k| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 4.58k| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 4.58k| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 4.58k| <indexLength, (c)) | | | | ------------------ | | | | | | 871| 1.61k| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 1.61k| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 1.61k, False: 0] | | | | | | | | ------------------ | | | | | | | | 846| 1.61k| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 1.61k| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 1.61k| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 0| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 0| (trie)->index, c) : \ | | | | | | | | 851| 0| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 852| 0| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 0| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 854| 0| (trie)->highValueIndex : \ | | | | | | | | 855| 0| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 0| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 0| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 0| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 0| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 0| <>UPROPS_NUMERIC_TYPE_VALUE_SHIFT) ------------------ 348| 1.61k| if(value<=9) { ------------------ | Branch (348:8): [True: 1.61k, False: 0] ------------------ 349| 1.61k| return value; 350| 1.61k| } else { 351| 0| return -1; 352| 0| } 353| 1.61k|} u_getNumericValue_78: 356| 38.2M|u_getNumericValue(UChar32 c) { 357| 38.2M| uint32_t props; 358| 38.2M| int32_t ntv; 359| 38.2M| GET_PROPS(c, props); ------------------ | | 44| 38.2M|#define GET_PROPS(c, result) ((result)=UTRIE2_GET16(&propsTrie, c)) | | ------------------ | | | | 360| 38.2M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | | | ------------------ | | | | | | 871| 38.2M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | | | ------------------ | | | | | | | | 845| 38.2M| ((uint32_t)(c)<0xd800 ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (845:6): [True: 22.5M, False: 15.7M] | | | | | | | | ------------------ | | | | | | | | 846| 38.2M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | | | ------------------ | | | | | | | | | | 815| 22.5M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | 816| 22.5M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (815:30): [True: 6.37k, False: 1.14M] | | | | | | | | | | ------------------ | | | | | | | | | | 816| 1.15M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | | | 850| 15.7M| (trie)->index, c) : \ | | | | | | | | 851| 15.7M| (uint32_t)(c)>0x10ffff ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (851:13): [True: 0, False: 14.5M] | | | | | | | | ------------------ | | | | | | | | 852| 14.5M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | | | 853| 14.5M| (c)>=(trie)->highStart ? \ | | | | | | | | ------------------ | | | | | | | | | Branch (853:17): [True: 0, False: 14.5M] | | | | | | | | ------------------ | | | | | | | | 854| 14.5M| (trie)->highValueIndex : \ | | | | | | | | 855| 14.5M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | | | ------------------ | | | | | | | | | | 833| 14.5M| (((int32_t)((trieIndex)[ \ | | | | | | | | | | 834| 14.5M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | | | 835| 14.5M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | | | 836| 14.5M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | | | 837| 14.5M| <>UPROPS_NUMERIC_TYPE_VALUE_SHIFT) ------------------ 361| | 362| 38.2M| if(ntv==UPROPS_NTV_NONE) { ------------------ | Branch (362:8): [True: 25.7M, False: 12.4M] ------------------ 363| 25.7M| return U_NO_NUMERIC_VALUE; ------------------ | | 3134| 25.7M|#define U_NO_NUMERIC_VALUE ((double)-123456789.) ------------------ 364| 25.7M| } else if(ntv>4)-12; 376| 656k| int32_t denominator=(ntv&0xf)+1; 377| 656k| return (double)numerator/denominator; 378| 1.32M| } else if(ntv>5)-14; 382| 1.21M| int32_t exp=(ntv&0x1f)+2; 383| 1.21M| numValue=mant; 384| | 385| | /* multiply by 10^exp without math.h */ 386| 1.73M| while(exp>=4) { ------------------ | Branch (386:15): [True: 528k, False: 1.21M] ------------------ 387| 528k| numValue*=10000.; 388| 528k| exp-=4; 389| 528k| } 390| 1.21M| switch(exp) { 391| 382k| case 3: ------------------ | Branch (391:9): [True: 382k, False: 828k] ------------------ 392| 382k| numValue*=1000.; 393| 382k| break; 394| 395k| case 2: ------------------ | Branch (394:9): [True: 395k, False: 815k] ------------------ 395| 395k| numValue*=100.; 396| 395k| break; 397| 95.5k| case 1: ------------------ | Branch (397:9): [True: 95.5k, False: 1.11M] ------------------ 398| 95.5k| numValue*=10.; 399| 95.5k| break; 400| 337k| case 0: ------------------ | Branch (400:9): [True: 337k, False: 872k] ------------------ 401| 337k| default: ------------------ | Branch (401:9): [True: 0, False: 1.21M] ------------------ 402| 337k| break; 403| 1.21M| } 404| | 405| 1.21M| return numValue; 406| 1.21M| } else if(ntv>2)-0xbf; 409| 12.7k| int32_t exp=(ntv&3)+1; 410| | 411| 12.7k| switch(exp) { 412| 0| case 4: ------------------ | Branch (412:9): [True: 0, False: 12.7k] ------------------ 413| 0| numValue*=60*60*60*60; 414| 0| break; 415| 12.7k| case 3: ------------------ | Branch (415:9): [True: 12.7k, False: 0] ------------------ 416| 12.7k| numValue*=60*60*60; 417| 12.7k| break; 418| 0| case 2: ------------------ | Branch (418:9): [True: 0, False: 12.7k] ------------------ 419| 0| numValue*=60*60; 420| 0| break; 421| 0| case 1: ------------------ | Branch (421:9): [True: 0, False: 12.7k] ------------------ 422| 0| numValue*=60; 423| 0| break; 424| 0| case 0: ------------------ | Branch (424:9): [True: 0, False: 12.7k] ------------------ 425| 0| default: ------------------ | Branch (425:9): [True: 0, False: 12.7k] ------------------ 426| 0| break; 427| 12.7k| } 428| | 429| 12.7k| return numValue; 430| 101k| } else if(ntv>2); 435| 82.8k| return (double)numerator/denominator; 436| 82.8k| } else if(ntv>2); 441| 19.1k| return (double)numerator/denominator; 442| 19.1k| } else { 443| | /* reserved */ 444| 0| return U_NO_NUMERIC_VALUE; ------------------ | | 3134| 0|#define U_NO_NUMERIC_VALUE ((double)-123456789.) ------------------ 445| 0| } 446| 38.2M|} u_getUnicodeProperties_78: 499| 73.9M|u_getUnicodeProperties(UChar32 c, int32_t column) { 500| 73.9M| U_ASSERT(column>=0); ------------------ | | 35| 73.9M|# define U_ASSERT(exp) (void)0 ------------------ 501| 73.9M| if(column>=propsVectorsColumns) { ------------------ | Branch (501:8): [True: 0, False: 73.9M] ------------------ 502| 0| return 0; 503| 73.9M| } else { 504| 73.9M| uint16_t vecIndex=UTRIE2_GET16(&propsVectorsTrie, c); ------------------ | | 360| 73.9M|#define UTRIE2_GET16(trie, c) _UTRIE2_GET((trie), index, (trie)->indexLength, (c)) | | ------------------ | | | | 871| 73.9M| (trie)->data[_UTRIE2_INDEX_FROM_CP(trie, asciiOffset, c)] | | | | ------------------ | | | | | | 845| 73.9M| ((uint32_t)(c)<0xd800 ? \ | | | | | | ------------------ | | | | | | | Branch (845:6): [True: 50.2M, False: 23.7M] | | | | | | ------------------ | | | | | | 846| 73.9M| _UTRIE2_INDEX_RAW(0, (trie)->index, c) : \ | | | | | | ------------------ | | | | | | | | 815| 50.2M| (((int32_t)((trieIndex)[(offset)+((c)>>UTRIE2_SHIFT_2)]) \ | | | | | | | | 816| 50.2M| <>UTRIE2_SHIFT_2)]) \ | | | | | | | | ------------------ | | | | | | | | | Branch (815:30): [True: 6.98k, False: 4.90M] | | | | | | | | ------------------ | | | | | | | | 816| 4.90M| <>UTRIE2_SHIFT_2) : 0, \ | | | | | | 850| 23.7M| (trie)->index, c) : \ | | | | | | 851| 23.7M| (uint32_t)(c)>0x10ffff ? \ | | | | | | ------------------ | | | | | | | Branch (851:13): [True: 0, False: 18.8M] | | | | | | ------------------ | | | | | | 852| 18.8M| (asciiOffset)+UTRIE2_BAD_UTF8_DATA_OFFSET : \ | | | | | | 853| 18.8M| (c)>=(trie)->highStart ? \ | | | | | | ------------------ | | | | | | | Branch (853:17): [True: 0, False: 18.8M] | | | | | | ------------------ | | | | | | 854| 18.8M| (trie)->highValueIndex : \ | | | | | | 855| 18.8M| _UTRIE2_INDEX_FROM_SUPP((trie)->index, c)) | | | | | | ------------------ | | | | | | | | 833| 18.8M| (((int32_t)((trieIndex)[ \ | | | | | | | | 834| 18.8M| (trieIndex)[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ \ | | | | | | | | 835| 18.8M| ((c)>>UTRIE2_SHIFT_1)]+ \ | | | | | | | | 836| 18.8M| (((c)>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK)]) \ | | | | | | | | 837| 18.8M| <0x10ffff) { ------------------ | Branch (538:8): [True: 0, False: 15.7M] ------------------ 539| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 540| 0| return USCRIPT_INVALID_CODE; 541| 0| } 542| 15.7M| uint32_t scriptX=u_getUnicodeProperties(c, 0)&UPROPS_SCRIPT_X_MASK; ------------------ | | 288| 15.7M|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 15.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 543| 15.7M| uint32_t codeOrIndex=scriptX&UPROPS_MAX_SCRIPT; 544| 15.7M| if(scriptX=UPROPS_SCRIPT_X_WITH_OTHER) { ------------------ | Branch (564:8): [True: 189k, False: 1.21M] ------------------ 565| 189k| scx=scriptExtensions+scx[1]; 566| 189k| } 567| 1.40M| uint32_t sc32=sc; 568| 1.40M| if(sc32>0x7fff) { ------------------ | Branch (568:8): [True: 0, False: 1.40M] ------------------ 569| | /* Guard against bogus input that would make us go past the Script_Extensions terminator. */ 570| 0| return false; 571| 0| } 572| 4.36M| while(sc32>*scx) { ------------------ | Branch (572:11): [True: 2.95M, False: 1.40M] ------------------ 573| 2.95M| ++scx; 574| 2.95M| } 575| 1.40M| return sc32==(*scx&0x7fff); 576| 1.40M|} uchar_addPropertyStarts_78: 647| 2|uchar_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 648| 2| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (648:8): [True: 0, False: 2] ------------------ 649| 0| return; 650| 0| } 651| | 652| | /* add the start code point of each same-value range of the main trie */ 653| 2| utrie2_enum(&propsTrie, 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 654| | 655| | /* add code points with hardcoded properties, plus the ones following them */ 656| | 657| | /* add for u_isblank() */ 658| 2| USET_ADD_CP_AND_NEXT(sa, TAB); ------------------ | | 644| 2|#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| 2| sa->add(sa->set, CR+1); /* range TAB..CR */ 662| 2| sa->add(sa->set, 0x1c); 663| 2| sa->add(sa->set, 0x1f+1); 664| 2| USET_ADD_CP_AND_NEXT(sa, 0x85); // NEXT LINE (NEL) ------------------ | | 644| 2|#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| 2| sa->add(sa->set, 0x7f); /* range DEL..NBSP-1, NBSP added below */ 668| 2| sa->add(sa->set, HAIRSP); 669| 2| sa->add(sa->set, RLM+1); 670| 2| sa->add(sa->set, 0x206a); // INHIBIT SYMMETRIC SWAPPING 671| 2| sa->add(sa->set, 0x206f+1); // NOMINAL DIGIT SHAPES 672| 2| USET_ADD_CP_AND_NEXT(sa, ZWNBSP); ------------------ | | 644| 2|#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| 2| USET_ADD_CP_AND_NEXT(sa, NBSP); ------------------ | | 644| 2|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 676| 2| USET_ADD_CP_AND_NEXT(sa, FIGURESP); ------------------ | | 644| 2|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 677| 2| USET_ADD_CP_AND_NEXT(sa, NNBSP); ------------------ | | 644| 2|#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| 2| sa->add(sa->set, u'a'); 681| 2| sa->add(sa->set, u'z'+1); 682| 2| sa->add(sa->set, u'A'); 683| 2| sa->add(sa->set, u'Z'+1); 684| | // fullwidth 685| 2| sa->add(sa->set, u'ａ'); 686| 2| sa->add(sa->set, u'ｚ'+1); 687| 2| sa->add(sa->set, u'Ａ'); 688| 2| sa->add(sa->set, u'Ｚ'+1); 689| | 690| | /* add for u_isxdigit() */ 691| 2| sa->add(sa->set, u'f'+1); 692| 2| sa->add(sa->set, u'F'+1); 693| | // fullwidth 694| 2| sa->add(sa->set, u'ｆ'+1); 695| 2| sa->add(sa->set, u'Ｆ'+1); 696| | 697| | /* add for UCHAR_DEFAULT_IGNORABLE_CODE_POINT what was not added above */ 698| 2| sa->add(sa->set, 0x2060); /* range 2060..206f */ 699| 2| sa->add(sa->set, 0xfff0); 700| 2| sa->add(sa->set, 0xfffb+1); 701| 2| sa->add(sa->set, 0xe0000); 702| 2| sa->add(sa->set, 0xe0fff+1); 703| | 704| | /* add for UCHAR_GRAPHEME_BASE and others */ 705| 2| USET_ADD_CP_AND_NEXT(sa, CGJ); ------------------ | | 644| 2|#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1) ------------------ 706| 2|} upropsvec_addPropertyStarts_78: 709| 2|upropsvec_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) { 710| 2| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (710:8): [True: 0, False: 2] ------------------ 711| 0| return; 712| 0| } 713| | 714| | /* add the start code point of each same-value range of the properties vectors trie */ 715| 2| utrie2_enum(&propsVectorsTrie, 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 716| 2|} uchar.cpp:_ZL24_enumPropertyStartsRangePKviij: 635| 26.2k|_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 end, uint32_t value) { 636| | /* add the start code point to the USet */ 637| 26.2k| const USetAdder* sa = static_cast(context); 638| 26.2k| sa->add(sa->set, start); 639| 26.2k| (void)end; 640| 26.2k| (void)value; 641| 26.2k| return true; 642| 26.2k|} _ZN6icu_7822UCharCharacterIteratorC2ENS_14ConstChar16PtrEi: 30| 11.0k| : CharacterIterator(textPtr != nullptr ? (length >= 0 ? length : u_strlen(textPtr)) : 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 (30:23): [True: 11.0k, False: 0] | Branch (30:45): [True: 11.0k, False: 0] ------------------ 31| 11.0k| text(textPtr) 32| 11.0k|{ 33| 11.0k|} _ZN6icu_7822UCharCharacterIteratoraSERKS0_: 61| 2.63k|UCharCharacterIterator::operator=(const UCharCharacterIterator& that) { 62| 2.63k| CharacterIterator::operator=(that); 63| 2.63k| text = that.text; 64| 2.63k| return *this; 65| 2.63k|} _ZN6icu_7822UCharCharacterIteratorD2Ev: 67| 11.0k|UCharCharacterIterator::~UCharCharacterIterator() { 68| 11.0k|} ucln_common_registerCleanup_78: 67| 19|{ 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| 19| U_ASSERT(UCLN_COMMON_START < type && type < UCLN_COMMON_COUNT); ------------------ | | 35| 19|# define U_ASSERT(exp) (void)0 ------------------ 79| 19| if (type == UCLN_COMMON_MUTEX) { ------------------ | Branch (79:9): [True: 1, False: 18] ------------------ 80| 1| gCommonCleanupFunctions[type] = func; 81| 18| } else if (UCLN_COMMON_START < type && type < UCLN_COMMON_COUNT) { ------------------ | Branch (81:16): [True: 18, False: 0] | Branch (81:44): [True: 18, False: 0] ------------------ 82| 18| icu::Mutex m; // See ticket 10295 for discussion. 83| 18| gCommonCleanupFunctions[type] = func; 84| 18| } 85| |#if !UCLN_NO_AUTO_CLEANUP && (defined(UCLN_AUTO_ATEXIT) || defined(UCLN_AUTO_LOCAL)) 86| | ucln_registerAutomaticCleanup(); 87| |#endif 88| 19|} udata_getHeaderSize_78: 36| 2|udata_getHeaderSize(const DataHeader *udh) { 37| 2| if(udh==nullptr) { ------------------ | Branch (37:8): [True: 0, False: 2] ------------------ 38| 0| return 0; 39| 2| } else if(udh->info.isBigEndian==U_IS_BIG_ENDIAN) { ------------------ | | 353| 2|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (39:15): [True: 2, False: 0] ------------------ 40| | /* same endianness */ 41| 2| return udh->dataHeader.headerSize; 42| 2| } else { 43| | /* opposite endianness */ 44| 0| uint16_t x=udh->dataHeader.headerSize; 45| 0| return (uint16_t)((x<<8)|(x>>8)); 46| 0| } 47| 2|} 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| 1| UErrorCode *pErrorCode) { 230| 1| (void)pErrorCode; 231| 1| const UDataOffsetTOC *toc = (UDataOffsetTOC *)pData->toc; 232| 1| if(toc!=nullptr) { ------------------ | Branch (232:8): [True: 1, False: 0] ------------------ 233| 1| const char *base=(const char *)toc; 234| 1| 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| 1| number=offsetTOCPrefixBinarySearch(tocEntryName, base, toc->entry, count); 244| 1| if(number>=0) { ------------------ | Branch (244:12): [True: 1, False: 0] ------------------ 245| | /* found it */ 246| 1| const UDataOffsetTOCEntry *entry=toc->entry+number; 247| |#ifdef UDATA_DEBUG 248| | fprintf(stderr, "%s: Found.\n", tocEntryName); 249| |#endif 250| 1| if((number+1) < count) { ------------------ | Branch (250:16): [True: 1, False: 0] ------------------ 251| 1| *pLength = (int32_t)(entry[1].dataOffset - entry->dataOffset); 252| 1| } else { 253| 0| *pLength = -1; 254| 0| } 255| 1| return (const DataHeader *)(base+entry->dataOffset); 256| 1| } else { 257| |#ifdef UDATA_DEBUG 258| | fprintf(stderr, "%s: Not found.\n", tocEntryName); 259| |#endif 260| 0| return nullptr; 261| 0| } 262| 1| } else { 263| |#ifdef UDATA_DEBUG 264| | fprintf(stderr, "returning header\n"); 265| |#endif 266| | 267| 0| return pData->pHeader; 268| 0| } 269| 1|} ucmndata.cpp:_ZL27offsetTOCPrefixBinarySearchPKcS0_PK19UDataOffsetTOCEntryi: 125| 1| const UDataOffsetTOCEntry *toc, int32_t count) { 126| 1| int32_t start=0; 127| 1| 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| 1| int32_t startPrefixLength=0; 134| 1| int32_t limitPrefixLength=0; 135| 1| if(count==0) { ------------------ | Branch (135:8): [True: 0, False: 1] ------------------ 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| 1| if(0==strcmpAfterPrefix(s, names+toc[0].nameOffset, &startPrefixLength)) { ------------------ | Branch (144:8): [True: 0, False: 1] ------------------ 145| 0| return 0; 146| 0| } 147| 1| ++start; 148| 1| --limit; 149| 1| if(0==strcmpAfterPrefix(s, names+toc[limit].nameOffset, &limitPrefixLength)) { ------------------ | Branch (149:8): [True: 0, False: 1] ------------------ 150| 0| return limit; 151| 0| } 152| 11| while(start(*s1++); 112| 48| int32_t c2 = static_cast(*s2++); 113| 48| cmp=c1-c2; 114| 48| if(cmp!=0 || c1==0) { /* different or done */ ------------------ | Branch (114:12): [True: 12, False: 36] | Branch (114:22): [True: 1, False: 35] ------------------ 115| 13| break; 116| 13| } 117| 35| ++pl; /* increment shared same-prefix length */ 118| 35| } 119| 13| *pPrefixLength=pl; 120| 13| return cmp; 121| 13|} ucptrie_openFromBinary_78: 24| 2.63k| UErrorCode *pErrorCode) { 25| 2.63k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (25:9): [True: 0, False: 2.63k] ------------------ 26| 0| return nullptr; 27| 0| } 28| | 29| 2.63k| if (length <= 0 || (U_POINTER_MASK_LSB(data, 3) != 0) || ------------------ | | 123| 2.63k|#define U_POINTER_MASK_LSB(ptr, mask) ((uintptr_t)(ptr) & (mask)) ------------------ | Branch (29:9): [True: 0, False: 2.63k] | Branch (29:24): [True: 0, False: 2.63k] ------------------ 30| 2.63k| type < UCPTRIE_TYPE_ANY || UCPTRIE_TYPE_SMALL < type || ------------------ | Branch (30:13): [True: 0, False: 2.63k] | Branch (30:40): [True: 0, False: 2.63k] ------------------ 31| 2.63k| valueWidth < UCPTRIE_VALUE_BITS_ANY || UCPTRIE_VALUE_BITS_8 < valueWidth) { ------------------ | Branch (31:13): [True: 0, False: 2.63k] | Branch (31:52): [True: 0, False: 2.63k] ------------------ 32| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 33| 0| return nullptr; 34| 0| } 35| | 36| | // Enough data for a trie header? 37| 2.63k| if (length < (int32_t)sizeof(UCPTrieHeader)) { ------------------ | Branch (37:9): [True: 0, False: 2.63k] ------------------ 38| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 39| 0| return nullptr; 40| 0| } 41| | 42| | // Check the signature. 43| 2.63k| const UCPTrieHeader *header = (const UCPTrieHeader *)data; 44| 2.63k| if (header->signature != UCPTRIE_SIG) { ------------------ | | 17| 2.63k|#define UCPTRIE_SIG 0x54726933 ------------------ | Branch (44:9): [True: 0, False: 2.63k] ------------------ 45| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 46| 0| return nullptr; 47| 0| } 48| | 49| 2.63k| int32_t options = header->options; 50| 2.63k| int32_t typeInt = (options >> 6) & 3; 51| 2.63k| int32_t valueWidthInt = options & UCPTRIE_OPTIONS_VALUE_BITS_MASK; 52| 2.63k| if (typeInt > UCPTRIE_TYPE_SMALL || valueWidthInt > UCPTRIE_VALUE_BITS_8 || ------------------ | Branch (52:9): [True: 0, False: 2.63k] | Branch (52:41): [True: 0, False: 2.63k] ------------------ 53| 2.63k| (options & UCPTRIE_OPTIONS_RESERVED_MASK) != 0) { ------------------ | Branch (53:13): [True: 0, False: 2.63k] ------------------ 54| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 55| 0| return nullptr; 56| 0| } 57| 2.63k| UCPTrieType actualType = (UCPTrieType)typeInt; 58| 2.63k| UCPTrieValueWidth actualValueWidth = (UCPTrieValueWidth)valueWidthInt; 59| 2.63k| if (type < 0) { ------------------ | Branch (59:9): [True: 0, False: 2.63k] ------------------ 60| 0| type = actualType; 61| 0| } 62| 2.63k| if (valueWidth < 0) { ------------------ | Branch (62:9): [True: 2.63k, False: 0] ------------------ 63| 2.63k| valueWidth = actualValueWidth; 64| 2.63k| } 65| 2.63k| if (type != actualType || valueWidth != actualValueWidth) { ------------------ | Branch (65:9): [True: 0, False: 2.63k] | Branch (65:31): [True: 0, False: 2.63k] ------------------ 66| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 67| 0| return nullptr; 68| 0| } 69| | 70| | // Get the length values and offsets. 71| 2.63k| UCPTrie tempTrie; 72| 2.63k| uprv_memset(&tempTrie, 0, sizeof(tempTrie)); ------------------ | | 100| 2.63k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 73| 2.63k| tempTrie.indexLength = header->indexLength; 74| 2.63k| tempTrie.dataLength = 75| 2.63k| ((options & UCPTRIE_OPTIONS_DATA_LENGTH_MASK) << 4) | header->dataLength; 76| 2.63k| tempTrie.index3NullOffset = header->index3NullOffset; 77| 2.63k| tempTrie.dataNullOffset = 78| 2.63k| ((options & UCPTRIE_OPTIONS_DATA_NULL_OFFSET_MASK) << 8) | header->dataNullOffset; 79| | 80| 2.63k| tempTrie.highStart = header->shiftedHighStart << UCPTRIE_SHIFT_2; 81| 2.63k| tempTrie.shifted12HighStart = (tempTrie.highStart + 0xfff) >> 12; 82| 2.63k| tempTrie.type = type; 83| 2.63k| tempTrie.valueWidth = valueWidth; 84| | 85| | // Calculate the actual length. 86| 2.63k| int32_t actualLength = (int32_t)sizeof(UCPTrieHeader) + tempTrie.indexLength * 2; 87| 2.63k| if (valueWidth == UCPTRIE_VALUE_BITS_16) { ------------------ | Branch (87:9): [True: 66, False: 2.56k] ------------------ 88| 66| actualLength += tempTrie.dataLength * 2; 89| 2.56k| } else if (valueWidth == UCPTRIE_VALUE_BITS_32) { ------------------ | Branch (89:16): [True: 0, False: 2.56k] ------------------ 90| 0| actualLength += tempTrie.dataLength * 4; 91| 2.56k| } else { 92| 2.56k| actualLength += tempTrie.dataLength; 93| 2.56k| } 94| 2.63k| if (length < actualLength) { ------------------ | Branch (94:9): [True: 0, False: 2.63k] ------------------ 95| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; // Not enough bytes. 96| 0| return nullptr; 97| 0| } 98| | 99| | // Allocate the trie. 100| 2.63k| UCPTrie *trie = (UCPTrie *)uprv_malloc(sizeof(UCPTrie)); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 101| 2.63k| if (trie == nullptr) { ------------------ | Branch (101:9): [True: 0, False: 2.63k] ------------------ 102| 0| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 103| 0| return nullptr; 104| 0| } 105| 2.63k| uprv_memcpy(trie, &tempTrie, sizeof(tempTrie)); ------------------ | | 42| 2.63k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.63k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.63k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.63k| _Pragma("clang diagnostic push") \ | | 45| 2.63k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.63k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.63k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.63k| _Pragma("clang diagnostic pop") \ | | 49| 2.63k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.63k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63k|#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| 2.63k| const uint16_t *p16 = (const uint16_t *)(header + 1); 112| 2.63k| trie->index = p16; 113| 2.63k| p16 += trie->indexLength; 114| | 115| | // Get the data. 116| 2.63k| int32_t nullValueOffset = trie->dataNullOffset; 117| 2.63k| if (nullValueOffset >= trie->dataLength) { ------------------ | Branch (117:9): [True: 0, False: 2.63k] ------------------ 118| 0| nullValueOffset = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 119| 0| } 120| 2.63k| switch (valueWidth) { 121| 66| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (121:5): [True: 66, False: 2.56k] ------------------ 122| 66| trie->data.ptr16 = p16; 123| 66| trie->nullValue = trie->data.ptr16[nullValueOffset]; 124| 66| break; 125| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (125:5): [True: 0, False: 2.63k] ------------------ 126| 0| trie->data.ptr32 = (const uint32_t *)p16; 127| 0| trie->nullValue = trie->data.ptr32[nullValueOffset]; 128| 0| break; 129| 2.56k| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (129:5): [True: 2.56k, False: 66] ------------------ 130| 2.56k| trie->data.ptr8 = (const uint8_t *)p16; 131| 2.56k| trie->nullValue = trie->data.ptr8[nullValueOffset]; 132| 2.56k| break; 133| 0| default: ------------------ | Branch (133:5): [True: 0, False: 2.63k] ------------------ 134| | // Unreachable because valueWidth was checked above. 135| 0| *pErrorCode = U_INVALID_FORMAT_ERROR; 136| 0| return nullptr; 137| 2.63k| } 138| | 139| 2.63k| if (pActualLength != nullptr) { ------------------ | Branch (139:9): [True: 0, False: 2.63k] ------------------ 140| 0| *pActualLength = actualLength; 141| 0| } 142| 2.63k| return trie; 143| 2.63k|} ucptrie_close_78: 146| 11.0k|ucptrie_close(UCPTrie *trie) { 147| 11.0k| uprv_free(trie); ------------------ | | 1503| 11.0k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 11.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 148| 11.0k|} ucptrie_getValueWidth_78: 156| 2.63k|ucptrie_getValueWidth(const UCPTrie *trie) { 157| 2.63k| return (UCPTrieValueWidth)trie->valueWidth; 158| 2.63k|} ucptrie_internalSmallIndex_78: 161| 1.76M|ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c) { 162| 1.76M| int32_t i1 = c >> UCPTRIE_SHIFT_1; 163| 1.76M| if (trie->type == UCPTRIE_TYPE_FAST) { ------------------ | Branch (163:9): [True: 1.76M, False: 0] ------------------ 164| 1.76M| U_ASSERT(0xffff < c && c < trie->highStart); ------------------ | | 35| 1.76M|# define U_ASSERT(exp) (void)0 ------------------ 165| 1.76M| i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 166| 1.76M| } else { 167| 0| U_ASSERT((uint32_t)c < (uint32_t)trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 168| 0| i1 += UCPTRIE_SMALL_INDEX_LENGTH; 169| 0| } 170| 1.76M| int32_t i3Block = trie->index[ 171| 1.76M| (int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 172| 1.76M| int32_t i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 173| 1.76M| int32_t dataBlock; 174| 1.76M| if ((i3Block & 0x8000) == 0) { ------------------ | Branch (174:9): [True: 1.76M, False: 0] ------------------ 175| | // 16-bit indexes 176| 1.76M| dataBlock = trie->index[i3Block + i3]; 177| 1.76M| } 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| 1.76M| return dataBlock + (c & UCPTRIE_SMALL_DATA_MASK); 185| 1.76M|} ucptrie_internalGetRange_78: 418| 4.01k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 419| 4.01k| if (option == UCPMAP_RANGE_NORMAL) { ------------------ | Branch (419:9): [True: 0, False: 4.01k] ------------------ 420| 0| return getRange(trie, start, filter, context, pValue); 421| 0| } 422| 4.01k| uint32_t value; 423| 4.01k| if (pValue == nullptr) { ------------------ | Branch (423:9): [True: 0, False: 4.01k] ------------------ 424| | // We need to examine the range value even if the caller does not want it. 425| 0| pValue = &value; 426| 0| } 427| 4.01k| UChar32 surrEnd = option == UCPMAP_RANGE_FIXED_ALL_SURROGATES ? 0xdfff : 0xdbff; ------------------ | Branch (427:23): [True: 0, False: 4.01k] ------------------ 428| 4.01k| UChar32 end = getRange(trie, start, filter, context, pValue); 429| 4.01k| if (end < 0xd7ff || start > surrEnd) { ------------------ | Branch (429:9): [True: 2.68k, False: 1.33k] | Branch (429:25): [True: 1.32k, False: 1] ------------------ 430| 4.00k| return end; 431| 4.00k| } 432| | // The range overlaps with surrogates, or ends just before the first one. 433| 1| if (*pValue == surrogateValue) { ------------------ | Branch (433:9): [True: 1, False: 0] ------------------ 434| 1| if (end >= surrEnd) { ------------------ | Branch (434:13): [True: 0, False: 1] ------------------ 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| 1| } 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| 1| uint32_t value2; 453| 1| UChar32 end2 = getRange(trie, surrEnd + 1, filter, context, &value2); 454| 1| if (value2 == surrogateValue) { ------------------ | Branch (454:9): [True: 1, False: 0] ------------------ 455| 1| return end2; 456| 1| } 457| 0| return surrEnd; 458| 1|} ucptrie_getRange_78: 463| 4.01k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 464| 4.01k| return ucptrie_internalGetRange(getRange, trie, start, ------------------ | | 809| 4.01k|#define ucptrie_internalGetRange U_ICU_ENTRY_POINT_RENAME(ucptrie_internalGetRange) | | ------------------ | | | | 123| 4.01k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.01k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.01k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 465| 4.01k| option, surrogateValue, 466| 4.01k| filter, context, pValue); 467| 4.01k|} ucptrie_toBinary_78: 472| 5.27k| UErrorCode *pErrorCode) { 473| 5.27k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (473:9): [True: 0, False: 5.27k] ------------------ 474| 0| return 0; 475| 0| } 476| | 477| 5.27k| UCPTrieType type = (UCPTrieType)trie->type; 478| 5.27k| UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->valueWidth; 479| 5.27k| if (type < UCPTRIE_TYPE_FAST || UCPTRIE_TYPE_SMALL < type || ------------------ | Branch (479:9): [True: 0, False: 5.27k] | Branch (479:37): [True: 0, False: 5.27k] ------------------ 480| 5.27k| valueWidth < UCPTRIE_VALUE_BITS_16 || UCPTRIE_VALUE_BITS_8 < valueWidth || ------------------ | Branch (480:13): [True: 0, False: 5.27k] | Branch (480:51): [True: 0, False: 5.27k] ------------------ 481| 5.27k| capacity < 0 || ------------------ | Branch (481:13): [True: 0, False: 5.27k] ------------------ 482| 5.27k| (capacity > 0 && (data == nullptr || (U_POINTER_MASK_LSB(data, 3) != 0)))) { ------------------ | | 123| 2.63k|#define U_POINTER_MASK_LSB(ptr, mask) ((uintptr_t)(ptr) & (mask)) ------------------ | Branch (482:14): [True: 2.63k, False: 2.63k] | Branch (482:31): [True: 0, False: 2.63k] | Branch (482:50): [True: 0, False: 2.63k] ------------------ 483| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 484| 0| return 0; 485| 0| } 486| | 487| 5.27k| int32_t length = (int32_t)sizeof(UCPTrieHeader) + trie->indexLength * 2; 488| 5.27k| switch (valueWidth) { 489| 132| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (489:5): [True: 132, False: 5.13k] ------------------ 490| 132| length += trie->dataLength * 2; 491| 132| break; 492| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (492:5): [True: 0, False: 5.27k] ------------------ 493| 0| length += trie->dataLength * 4; 494| 0| break; 495| 5.13k| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (495:5): [True: 5.13k, False: 132] ------------------ 496| 5.13k| length += trie->dataLength; 497| 5.13k| break; 498| 0| default: ------------------ | Branch (498:5): [True: 0, False: 5.27k] ------------------ 499| | // unreachable 500| 0| break; 501| 5.27k| } 502| 5.27k| if (capacity < length) { ------------------ | Branch (502:9): [True: 2.63k, False: 2.63k] ------------------ 503| 2.63k| *pErrorCode = U_BUFFER_OVERFLOW_ERROR; 504| 2.63k| return length; 505| 2.63k| } 506| | 507| 2.63k| char *bytes = (char *)data; 508| 2.63k| UCPTrieHeader *header = (UCPTrieHeader *)bytes; 509| 2.63k| header->signature = UCPTRIE_SIG; // "Tri3" ------------------ | | 17| 2.63k|#define UCPTRIE_SIG 0x54726933 ------------------ 510| 2.63k| header->options = (uint16_t)( 511| 2.63k| ((trie->dataLength & 0xf0000) >> 4) | 512| 2.63k| ((trie->dataNullOffset & 0xf0000) >> 8) | 513| 2.63k| (trie->type << 6) | 514| 2.63k| valueWidth); 515| 2.63k| header->indexLength = (uint16_t)trie->indexLength; 516| 2.63k| header->dataLength = (uint16_t)trie->dataLength; 517| 2.63k| header->index3NullOffset = trie->index3NullOffset; 518| 2.63k| header->dataNullOffset = (uint16_t)trie->dataNullOffset; 519| 2.63k| header->shiftedHighStart = trie->highStart >> UCPTRIE_SHIFT_2; 520| 2.63k| bytes += sizeof(UCPTrieHeader); 521| | 522| 2.63k| uprv_memcpy(bytes, trie->index, trie->indexLength * 2); ------------------ | | 42| 2.63k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.63k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.63k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.63k| _Pragma("clang diagnostic push") \ | | 45| 2.63k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.63k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.63k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.63k| _Pragma("clang diagnostic pop") \ | | 49| 2.63k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.63k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 523| 2.63k| bytes += trie->indexLength * 2; 524| | 525| 2.63k| switch (valueWidth) { 526| 66| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (526:5): [True: 66, False: 2.56k] ------------------ 527| 66| uprv_memcpy(bytes, trie->data.ptr16, trie->dataLength * 2); ------------------ | | 42| 66|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 66|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 66| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 66| _Pragma("clang diagnostic push") \ | | 45| 66| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 66| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 66|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 66| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 66|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 66| _Pragma("clang diagnostic pop") \ | | 49| 66| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 66|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 66|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 66|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 528| 66| break; 529| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (529:5): [True: 0, False: 2.63k] ------------------ 530| 0| uprv_memcpy(bytes, trie->data.ptr32, trie->dataLength * 4); ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 531| 0| break; 532| 2.56k| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (532:5): [True: 2.56k, False: 66] ------------------ 533| 2.56k| uprv_memcpy(bytes, trie->data.ptr8, trie->dataLength); ------------------ | | 42| 2.56k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.56k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.56k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.56k| _Pragma("clang diagnostic push") \ | | 45| 2.56k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.56k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.56k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.56k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.56k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.56k| _Pragma("clang diagnostic pop") \ | | 49| 2.56k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.56k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.56k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.56k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 534| 2.56k| break; 535| 0| default: ------------------ | Branch (535:5): [True: 0, False: 2.63k] ------------------ 536| | // unreachable 537| 0| break; 538| 2.63k| } 539| 2.63k| return length; 540| 2.63k|} ucptrie.cpp:_ZN12_GLOBAL__N_18getValueE11UCPTrieData17UCPTrieValueWidthi: 216| 25.2k|inline uint32_t getValue(UCPTrieData data, UCPTrieValueWidth valueWidth, int32_t dataIndex) { 217| 25.2k| switch (valueWidth) { 218| 25.2k| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (218:5): [True: 25.2k, False: 0] ------------------ 219| 25.2k| return data.ptr16[dataIndex]; 220| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (220:5): [True: 0, False: 25.2k] ------------------ 221| 0| return data.ptr32[dataIndex]; 222| 0| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (222:5): [True: 0, False: 25.2k] ------------------ 223| 0| return data.ptr8[dataIndex]; 224| 0| default: ------------------ | Branch (224:5): [True: 0, False: 25.2k] ------------------ 225| | // Unreachable if the trie is properly initialized. 226| 0| return 0xffffffff; 227| 25.2k| } 228| 25.2k|} ucptrie.cpp:_ZN12_GLOBAL__N_18getRangeEPKviPFjS1_jES1_Pj: 260| 4.01k| UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 261| 4.01k| if (static_cast(start) > MAX_UNICODE) { ------------------ | Branch (261:9): [True: 1, False: 4.01k] ------------------ 262| 1| return U_SENTINEL; ------------------ | | 469| 1|#define U_SENTINEL (-1) ------------------ 263| 1| } 264| 4.01k| const UCPTrie *trie = reinterpret_cast(t); 265| 4.01k| UCPTrieValueWidth valueWidth = static_cast(trie->valueWidth); 266| 4.01k| if (start >= trie->highStart) { ------------------ | Branch (266:9): [True: 0, False: 4.01k] ------------------ 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| 4.01k| uint32_t nullValue = trie->nullValue; 277| 4.01k| if (filter != nullptr) { nullValue = filter(context, nullValue); } ------------------ | Branch (277:9): [True: 0, False: 4.01k] ------------------ 278| 4.01k| const uint16_t *index = trie->index; 279| | 280| 4.01k| int32_t prevI3Block = -1; 281| 4.01k| int32_t prevBlock = -1; 282| 4.01k| UChar32 c = start; 283| 4.01k| uint32_t trieValue, value = nullValue; 284| 4.01k| bool haveValue = false; 285| 4.26k| do { 286| 4.26k| int32_t i3Block; 287| 4.26k| int32_t i3; 288| 4.26k| int32_t i3BlockLength; 289| 4.26k| int32_t dataBlockLength; 290| 4.26k| if (c <= 0xffff && (trie->type == UCPTRIE_TYPE_FAST || c <= UCPTRIE_SMALL_MAX)) { ------------------ | Branch (290:13): [True: 3.19k, False: 1.07k] | Branch (290:29): [True: 3.19k, False: 0] | Branch (290:64): [True: 0, False: 0] ------------------ 291| 3.19k| i3Block = 0; 292| 3.19k| i3 = c >> UCPTRIE_FAST_SHIFT; 293| 3.19k| i3BlockLength = trie->type == UCPTRIE_TYPE_FAST ? ------------------ | Branch (293:29): [True: 3.19k, False: 0] ------------------ 294| 3.19k| UCPTRIE_BMP_INDEX_LENGTH : UCPTRIE_SMALL_INDEX_LENGTH; 295| 3.19k| dataBlockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 296| 3.19k| } else { 297| | // Use the multi-stage index. 298| 1.07k| int32_t i1 = c >> UCPTRIE_SHIFT_1; 299| 1.07k| if (trie->type == UCPTRIE_TYPE_FAST) { ------------------ | Branch (299:17): [True: 1.07k, False: 0] ------------------ 300| 1.07k| U_ASSERT(0xffff < c && c < trie->highStart); ------------------ | | 35| 1.07k|# define U_ASSERT(exp) (void)0 ------------------ 301| 1.07k| i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 302| 1.07k| } else { 303| 0| U_ASSERT(c < trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 304| 0| i1 += UCPTRIE_SMALL_INDEX_LENGTH; 305| 0| } 306| 1.07k| i3Block = trie->index[ 307| 1.07k| static_cast(trie->index[i1]) + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 308| 1.07k| if (i3Block == prevI3Block && (c - start) >= UCPTRIE_CP_PER_INDEX_2_ENTRY) { ------------------ | Branch (308:17): [True: 219, False: 851] | Branch (308:43): [True: 219, False: 0] ------------------ 309| | // The index-3 block is the same as the previous one, and filled with value. 310| 219| U_ASSERT((c & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0); ------------------ | | 35| 219|# define U_ASSERT(exp) (void)0 ------------------ 311| 219| c += UCPTRIE_CP_PER_INDEX_2_ENTRY; 312| 219| continue; 313| 219| } 314| 851| prevI3Block = i3Block; 315| 851| if (i3Block == trie->index3NullOffset) { ------------------ | Branch (315:17): [True: 8, False: 843] ------------------ 316| | // This is the index-3 null block. 317| 8| if (haveValue) { ------------------ | Branch (317:21): [True: 8, False: 0] ------------------ 318| 8| if (nullValue != value) { ------------------ | Branch (318:25): [True: 0, False: 8] ------------------ 319| 0| return c - 1; 320| 0| } 321| 8| } else { 322| 0| trieValue = trie->nullValue; 323| 0| value = nullValue; 324| 0| if (pValue != nullptr) { *pValue = nullValue; } ------------------ | Branch (324:25): [True: 0, False: 0] ------------------ 325| 0| haveValue = true; 326| 0| } 327| 8| prevBlock = trie->dataNullOffset; 328| 8| c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 329| 8| continue; 330| 8| } 331| 843| i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 332| 843| i3BlockLength = UCPTRIE_INDEX_3_BLOCK_LENGTH; 333| 843| dataBlockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 334| 843| } 335| | // Enumerate data blocks for one index-3 block. 336| 5.88k| do { 337| 5.88k| int32_t block; 338| 5.88k| if ((i3Block & 0x8000) == 0) { ------------------ | Branch (338:17): [True: 5.88k, False: 0] ------------------ 339| 5.88k| block = index[i3Block + i3]; 340| 5.88k| } 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| 5.88k| if (block == prevBlock && (c - start) >= dataBlockLength) { ------------------ | Branch (347:17): [True: 1.36k, False: 4.52k] | Branch (347:39): [True: 1.36k, False: 0] ------------------ 348| | // The block is the same as the previous one, and filled with value. 349| 1.36k| U_ASSERT((c & (dataBlockLength - 1)) == 0); ------------------ | | 35| 1.36k|# define U_ASSERT(exp) (void)0 ------------------ 350| 1.36k| c += dataBlockLength; 351| 4.52k| } else { 352| 4.52k| int32_t dataMask = dataBlockLength - 1; 353| 4.52k| prevBlock = block; 354| 4.52k| if (block == trie->dataNullOffset) { ------------------ | Branch (354:21): [True: 102, False: 4.41k] ------------------ 355| | // This is the data null block. 356| 102| if (haveValue) { ------------------ | Branch (356:25): [True: 88, False: 14] ------------------ 357| 88| if (nullValue != value) { ------------------ | Branch (357:29): [True: 13, False: 75] ------------------ 358| 13| return c - 1; 359| 13| } 360| 88| } else { 361| 14| trieValue = trie->nullValue; 362| 14| value = nullValue; 363| 14| if (pValue != nullptr) { *pValue = nullValue; } ------------------ | Branch (363:29): [True: 14, False: 0] ------------------ 364| 14| haveValue = true; 365| 14| } 366| 89| c = (c + dataBlockLength) & ~dataMask; 367| 4.41k| } else { 368| 4.41k| int32_t di = block + (c & dataMask); 369| 4.41k| uint32_t trieValue2 = getValue(trie->data, valueWidth, di); 370| 4.41k| if (haveValue) { ------------------ | Branch (370:25): [True: 422, False: 3.99k] ------------------ 371| 422| if (trieValue2 != trieValue) { ------------------ | Branch (371:29): [True: 119, False: 303] ------------------ 372| 119| if (filter == nullptr || ------------------ | Branch (372:33): [True: 119, False: 0] ------------------ 373| 119| maybeFilterValue(trieValue2, trie->nullValue, nullValue, ------------------ | Branch (373:37): [True: 0, False: 0] ------------------ 374| 119| filter, context) != value) { 375| 119| return c - 1; 376| 119| } 377| 0| trieValue = trieValue2; // may or may not help 378| 0| } 379| 3.99k| } else { 380| 3.99k| trieValue = trieValue2; 381| 3.99k| value = maybeFilterValue(trieValue2, trie->nullValue, nullValue, 382| 3.99k| filter, context); 383| 3.99k| if (pValue != nullptr) { *pValue = value; } ------------------ | Branch (383:29): [True: 3.99k, False: 0] ------------------ 384| 3.99k| haveValue = true; 385| 3.99k| } 386| 21.2k| while ((++c & dataMask) != 0) { ------------------ | Branch (386:28): [True: 20.8k, False: 422] ------------------ 387| 20.8k| trieValue2 = getValue(trie->data, valueWidth, ++di); 388| 20.8k| if (trieValue2 != trieValue) { ------------------ | Branch (388:29): [True: 3.87k, False: 16.9k] ------------------ 389| 3.87k| if (filter == nullptr || ------------------ | Branch (389:33): [True: 3.87k, False: 0] ------------------ 390| 3.87k| maybeFilterValue(trieValue2, trie->nullValue, nullValue, ------------------ | Branch (390:37): [True: 0, False: 0] ------------------ 391| 3.87k| filter, context) != value) { 392| 3.87k| return c - 1; 393| 3.87k| } 394| 0| trieValue = trieValue2; // may or may not help 395| 0| } 396| 20.8k| } 397| 4.29k| } 398| 4.52k| } 399| 5.88k| } while (++i3 < i3BlockLength); ------------------ | Branch (399:18): [True: 1.84k, False: 28] ------------------ 400| 4.03k| } while (c < trie->highStart); ------------------ | Branch (400:14): [True: 254, False: 1] ------------------ 401| 1| U_ASSERT(haveValue); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 402| 1| int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 403| 1| uint32_t highValue = getValue(trie->data, valueWidth, di); 404| 1| if (maybeFilterValue(highValue, trie->nullValue, nullValue, ------------------ | Branch (404:9): [True: 0, False: 1] ------------------ 405| 1| filter, context) != value) { 406| 0| return c - 1; 407| 1| } else { 408| 1| return MAX_UNICODE; 409| 1| } 410| 1|} ucptrie.cpp:_ZN12_GLOBAL__N_116maybeFilterValueEjjjPFjPKvjES1_: 250| 3.99k| UCPMapValueFilter *filter, const void *context) { 251| 3.99k| if (value == trieNullValue) { ------------------ | Branch (251:9): [True: 440, False: 3.55k] ------------------ 252| 440| value = nullValue; 253| 3.55k| } else if (filter != nullptr) { ------------------ | Branch (253:16): [True: 0, False: 3.55k] ------------------ 254| 0| value = filter(context, value); 255| 0| } 256| 3.99k| return value; 257| 3.99k|} udata_openChoice_78: 1406| 1| 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| 1| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1411:8): [True: 0, False: 1] | Branch (1411:31): [True: 0, False: 1] ------------------ 1412| 0| return nullptr; 1413| 1| } else if(name==nullptr || *name==0 || isAcceptable==nullptr) { ------------------ | Branch (1413:15): [True: 0, False: 1] | Branch (1413:32): [True: 0, False: 1] | Branch (1413:44): [True: 0, False: 1] ------------------ 1414| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1415| 0| return nullptr; 1416| 1| } else { 1417| 1| return doOpenChoice(path, type, name, isAcceptable, context, pErrorCode); 1418| 1| } 1419| 1|} 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| 1|{ 1152| 1| UDataMemory *retVal = nullptr; 1153| | 1154| 1| const char *dataPath; 1155| | 1156| 1| int32_t tocEntrySuffixIndex; 1157| 1| const char *tocEntryPathSuffix; 1158| 1| UErrorCode subErrorCode=U_ZERO_ERROR; 1159| 1| const char *treeChar; 1160| | 1161| 1| UBool isICUData = false; 1162| | 1163| | 1164| 1| FileTracer::traceOpen(path, type, name); 1165| | 1166| | 1167| | /* Is this path ICU data? */ 1168| 1| if(path == nullptr || ------------------ | Branch (1168:8): [True: 1, False: 0] ------------------ 1169| 1| !strcmp(path, U_ICUDATA_ALIAS) || /* "ICUDATA" */ ------------------ | | 74| 0|#define U_ICUDATA_ALIAS "ICUDATA" ------------------ | Branch (1169:8): [True: 0, False: 0] ------------------ 1170| 1| !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| 1| uprv_strlen(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING)) || 1172| 1| !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| 1| uprv_strlen(U_ICUDATA_ALIAS U_TREE_SEPARATOR_STRING))) { 1174| 1| isICUData = true; 1175| 1| } 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| 1| CharString tocEntryName; /* entry name in tree format. ex: 'icudt28b/coll/ar.res' */ 1196| 1| CharString tocEntryPath; /* entry name in path format. ex: 'icudt28b\\coll\\ar.res' */ 1197| | 1198| 1| CharString pkgName; 1199| 1| CharString treeName; 1200| | 1201| | /* ======= Set up strings */ 1202| 1| if(path==nullptr) { ------------------ | Branch (1202:8): [True: 1, False: 0] ------------------ 1203| 1| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 1|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 1|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1204| 1| } 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| 1| tocEntryName.append(pkgName, *pErrorCode); 1253| 1| tocEntryPath.append(pkgName, *pErrorCode); 1254| 1| tocEntrySuffixIndex = tocEntryName.length(); 1255| | 1256| 1| if(!treeName.isEmpty()) { ------------------ | Branch (1256:8): [True: 0, False: 1] ------------------ 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| 1| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 62| 1|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1262| 1| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 130| 1|# define U_FILE_SEP_CHAR '/' ------------------ 1263| 1| if(type!=nullptr && *type!=0) { ------------------ | Branch (1263:8): [True: 1, False: 0] | Branch (1263:25): [True: 1, False: 0] ------------------ 1264| 1| tocEntryName.append(".", *pErrorCode).append(type, *pErrorCode); 1265| 1| tocEntryPath.append(".", *pErrorCode).append(type, *pErrorCode); 1266| 1| } 1267| | // The +1 is for the U_FILE_SEP_CHAR that is always appended above. 1268| 1| 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| 1|#if !defined(ICU_DATA_DIR_WINDOWS) 1276| 1| if(path == nullptr) { ------------------ | Branch (1276:8): [True: 1, False: 0] ------------------ 1277| 1| path = COMMON_DATA_NAME; /* "icudt26e" */ ------------------ | | 34| 1|#define COMMON_DATA_NAME U_ICUDATA_NAME | | ------------------ | | | | 154| 1|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | | | ------------------ | | | | | | 144| 1|# define U_ICUDATA_TYPE_LETTER "l" | | | | ------------------ | | ------------------ ------------------ 1278| 1| } 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| 1| dataPath = u_getDataDirectory(); ------------------ | | 271| 1|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1291| | 1292| | /**** Time zone individual files override */ 1293| 1| if (isICUData && isTimeZoneFile(name, type)) { ------------------ | Branch (1293:9): [True: 1, False: 0] | Branch (1293:22): [True: 0, False: 1] ------------------ 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| 1| if(gDataFileAccess == UDATA_PACKAGES_FIRST) { ------------------ | Branch (1308:8): [True: 0, False: 1] ------------------ 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| 1| if((gDataFileAccess==UDATA_PACKAGES_FIRST) || ------------------ | Branch (1322:8): [True: 0, False: 1] ------------------ 1323| 1| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1323:8): [True: 1, 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| 1| if ((dataPath && *dataPath) || !isICUData) { ------------------ | Branch (1328:14): [True: 1, False: 0] | Branch (1328:26): [True: 0, False: 1] | Branch (1328:40): [True: 0, False: 1] ------------------ 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| 1| } 1336| | 1337| | /**** COMMON PACKAGE */ 1338| 1| if((gDataFileAccess==UDATA_ONLY_PACKAGES) || ------------------ | Branch (1338:8): [True: 0, False: 1] ------------------ 1339| 1| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1339:8): [True: 1, False: 0] ------------------ 1340| |#ifdef UDATA_DEBUG 1341| | fprintf(stderr, "Trying packages (UDATA_ONLY_PACKAGES || UDATA_FILES_FIRST)\n"); 1342| |#endif 1343| 1| retVal = doLoadFromCommonData(isICUData, 1344| 1| pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(), 1345| 1| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1346| 1| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1346:12): [True: 1, False: 0] | Branch (1346:35): [True: 0, False: 0] ------------------ 1347| 1| return retVal; 1348| 1| } 1349| 1| } 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| 1|static UBool isTimeZoneFile(const char *name, const char *type) { 1108| 1| return ((uprv_strcmp(type, "res") == 0) && ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1108:13): [True: 0, False: 1] ------------------ 1109| 1| (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| 1|} udata.cpp:_ZL13checkDataItemPK10DataHeaderPFaPvPKcS4_PK9UDataInfoES2_S4_S4_P10UErrorCodeSB_: 949| 1|{ 950| 1| UDataMemory *rDataMem = nullptr; /* the new UDataMemory, to be returned. */ 951| | 952| 1| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (952:9): [True: 0, False: 1] ------------------ 953| 0| return nullptr; 954| 0| } 955| | 956| 1| if(pHeader->dataHeader.magic1==0xda && ------------------ | Branch (956:8): [True: 1, False: 0] ------------------ 957| 1| pHeader->dataHeader.magic2==0x27 && ------------------ | Branch (957:9): [True: 1, False: 0] ------------------ 958| 1| (isAcceptable==nullptr || isAcceptable(context, type, name, &pHeader->info)) ------------------ | Branch (958:10): [True: 0, False: 1] | Branch (958:35): [True: 1, False: 0] ------------------ 959| 1| ) { 960| 1| rDataMem=UDataMemory_createNewInstance(fatalErr); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 961| 1| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (961:13): [True: 0, False: 1] ------------------ 962| 0| return nullptr; 963| 0| } 964| 1| rDataMem->pHeader = pHeader; 965| 1| } 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| 1| return rDataMem; 972| 1|} udata.cpp:_ZL20doLoadFromCommonDataaPKcS0_S0_S0_S0_S0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCodeS8_: 1042| 1|{ 1043| 1| UDataMemory *pEntryData; 1044| 1| const DataHeader *pHeader; 1045| 1| UDataMemory *pCommonData; 1046| 1| int32_t commonDataIndex; 1047| 1| UBool checkedExtendedICUData = false; 1048| | /* try to get common data. The loop is for platforms such as the 390 that do 1049| | * not initially load the full set of ICU data. If the lookup of an ICU data item 1050| | * fails, the full (but slower to load) set is loaded, the and the loop repeats, 1051| | * trying the lookup again. Once the full set of ICU data is loaded, the loop wont 1052| | * repeat because the full set will be checked the first time through. 1053| | * 1054| | * The loop also handles the fallback to a .dat file if the application linked 1055| | * to the stub data library rather than a real library. 1056| | */ 1057| 1| for (commonDataIndex = isICUData ? 0 : -1;;) { ------------------ | Branch (1057:28): [True: 1, False: 0] ------------------ 1058| 1| pCommonData=openCommonData(path, commonDataIndex, subErrorCode); /** search for pkg **/ 1059| | 1060| 1| if(U_SUCCESS(*subErrorCode) && pCommonData!=nullptr) { ------------------ | Branch (1060:12): [True: 1, False: 0] | Branch (1060:40): [True: 1, False: 0] ------------------ 1061| 1| int32_t length; 1062| | 1063| | /* look up the data piece in the common data */ 1064| 1| 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| 1| if(pHeader!=nullptr) { ------------------ | Branch (1069:16): [True: 1, False: 0] ------------------ 1070| 1| pEntryData = checkDataItem(pHeader, isAcceptable, context, type, name, subErrorCode, pErrorCode); 1071| |#ifdef UDATA_DEBUG 1072| | fprintf(stderr, "pEntryData=%p\n", (void*) pEntryData); 1073| |#endif 1074| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1074:21): [True: 0, False: 1] ------------------ 1075| 0| return nullptr; 1076| 0| } 1077| 1| if (pEntryData != nullptr) { ------------------ | Branch (1077:21): [True: 1, False: 0] ------------------ 1078| 1| pEntryData->length = length; 1079| 1| return pEntryData; 1080| 1| } 1081| 1| } 1082| 1| } 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| 1|} udata.cpp:_ZL14openCommonDataPKciP10UErrorCode: 673| 1|{ 674| 1| UDataMemory tData; 675| 1| const char *pathBuffer; 676| 1| const char *inBasename; 677| | 678| 1| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (678:9): [True: 0, False: 1] ------------------ 679| 0| return nullptr; 680| 0| } 681| | 682| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 683| | 684| | /* ??????? TODO revisit this */ 685| 1| if (commonDataIndex >= 0) { ------------------ | Branch (685:9): [True: 1, False: 0] ------------------ 686| | /* "mini-cache" for common ICU data */ 687| 1| if(commonDataIndex >= UPRV_LENGTHOF(gCommonICUDataArray)) { ------------------ | | 99| 1|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (687:12): [True: 0, False: 1] ------------------ 688| 0| return nullptr; 689| 0| } 690| 1| { 691| 1| Mutex lock; 692| 1| if(gCommonICUDataArray[commonDataIndex] != nullptr) { ------------------ | Branch (692:16): [True: 0, False: 1] ------------------ 693| 0| return gCommonICUDataArray[commonDataIndex]; 694| 0| } 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| 4|U_CFUNC void UDataMemory_init(UDataMemory *This) { 29| 4| uprv_memset(This, 0, sizeof(UDataMemory)); ------------------ | | 100| 4|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 30| 4| This->length=-1; 31| 4|} 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| 2|U_CFUNC UDataMemory *UDataMemory_createNewInstance(UErrorCode *pErr) { 42| 2| UDataMemory *This; 43| | 44| 2| if (U_FAILURE(*pErr)) { ------------------ | Branch (44:9): [True: 0, False: 2] ------------------ 45| 0| return nullptr; 46| 0| } 47| 2| This = (UDataMemory *)uprv_malloc(sizeof(UDataMemory)); ------------------ | | 1524| 2|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 48| 2| if (This == nullptr) { ------------------ | Branch (48:9): [True: 0, False: 2] ------------------ 49| 0| *pErr = U_MEMORY_ALLOCATION_ERROR; } 50| 2| else { 51| 2| UDataMemory_init(This); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 52| 2| This->heapAllocated = true; 53| 2| } 54| 2| return This; 55| 2|} 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| 1|udata_getMemory(UDataMemory *pData) { 105| 1| if(pData!=nullptr && pData->pHeader!=nullptr) { ------------------ | Branch (105:8): [True: 1, False: 0] | Branch (105:26): [True: 1, False: 0] ------------------ 106| 1| return (char *)(pData->pHeader)+udata_getHeaderSize(pData->pHeader); ------------------ | | 887| 1|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 1| } else { 108| 0| return nullptr; 109| 0| } 110| 1|} uhash_open_78: 547| 16.8k| UErrorCode *status) { 548| | 549| 16.8k| return _uhash_create(keyHash, keyComp, valueComp, DEFAULT_PRIME_INDEX, status); ------------------ | | 91| 16.8k|#define DEFAULT_PRIME_INDEX 4 ------------------ 550| 16.8k|} uhash_close_78: 595| 16.8k|uhash_close(UHashtable *hash) { 596| 16.8k| if (hash == nullptr) { ------------------ | Branch (596:9): [True: 0, False: 16.8k] ------------------ 597| 0| return; 598| 0| } 599| 16.8k| if (hash->elements != nullptr) { ------------------ | Branch (599:9): [True: 16.8k, False: 0] ------------------ 600| 16.8k| if (hash->keyDeleter != nullptr || hash->valueDeleter != nullptr) { ------------------ | Branch (600:13): [True: 0, False: 16.8k] | Branch (600:44): [True: 16.8k, False: 0] ------------------ 601| 16.8k| int32_t pos=UHASH_FIRST; ------------------ | | 610| 16.8k|#define UHASH_FIRST (-1) ------------------ 602| 16.8k| UHashElement *e; 603| 192k| while ((e = (UHashElement*) uhash_nextElement(hash, &pos)) != nullptr) { ------------------ | | 1029| 192k|#define uhash_nextElement U_ICU_ENTRY_POINT_RENAME(uhash_nextElement) | | ------------------ | | | | 123| 192k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 192k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 192k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (603:20): [True: 175k, False: 16.8k] ------------------ 604| 175k| HASH_DELETE_KEY_VALUE(hash, e->key.pointer, e->value.pointer); ------------------ | | 124| 175k|#define HASH_DELETE_KEY_VALUE(hash, keypointer, valuepointer) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 175k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 125| 175k| if (hash->keyDeleter != nullptr && keypointer != nullptr) { \ | | ------------------ | | | Branch (125:9): [True: 0, False: 175k] | | | Branch (125:40): [True: 0, False: 0] | | ------------------ | | 126| 0| (*hash->keyDeleter)(keypointer); \ | | 127| 0| } \ | | 128| 175k| if (hash->valueDeleter != nullptr && valuepointer != nullptr) { \ | | ------------------ | | | Branch (128:9): [True: 175k, False: 0] | | | Branch (128:42): [True: 175k, False: 0] | | ------------------ | | 129| 175k| (*hash->valueDeleter)(valuepointer); \ | | 130| 175k| } \ | | 131| 175k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 175k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 605| 175k| } 606| 16.8k| } 607| 16.8k| uprv_free(hash->elements); ------------------ | | 1503| 16.8k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 608| 16.8k| hash->elements = nullptr; 609| 16.8k| } 610| 16.8k| if (hash->allocated) { ------------------ | Branch (610:9): [True: 16.8k, False: 0] ------------------ 611| 16.8k| uprv_free(hash); ------------------ | | 1503| 16.8k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 612| 16.8k| } 613| 16.8k|} uhash_setValueDeleter_78: 643| 16.8k|uhash_setValueDeleter(UHashtable *hash, UObjectDeleter *fn) { 644| 16.8k| UObjectDeleter *result = hash->valueDeleter; 645| 16.8k| hash->valueDeleter = fn; 646| 16.8k| return result; 647| 16.8k|} uhash_get_78: 665| 4.68M| const void* key) { 666| 4.68M| UHashTok keyholder; 667| 4.68M| keyholder.pointer = (void*) key; 668| 4.68M| return _uhash_find(hash, keyholder, hash->keyHasher(keyholder))->value.pointer; 669| 4.68M|} uhash_put_78: 721| 175k| UErrorCode *status) { 722| 175k| UHashTok keyholder, valueholder; 723| 175k| keyholder.pointer = key; 724| 175k| valueholder.pointer = value; 725| 175k| return _uhash_put(hash, keyholder, valueholder, 726| 175k| HINT_KEY_POINTER | HINT_VALUE_POINTER, ------------------ | | 139| 175k|#define HINT_KEY_POINTER (1) ------------------ HINT_KEY_POINTER | HINT_VALUE_POINTER, ------------------ | | 140| 175k|#define HINT_VALUE_POINTER (2) ------------------ 727| 175k| status).pointer; 728| 175k|} uhash_nextElement_78: 875| 192k|uhash_nextElement(const UHashtable *hash, int32_t *pos) { 876| | /* Walk through the array until we find an element that is not 877| | * EMPTY and not DELETED. 878| | */ 879| 192k| int32_t i; 880| 192k| U_ASSERT(hash != nullptr); ------------------ | | 35| 192k|# define U_ASSERT(exp) (void)0 ------------------ 881| 2.49M| for (i = *pos + 1; i < hash->length; ++i) { ------------------ | Branch (881:24): [True: 2.47M, False: 16.8k] ------------------ 882| 2.47M| if (!IS_EMPTY_OR_DELETED(hash->elements[i].hashcode)) { ------------------ | | 120| 2.47M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (882:13): [True: 175k, False: 2.30M] ------------------ 883| 175k| *pos = i; 884| 175k| return &(hash->elements[i]); 885| 175k| } 886| 2.47M| } 887| | 888| | /* No more elements */ 889| 16.8k| return nullptr; 890| 192k|} uhash.cpp:_ZL13_uhash_createPFi8UElementEPFaS_S_ES3_iP10UErrorCode: 287| 16.8k| UErrorCode *status) { 288| 16.8k| UHashtable *result; 289| | 290| 16.8k| if (U_FAILURE(*status)) return nullptr; ------------------ | Branch (290:9): [True: 0, False: 16.8k] ------------------ 291| | 292| 16.8k| result = static_cast(uprv_malloc(sizeof(UHashtable))); ------------------ | | 1524| 16.8k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 293| 16.8k| if (result == nullptr) { ------------------ | Branch (293:9): [True: 0, False: 16.8k] ------------------ 294| 0| *status = U_MEMORY_ALLOCATION_ERROR; 295| 0| return nullptr; 296| 0| } 297| | 298| 16.8k| _uhash_init(result, keyHash, keyComp, valueComp, primeIndex, status); 299| 16.8k| result->allocated = true; 300| | 301| 16.8k| if (U_FAILURE(*status)) { ------------------ | Branch (301:9): [True: 0, False: 16.8k] ------------------ 302| 0| uprv_free(result); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 303| 0| return nullptr; 304| 0| } 305| | 306| 16.8k| return result; 307| 16.8k|} uhash.cpp:_ZL11_uhash_initP10UHashtablePFi8UElementEPFaS1_S1_ES5_iP10UErrorCode: 260| 16.8k|{ 261| 16.8k| if (U_FAILURE(*status)) return nullptr; ------------------ | Branch (261:9): [True: 0, False: 16.8k] ------------------ 262| 16.8k| U_ASSERT(keyHash != nullptr); ------------------ | | 35| 16.8k|# define U_ASSERT(exp) (void)0 ------------------ 263| 16.8k| U_ASSERT(keyComp != nullptr); ------------------ | | 35| 16.8k|# define U_ASSERT(exp) (void)0 ------------------ 264| | 265| 16.8k| result->keyHasher = keyHash; 266| 16.8k| result->keyComparator = keyComp; 267| 16.8k| result->valueComparator = valueComp; 268| 16.8k| result->keyDeleter = nullptr; 269| 16.8k| result->valueDeleter = nullptr; 270| 16.8k| result->allocated = false; 271| 16.8k| _uhash_internalSetResizePolicy(result, U_GROW); 272| | 273| 16.8k| _uhash_allocate(result, primeIndex, status); 274| | 275| 16.8k| if (U_FAILURE(*status)) { ------------------ | Branch (275:9): [True: 0, False: 16.8k] ------------------ 276| 0| return nullptr; 277| 0| } 278| | 279| 16.8k| return result; 280| 16.8k|} uhash.cpp:_ZL15_uhash_allocateP10UHashtableiP10UErrorCode: 217| 17.6k| UErrorCode *status) { 218| | 219| 17.6k| UHashElement *p, *limit; 220| 17.6k| UHashTok emptytok; 221| | 222| 17.6k| if (U_FAILURE(*status)) return; ------------------ | Branch (222:9): [True: 0, False: 17.6k] ------------------ 223| | 224| 17.6k| U_ASSERT(primeIndex >= 0 && primeIndex < PRIMES_LENGTH); ------------------ | | 35| 17.6k|# define U_ASSERT(exp) (void)0 ------------------ 225| | 226| 17.6k| hash->primeIndex = static_cast(primeIndex); 227| 17.6k| hash->length = PRIMES[primeIndex]; 228| | 229| 17.6k| p = hash->elements = static_cast( 230| 17.6k| uprv_malloc(sizeof(UHashElement) * hash->length)); ------------------ | | 1524| 17.6k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 17.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 17.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 17.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 231| | 232| 17.6k| if (hash->elements == nullptr) { ------------------ | Branch (232:9): [True: 0, False: 17.6k] ------------------ 233| 0| *status = U_MEMORY_ALLOCATION_ERROR; 234| 0| return; 235| 0| } 236| | 237| 17.6k| emptytok.pointer = nullptr; /* Only one of these two is needed */ 238| 17.6k| emptytok.integer = 0; /* but we don't know which one. */ 239| | 240| 17.6k| limit = p + hash->length; 241| 2.83M| while (p < limit) { ------------------ | Branch (241:12): [True: 2.81M, False: 17.6k] ------------------ 242| 2.81M| p->key = emptytok; 243| 2.81M| p->value = emptytok; 244| 2.81M| p->hashcode = HASH_EMPTY; ------------------ | | 118| 2.81M|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 2.81M|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ 245| 2.81M| ++p; 246| 2.81M| } 247| | 248| 17.6k| hash->count = 0; 249| 17.6k| hash->lowWaterMark = static_cast(hash->length * hash->lowWaterRatio); 250| 17.6k| hash->highWaterMark = static_cast(hash->length * hash->highWaterRatio); 251| 17.6k|} uhash.cpp:_ZL30_uhash_internalSetResizePolicyP10UHashtable17UHashResizePolicy: 197| 16.8k|_uhash_internalSetResizePolicy(UHashtable *hash, enum UHashResizePolicy policy) { 198| 16.8k| U_ASSERT(hash != nullptr); ------------------ | | 35| 16.8k|# define U_ASSERT(exp) (void)0 ------------------ 199| 16.8k| U_ASSERT(((int32_t)policy) >= 0); ------------------ | | 35| 16.8k|# define U_ASSERT(exp) (void)0 ------------------ 200| 16.8k| U_ASSERT(((int32_t)policy) < 3); ------------------ | | 35| 16.8k|# define U_ASSERT(exp) (void)0 ------------------ 201| 16.8k| hash->lowWaterRatio = RESIZE_POLICY_RATIO_TABLE[policy * 2]; 202| 16.8k| hash->highWaterRatio = RESIZE_POLICY_RATIO_TABLE[policy * 2 + 1]; 203| 16.8k|} uhash.cpp:_ZL13_uhash_rehashP10UHashtableP10UErrorCode: 399| 784|_uhash_rehash(UHashtable *hash, UErrorCode *status) { 400| | 401| 784| UHashElement *old = hash->elements; 402| 784| int32_t oldLength = hash->length; 403| 784| int32_t newPrimeIndex = hash->primeIndex; 404| 784| int32_t i; 405| | 406| 784| if (hash->count > hash->highWaterMark) { ------------------ | Branch (406:9): [True: 784, False: 0] ------------------ 407| 784| if (++newPrimeIndex >= PRIMES_LENGTH) { ------------------ | | 90| 784|#define PRIMES_LENGTH UPRV_LENGTHOF(PRIMES) | | ------------------ | | | | 99| 784|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) | | ------------------ ------------------ | Branch (407:13): [True: 0, False: 784] ------------------ 408| 0| return; 409| 0| } 410| 784| } else if (hash->count < hash->lowWaterMark) { ------------------ | Branch (410:16): [True: 0, False: 0] ------------------ 411| 0| if (--newPrimeIndex < 0) { ------------------ | Branch (411:13): [True: 0, False: 0] ------------------ 412| 0| return; 413| 0| } 414| 0| } else { 415| 0| return; 416| 0| } 417| | 418| 784| _uhash_allocate(hash, newPrimeIndex, status); 419| | 420| 784| if (U_FAILURE(*status)) { ------------------ | Branch (420:9): [True: 0, False: 784] ------------------ 421| 0| hash->elements = old; 422| 0| hash->length = oldLength; 423| 0| return; 424| 0| } 425| | 426| 341k| for (i = oldLength - 1; i >= 0; --i) { ------------------ | Branch (426:29): [True: 340k, False: 784] ------------------ 427| 340k| if (!IS_EMPTY_OR_DELETED(old[i].hashcode)) { ------------------ | | 120| 340k|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (427:13): [True: 170k, False: 169k] ------------------ 428| 170k| UHashElement *e = _uhash_find(hash, old[i].key, old[i].hashcode); 429| 170k| U_ASSERT(e != nullptr); ------------------ | | 35| 170k|# define U_ASSERT(exp) (void)0 ------------------ 430| 170k| U_ASSERT(e->hashcode == HASH_EMPTY); ------------------ | | 35| 170k|# define U_ASSERT(exp) (void)0 ------------------ 431| 170k| e->key = old[i].key; 432| 170k| e->value = old[i].value; 433| 170k| e->hashcode = old[i].hashcode; 434| 170k| ++hash->count; 435| 170k| } 436| 340k| } 437| | 438| 784| uprv_free(old); ------------------ | | 1503| 784|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 784|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 784|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 784|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 439| 784|} uhash.cpp:_ZL11_uhash_findPK10UHashtable8UElementi: 339| 5.03M| int32_t hashcode) { 340| | 341| 5.03M| int32_t firstDeleted = -1; /* assume invalid index */ 342| 5.03M| int32_t theIndex, startIndex; 343| 5.03M| int32_t jump = 0; /* lazy evaluate */ 344| 5.03M| int32_t tableHash; 345| 5.03M| UHashElement *elements = hash->elements; 346| | 347| 5.03M| hashcode &= 0x7FFFFFFF; /* must be positive */ 348| 5.03M| startIndex = theIndex = (hashcode ^ 0x4000000) % hash->length; 349| | 350| 5.60M| do { 351| 5.60M| tableHash = elements[theIndex].hashcode; 352| 5.60M| if (tableHash == hashcode) { /* quick check */ ------------------ | Branch (352:13): [True: 4.56M, False: 1.03M] ------------------ 353| 4.56M| if ((*hash->keyComparator)(key, elements[theIndex].key)) { ------------------ | Branch (353:17): [True: 4.50M, False: 58.7k] ------------------ 354| 4.50M| return &(elements[theIndex]); 355| 4.50M| } 356| 4.56M| } else if (!IS_EMPTY_OR_DELETED(tableHash)) { ------------------ | | 120| 1.03M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (356:20): [True: 512k, False: 525k] ------------------ 357| | /* We have hit a slot which contains a key-value pair, 358| | * but for which the hash code does not match. Keep 359| | * looking. 360| | */ 361| 525k| } else if (tableHash == HASH_EMPTY) { /* empty, end o' the line */ ------------------ | | 118| 525k|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 525k|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ | Branch (361:20): [True: 525k, False: 0] ------------------ 362| 525k| break; 363| 525k| } else if (firstDeleted < 0) { /* remember first deleted */ ------------------ | Branch (363:20): [True: 0, False: 0] ------------------ 364| 0| firstDeleted = theIndex; 365| 0| } 366| 570k| if (jump == 0) { /* lazy compute jump */ ------------------ | Branch (366:13): [True: 409k, False: 161k] ------------------ 367| | /* The jump value must be relatively prime to the table 368| | * length. As long as the length is prime, then any value 369| | * 1..length-1 will be relatively prime to it. 370| | */ 371| 409k| jump = (hashcode % (hash->length - 1)) + 1; 372| 409k| } 373| 570k| theIndex = (theIndex + jump) % hash->length; 374| 570k| } while (theIndex != startIndex); ------------------ | Branch (374:14): [True: 570k, False: 0] ------------------ 375| | 376| 525k| if (firstDeleted >= 0) { ------------------ | Branch (376:9): [True: 0, False: 525k] ------------------ 377| 0| theIndex = firstDeleted; /* reset if had deleted slot */ 378| 525k| } else if (tableHash != HASH_EMPTY) { ------------------ | | 118| 525k|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 525k|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ | Branch (378:16): [True: 0, False: 525k] ------------------ 379| | /* We get to this point if the hashtable is full (no empty or 380| | * deleted slots), and we've failed to find a match. THIS 381| | * WILL NEVER HAPPEN as long as uhash_put() makes sure that 382| | * count is always < length. 383| | */ 384| 0| UPRV_UNREACHABLE_EXIT; ------------------ | | 68| 0|# define UPRV_UNREACHABLE_EXIT abort() ------------------ 385| 0| } 386| 525k| return &(elements[theIndex]); 387| 525k|} uhash.cpp:_ZL10_uhash_putP10UHashtable8UElementS1_aP10UErrorCode: 471| 175k| UErrorCode *status) { 472| | 473| | /* Put finds the position in the table for the new value. If the 474| | * key is already in the table, it is deleted, if there is a 475| | * non-nullptr keyDeleter. Then the key, the hash and the value are 476| | * all put at the position in their respective arrays. 477| | */ 478| 175k| int32_t hashcode; 479| 175k| UHashElement* e; 480| 175k| UHashTok emptytok; 481| | 482| 175k| if (U_FAILURE(*status)) { ------------------ | Branch (482:9): [True: 0, False: 175k] ------------------ 483| 0| goto err; 484| 0| } 485| 175k| U_ASSERT(hash != nullptr); ------------------ | | 35| 175k|# define U_ASSERT(exp) (void)0 ------------------ 486| 175k| if ((hint & HINT_VALUE_POINTER) ? ------------------ | | 140| 175k|#define HINT_VALUE_POINTER (2) ------------------ | Branch (486:9): [True: 175k, False: 0] | Branch (486:9): [True: 0, False: 175k] ------------------ 487| 175k| value.pointer == nullptr : 488| 175k| value.integer == 0 && (hint & HINT_ALLOW_ZERO) == 0) { ------------------ | | 141| 0|#define HINT_ALLOW_ZERO (4) ------------------ | Branch (488:13): [True: 0, False: 0] | Branch (488:35): [True: 0, False: 0] ------------------ 489| | /* Disallow storage of nullptr values, since nullptr is returned by 490| | * get() to indicate an absent key. Storing nullptr == removing. 491| | */ 492| 0| return _uhash_remove(hash, key); 493| 0| } 494| 175k| if (hash->count > hash->highWaterMark) { ------------------ | Branch (494:9): [True: 784, False: 174k] ------------------ 495| 784| _uhash_rehash(hash, status); 496| 784| if (U_FAILURE(*status)) { ------------------ | Branch (496:13): [True: 0, False: 784] ------------------ 497| 0| goto err; 498| 0| } 499| 784| } 500| | 501| 175k| hashcode = (*hash->keyHasher)(key); 502| 175k| e = _uhash_find(hash, key, hashcode); 503| 175k| U_ASSERT(e != nullptr); ------------------ | | 35| 175k|# define U_ASSERT(exp) (void)0 ------------------ 504| | 505| 175k| if (IS_EMPTY_OR_DELETED(e->hashcode)) { ------------------ | | 120| 175k|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) | | ------------------ | | | Branch (120:32): [True: 175k, False: 0] | | ------------------ ------------------ 506| | /* Important: We must never actually fill the table up. If we 507| | * do so, then _uhash_find() will return nullptr, and we'll have 508| | * to check for nullptr after every call to _uhash_find(). To 509| | * avoid this we make sure there is always at least one empty 510| | * or deleted slot in the table. This only is a problem if we 511| | * are out of memory and rehash isn't working. 512| | */ 513| 175k| ++hash->count; 514| 175k| if (hash->count == hash->length) { ------------------ | Branch (514:13): [True: 0, False: 175k] ------------------ 515| | /* Don't allow count to reach length */ 516| 0| --hash->count; 517| 0| *status = U_MEMORY_ALLOCATION_ERROR; 518| 0| goto err; 519| 0| } 520| 175k| } 521| | 522| | /* We must in all cases handle storage properly. If there was an 523| | * old key, then it must be deleted (if the deleter != nullptr). 524| | * Make hashcodes stored in table positive. 525| | */ 526| 175k| return _uhash_setElement(hash, e, hashcode & 0x7FFFFFFF, key, value, hint); 527| | 528| 0| err: 529| | /* If the deleters are non-nullptr, this method adopts its key and/or 530| | * value arguments, and we must be sure to delete the key and/or 531| | * value in all cases, even upon failure. 532| | */ 533| 0| HASH_DELETE_KEY_VALUE(hash, key.pointer, value.pointer); ------------------ | | 124| 0|#define HASH_DELETE_KEY_VALUE(hash, keypointer, valuepointer) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 125| 0| if (hash->keyDeleter != nullptr && keypointer != nullptr) { \ | | ------------------ | | | Branch (125:9): [True: 0, False: 0] | | | Branch (125:40): [True: 0, False: 0] | | ------------------ | | 126| 0| (*hash->keyDeleter)(keypointer); \ | | 127| 0| } \ | | 128| 0| if (hash->valueDeleter != nullptr && valuepointer != nullptr) { \ | | ------------------ | | | Branch (128:9): [True: 0, False: 0] | | | Branch (128:42): [True: 0, False: 0] | | ------------------ | | 129| 0| (*hash->valueDeleter)(valuepointer); \ | | 130| 0| } \ | | 131| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 534| 0| emptytok.pointer = nullptr; emptytok.integer = 0; 535| 0| return emptytok; 536| 175k|} uhash.cpp:_ZL17_uhash_setElementP10UHashtableP12UHashElementi8UElementS3_a: 150| 175k| UHashTok key, UHashTok value, int8_t hint) { 151| | 152| 175k| UHashTok oldValue = e->value; 153| 175k| if (hash->keyDeleter != nullptr && e->key.pointer != nullptr && ------------------ | Branch (153:9): [True: 0, False: 175k] | Branch (153:40): [True: 0, False: 0] ------------------ 154| 175k| e->key.pointer != key.pointer) { /* Avoid double deletion */ ------------------ | Branch (154:9): [True: 0, False: 0] ------------------ 155| 0| (*hash->keyDeleter)(e->key.pointer); 156| 0| } 157| 175k| if (hash->valueDeleter != nullptr) { ------------------ | Branch (157:9): [True: 175k, False: 0] ------------------ 158| 175k| if (oldValue.pointer != nullptr && ------------------ | Branch (158:13): [True: 0, False: 175k] ------------------ 159| 175k| oldValue.pointer != value.pointer) { /* Avoid double deletion */ ------------------ | Branch (159:13): [True: 0, False: 0] ------------------ 160| 0| (*hash->valueDeleter)(oldValue.pointer); 161| 0| } 162| 175k| oldValue.pointer = nullptr; 163| 175k| } 164| | /* Compilers should copy the UHashTok union correctly, but even if 165| | * they do, memory heap tools (e.g. BoundsChecker) can get 166| | * confused when a pointer is cloaked in a union and then copied. 167| | * TO ALLEVIATE THIS, we use hints (based on what API the user is 168| | * calling) to copy pointers when we know the user thinks 169| | * something is a pointer. */ 170| 175k| if (hint & HINT_KEY_POINTER) { ------------------ | | 139| 175k|#define HINT_KEY_POINTER (1) ------------------ | Branch (170:9): [True: 175k, False: 0] ------------------ 171| 175k| e->key.pointer = key.pointer; 172| 175k| } else { 173| 0| e->key = key; 174| 0| } 175| 175k| if (hint & HINT_VALUE_POINTER) { ------------------ | | 140| 175k|#define HINT_VALUE_POINTER (2) ------------------ | Branch (175:9): [True: 175k, False: 0] ------------------ 176| 175k| e->value.pointer = value.pointer; 177| 175k| } else { 178| 0| e->value = value; 179| 0| } 180| 175k| e->hashcode = hashcode; 181| 175k| return oldValue; 182| 175k|} u_UCharsToChars_78: 204| 316k|u_UCharsToChars(const char16_t *us, char *cs, int32_t length) { 205| 316k| char16_t u; 206| | 207| 1.83M| while(length>0) { ------------------ | Branch (207:11): [True: 1.51M, False: 316k] ------------------ 208| 1.51M| u=*us++; 209| 1.51M| if(!UCHAR_IS_INVARIANT(u)) { ------------------ | | 168| 1.51M|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 1.51M, False: 0] | | | Branch (168:47): [True: 1.51M, 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.51M| *cs++=(char)UCHAR_TO_CHAR(u); ------------------ | | 175| 1.51M|#define UCHAR_TO_CHAR(c) c ------------------ 214| 1.51M| --length; 215| 1.51M| } 216| 316k|} uprv_isInvariantUString_78: 263| 632k|uprv_isInvariantUString(const char16_t *s, int32_t length) { 264| 632k| char16_t c; 265| | 266| 3.68M| for(;;) { 267| 3.68M| if(length<0) { ------------------ | Branch (267:12): [True: 0, False: 3.68M] ------------------ 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.68M| } else { 274| | /* count length */ 275| 3.68M| if(length==0) { ------------------ | Branch (275:16): [True: 632k, False: 3.05M] ------------------ 276| 632k| break; 277| 632k| } 278| 3.05M| --length; 279| 3.05M| c=*s++; 280| 3.05M| } 281| | 282| | /* 283| | * no assertions here because these functions are legitimately called 284| | * for strings with variant characters 285| | */ 286| 3.05M| if(!UCHAR_IS_INVARIANT(c)) { ------------------ | | 168| 3.05M|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 3.05M, False: 132] | | | Branch (168:47): [True: 3.05M, False: 12] | | ------------------ ------------------ 287| 144| return false; /* found a variant char */ 288| 144| } 289| 3.05M| } 290| 632k| return true; 291| 632k|} umutablecptrie_open_78: 1740| 2.67k|umutablecptrie_open(uint32_t initialValue, uint32_t errorValue, UErrorCode *pErrorCode) { 1741| 2.67k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1741:9): [True: 41, False: 2.63k] ------------------ 1742| 41| return nullptr; 1743| 41| } 1744| 2.63k| LocalPointer trie( 1745| 2.63k| new MutableCodePointTrie(initialValue, errorValue, *pErrorCode), *pErrorCode); 1746| 2.63k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1746:9): [True: 0, False: 2.63k] ------------------ 1747| 0| return nullptr; 1748| 0| } 1749| 2.63k| return reinterpret_cast(trie.orphan()); 1750| 2.63k|} umutablecptrie_close_78: 1769| 8.41k|umutablecptrie_close(UMutableCPTrie *trie) { 1770| 8.41k| delete reinterpret_cast(trie); 1771| 8.41k|} umutablecptrie_setRange_78: 1831| 817k| uint32_t value, UErrorCode *pErrorCode) { 1832| 817k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1832:9): [True: 0, False: 817k] ------------------ 1833| 0| return; 1834| 0| } 1835| 817k| reinterpret_cast(trie)->setRange(start, end, value, *pErrorCode); 1836| 817k|} umutablecptrie_buildImmutable_78: 1841| 2.63k| UErrorCode *pErrorCode) { 1842| 2.63k| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1842:9): [True: 0, False: 2.63k] ------------------ 1843| 0| return nullptr; 1844| 0| } 1845| 2.63k| return reinterpret_cast(trie)->build(type, valueWidth, *pErrorCode); 1846| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrieC2EjjR10UErrorCode: 131| 2.63k| origInitialValue(iniValue), initialValue(iniValue), errorValue(errValue), 132| 2.63k| highStart(0), highValue(initialValue) 133| |#ifdef UCPTRIE_DEBUG 134| | , name("open") 135| |#endif 136| 2.63k| { 137| 2.63k| if (U_FAILURE(errorCode)) { return; } ------------------ | Branch (137:9): [True: 0, False: 2.63k] ------------------ 138| 2.63k| index = static_cast(uprv_malloc(BMP_I_LIMIT * 4)); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 139| 2.63k| data = static_cast(uprv_malloc(INITIAL_DATA_LENGTH * 4)); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 140| 2.63k| if (index == nullptr || data == nullptr) { ------------------ | Branch (140:9): [True: 0, False: 2.63k] | Branch (140:29): [True: 0, False: 2.63k] ------------------ 141| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 142| 0| return; 143| 0| } 144| 2.63k| indexCapacity = BMP_I_LIMIT; 145| 2.63k| dataCapacity = INITIAL_DATA_LENGTH; 146| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrieD2Ev: 177| 2.63k|MutableCodePointTrie::~MutableCodePointTrie() { 178| 2.63k| uprv_free(index); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 179| 2.63k| uprv_free(data); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 180| 2.63k| uprv_free(index16); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 181| 2.63k|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_120MutableCodePointTrie3getEi: 270| 339k|uint32_t MutableCodePointTrie::get(UChar32 c) const { 271| 339k| if (static_cast(c) > MAX_UNICODE) { ------------------ | Branch (271:9): [True: 0, False: 339k] ------------------ 272| 0| return errorValue; 273| 0| } 274| 339k| if (c >= highStart) { ------------------ | Branch (274:9): [True: 0, False: 339k] ------------------ 275| 0| return highValue; 276| 0| } 277| 339k| int32_t i = c >> UCPTRIE_SHIFT_3; 278| 339k| if (flags[i] == ALL_SAME) { ------------------ | Branch (278:9): [True: 168k, False: 171k] ------------------ 279| 168k| return index[i]; 280| 171k| } else { 281| 171k| return data[index[i] + (c & UCPTRIE_SMALL_DATA_MASK)]; 282| 171k| } 283| 339k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie15ensureHighStartEi: 383| 817k|bool MutableCodePointTrie::ensureHighStart(UChar32 c) { 384| 817k| if (c >= highStart) { ------------------ | Branch (384:9): [True: 82.3k, False: 735k] ------------------ 385| | // Round up to a UCPTRIE_CP_PER_INDEX_2_ENTRY boundary to simplify compaction. 386| 82.3k| c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 387| 82.3k| int32_t i = highStart >> UCPTRIE_SHIFT_3; 388| 82.3k| int32_t iLimit = c >> UCPTRIE_SHIFT_3; 389| 82.3k| if (iLimit > indexCapacity) { ------------------ | Branch (389:13): [True: 2.63k, False: 79.6k] ------------------ 390| 2.63k| uint32_t* newIndex = static_cast(uprv_malloc(I_LIMIT * 4)); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 391| 2.63k| if (newIndex == nullptr) { return false; } ------------------ | Branch (391:17): [True: 0, False: 2.63k] ------------------ 392| 2.63k| uprv_memcpy(newIndex, index, i * 4); ------------------ | | 42| 2.63k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.63k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.63k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.63k| _Pragma("clang diagnostic push") \ | | 45| 2.63k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.63k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.63k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.63k| _Pragma("clang diagnostic pop") \ | | 49| 2.63k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.63k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 393| 2.63k| uprv_free(index); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 394| 2.63k| index = newIndex; 395| 2.63k| indexCapacity = I_LIMIT; 396| 2.63k| } 397| 183M| do { 398| 183M| flags[i] = ALL_SAME; 399| 183M| index[i] = initialValue; 400| 183M| } while(++i < iLimit); ------------------ | Branch (400:17): [True: 183M, False: 82.3k] ------------------ 401| 82.3k| highStart = c; 402| 82.3k| } 403| 817k| return true; 404| 817k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie12getDataBlockEi: 440| 960k|int32_t MutableCodePointTrie::getDataBlock(int32_t i) { 441| 960k| if (flags[i] == MIXED) { ------------------ | Branch (441:9): [True: 720k, False: 240k] ------------------ 442| 720k| return index[i]; 443| 720k| } 444| 240k| if (i < BMP_I_LIMIT) { ------------------ | Branch (444:9): [True: 123k, False: 117k] ------------------ 445| 123k| int32_t newBlock = allocDataBlock(UCPTRIE_FAST_DATA_BLOCK_LENGTH); 446| 123k| if (newBlock < 0) { return newBlock; } ------------------ | Branch (446:13): [True: 0, False: 123k] ------------------ 447| 123k| int32_t iStart = i & ~(SMALL_DATA_BLOCKS_PER_BMP_BLOCK -1); 448| 123k| int32_t iLimit = iStart + SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 449| 492k| do { 450| 492k| U_ASSERT(flags[iStart] == ALL_SAME); ------------------ | | 35| 492k|# define U_ASSERT(exp) (void)0 ------------------ 451| 492k| writeBlock(data + newBlock, index[iStart]); 452| 492k| flags[iStart] = MIXED; 453| 492k| index[iStart++] = newBlock; 454| 492k| newBlock += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 455| 492k| } while (iStart < iLimit); ------------------ | Branch (455:18): [True: 369k, False: 123k] ------------------ 456| 123k| return index[i]; 457| 123k| } else { 458| 117k| int32_t newBlock = allocDataBlock(UCPTRIE_SMALL_DATA_BLOCK_LENGTH); 459| 117k| if (newBlock < 0) { return newBlock; } ------------------ | Branch (459:13): [True: 0, False: 117k] ------------------ 460| 117k| writeBlock(data + newBlock, index[i]); 461| 117k| flags[i] = MIXED; 462| 117k| index[i] = newBlock; 463| 117k| return newBlock; 464| 117k| } 465| 240k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie14allocDataBlockEi: 406| 240k|int32_t MutableCodePointTrie::allocDataBlock(int32_t blockLength) { 407| 240k| int32_t newBlock = dataLength; 408| 240k| int32_t newTop = newBlock + blockLength; 409| 240k| if (newTop > dataCapacity) { ------------------ | Branch (409:9): [True: 108, False: 240k] ------------------ 410| 108| int32_t capacity; 411| 108| if (dataCapacity < MEDIUM_DATA_LENGTH) { ------------------ | Branch (411:13): [True: 108, False: 0] ------------------ 412| 108| capacity = MEDIUM_DATA_LENGTH; 413| 108| } else if (dataCapacity < MAX_DATA_LENGTH) { ------------------ | Branch (413:20): [True: 0, False: 0] ------------------ 414| 0| capacity = MAX_DATA_LENGTH; 415| 0| } else { 416| | // Should never occur. 417| | // Either MAX_DATA_LENGTH is incorrect, 418| | // or the code writes more values than should be possible. 419| 0| return -1; 420| 0| } 421| 108| uint32_t* newData = static_cast(uprv_malloc(capacity * 4)); ------------------ | | 1524| 108|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 108|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 108|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 108|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| 108| if (newData == nullptr) { ------------------ | Branch (422:13): [True: 0, False: 108] ------------------ 423| 0| return -1; 424| 0| } 425| 108| uprv_memcpy(newData, data, (size_t)dataLength * 4); ------------------ | | 42| 108|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 108|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 108| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 108| _Pragma("clang diagnostic push") \ | | 45| 108| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 108| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 108|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 108| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 108|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 108| _Pragma("clang diagnostic pop") \ | | 49| 108| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 108|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 108|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 108|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 426| 108| uprv_free(data); ------------------ | | 1503| 108|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 108|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 108|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 108|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 427| 108| data = newData; 428| 108| dataCapacity = capacity; 429| 108| } 430| 240k| dataLength = newTop; 431| 240k| return newBlock; 432| 240k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110writeBlockEPjj: 376| 609k|writeBlock(uint32_t *block, uint32_t value) { 377| 609k| uint32_t *limit = block + UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 378| 10.3M| while (block < limit) { ------------------ | Branch (378:12): [True: 9.75M, False: 609k] ------------------ 379| 9.75M| *block++ = value; 380| 9.75M| } 381| 609k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie8setRangeEiijR10UErrorCode: 494| 817k|void MutableCodePointTrie::setRange(UChar32 start, UChar32 end, uint32_t value, UErrorCode &errorCode) { 495| 817k| if (U_FAILURE(errorCode)) { ------------------ | Branch (495:9): [True: 0, False: 817k] ------------------ 496| 0| return; 497| 0| } 498| 817k| if (static_cast(start) > MAX_UNICODE || static_cast(end) > MAX_UNICODE || start > end) { ------------------ | Branch (498:9): [True: 0, False: 817k] | Branch (498:55): [True: 0, False: 817k] | Branch (498:99): [True: 0, False: 817k] ------------------ 499| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 500| 0| return; 501| 0| } 502| 817k| if (!ensureHighStart(end)) { ------------------ | Branch (502:9): [True: 0, False: 817k] ------------------ 503| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 504| 0| return; 505| 0| } 506| | 507| 817k| UChar32 limit = end + 1; 508| 817k| if (start & UCPTRIE_SMALL_DATA_MASK) { ------------------ | Branch (508:9): [True: 651k, False: 165k] ------------------ 509| | // Set partial block at [start..following block boundary[. 510| 651k| int32_t block = getDataBlock(start >> UCPTRIE_SHIFT_3); 511| 651k| if (block < 0) { ------------------ | Branch (511:13): [True: 0, False: 651k] ------------------ 512| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 513| 0| return; 514| 0| } 515| | 516| 651k| UChar32 nextStart = (start + UCPTRIE_SMALL_DATA_MASK) & ~UCPTRIE_SMALL_DATA_MASK; 517| 651k| if (nextStart <= limit) { ------------------ | Branch (517:13): [True: 307k, False: 344k] ------------------ 518| 307k| fillBlock(data + block, start & UCPTRIE_SMALL_DATA_MASK, UCPTRIE_SMALL_DATA_BLOCK_LENGTH, 519| 307k| value); 520| 307k| start = nextStart; 521| 344k| } else { 522| 344k| fillBlock(data + block, start & UCPTRIE_SMALL_DATA_MASK, limit & UCPTRIE_SMALL_DATA_MASK, 523| 344k| value); 524| 344k| return; 525| 344k| } 526| 651k| } 527| | 528| | // Number of positions in the last, partial block. 529| 473k| int32_t rest = limit & UCPTRIE_SMALL_DATA_MASK; 530| | 531| | // Round down limit to a block boundary. 532| 473k| limit &= ~UCPTRIE_SMALL_DATA_MASK; 533| | 534| | // Iterate over all-value blocks. 535| 183M| while (start < limit) { ------------------ | Branch (535:12): [True: 183M, False: 473k] ------------------ 536| 183M| int32_t i = start >> UCPTRIE_SHIFT_3; 537| 183M| if (flags[i] == ALL_SAME) { ------------------ | Branch (537:13): [True: 183M, False: 158k] ------------------ 538| 183M| index[i] = value; 539| 183M| } else /* MIXED */ { 540| 158k| fillBlock(data + index[i], 0, UCPTRIE_SMALL_DATA_BLOCK_LENGTH, value); 541| 158k| } 542| 183M| start += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 543| 183M| } 544| | 545| 473k| if (rest > 0) { ------------------ | Branch (545:9): [True: 307k, False: 165k] ------------------ 546| | // Set partial block at [last block boundary..limit[. 547| 307k| int32_t block = getDataBlock(start >> UCPTRIE_SHIFT_3); 548| 307k| if (block < 0) { ------------------ | Branch (548:13): [True: 0, False: 307k] ------------------ 549| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 550| 0| return; 551| 0| } 552| | 553| 307k| fillBlock(data + block, 0, rest, value); 554| 307k| } 555| 473k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_19fillBlockEPjiij: 486| 1.11M|fillBlock(uint32_t *block, UChar32 start, UChar32 limit, uint32_t value) { 487| 1.11M| uint32_t *pLimit = block + limit; 488| 1.11M| block += start; 489| 8.58M| while (block < pLimit) { ------------------ | Branch (489:12): [True: 7.46M, False: 1.11M] ------------------ 490| 7.46M| *block++ = value; 491| 7.46M| } 492| 1.11M|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie5buildE11UCPTrieType17UCPTrieValueWidthR10UErrorCode: 1576| 2.63k|UCPTrie *MutableCodePointTrie::build(UCPTrieType type, UCPTrieValueWidth valueWidth, UErrorCode &errorCode) { 1577| 2.63k| if (U_FAILURE(errorCode)) { ------------------ | Branch (1577:9): [True: 0, False: 2.63k] ------------------ 1578| 0| return nullptr; 1579| 0| } 1580| 2.63k| if (type < UCPTRIE_TYPE_FAST || UCPTRIE_TYPE_SMALL < type || ------------------ | Branch (1580:9): [True: 0, False: 2.63k] | Branch (1580:37): [True: 0, False: 2.63k] ------------------ 1581| 2.63k| valueWidth < UCPTRIE_VALUE_BITS_16 || UCPTRIE_VALUE_BITS_8 < valueWidth) { ------------------ | Branch (1581:13): [True: 0, False: 2.63k] | Branch (1581:51): [True: 0, False: 2.63k] ------------------ 1582| 0| errorCode = U_ILLEGAL_ARGUMENT_ERROR; 1583| 0| return nullptr; 1584| 0| } 1585| | 1586| | // The mutable trie always stores 32-bit values. 1587| | // When we build a UCPTrie for a smaller value width, we first mask off unused bits 1588| | // before compacting the data. 1589| 2.63k| switch (valueWidth) { 1590| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (1590:5): [True: 0, False: 2.63k] ------------------ 1591| 0| break; 1592| 66| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (1592:5): [True: 66, False: 2.56k] ------------------ 1593| 66| maskValues(0xffff); 1594| 66| break; 1595| 2.56k| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (1595:5): [True: 2.56k, False: 66] ------------------ 1596| 2.56k| maskValues(0xff); 1597| 2.56k| break; 1598| 0| default: ------------------ | Branch (1598:5): [True: 0, False: 2.63k] ------------------ 1599| 0| break; 1600| 2.63k| } 1601| | 1602| 2.63k| UChar32 fastLimit = type == UCPTRIE_TYPE_FAST ? BMP_LIMIT : UCPTRIE_SMALL_LIMIT; ------------------ | Branch (1602:25): [True: 2.63k, False: 0] ------------------ 1603| 2.63k| int32_t indexLength = compactTrie(fastLimit >> UCPTRIE_SHIFT_3, errorCode); 1604| 2.63k| if (U_FAILURE(errorCode)) { ------------------ | Branch (1604:9): [True: 0, False: 2.63k] ------------------ 1605| 0| clear(); 1606| 0| return nullptr; 1607| 0| } 1608| | 1609| | // Ensure data table alignment: The index length must be even for uint32_t data. 1610| 2.63k| if (valueWidth == UCPTRIE_VALUE_BITS_32 && (indexLength & 1) != 0) { ------------------ | Branch (1610:9): [True: 0, False: 2.63k] | Branch (1610:48): [True: 0, False: 0] ------------------ 1611| 0| index16[indexLength++] = 0xffee; // arbitrary value 1612| 0| } 1613| | 1614| | // Make the total trie structure length a multiple of 4 bytes by padding the data table, 1615| | // and store special values as the last two data values. 1616| 2.63k| int32_t length = indexLength * 2; 1617| 2.63k| if (valueWidth == UCPTRIE_VALUE_BITS_16) { ------------------ | Branch (1617:9): [True: 66, False: 2.56k] ------------------ 1618| 66| if (((indexLength ^ dataLength) & 1) != 0) { ------------------ | Branch (1618:13): [True: 31, False: 35] ------------------ 1619| | // padding 1620| 31| data[dataLength++] = errorValue; 1621| 31| } 1622| 66| if (data[dataLength - 1] != errorValue || data[dataLength - 2] != highValue) { ------------------ | Branch (1622:13): [True: 35, False: 31] | Branch (1622:51): [True: 21, False: 10] ------------------ 1623| 56| data[dataLength++] = highValue; 1624| 56| data[dataLength++] = errorValue; 1625| 56| } 1626| 66| length += dataLength * 2; 1627| 2.56k| } else if (valueWidth == UCPTRIE_VALUE_BITS_32) { ------------------ | Branch (1627:16): [True: 0, False: 2.56k] ------------------ 1628| | // 32-bit data words never need padding to a multiple of 4 bytes. 1629| 0| if (data[dataLength - 1] != errorValue || data[dataLength - 2] != highValue) { ------------------ | Branch (1629:13): [True: 0, False: 0] | Branch (1629:51): [True: 0, False: 0] ------------------ 1630| 0| if (data[dataLength - 1] != highValue) { ------------------ | Branch (1630:17): [True: 0, False: 0] ------------------ 1631| 0| data[dataLength++] = highValue; 1632| 0| } 1633| 0| data[dataLength++] = errorValue; 1634| 0| } 1635| 0| length += dataLength * 4; 1636| 2.56k| } else { 1637| 2.56k| int32_t and3 = (length + dataLength) & 3; 1638| 2.56k| if (and3 == 0 && data[dataLength - 1] == errorValue && data[dataLength - 2] == highValue) { ------------------ | Branch (1638:13): [True: 782, False: 1.78k] | Branch (1638:26): [True: 0, False: 782] | Branch (1638:64): [True: 0, False: 0] ------------------ 1639| | // all set 1640| 2.56k| } else if(and3 == 3 && data[dataLength - 1] == highValue) { ------------------ | Branch (1640:19): [True: 554, False: 2.01k] | Branch (1640:32): [True: 323, False: 231] ------------------ 1641| 323| data[dataLength++] = errorValue; 1642| 2.24k| } else { 1643| 5.17k| while (and3 != 2) { ------------------ | Branch (1643:20): [True: 2.92k, False: 2.24k] ------------------ 1644| 2.92k| data[dataLength++] = highValue; 1645| 2.92k| and3 = (and3 + 1) & 3; 1646| 2.92k| } 1647| 2.24k| data[dataLength++] = highValue; 1648| 2.24k| data[dataLength++] = errorValue; 1649| 2.24k| } 1650| 2.56k| length += dataLength; 1651| 2.56k| } 1652| | 1653| | // Calculate the total length of the UCPTrie as a single memory block. 1654| 2.63k| length += sizeof(UCPTrie); 1655| 2.63k| U_ASSERT((length & 3) == 0); ------------------ | | 35| 2.63k|# define U_ASSERT(exp) (void)0 ------------------ 1656| | 1657| 2.63k| uint8_t* bytes = static_cast(uprv_malloc(length)); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1658| 2.63k| if (bytes == nullptr) { ------------------ | Branch (1658:9): [True: 0, False: 2.63k] ------------------ 1659| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1660| 0| clear(); 1661| 0| return nullptr; 1662| 0| } 1663| 2.63k| UCPTrie *trie = reinterpret_cast(bytes); 1664| 2.63k| uprv_memset(trie, 0, sizeof(UCPTrie)); ------------------ | | 100| 2.63k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1665| 2.63k| trie->indexLength = indexLength; 1666| 2.63k| trie->dataLength = dataLength; 1667| | 1668| 2.63k| trie->highStart = highStart; 1669| | // Round up shifted12HighStart to a multiple of 0x1000 for easy testing from UTF-8 lead bytes. 1670| | // Runtime code needs to then test for the real highStart as well. 1671| 2.63k| trie->shifted12HighStart = (highStart + 0xfff) >> 12; 1672| 2.63k| trie->type = type; 1673| 2.63k| trie->valueWidth = valueWidth; 1674| | 1675| 2.63k| trie->index3NullOffset = index3NullOffset; 1676| 2.63k| trie->dataNullOffset = dataNullOffset; 1677| 2.63k| trie->nullValue = initialValue; 1678| | 1679| 2.63k| bytes += sizeof(UCPTrie); 1680| | 1681| | // Fill the index and data arrays. 1682| 2.63k| uint16_t* dest16 = reinterpret_cast(bytes); 1683| 2.63k| trie->index = dest16; 1684| | 1685| 2.63k| if (highStart <= fastLimit) { ------------------ | Branch (1685:9): [True: 1.64k, False: 994] ------------------ 1686| | // Condense only the fast index from the mutable-trie index. 1687| 1.68M| for (int32_t i = 0, j = 0; j < indexLength; i += SMALL_DATA_BLOCKS_PER_BMP_BLOCK, ++j) { ------------------ | Branch (1687:36): [True: 1.68M, False: 1.64k] ------------------ 1688| 1.68M| *dest16++ = static_cast(index[i]); // dest16[j] 1689| 1.68M| } 1690| 1.64k| } else { 1691| 994| uprv_memcpy(dest16, index16, indexLength * 2); ------------------ | | 42| 994|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 994|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 994| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 994| _Pragma("clang diagnostic push") \ | | 45| 994| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 994| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 994|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 994| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 994|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 994| _Pragma("clang diagnostic pop") \ | | 49| 994| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 994|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 994|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 994|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1692| 994| dest16 += indexLength; 1693| 994| } 1694| 2.63k| bytes += indexLength * 2; 1695| | 1696| | // Write the data array. 1697| 2.63k| const uint32_t *p = data; 1698| 2.63k| switch (valueWidth) { 1699| 66| case UCPTRIE_VALUE_BITS_16: ------------------ | Branch (1699:5): [True: 66, False: 2.56k] ------------------ 1700| | // Write 16-bit data values. 1701| 66| trie->data.ptr16 = dest16; 1702| 824k| for (int32_t i = dataLength; i > 0; --i) { ------------------ | Branch (1702:38): [True: 824k, False: 66] ------------------ 1703| 824k| *dest16++ = static_cast(*p++); 1704| 824k| } 1705| 66| break; 1706| 0| case UCPTRIE_VALUE_BITS_32: ------------------ | Branch (1706:5): [True: 0, False: 2.63k] ------------------ 1707| | // Write 32-bit data values. 1708| 0| trie->data.ptr32 = reinterpret_cast(bytes); 1709| 0| uprv_memcpy(bytes, p, (size_t)dataLength * 4); ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 1710| 0| break; 1711| 2.56k| case UCPTRIE_VALUE_BITS_8: ------------------ | Branch (1711:5): [True: 2.56k, False: 66] ------------------ 1712| | // Write 8-bit data values. 1713| 2.56k| trie->data.ptr8 = bytes; 1714| 4.83M| for (int32_t i = dataLength; i > 0; --i) { ------------------ | Branch (1714:38): [True: 4.83M, False: 2.56k] ------------------ 1715| 4.83M| *bytes++ = static_cast(*p++); 1716| 4.83M| } 1717| 2.56k| break; 1718| 0| default: ------------------ | Branch (1718:5): [True: 0, False: 2.63k] ------------------ 1719| | // Will not occur, valueWidth checked at the beginning. 1720| 0| break; 1721| 2.63k| } 1722| | 1723| |#ifdef UCPTRIE_DEBUG 1724| | trie->name = name; 1725| | 1726| | ucptrie_printLengths(trie, ""); 1727| |#endif 1728| | 1729| 2.63k| clear(); 1730| 2.63k| return trie; 1731| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie10maskValuesEj: 559| 2.63k|void MutableCodePointTrie::maskValues(uint32_t mask) { 560| 2.63k| initialValue &= mask; 561| 2.63k| errorValue &= mask; 562| 2.63k| highValue &= mask; 563| 2.63k| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 564| 183M| for (int32_t i = 0; i < iLimit; ++i) { ------------------ | Branch (564:25): [True: 183M, False: 2.63k] ------------------ 565| 183M| if (flags[i] == ALL_SAME) { ------------------ | Branch (565:13): [True: 182M, False: 604k] ------------------ 566| 182M| index[i] &= mask; 567| 182M| } 568| 183M| } 569| 9.66M| for (int32_t i = 0; i < dataLength; ++i) { ------------------ | Branch (569:25): [True: 9.66M, False: 2.63k] ------------------ 570| 9.66M| data[i] &= mask; 571| 9.66M| } 572| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie11compactTrieEiR10UErrorCode: 1491| 2.63k|int32_t MutableCodePointTrie::compactTrie(int32_t fastILimit, UErrorCode &errorCode) { 1492| | // Find the real highStart and round it up. 1493| 2.63k| U_ASSERT((highStart & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0); ------------------ | | 35| 2.63k|# define U_ASSERT(exp) (void)0 ------------------ 1494| 2.63k| highValue = get(MAX_UNICODE); 1495| 2.63k| int32_t realHighStart = findHighStart(); 1496| 2.63k| realHighStart = (realHighStart + (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) & 1497| 2.63k| ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 1498| 2.63k| if (realHighStart == UNICODE_LIMIT) { ------------------ | Branch (1498:9): [True: 97, False: 2.53k] ------------------ 1499| 97| highValue = initialValue; 1500| 97| } 1501| | 1502| |#ifdef UCPTRIE_DEBUG 1503| | printf("UCPTrie: highStart U+%06lx highValue 0x%lx initialValue 0x%lx\n", 1504| | (long)realHighStart, (long)highValue, (long)initialValue); 1505| |#endif 1506| | 1507| | // We always store indexes and data values for the fast range. 1508| | // Pin highStart to the top of that range while building. 1509| 2.63k| UChar32 fastLimit = fastILimit << UCPTRIE_SHIFT_3; 1510| 2.63k| if (realHighStart < fastLimit) { ------------------ | Branch (1510:9): [True: 927, False: 1.70k] ------------------ 1511| 2.11M| for (int32_t i = (realHighStart >> UCPTRIE_SHIFT_3); i < fastILimit; ++i) { ------------------ | Branch (1511:62): [True: 2.10M, False: 927] ------------------ 1512| 2.10M| flags[i] = ALL_SAME; 1513| 2.10M| index[i] = highValue; 1514| 2.10M| } 1515| 927| highStart = fastLimit; 1516| 1.70k| } else { 1517| 1.70k| highStart = realHighStart; 1518| 1.70k| } 1519| | 1520| 2.63k| uint32_t asciiData[ASCII_LIMIT]; 1521| 339k| for (int32_t i = 0; i < ASCII_LIMIT; ++i) { ------------------ | Branch (1521:25): [True: 337k, False: 2.63k] ------------------ 1522| 337k| asciiData[i] = get(i); 1523| 337k| } 1524| | 1525| | // First we look for which data blocks have the same value repeated over the whole block, 1526| | // deduplicate such blocks, find a good null data block (for faster enumeration), 1527| | // and get an upper bound for the necessary data array length. 1528| 2.63k| AllSameBlocks allSameBlocks; 1529| 2.63k| int32_t newDataCapacity = compactWholeDataBlocks(fastILimit, allSameBlocks); 1530| 2.63k| if (newDataCapacity < 0) { ------------------ | Branch (1530:9): [True: 0, False: 2.63k] ------------------ 1531| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1532| 0| return 0; 1533| 0| } 1534| 2.63k| uint32_t* newData = static_cast(uprv_malloc(newDataCapacity * 4)); ------------------ | | 1524| 2.63k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1535| 2.63k| if (newData == nullptr) { ------------------ | Branch (1535:9): [True: 0, False: 2.63k] ------------------ 1536| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1537| 0| return 0; 1538| 0| } 1539| 2.63k| uprv_memcpy(newData, asciiData, sizeof(asciiData)); ------------------ | | 42| 2.63k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.63k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.63k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.63k| _Pragma("clang diagnostic push") \ | | 45| 2.63k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.63k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.63k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.63k| _Pragma("clang diagnostic pop") \ | | 49| 2.63k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.63k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1540| | 1541| 2.63k| int32_t dataNullIndex = allSameBlocks.findMostUsed(); 1542| | 1543| 2.63k| MixedBlocks mixedBlocks; 1544| 2.63k| int32_t newDataLength = compactData(fastILimit, newData, newDataCapacity, 1545| 2.63k| dataNullIndex, mixedBlocks, errorCode); 1546| 2.63k| if (U_FAILURE(errorCode)) { return 0; } ------------------ | Branch (1546:9): [True: 0, False: 2.63k] ------------------ 1547| 2.63k| U_ASSERT(newDataLength <= newDataCapacity); ------------------ | | 35| 2.63k|# define U_ASSERT(exp) (void)0 ------------------ 1548| 2.63k| uprv_free(data); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1549| 2.63k| data = newData; 1550| 2.63k| dataCapacity = newDataCapacity; 1551| 2.63k| dataLength = newDataLength; 1552| 2.63k| if (dataLength > (0x3ffff + UCPTRIE_SMALL_DATA_BLOCK_LENGTH)) { ------------------ | Branch (1552:9): [True: 0, False: 2.63k] ------------------ 1553| | // The offset of the last data block is too high to be stored in the index table. 1554| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 1555| 0| return 0; 1556| 0| } 1557| | 1558| 2.63k| if (dataNullIndex >= 0) { ------------------ | Branch (1558:9): [True: 2.63k, False: 0] ------------------ 1559| 2.63k| dataNullOffset = index[dataNullIndex]; 1560| |#ifdef UCPTRIE_DEBUG 1561| | if (data[dataNullOffset] != initialValue) { 1562| | printf("UCPTrie initialValue %lx -> more common nullValue %lx\n", 1563| | (long)initialValue, (long)data[dataNullOffset]); 1564| | } 1565| |#endif 1566| 2.63k| initialValue = data[dataNullOffset]; 1567| 2.63k| } else { 1568| 0| dataNullOffset = UCPTRIE_NO_DATA_NULL_OFFSET; 1569| 0| } 1570| | 1571| 2.63k| int32_t indexLength = compactIndex(fastILimit, mixedBlocks, errorCode); 1572| 2.63k| highStart = realHighStart; 1573| 2.63k| return indexLength; 1574| 2.63k|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_120MutableCodePointTrie13findHighStartEv: 664| 2.63k|UChar32 MutableCodePointTrie::findHighStart() const { 665| 2.63k| int32_t i = highStart >> UCPTRIE_SHIFT_3; 666| 141M| while (i > 0) { ------------------ | Branch (666:12): [True: 141M, False: 41] ------------------ 667| 141M| bool match; 668| 141M| if (flags[--i] == ALL_SAME) { ------------------ | Branch (668:13): [True: 141M, False: 7.06k] ------------------ 669| 141M| match = index[i] == highValue; 670| 141M| } else /* MIXED */ { 671| 7.06k| const uint32_t *p = data + index[i]; 672| 100k| for (int32_t j = 0;; ++j) { 673| 100k| if (j == UCPTRIE_SMALL_DATA_BLOCK_LENGTH) { ------------------ | Branch (673:21): [True: 4.82k, False: 95.4k] ------------------ 674| 4.82k| match = true; 675| 4.82k| break; 676| 4.82k| } 677| 95.4k| if (p[j] != highValue) { ------------------ | Branch (677:21): [True: 2.24k, False: 93.1k] ------------------ 678| 2.24k| match = false; 679| 2.24k| break; 680| 2.24k| } 681| 95.4k| } 682| 7.06k| } 683| 141M| if (!match) { ------------------ | Branch (683:13): [True: 2.59k, False: 141M] ------------------ 684| 2.59k| return (i + 1) << UCPTRIE_SHIFT_3; 685| 2.59k| } 686| 141M| } 687| 41| return 0; 688| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_113AllSameBlocksC2Ev: 695| 2.63k| AllSameBlocks() : length(0), mostRecent(-1) {} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie22compactWholeDataBlocksEiRNS0_13AllSameBlocksE: 927| 2.63k|int32_t MutableCodePointTrie::compactWholeDataBlocks(int32_t fastILimit, AllSameBlocks &allSameBlocks) { 928| |#ifdef UCPTRIE_DEBUG 929| | bool overflow = false; 930| |#endif 931| | 932| | // ASCII data will be stored as a linear table, even if the following code 933| | // does not yet count it that way. 934| 2.63k| int32_t newDataCapacity = ASCII_LIMIT; 935| | // Add room for a small data null block in case it would match the start of 936| | // a fast data block where dataNullOffset must not be set in that case. 937| 2.63k| newDataCapacity += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 938| | // Add room for special values (errorValue, highValue) and padding. 939| 2.63k| newDataCapacity += 4; 940| 2.63k| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 941| 2.63k| int32_t blockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 942| 2.63k| int32_t inc = SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 943| 36.0M| for (int32_t i = 0; i < iLimit; i += inc) { ------------------ | Branch (943:25): [True: 36.0M, False: 2.63k] ------------------ 944| 36.0M| if (i == fastILimit) { ------------------ | Branch (944:13): [True: 994, False: 36.0M] ------------------ 945| 994| blockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 946| 994| inc = 1; 947| 994| } 948| 36.0M| uint32_t value = index[i]; 949| 36.0M| if (flags[i] == MIXED) { ------------------ | Branch (949:13): [True: 237k, False: 35.7M] ------------------ 950| | // Really mixed? 951| 237k| const uint32_t *p = data + value; 952| 237k| value = *p; 953| 237k| if (allValuesSameAs(p + 1, blockLength - 1, value)) { ------------------ | Branch (953:17): [True: 4.16k, False: 233k] ------------------ 954| 4.16k| flags[i] = ALL_SAME; 955| 4.16k| index[i] = value; 956| | // Fall through to ALL_SAME handling. 957| 233k| } else { 958| 233k| newDataCapacity += blockLength; 959| 233k| continue; 960| 233k| } 961| 35.7M| } else { 962| 35.7M| U_ASSERT(flags[i] == ALL_SAME); ------------------ | | 35| 35.7M|# define U_ASSERT(exp) (void)0 ------------------ 963| 35.7M| if (inc > 1) { ------------------ | Branch (963:17): [True: 2.57M, False: 33.1M] ------------------ 964| | // Do all of the fast-range data block's ALL_SAME parts have the same value? 965| 2.57M| bool allSame = true; 966| 2.57M| int32_t next_i = i + inc; 967| 10.3M| for (int32_t j = i + 1; j < next_i; ++j) { ------------------ | Branch (967:41): [True: 7.72M, False: 2.57M] ------------------ 968| 7.72M| U_ASSERT(flags[j] == ALL_SAME); ------------------ | | 35| 7.72M|# define U_ASSERT(exp) (void)0 ------------------ 969| 7.72M| if (index[j] != value) { ------------------ | Branch (969:25): [True: 1.33k, False: 7.72M] ------------------ 970| 1.33k| allSame = false; 971| 1.33k| break; 972| 1.33k| } 973| 7.72M| } 974| 2.57M| if (!allSame) { ------------------ | Branch (974:21): [True: 1.33k, False: 2.57M] ------------------ 975| | // Turn it into a MIXED block. 976| 1.33k| if (getDataBlock(i) < 0) { ------------------ | Branch (976:25): [True: 0, False: 1.33k] ------------------ 977| 0| return -1; 978| 0| } 979| 1.33k| newDataCapacity += blockLength; 980| 1.33k| continue; 981| 1.33k| } 982| 2.57M| } 983| 35.7M| } 984| | // Is there another ALL_SAME block with the same value? 985| 35.7M| int32_t other = allSameBlocks.findOrAdd(i, inc, value); 986| 35.7M| if (other == AllSameBlocks::OVERFLOW) { ------------------ | Branch (986:13): [True: 0, False: 35.7M] ------------------ 987| | // The fixed-size array overflowed. Slow check for a duplicate block. 988| |#ifdef UCPTRIE_DEBUG 989| | if (!overflow) { 990| | puts("UCPTrie AllSameBlocks overflow"); 991| | overflow = true; 992| | } 993| |#endif 994| 0| int32_t jInc = SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 995| 0| for (int32_t j = 0;; j += jInc) { 996| 0| if (j == i) { ------------------ | Branch (996:21): [True: 0, False: 0] ------------------ 997| 0| allSameBlocks.add(i, inc, value); 998| 0| break; 999| 0| } 1000| 0| if (j == fastILimit) { ------------------ | Branch (1000:21): [True: 0, False: 0] ------------------ 1001| 0| jInc = 1; 1002| 0| } 1003| 0| if (flags[j] == ALL_SAME && index[j] == value) { ------------------ | Branch (1003:21): [True: 0, False: 0] | Branch (1003:45): [True: 0, False: 0] ------------------ 1004| 0| allSameBlocks.add(j, jInc + inc, value); 1005| 0| other = j; 1006| 0| break; 1007| | // We could keep counting blocks with the same value 1008| | // before we add the first one, which may improve compaction in rare cases, 1009| | // but it would make it slower. 1010| 0| } 1011| 0| } 1012| 0| } 1013| 35.7M| if (other >= 0) { ------------------ | Branch (1013:13): [True: 35.7M, False: 3.84k] ------------------ 1014| 35.7M| flags[i] = SAME_AS; 1015| 35.7M| index[i] = other; 1016| 35.7M| } else { 1017| | // New unique same-value block. 1018| 3.84k| newDataCapacity += blockLength; 1019| 3.84k| } 1020| 35.7M| } 1021| 2.63k| return newDataCapacity; 1022| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_115allValuesSameAsEPKjij: 584| 238k|bool allValuesSameAs(const uint32_t *p, int32_t length, uint32_t value) { 585| 238k| const uint32_t *pLimit = p + length; 586| 3.97M| while (p < pLimit && *p == value) { ++p; } ------------------ | Branch (586:12): [True: 3.96M, False: 4.73k] | Branch (586:26): [True: 3.73M, False: 233k] ------------------ 587| 238k| return p == pLimit; 588| 238k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_113AllSameBlocks9findOrAddEiij: 697| 35.7M| int32_t findOrAdd(int32_t index, int32_t count, uint32_t value) { 698| 35.7M| if (mostRecent >= 0 && values[mostRecent] == value) { ------------------ | Branch (698:13): [True: 35.7M, False: 2.63k] | Branch (698:32): [True: 35.7M, False: 65.8k] ------------------ 699| 35.7M| refCounts[mostRecent] += count; 700| 35.7M| return indexes[mostRecent]; 701| 35.7M| } 702| 144k| for (int32_t i = 0; i < length; ++i) { ------------------ | Branch (702:29): [True: 140k, False: 3.84k] ------------------ 703| 140k| if (values[i] == value) { ------------------ | Branch (703:17): [True: 64.6k, False: 75.4k] ------------------ 704| 64.6k| mostRecent = i; 705| 64.6k| refCounts[i] += count; 706| 64.6k| return indexes[i]; 707| 64.6k| } 708| 140k| } 709| 3.84k| if (length == CAPACITY) { ------------------ | Branch (709:13): [True: 0, False: 3.84k] ------------------ 710| 0| return OVERFLOW; 711| 0| } 712| 3.84k| mostRecent = length; 713| 3.84k| indexes[length] = index; 714| 3.84k| values[length] = value; 715| 3.84k| refCounts[length++] = count; 716| 3.84k| return NEW_UNIQUE; 717| 3.84k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_113AllSameBlocks12findMostUsedEv: 738| 2.63k| int32_t findMostUsed() const { 739| 2.63k| if (length == 0) { return -1; } ------------------ | Branch (739:13): [True: 0, False: 2.63k] ------------------ 740| 2.63k| int32_t max = -1; 741| 2.63k| int32_t maxCount = 0; 742| 6.47k| for (int32_t i = 0; i < length; ++i) { ------------------ | Branch (742:29): [True: 3.84k, False: 2.63k] ------------------ 743| 3.84k| if (refCounts[i] > maxCount) { ------------------ | Branch (743:17): [True: 3.12k, False: 721] ------------------ 744| 3.12k| max = i; 745| 3.12k| maxCount = refCounts[i]; 746| 3.12k| } 747| 3.84k| } 748| 2.63k| return indexes[max]; 749| 2.63k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocksC2Ev: 766| 3.62k| MixedBlocks() {} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie11compactDataEiPjiiRNS0_11MixedBlocksER10UErrorCode: 1084| 2.63k| int32_t dataNullIndex, MixedBlocks &mixedBlocks, UErrorCode &errorCode) { 1085| |#ifdef UCPTRIE_DEBUG 1086| | int32_t countSame=0, sumOverlaps=0; 1087| | bool printData = dataLength == 29088 /* line.brk */ || 1088| | // dataLength == 30048 /* CanonIterData */ || 1089| | dataLength == 50400 /* zh.txt~stroke */; 1090| |#endif 1091| | 1092| | // The linear ASCII data has been copied into newData already. 1093| 2.63k| int32_t newDataLength = 0; 1094| 7.90k| for (int32_t i = 0; newDataLength < ASCII_LIMIT; ------------------ | Branch (1094:25): [True: 5.27k, False: 2.63k] ------------------ 1095| 5.27k| newDataLength += UCPTRIE_FAST_DATA_BLOCK_LENGTH, i += SMALL_DATA_BLOCKS_PER_BMP_BLOCK) { 1096| 5.27k| index[i] = newDataLength; 1097| |#ifdef UCPTRIE_DEBUG 1098| | if (printData) { 1099| | printBlock(newData + newDataLength, UCPTRIE_FAST_DATA_BLOCK_LENGTH, 0, newDataLength, 0, initialValue); 1100| | } 1101| |#endif 1102| 5.27k| } 1103| | 1104| 2.63k| int32_t blockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 1105| 2.63k| if (!mixedBlocks.init(newDataCapacity, blockLength)) { ------------------ | Branch (1105:9): [True: 0, False: 2.63k] ------------------ 1106| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1107| 0| return 0; 1108| 0| } 1109| 2.63k| mixedBlocks.extend(newData, 0, 0, newDataLength); 1110| | 1111| 2.63k| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 1112| 2.63k| int32_t inc = SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 1113| 2.63k| int32_t fastLength = 0; 1114| 36.0M| for (int32_t i = ASCII_I_LIMIT; i < iLimit; i += inc) { ------------------ | Branch (1114:37): [True: 36.0M, False: 2.63k] ------------------ 1115| 36.0M| if (i == fastILimit) { ------------------ | Branch (1115:13): [True: 994, False: 36.0M] ------------------ 1116| 994| blockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 1117| 994| inc = 1; 1118| 994| fastLength = newDataLength; 1119| 994| if (!mixedBlocks.init(newDataCapacity, blockLength)) { ------------------ | Branch (1119:17): [True: 0, False: 994] ------------------ 1120| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1121| 0| return 0; 1122| 0| } 1123| 994| mixedBlocks.extend(newData, 0, 0, newDataLength); 1124| 994| } 1125| 36.0M| if (flags[i] == ALL_SAME) { ------------------ | Branch (1125:13): [True: 2.10k, False: 36.0M] ------------------ 1126| 2.10k| uint32_t value = index[i]; 1127| | // Find an earlier part of the data array of length blockLength 1128| | // that is filled with this value. 1129| 2.10k| int32_t n = mixedBlocks.findAllSameBlock(newData, value); 1130| | // If we find a match, and the current block is the data null block, 1131| | // and it is not a fast block but matches the start of a fast block, 1132| | // then we need to continue looking. 1133| | // This is because this small block is shorter than the fast block, 1134| | // and not all of the rest of the fast block is filled with this value. 1135| | // Otherwise trie.getRange() would detect that the fast block starts at 1136| | // dataNullOffset and assume incorrectly that it is filled with the null value. 1137| 2.18k| while (n >= 0 && i == dataNullIndex && i >= fastILimit && n < fastLength && ------------------ | Branch (1137:20): [True: 619, False: 1.56k] | Branch (1137:30): [True: 405, False: 214] | Branch (1137:52): [True: 159, False: 246] | Branch (1137:71): [True: 159, False: 0] ------------------ 1138| 2.18k| isStartOfSomeFastBlock(n, index, fastILimit)) { ------------------ | Branch (1138:21): [True: 83, False: 76] ------------------ 1139| 83| n = findAllSameBlock(newData, n + 1, newDataLength, value, blockLength); 1140| 83| } 1141| 2.10k| if (n >= 0) { ------------------ | Branch (1141:17): [True: 536, False: 1.56k] ------------------ 1142| 536| DEBUG_DO(++countSame); 1143| 536| index[i] = n; 1144| 1.56k| } else { 1145| 1.56k| n = getAllSameOverlap(newData, newDataLength, value, blockLength); 1146| 1.56k| DEBUG_DO(sumOverlaps += n); 1147| |#ifdef UCPTRIE_DEBUG 1148| | if (printData) { 1149| | printBlock(nullptr, blockLength, value, i << UCPTRIE_SHIFT_3, n, initialValue); 1150| | } 1151| |#endif 1152| 1.56k| index[i] = newDataLength - n; 1153| 1.56k| int32_t prevDataLength = newDataLength; 1154| 67.3k| while (n < blockLength) { ------------------ | Branch (1154:24): [True: 65.7k, False: 1.56k] ------------------ 1155| 65.7k| newData[newDataLength++] = value; 1156| 65.7k| ++n; 1157| 65.7k| } 1158| 1.56k| mixedBlocks.extend(newData, 0, prevDataLength, newDataLength); 1159| 1.56k| } 1160| 36.0M| } else if (flags[i] == MIXED) { ------------------ | Branch (1160:20): [True: 232k, False: 35.7M] ------------------ 1161| 232k| const uint32_t *block = data + index[i]; 1162| 232k| int32_t n = mixedBlocks.findBlock(newData, block, 0); 1163| 232k| if (n >= 0) { ------------------ | Branch (1163:17): [True: 115k, False: 116k] ------------------ 1164| 115k| DEBUG_DO(++countSame); 1165| 115k| index[i] = n; 1166| 116k| } else { 1167| 116k| n = getOverlap(newData, newDataLength, block, 0, blockLength); 1168| 116k| DEBUG_DO(sumOverlaps += n); 1169| |#ifdef UCPTRIE_DEBUG 1170| | if (printData) { 1171| | printBlock(block, blockLength, 0, i << UCPTRIE_SHIFT_3, n, initialValue); 1172| | } 1173| |#endif 1174| 116k| index[i] = newDataLength - n; 1175| 116k| int32_t prevDataLength = newDataLength; 1176| 5.36M| while (n < blockLength) { ------------------ | Branch (1176:24): [True: 5.24M, False: 116k] ------------------ 1177| 5.24M| newData[newDataLength++] = block[n++]; 1178| 5.24M| } 1179| 116k| mixedBlocks.extend(newData, 0, prevDataLength, newDataLength); 1180| 116k| } 1181| 35.7M| } else /* SAME_AS */ { 1182| 35.7M| uint32_t j = index[i]; 1183| 35.7M| index[i] = index[j]; 1184| 35.7M| } 1185| 36.0M| } 1186| | 1187| |#ifdef UCPTRIE_DEBUG 1188| | /* we saved some space */ 1189| | printf("compacting UCPTrie: count of 32-bit data words %lu->%lu countSame=%ld sumOverlaps=%ld\n", 1190| | (long)dataLength, (long)newDataLength, (long)countSame, (long)sumOverlaps); 1191| |#endif 1192| 2.63k| return newDataLength; 1193| 2.63k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks4initEii: 771| 5.61k| bool init(int32_t maxLength, int32_t newBlockLength) { 772| | // We store actual data indexes + 1 to reserve 0 for empty entries. 773| 5.61k| int32_t maxDataIndex = maxLength - newBlockLength + 1; 774| 5.61k| int32_t newLength; 775| 5.61k| if (maxDataIndex <= 0xfff) { // 4k ------------------ | Branch (775:13): [True: 4.15k, False: 1.46k] ------------------ 776| 4.15k| newLength = 6007; 777| 4.15k| shift = 12; 778| 4.15k| mask = 0xfff; 779| 4.15k| } else if (maxDataIndex <= 0x7fff) { // 32k ------------------ | Branch (779:20): [True: 1.40k, False: 64] ------------------ 780| 1.40k| newLength = 50021; 781| 1.40k| shift = 15; 782| 1.40k| mask = 0x7fff; 783| 1.40k| } else if (maxDataIndex <= 0x1ffff) { // 128k ------------------ | Branch (783:20): [True: 64, False: 0] ------------------ 784| 64| newLength = 200003; 785| 64| shift = 17; 786| 64| mask = 0x1ffff; 787| 64| } else { 788| | // maxDataIndex up to around MAX_DATA_LENGTH, ca. 1.1M 789| 0| newLength = 1500007; 790| 0| shift = 21; 791| 0| mask = 0x1fffff; 792| 0| } 793| 5.61k| if (newLength > capacity) { ------------------ | Branch (793:13): [True: 2.69k, False: 2.92k] ------------------ 794| 2.69k| uprv_free(table); ------------------ | | 1503| 2.69k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.69k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.69k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.69k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 795| 2.69k| table = static_cast(uprv_malloc(newLength * 4)); ------------------ | | 1524| 2.69k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.69k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.69k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.69k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 796| 2.69k| if (table == nullptr) { ------------------ | Branch (796:17): [True: 0, False: 2.69k] ------------------ 797| 0| return false; 798| 0| } 799| 2.69k| capacity = newLength; 800| 2.69k| } 801| 5.61k| length = newLength; 802| 5.61k| uprv_memset(table, 0, length * 4); ------------------ | | 100| 5.61k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 5.61k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 803| | 804| 5.61k| blockLength = newBlockLength; 805| 5.61k| return true; 806| 5.61k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks6extendIjEEvPKT_iii: 809| 121k| void extend(const UInt *data, int32_t minStart, int32_t prevDataLength, int32_t newDataLength) { 810| 121k| int32_t start = prevDataLength - blockLength; 811| 121k| if (start >= minStart) { ------------------ | Branch (811:13): [True: 117k, False: 3.62k] ------------------ 812| 117k| ++start; // Skip the last block that we added last time. 813| 117k| } else { 814| 3.62k| start = minStart; // Begin with the first full block. 815| 3.62k| } 816| 9.56M| for (int32_t end = newDataLength - blockLength; start <= end; ++start) { ------------------ | Branch (816:57): [True: 9.43M, False: 121k] ------------------ 817| 9.43M| uint32_t hashCode = makeHashCode(data, start); 818| 9.43M| addEntry(data, start, hashCode, start); 819| 9.43M| } 820| 121k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks12makeHashCodeIjEEjPKT_i: 845| 9.92M| uint32_t makeHashCode(const UInt *blockData, int32_t blockStart) const { 846| 9.92M| int32_t blockLimit = blockStart + blockLength; 847| 9.92M| uint32_t hashCode = blockData[blockStart++]; 848| 409M| do { 849| 409M| hashCode = 37 * hashCode + blockData[blockStart++]; 850| 409M| } while (blockStart < blockLimit); ------------------ | Branch (850:18): [True: 399M, False: 9.92M] ------------------ 851| 9.92M| return hashCode; 852| 9.92M| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks8addEntryIjEEvPKT_iji: 863| 9.43M| void addEntry(const UInt *data, int32_t blockStart, uint32_t hashCode, int32_t dataIndex) { 864| 9.43M| U_ASSERT(0 <= dataIndex && dataIndex < (int32_t)mask); ------------------ | | 35| 9.43M|# define U_ASSERT(exp) (void)0 ------------------ 865| 9.43M| int32_t entryIndex = findEntry(data, data, blockStart, hashCode); 866| 9.43M| if (entryIndex < 0) { ------------------ | Branch (866:13): [True: 6.23M, False: 3.20M] ------------------ 867| 6.23M| table[~entryIndex] = (hashCode << shift) | (dataIndex + 1); 868| 6.23M| } 869| 9.43M| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryIjjEEiPKT_PKT0_ij: 873| 9.67M| uint32_t hashCode) const { 874| 9.67M| uint32_t shiftedHashCode = hashCode << shift; 875| 9.67M| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 876| 10.3M| for (int32_t entryIndex = initialEntryIndex;;) { 877| 10.3M| uint32_t entry = table[entryIndex]; 878| 10.3M| if (entry == 0) { ------------------ | Branch (878:17): [True: 6.35M, False: 4.04M] ------------------ 879| 6.35M| return ~entryIndex; 880| 6.35M| } 881| 4.04M| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (881:17): [True: 3.33M, False: 706k] ------------------ 882| 3.33M| int32_t dataIndex = (entry & mask) - 1; 883| 3.33M| if (equalBlocks(data + dataIndex, blockData + blockStart, blockLength)) { ------------------ | Branch (883:21): [True: 3.31M, False: 17.1k] ------------------ 884| 3.31M| return entryIndex; 885| 3.31M| } 886| 3.33M| } 887| 723k| entryIndex = nextIndex(initialEntryIndex, entryIndex); 888| 723k| } 889| 9.67M| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111equalBlocksIjjEEbPKT_PKT0_i: 575| 8.55M|bool equalBlocks(const UIntA *s, const UIntB *t, int32_t length) { 576| 117M| while (length > 0 && *s == *t) { ------------------ | Branch (576:12): [True: 114M, False: 3.40M] | Branch (576:26): [True: 109M, False: 5.14M] ------------------ 577| 109M| ++s; 578| 109M| ++t; 579| 109M| --length; 580| 109M| } 581| 8.55M| return length == 0; 582| 8.55M|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9nextIndexEii: 909| 882k| inline int32_t nextIndex(int32_t initialEntryIndex, int32_t entryIndex) const { 910| | // U_ASSERT(0 < initialEntryIndex && initialEntryIndex < length); 911| 882k| return (entryIndex + initialEntryIndex) % length; 912| 882k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks16findAllSameBlockEPKjj: 833| 2.10k| int32_t findAllSameBlock(const uint32_t *data, uint32_t blockValue) const { 834| 2.10k| uint32_t hashCode = makeHashCode(blockValue); 835| 2.10k| int32_t entryIndex = findEntry(data, blockValue, hashCode); 836| 2.10k| if (entryIndex >= 0) { ------------------ | Branch (836:13): [True: 565, False: 1.53k] ------------------ 837| 565| return (table[entryIndex] & mask) - 1; 838| 1.53k| } else { 839| 1.53k| return -1; 840| 1.53k| } 841| 2.10k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks12makeHashCodeEj: 854| 2.10k| uint32_t makeHashCode(uint32_t blockValue) const { 855| 2.10k| uint32_t hashCode = blockValue; 856| 118k| for (int32_t i = 1; i < blockLength; ++i) { ------------------ | Branch (856:29): [True: 115k, False: 2.10k] ------------------ 857| 115k| hashCode = 37 * hashCode + blockValue; 858| 115k| } 859| 2.10k| return hashCode; 860| 2.10k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryEPKjjj: 891| 2.10k| int32_t findEntry(const uint32_t *data, uint32_t blockValue, uint32_t hashCode) const { 892| 2.10k| uint32_t shiftedHashCode = hashCode << shift; 893| 2.10k| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 894| 2.59k| for (int32_t entryIndex = initialEntryIndex;;) { 895| 2.59k| uint32_t entry = table[entryIndex]; 896| 2.59k| if (entry == 0) { ------------------ | Branch (896:17): [True: 1.53k, False: 1.05k] ------------------ 897| 1.53k| return ~entryIndex; 898| 1.53k| } 899| 1.05k| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (899:17): [True: 778, False: 274] ------------------ 900| 778| int32_t dataIndex = (entry & mask) - 1; 901| 778| if (allValuesSameAs(data + dataIndex, blockLength, blockValue)) { ------------------ | Branch (901:21): [True: 565, False: 213] ------------------ 902| 565| return entryIndex; 903| 565| } 904| 778| } 905| 487| entryIndex = nextIndex(initialEntryIndex, entryIndex); 906| 487| } 907| 2.10k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_122isStartOfSomeFastBlockEjPKji: 651| 159|bool isStartOfSomeFastBlock(uint32_t dataOffset, const uint32_t index[], int32_t fastILimit) { 652| 89.3k| for (int32_t i = 0; i < fastILimit; i += SMALL_DATA_BLOCKS_PER_BMP_BLOCK) { ------------------ | Branch (652:25): [True: 89.2k, False: 76] ------------------ 653| 89.2k| if (index[i] == dataOffset) { ------------------ | Branch (653:13): [True: 83, False: 89.1k] ------------------ 654| 83| return true; 655| 83| } 656| 89.2k| } 657| 76| return false; 658| 159|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_116findAllSameBlockEPKjiiji: 607| 83| uint32_t value, int32_t blockLength) { 608| | // Ensure that we do not even partially get past limit. 609| 83| limit -= blockLength; 610| | 611| 134k| for (int32_t block = start; block <= limit; ++block) { ------------------ | Branch (611:33): [True: 134k, False: 29] ------------------ 612| 134k| if (p[block] == value) { ------------------ | Branch (612:13): [True: 2.28k, False: 132k] ------------------ 613| 8.31k| for (int32_t i = 1;; ++i) { 614| 8.31k| if (i == blockLength) { ------------------ | Branch (614:21): [True: 54, False: 8.26k] ------------------ 615| 54| return block; 616| 54| } 617| 8.26k| if (p[block + i] != value) { ------------------ | Branch (617:21): [True: 2.23k, False: 6.03k] ------------------ 618| 2.23k| block += i; 619| 2.23k| break; 620| 2.23k| } 621| 8.26k| } 622| 2.28k| } 623| 134k| } 624| 29| return -1; 625| 83|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_117getAllSameOverlapEPKjiji: 644| 1.56k| int32_t blockLength) { 645| 1.56k| int32_t min = length - (blockLength - 1); 646| 1.56k| int32_t i = length; 647| 29.2k| while (min < i && p[i - 1] == value) { --i; } ------------------ | Branch (647:12): [True: 29.1k, False: 93] | Branch (647:23): [True: 27.7k, False: 1.47k] ------------------ 648| 1.56k| return length - i; 649| 1.56k|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findBlockIjjEEiPKT_PKT0_i: 823| 232k| int32_t findBlock(const UIntA *data, const UIntB *blockData, int32_t blockStart) const { 824| 232k| uint32_t hashCode = makeHashCode(blockData, blockStart); 825| 232k| int32_t entryIndex = findEntry(data, blockData, blockStart, hashCode); 826| 232k| if (entryIndex >= 0) { ------------------ | Branch (826:13): [True: 115k, False: 116k] ------------------ 827| 115k| return (table[entryIndex] & mask) - 1; 828| 116k| } else { 829| 116k| return -1; 830| 116k| } 831| 232k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110getOverlapIjjEEiPKT_iPKT0_ii: 633| 116k| const UIntB *q, int32_t qStart, int32_t blockLength) { 634| 116k| int32_t overlap = blockLength - 1; 635| 116k| U_ASSERT(overlap <= length); ------------------ | | 35| 116k|# define U_ASSERT(exp) (void)0 ------------------ 636| 116k| q += qStart; 637| 5.24M| while (overlap > 0 && !equalBlocks(p + (length - overlap), q, overlap)) { ------------------ | Branch (637:12): [True: 5.21M, False: 32.4k] | Branch (637:27): [True: 5.13M, False: 83.9k] ------------------ 638| 5.13M| --overlap; 639| 5.13M| } 640| 116k| return overlap; 641| 116k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie12compactIndexEiRNS0_11MixedBlocksER10UErrorCode: 1196| 2.63k| UErrorCode &errorCode) { 1197| 2.63k| int32_t fastIndexLength = fastILimit >> (UCPTRIE_FAST_SHIFT - UCPTRIE_SHIFT_3); 1198| 2.63k| if ((highStart >> UCPTRIE_FAST_SHIFT) <= fastIndexLength) { ------------------ | Branch (1198:9): [True: 1.64k, False: 994] ------------------ 1199| | // Only the linear fast index, no multi-stage index tables. 1200| 1.64k| index3NullOffset = UCPTRIE_NO_INDEX3_NULL_OFFSET; 1201| 1.64k| return fastIndexLength; 1202| 1.64k| } 1203| | 1204| | // Condense the fast index table. 1205| | // Also, does it contain an index-3 block with all dataNullOffset? 1206| 994| uint16_t fastIndex[UCPTRIE_BMP_INDEX_LENGTH]; // fastIndexLength 1207| 994| int32_t i3FirstNull = -1; 1208| 1.01M| for (int32_t i = 0, j = 0; i < fastILimit; ++j) { ------------------ | Branch (1208:32): [True: 1.01M, False: 994] ------------------ 1209| 1.01M| uint32_t i3 = index[i]; 1210| 1.01M| fastIndex[j] = static_cast(i3); 1211| 1.01M| if (i3 == static_cast(dataNullOffset)) { ------------------ | Branch (1211:13): [True: 633k, False: 384k] ------------------ 1212| 633k| if (i3FirstNull < 0) { ------------------ | Branch (1212:17): [True: 18.7k, False: 614k] ------------------ 1213| 18.7k| i3FirstNull = j; 1214| 614k| } else if (index3NullOffset < 0 && ------------------ | Branch (1214:24): [True: 59.6k, False: 554k] ------------------ 1215| 614k| (j - i3FirstNull + 1) == UCPTRIE_INDEX_3_BLOCK_LENGTH) { ------------------ | Branch (1215:21): [True: 819, False: 58.8k] ------------------ 1216| 819| index3NullOffset = i3FirstNull; 1217| 819| } 1218| 633k| } else { 1219| 384k| i3FirstNull = -1; 1220| 384k| } 1221| | // Set the index entries that compactData() skipped. 1222| | // Needed when the multi-stage index covers the fast index range as well. 1223| 1.01M| int32_t iNext = i + SMALL_DATA_BLOCKS_PER_BMP_BLOCK; 1224| 4.07M| while (++i < iNext) { ------------------ | Branch (1224:16): [True: 3.05M, False: 1.01M] ------------------ 1225| 3.05M| i3 += UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 1226| 3.05M| index[i] = i3; 1227| 3.05M| } 1228| 1.01M| } 1229| | 1230| 994| if (!mixedBlocks.init(fastIndexLength, UCPTRIE_INDEX_3_BLOCK_LENGTH)) { ------------------ | Branch (1230:9): [True: 0, False: 994] ------------------ 1231| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1232| 0| return 0; 1233| 0| } 1234| 994| mixedBlocks.extend(fastIndex, 0, 0, fastIndexLength); 1235| | 1236| | // Examine index-3 blocks. For each determine one of: 1237| | // - same as the index-3 null block 1238| | // - same as a fast-index block 1239| | // - 16-bit indexes 1240| | // - 18-bit indexes 1241| | // We store this in the first flags entry for the index-3 block. 1242| | // 1243| | // Also determine an upper limit for the index-3 table length. 1244| 994| int32_t index3Capacity = 0; 1245| 994| i3FirstNull = index3NullOffset; 1246| 994| bool hasLongI3Blocks = false; 1247| | // If the fast index covers the whole BMP, then 1248| | // the multi-stage index is only for supplementary code points. 1249| | // Otherwise, the multi-stage index covers all of Unicode. 1250| 994| int32_t iStart = fastILimit < BMP_I_LIMIT ? 0 : BMP_I_LIMIT; ------------------ | Branch (1250:22): [True: 0, False: 994] ------------------ 1251| 994| int32_t iLimit = highStart >> UCPTRIE_SHIFT_3; 1252| 1.04M| for (int32_t i = iStart; i < iLimit;) { ------------------ | Branch (1252:30): [True: 1.04M, False: 994] ------------------ 1253| 1.04M| int32_t j = i; 1254| 1.04M| int32_t jLimit = i + UCPTRIE_INDEX_3_BLOCK_LENGTH; 1255| 1.04M| uint32_t oredI3 = 0; 1256| 1.04M| bool isNull = true; 1257| 33.3M| do { 1258| 33.3M| uint32_t i3 = index[j]; 1259| 33.3M| oredI3 |= i3; 1260| 33.3M| if (i3 != static_cast(dataNullOffset)) { ------------------ | Branch (1260:17): [True: 4.89M, False: 28.4M] ------------------ 1261| 4.89M| isNull = false; 1262| 4.89M| } 1263| 33.3M| } while (++j < jLimit); ------------------ | Branch (1263:18): [True: 32.2M, False: 1.04M] ------------------ 1264| 1.04M| if (isNull) { ------------------ | Branch (1264:13): [True: 877k, False: 163k] ------------------ 1265| 877k| flags[i] = I3_NULL; 1266| 877k| if (i3FirstNull < 0) { ------------------ | Branch (1266:17): [True: 175, False: 877k] ------------------ 1267| 175| if (oredI3 <= 0xffff) { ------------------ | Branch (1267:21): [True: 175, False: 0] ------------------ 1268| 175| index3Capacity += UCPTRIE_INDEX_3_BLOCK_LENGTH; 1269| 175| } else { 1270| 0| index3Capacity += INDEX_3_18BIT_BLOCK_LENGTH; 1271| 0| hasLongI3Blocks = true; 1272| 0| } 1273| 175| i3FirstNull = 0; 1274| 175| } 1275| 877k| } else { 1276| 163k| if (oredI3 <= 0xffff) { ------------------ | Branch (1276:17): [True: 163k, False: 0] ------------------ 1277| 163k| int32_t n = mixedBlocks.findBlock(fastIndex, index, i); 1278| 163k| if (n >= 0) { ------------------ | Branch (1278:21): [True: 71.1k, False: 92.6k] ------------------ 1279| 71.1k| flags[i] = I3_BMP; 1280| 71.1k| index[i] = n; 1281| 92.6k| } else { 1282| 92.6k| flags[i] = I3_16; 1283| 92.6k| index3Capacity += UCPTRIE_INDEX_3_BLOCK_LENGTH; 1284| 92.6k| } 1285| 163k| } else { 1286| 0| flags[i] = I3_18; 1287| 0| index3Capacity += INDEX_3_18BIT_BLOCK_LENGTH; 1288| 0| hasLongI3Blocks = true; 1289| 0| } 1290| 163k| } 1291| 1.04M| i = j; 1292| 1.04M| } 1293| | 1294| 994| int32_t index2Capacity = (iLimit - iStart) >> UCPTRIE_SHIFT_2_3; 1295| | 1296| | // Length of the index-1 table, rounded up. 1297| 994| int32_t index1Length = (index2Capacity + UCPTRIE_INDEX_2_MASK) >> UCPTRIE_SHIFT_1_2; 1298| | 1299| | // Index table: Fast index, index-1, index-3, index-2. 1300| | // +1 for possible index table padding. 1301| 994| int32_t index16Capacity = fastIndexLength + index1Length + index3Capacity + index2Capacity + 1; 1302| 994| index16 = static_cast(uprv_malloc(index16Capacity * 2)); ------------------ | | 1524| 994|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 994|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 994|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 994|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1303| 994| if (index16 == nullptr) { ------------------ | Branch (1303:9): [True: 0, False: 994] ------------------ 1304| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1305| 0| return 0; 1306| 0| } 1307| 994| uprv_memcpy(index16, fastIndex, fastIndexLength * 2); ------------------ | | 42| 994|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 994|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 994| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 994| _Pragma("clang diagnostic push") \ | | 45| 994| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 994| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 994|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 994| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 994|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 994| _Pragma("clang diagnostic pop") \ | | 49| 994| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 994|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 994|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 994|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1308| | 1309| 994| if (!mixedBlocks.init(index16Capacity, UCPTRIE_INDEX_3_BLOCK_LENGTH)) { ------------------ | Branch (1309:9): [True: 0, False: 994] ------------------ 1310| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1311| 0| return 0; 1312| 0| } 1313| 994| MixedBlocks longI3Blocks; 1314| 994| if (hasLongI3Blocks) { ------------------ | Branch (1314:9): [True: 0, False: 994] ------------------ 1315| 0| if (!longI3Blocks.init(index16Capacity, INDEX_3_18BIT_BLOCK_LENGTH)) { ------------------ | Branch (1315:13): [True: 0, False: 0] ------------------ 1316| 0| errorCode = U_MEMORY_ALLOCATION_ERROR; 1317| 0| return 0; 1318| 0| } 1319| 0| } 1320| | 1321| | // Compact the index-3 table and write an uncompacted version of the index-2 table. 1322| 994| uint16_t index2[UNICODE_LIMIT >> UCPTRIE_SHIFT_2]; // index2Capacity 1323| 994| int32_t i2Length = 0; 1324| 994| i3FirstNull = index3NullOffset; 1325| 994| int32_t index3Start = fastIndexLength + index1Length; 1326| 994| int32_t indexLength = index3Start; 1327| 1.04M| for (int32_t i = iStart; i < iLimit; i += UCPTRIE_INDEX_3_BLOCK_LENGTH) { ------------------ | Branch (1327:30): [True: 1.04M, False: 994] ------------------ 1328| 1.04M| int32_t i3; 1329| 1.04M| uint8_t f = flags[i]; 1330| 1.04M| if (f == I3_NULL && i3FirstNull < 0) { ------------------ | Branch (1330:13): [True: 877k, False: 163k] | Branch (1330:29): [True: 175, False: 877k] ------------------ 1331| | // First index-3 null block. Write & overlap it like a normal block, then remember it. 1332| 175| f = dataNullOffset <= 0xffff ? I3_16 : I3_18; ------------------ | Branch (1332:17): [True: 175, False: 0] ------------------ 1333| 175| i3FirstNull = 0; 1334| 175| } 1335| 1.04M| if (f == I3_NULL) { ------------------ | Branch (1335:13): [True: 877k, False: 163k] ------------------ 1336| 877k| i3 = index3NullOffset; 1337| 877k| } else if (f == I3_BMP) { ------------------ | Branch (1337:20): [True: 71.1k, False: 92.8k] ------------------ 1338| 71.1k| i3 = index[i]; 1339| 92.8k| } else if (f == I3_16) { ------------------ | Branch (1339:20): [True: 92.8k, False: 0] ------------------ 1340| 92.8k| int32_t n = mixedBlocks.findBlock(index16, index, i); 1341| 92.8k| if (n >= 0) { ------------------ | Branch (1341:17): [True: 67.4k, False: 25.3k] ------------------ 1342| 67.4k| i3 = n; 1343| 67.4k| } else { 1344| 25.3k| if (indexLength == index3Start) { ------------------ | Branch (1344:21): [True: 986, False: 24.3k] ------------------ 1345| | // No overlap at the boundary between the index-1 and index-3 tables. 1346| 986| n = 0; 1347| 24.3k| } else { 1348| 24.3k| n = getOverlap(index16, indexLength, 1349| 24.3k| index, i, UCPTRIE_INDEX_3_BLOCK_LENGTH); 1350| 24.3k| } 1351| 25.3k| i3 = indexLength - n; 1352| 25.3k| int32_t prevIndexLength = indexLength; 1353| 713k| while (n < UCPTRIE_INDEX_3_BLOCK_LENGTH) { ------------------ | Branch (1353:24): [True: 687k, False: 25.3k] ------------------ 1354| 687k| index16[indexLength++] = index[i + n++]; 1355| 687k| } 1356| 25.3k| mixedBlocks.extend(index16, index3Start, prevIndexLength, indexLength); 1357| 25.3k| if (hasLongI3Blocks) { ------------------ | Branch (1357:21): [True: 0, False: 25.3k] ------------------ 1358| 0| longI3Blocks.extend(index16, index3Start, prevIndexLength, indexLength); 1359| 0| } 1360| 25.3k| } 1361| 92.8k| } else { 1362| 0| U_ASSERT(f == I3_18); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1363| 0| U_ASSERT(hasLongI3Blocks); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1364| | // Encode an index-3 block that contains one or more data indexes exceeding 16 bits. 1365| 0| int32_t j = i; 1366| 0| int32_t jLimit = i + UCPTRIE_INDEX_3_BLOCK_LENGTH; 1367| 0| int32_t k = indexLength; 1368| 0| do { 1369| 0| ++k; 1370| 0| uint32_t v = index[j++]; 1371| 0| uint32_t upperBits = (v & 0x30000) >> 2; 1372| 0| index16[k++] = v; 1373| 0| v = index[j++]; 1374| 0| upperBits |= (v & 0x30000) >> 4; 1375| 0| index16[k++] = v; 1376| 0| v = index[j++]; 1377| 0| upperBits |= (v & 0x30000) >> 6; 1378| 0| index16[k++] = v; 1379| 0| v = index[j++]; 1380| 0| upperBits |= (v & 0x30000) >> 8; 1381| 0| index16[k++] = v; 1382| 0| v = index[j++]; 1383| 0| upperBits |= (v & 0x30000) >> 10; 1384| 0| index16[k++] = v; 1385| 0| v = index[j++]; 1386| 0| upperBits |= (v & 0x30000) >> 12; 1387| 0| index16[k++] = v; 1388| 0| v = index[j++]; 1389| 0| upperBits |= (v & 0x30000) >> 14; 1390| 0| index16[k++] = v; 1391| 0| v = index[j++]; 1392| 0| upperBits |= (v & 0x30000) >> 16; 1393| 0| index16[k++] = v; 1394| 0| index16[k - 9] = upperBits; 1395| 0| } while (j < jLimit); ------------------ | Branch (1395:22): [True: 0, False: 0] ------------------ 1396| 0| int32_t n = longI3Blocks.findBlock(index16, index16, indexLength); 1397| 0| if (n >= 0) { ------------------ | Branch (1397:17): [True: 0, False: 0] ------------------ 1398| 0| i3 = n | 0x8000; 1399| 0| } else { 1400| 0| if (indexLength == index3Start) { ------------------ | Branch (1400:21): [True: 0, False: 0] ------------------ 1401| | // No overlap at the boundary between the index-1 and index-3 tables. 1402| 0| n = 0; 1403| 0| } else { 1404| 0| n = getOverlap(index16, indexLength, 1405| 0| index16, indexLength, INDEX_3_18BIT_BLOCK_LENGTH); 1406| 0| } 1407| 0| i3 = (indexLength - n) | 0x8000; 1408| 0| int32_t prevIndexLength = indexLength; 1409| 0| if (n > 0) { ------------------ | Branch (1409:21): [True: 0, False: 0] ------------------ 1410| 0| int32_t start = indexLength; 1411| 0| while (n < INDEX_3_18BIT_BLOCK_LENGTH) { ------------------ | Branch (1411:28): [True: 0, False: 0] ------------------ 1412| 0| index16[indexLength++] = index16[start + n++]; 1413| 0| } 1414| 0| } else { 1415| 0| indexLength += INDEX_3_18BIT_BLOCK_LENGTH; 1416| 0| } 1417| 0| mixedBlocks.extend(index16, index3Start, prevIndexLength, indexLength); 1418| 0| if (hasLongI3Blocks) { ------------------ | Branch (1418:21): [True: 0, False: 0] ------------------ 1419| 0| longI3Blocks.extend(index16, index3Start, prevIndexLength, indexLength); 1420| 0| } 1421| 0| } 1422| 0| } 1423| 1.04M| if (index3NullOffset < 0 && i3FirstNull >= 0) { ------------------ | Branch (1423:13): [True: 35.3k, False: 1.00M] | Branch (1423:37): [True: 175, False: 35.1k] ------------------ 1424| 175| index3NullOffset = i3; 1425| 175| } 1426| | // Set the index-2 table entry. 1427| 1.04M| index2[i2Length++] = i3; 1428| 1.04M| } 1429| 994| U_ASSERT(i2Length == index2Capacity); ------------------ | | 35| 994|# define U_ASSERT(exp) (void)0 ------------------ 1430| 994| U_ASSERT(indexLength <= index3Start + index3Capacity); ------------------ | | 35| 994|# define U_ASSERT(exp) (void)0 ------------------ 1431| | 1432| 994| if (index3NullOffset < 0) { ------------------ | Branch (1432:9): [True: 0, False: 994] ------------------ 1433| 0| index3NullOffset = UCPTRIE_NO_INDEX3_NULL_OFFSET; 1434| 0| } 1435| 994| if (indexLength >= (UCPTRIE_NO_INDEX3_NULL_OFFSET + UCPTRIE_INDEX_3_BLOCK_LENGTH)) { ------------------ | Branch (1435:9): [True: 0, False: 994] ------------------ 1436| | // The index-3 offsets exceed 15 bits, or 1437| | // the last one cannot be distinguished from the no-null-block value. 1438| 0| errorCode = U_INDEX_OUTOFBOUNDS_ERROR; 1439| 0| return 0; 1440| 0| } 1441| | 1442| | // Compact the index-2 table and write the index-1 table. 1443| 994| static_assert(UCPTRIE_INDEX_2_BLOCK_LENGTH == UCPTRIE_INDEX_3_BLOCK_LENGTH, 1444| 994| "must re-init mixedBlocks"); 1445| 994| int32_t blockLength = UCPTRIE_INDEX_2_BLOCK_LENGTH; 1446| 994| int32_t i1 = fastIndexLength; 1447| 33.9k| for (int32_t i = 0; i < i2Length; i += blockLength) { ------------------ | Branch (1447:25): [True: 32.9k, False: 994] ------------------ 1448| 32.9k| int32_t n; 1449| 32.9k| if ((i2Length - i) >= blockLength) { ------------------ | Branch (1449:13): [True: 32.1k, False: 841] ------------------ 1450| | // normal block 1451| 32.1k| U_ASSERT(blockLength == UCPTRIE_INDEX_2_BLOCK_LENGTH); ------------------ | | 35| 32.1k|# define U_ASSERT(exp) (void)0 ------------------ 1452| 32.1k| n = mixedBlocks.findBlock(index16, index2, i); 1453| 32.1k| } else { 1454| | // highStart is inside the last index-2 block. Shorten it. 1455| 841| blockLength = i2Length - i; 1456| 841| n = findSameBlock(index16, index3Start, indexLength, 1457| 841| index2, i, blockLength); 1458| 841| } 1459| 32.9k| int32_t i2; 1460| 32.9k| if (n >= 0) { ------------------ | Branch (1460:13): [True: 27.4k, False: 5.56k] ------------------ 1461| 27.4k| i2 = n; 1462| 27.4k| } else { 1463| 5.56k| if (indexLength == index3Start) { ------------------ | Branch (1463:17): [True: 8, False: 5.55k] ------------------ 1464| | // No overlap at the boundary between the index-1 and index-3/2 tables. 1465| 8| n = 0; 1466| 5.55k| } else { 1467| 5.55k| n = getOverlap(index16, indexLength, index2, i, blockLength); 1468| 5.55k| } 1469| 5.56k| i2 = indexLength - n; 1470| 5.56k| int32_t prevIndexLength = indexLength; 1471| 135k| while (n < blockLength) { ------------------ | Branch (1471:20): [True: 129k, False: 5.56k] ------------------ 1472| 129k| index16[indexLength++] = index2[i + n++]; 1473| 129k| } 1474| 5.56k| mixedBlocks.extend(index16, index3Start, prevIndexLength, indexLength); 1475| 5.56k| } 1476| | // Set the index-1 table entry. 1477| 32.9k| index16[i1++] = i2; 1478| 32.9k| } 1479| 994| U_ASSERT(i1 == index3Start); ------------------ | | 35| 994|# define U_ASSERT(exp) (void)0 ------------------ 1480| 994| U_ASSERT(indexLength <= index16Capacity); ------------------ | | 35| 994|# define U_ASSERT(exp) (void)0 ------------------ 1481| | 1482| |#ifdef UCPTRIE_DEBUG 1483| | /* we saved some space */ 1484| | printf("compacting UCPTrie: count of 16-bit index words %lu->%lu\n", 1485| | (long)iLimit, (long)indexLength); 1486| |#endif 1487| | 1488| 994| return indexLength; 1489| 994|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks6extendItEEvPKT_iii: 809| 31.9k| void extend(const UInt *data, int32_t minStart, int32_t prevDataLength, int32_t newDataLength) { 810| 31.9k| int32_t start = prevDataLength - blockLength; 811| 31.9k| if (start >= minStart) { ------------------ | Branch (811:13): [True: 29.9k, False: 1.98k] ------------------ 812| 29.9k| ++start; // Skip the last block that we added last time. 813| 29.9k| } else { 814| 1.98k| start = minStart; // Begin with the first full block. 815| 1.98k| } 816| 1.80M| for (int32_t end = newDataLength - blockLength; start <= end; ++start) { ------------------ | Branch (816:57): [True: 1.77M, False: 31.9k] ------------------ 817| 1.77M| uint32_t hashCode = makeHashCode(data, start); 818| 1.77M| addEntry(data, start, hashCode, start); 819| 1.77M| } 820| 31.9k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks12makeHashCodeItEEjPKT_i: 845| 1.80M| uint32_t makeHashCode(const UInt *blockData, int32_t blockStart) const { 846| 1.80M| int32_t blockLimit = blockStart + blockLength; 847| 1.80M| uint32_t hashCode = blockData[blockStart++]; 848| 55.9M| do { 849| 55.9M| hashCode = 37 * hashCode + blockData[blockStart++]; 850| 55.9M| } while (blockStart < blockLimit); ------------------ | Branch (850:18): [True: 54.1M, False: 1.80M] ------------------ 851| 1.80M| return hashCode; 852| 1.80M| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocks8addEntryItEEvPKT_iji: 863| 1.77M| void addEntry(const UInt *data, int32_t blockStart, uint32_t hashCode, int32_t dataIndex) { 864| 1.77M| U_ASSERT(0 <= dataIndex && dataIndex < (int32_t)mask); ------------------ | | 35| 1.77M|# define U_ASSERT(exp) (void)0 ------------------ 865| 1.77M| int32_t entryIndex = findEntry(data, data, blockStart, hashCode); 866| 1.77M| if (entryIndex < 0) { ------------------ | Branch (866:13): [True: 1.16M, False: 607k] ------------------ 867| 1.16M| table[~entryIndex] = (hashCode << shift) | (dataIndex + 1); 868| 1.16M| } 869| 1.77M| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryIttEEiPKT_PKT0_ij: 873| 1.80M| uint32_t hashCode) const { 874| 1.80M| uint32_t shiftedHashCode = hashCode << shift; 875| 1.80M| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 876| 1.92M| for (int32_t entryIndex = initialEntryIndex;;) { 877| 1.92M| uint32_t entry = table[entryIndex]; 878| 1.92M| if (entry == 0) { ------------------ | Branch (878:17): [True: 1.17M, False: 753k] ------------------ 879| 1.17M| return ~entryIndex; 880| 1.17M| } 881| 753k| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (881:17): [True: 662k, False: 90.8k] ------------------ 882| 662k| int32_t dataIndex = (entry & mask) - 1; 883| 662k| if (equalBlocks(data + dataIndex, blockData + blockStart, blockLength)) { ------------------ | Branch (883:21): [True: 634k, False: 28.2k] ------------------ 884| 634k| return entryIndex; 885| 634k| } 886| 662k| } 887| 119k| entryIndex = nextIndex(initialEntryIndex, entryIndex); 888| 119k| } 889| 1.80M| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111equalBlocksIttEEbPKT_PKT0_i: 575| 1.50M|bool equalBlocks(const UIntA *s, const UIntB *t, int32_t length) { 576| 22.8M| while (length > 0 && *s == *t) { ------------------ | Branch (576:12): [True: 22.2M, False: 638k] | Branch (576:26): [True: 21.3M, False: 868k] ------------------ 577| 21.3M| ++s; 578| 21.3M| ++t; 579| 21.3M| --length; 580| 21.3M| } 581| 1.50M| return length == 0; 582| 1.50M|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findBlockItjEEiPKT_PKT0_i: 823| 256k| int32_t findBlock(const UIntA *data, const UIntB *blockData, int32_t blockStart) const { 824| 256k| uint32_t hashCode = makeHashCode(blockData, blockStart); 825| 256k| int32_t entryIndex = findEntry(data, blockData, blockStart, hashCode); 826| 256k| if (entryIndex >= 0) { ------------------ | Branch (826:13): [True: 138k, False: 118k] ------------------ 827| 138k| return (table[entryIndex] & mask) - 1; 828| 138k| } else { 829| 118k| return -1; 830| 118k| } 831| 256k| } umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findEntryItjEEiPKT_PKT0_ij: 873| 256k| uint32_t hashCode) const { 874| 256k| uint32_t shiftedHashCode = hashCode << shift; 875| 256k| int32_t initialEntryIndex = (hashCode % (length - 1)) + 1; // 1..length-1 876| 295k| for (int32_t entryIndex = initialEntryIndex;;) { 877| 295k| uint32_t entry = table[entryIndex]; 878| 295k| if (entry == 0) { ------------------ | Branch (878:17): [True: 118k, False: 177k] ------------------ 879| 118k| return ~entryIndex; 880| 118k| } 881| 177k| if ((entry & ~mask) == shiftedHashCode) { ------------------ | Branch (881:17): [True: 161k, False: 16.1k] ------------------ 882| 161k| int32_t dataIndex = (entry & mask) - 1; 883| 161k| if (equalBlocks(data + dataIndex, blockData + blockStart, blockLength)) { ------------------ | Branch (883:21): [True: 138k, False: 23.0k] ------------------ 884| 138k| return entryIndex; 885| 138k| } 886| 161k| } 887| 39.2k| entryIndex = nextIndex(initialEntryIndex, entryIndex); 888| 39.2k| } 889| 256k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111equalBlocksItjEEbPKT_PKT0_i: 575| 805k|bool equalBlocks(const UIntA *s, const UIntB *t, int32_t length) { 576| 7.14M| while (length > 0 && *s == *t) { ------------------ | Branch (576:12): [True: 6.99M, False: 150k] | Branch (576:26): [True: 6.33M, False: 654k] ------------------ 577| 6.33M| ++s; 578| 6.33M| ++t; 579| 6.33M| --length; 580| 6.33M| } 581| 805k| return length == 0; 582| 805k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110getOverlapItjEEiPKT_iPKT0_ii: 633| 24.3k| const UIntB *q, int32_t qStart, int32_t blockLength) { 634| 24.3k| int32_t overlap = blockLength - 1; 635| 24.3k| U_ASSERT(overlap <= length); ------------------ | | 35| 24.3k|# define U_ASSERT(exp) (void)0 ------------------ 636| 24.3k| q += qStart; 637| 656k| while (overlap > 0 && !equalBlocks(p + (length - overlap), q, overlap)) { ------------------ | Branch (637:12): [True: 643k, False: 12.7k] | Branch (637:27): [True: 631k, False: 11.6k] ------------------ 638| 631k| --overlap; 639| 631k| } 640| 24.3k| return overlap; 641| 24.3k|} umutablecptrie.cpp:_ZNK6icu_7812_GLOBAL__N_111MixedBlocks9findBlockIttEEiPKT_PKT0_i: 823| 32.1k| int32_t findBlock(const UIntA *data, const UIntB *blockData, int32_t blockStart) const { 824| 32.1k| uint32_t hashCode = makeHashCode(blockData, blockStart); 825| 32.1k| int32_t entryIndex = findEntry(data, blockData, blockStart, hashCode); 826| 32.1k| if (entryIndex >= 0) { ------------------ | Branch (826:13): [True: 27.3k, False: 4.73k] ------------------ 827| 27.3k| return (table[entryIndex] & mask) - 1; 828| 27.3k| } else { 829| 4.73k| return -1; 830| 4.73k| } 831| 32.1k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_110getOverlapIttEEiPKT_iPKT0_ii: 633| 5.55k| const UIntB *q, int32_t qStart, int32_t blockLength) { 634| 5.55k| int32_t overlap = blockLength - 1; 635| 5.55k| U_ASSERT(overlap <= length); ------------------ | | 35| 5.55k|# define U_ASSERT(exp) (void)0 ------------------ 636| 5.55k| q += qStart; 637| 129k| while (overlap > 0 && !equalBlocks(p + (length - overlap), q, overlap)) { ------------------ | Branch (637:12): [True: 127k, False: 2.01k] | Branch (637:27): [True: 124k, False: 3.54k] ------------------ 638| 124k| --overlap; 639| 124k| } 640| 5.55k| return overlap; 641| 5.55k|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_113findSameBlockEPKtiiS2_ii: 592| 841| const uint16_t *q, int32_t qStart, int32_t blockLength) { 593| | // Ensure that we do not even partially get past length. 594| 841| length -= blockLength; 595| | 596| 841| q += qStart; 597| 717k| while (pStart <= length) { ------------------ | Branch (597:12): [True: 716k, False: 828] ------------------ 598| 716k| if (equalBlocks(p + pStart, q, blockLength)) { ------------------ | Branch (598:13): [True: 13, False: 716k] ------------------ 599| 13| return pStart; 600| 13| } 601| 716k| ++pStart; 602| 716k| } 603| 828| return -1; 604| 841|} umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_111MixedBlocksD2Ev: 767| 3.62k| ~MixedBlocks() { 768| 3.62k| uprv_free(table); ------------------ | | 1503| 3.62k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3.62k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.62k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.62k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 769| 3.62k| } umutablecptrie.cpp:_ZN6icu_7812_GLOBAL__N_120MutableCodePointTrie5clearEv: 261| 2.63k|void MutableCodePointTrie::clear() { 262| 2.63k| index3NullOffset = dataNullOffset = -1; 263| 2.63k| dataLength = 0; 264| 2.63k| highValue = initialValue = origInitialValue; 265| 2.63k| highStart = 0; 266| 2.63k| uprv_free(index16); ------------------ | | 1503| 2.63k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 267| 2.63k| index16 = nullptr; 268| 2.63k|} _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| 4.35k|umtx_lock(UMutex *mutex) { 113| 4.35k| if (mutex == nullptr) { ------------------ | Branch (113:9): [True: 21, False: 4.33k] ------------------ 114| 21| mutex = &globalMutex; 115| 21| } 116| 4.35k| mutex->lock(); 117| 4.35k|} umtx_unlock_78: 122| 4.35k|{ 123| 4.35k| if (mutex == nullptr) { ------------------ | Branch (123:9): [True: 21, False: 4.33k] ------------------ 124| 21| mutex = &globalMutex; 125| 21| } 126| 4.35k| mutex->unlock(); 127| 4.35k|} _ZN6icu_7820umtx_initImplPreInitERNS_9UInitOnceE: 145| 17|umtx_initImplPreInit(UInitOnce &uio) { 146| 17| std::call_once(*pInitFlag, umtx_init); 147| 17| std::unique_lock lock(*initMutex); 148| 17| if (umtx_loadAcquire(uio.fState) == 0) { ------------------ | Branch (148:9): [True: 17, False: 0] ------------------ 149| 17| umtx_storeRelease(uio.fState, 1); 150| 17| return true; // Caller will next call the init function. 151| 17| } 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| 17|} _ZN6icu_7821umtx_initImplPostInitERNS_9UInitOnceE: 170| 17|umtx_initImplPostInit(UInitOnce &uio) { 171| 17| { 172| 17| std::unique_lock lock(*initMutex); 173| 17| umtx_storeRelease(uio.fState, 2); 174| 17| } 175| 17| initCondition->notify_all(); 176| 17|} 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| 6.24M|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(UErrorCode &), UErrorCode &errCode) { 136| 6.24M| if (U_FAILURE(errCode)) { ------------------ | Branch (136:9): [True: 0, False: 6.24M] ------------------ 137| 0| return; 138| 0| } 139| 6.24M| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (139:9): [True: 2, False: 6.24M] | Branch (139:46): [True: 2, False: 0] ------------------ 140| | // We run the initialization. 141| 2| (*fp)(errCode); 142| 2| uio.fErrCode = errCode; 143| 2| umtx_initImplPostInit(uio); 144| 6.24M| } else { 145| | // Someone else already ran the initialization. 146| 6.24M| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (146:13): [True: 0, False: 6.24M] ------------------ 147| 0| errCode = uio.fErrCode; 148| 0| } 149| 6.24M| } 150| 6.24M|} _ZN6icu_7816umtx_loadAcquireERNSt3__16atomicIiEE: 75| 892M|inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 76| 892M| return var.load(std::memory_order_acquire); 77| 892M|} _ZN6icu_786UMutex4lockEv: 229| 4.35k| void lock() { 230| 4.35k| std::mutex *m = fMutex.load(std::memory_order_acquire); 231| 4.35k| if (m == nullptr) { m = getMutex(); } ------------------ | Branch (231:13): [True: 2, False: 4.35k] ------------------ 232| 4.35k| m->lock(); 233| 4.35k| } _ZN6icu_786UMutex6unlockEv: 234| 4.35k| void unlock() { fMutex.load(std::memory_order_relaxed)->unlock(); } _ZN6icu_7817umtx_storeReleaseERNSt3__16atomicIiEEi: 79| 34|inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 80| 34| var.store(val, std::memory_order_release); 81| 34|} _ZN6icu_7815umtx_atomic_incEPNSt3__16atomicIiEE: 83| 102k|inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) { 84| 102k| return var->fetch_add(1) + 1; 85| 102k|} _ZN6icu_7815umtx_atomic_decEPNSt3__16atomicIiEE: 87| 507k|inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) { 88| 507k| return var->fetch_sub(1) - 1; 89| 507k|} _ZN6icu_7813umtx_initOnceERNS_9UInitOnceEPFvvE: 123| 1|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)()) { 124| 1| if (umtx_loadAcquire(uio.fState) == 2) { ------------------ | Branch (124:9): [True: 0, False: 1] ------------------ 125| 0| return; 126| 0| } 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| 109k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 109k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 109k] ------------------ 168| 0| return; 169| 0| } 170| 109k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 7, False: 109k] | Branch (170:46): [True: 7, False: 0] ------------------ 171| | // We run the initialization. 172| 7| (*fp)(context, errCode); 173| 7| uio.fErrCode = errCode; 174| 7| umtx_initImplPostInit(uio); 175| 109k| } else { 176| | // Someone else already ran the initialization. 177| 109k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 109k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 109k| } 181| 109k|} _ZN6icu_7813umtx_initOnceI9UPropertyEEvRNS_9UInitOnceEPFvT_R10UErrorCodeES4_S6_: 166| 20.2k|template void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 167| 20.2k| if (U_FAILURE(errCode)) { ------------------ | Branch (167:9): [True: 0, False: 20.2k] ------------------ 168| 0| return; 169| 0| } 170| 20.2k| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (170:9): [True: 7, False: 20.2k] | Branch (170:46): [True: 7, False: 0] ------------------ 171| | // We run the initialization. 172| 7| (*fp)(context, errCode); 173| 7| uio.fErrCode = errCode; 174| 7| umtx_initImplPostInit(uio); 175| 20.2k| } else { 176| | // Someone else already ran the initialization. 177| 20.2k| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (177:13): [True: 0, False: 20.2k] ------------------ 178| 0| errCode = uio.fErrCode; 179| 0| } 180| 20.2k| } 181| 20.2k|} u_charFromName_78: 1521| 8.60k| UErrorCode *pErrorCode) { 1522| 8.60k| char upper[120] = {0}; 1523| 8.60k| char lower[120] = {0}; 1524| 8.60k| FindName findName; 1525| 8.60k| AlgorithmicRange *algRange; 1526| 8.60k| uint32_t *p; 1527| 8.60k| uint32_t i; 1528| 8.60k| UChar32 cp = 0; 1529| 8.60k| char c0; 1530| 8.60k| static constexpr UChar32 error = 0xffff; /* Undefined, but use this for backwards compatibility. */ 1531| | 1532| 8.60k| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1532:8): [True: 0, False: 8.60k] | Branch (1532:31): [True: 0, False: 8.60k] ------------------ 1533| 0| return error; 1534| 0| } 1535| | 1536| 8.60k| if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT || name==nullptr || *name==0) { ------------------ | Branch (1536:8): [True: 0, False: 8.60k] | Branch (1536:48): [True: 0, False: 8.60k] | Branch (1536:65): [True: 9, False: 8.60k] ------------------ 1537| 9| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1538| 9| return error; 1539| 9| } 1540| | 1541| 8.60k| if(!isDataLoaded(pErrorCode)) { ------------------ | Branch (1541:8): [True: 0, False: 8.60k] ------------------ 1542| 0| return error; 1543| 0| } 1544| | 1545| | /* construct the uppercase and lowercase of the name first */ 1546| 33.2k| for(i=0; i') { ------------------ | Branch (1564:13): [True: 68, False: 0] | Branch (1564:51): [True: 64, False: 4] ------------------ 1565| | // Parse a string like "" where HHHH is a hex code point. 1566| 64| uint32_t limit = i; 1567| 706| while (i >= 3 && lower[--i] != '-') {} ------------------ | Branch (1567:20): [True: 687, False: 19] | Branch (1567:30): [True: 642, False: 45] ------------------ 1568| | 1569| | // There should be 1 to 8 hex digits. 1570| 64| int32_t hexLength = limit - (i + 1); 1571| 64| if (i >= 2 && lower[i] == '-' && 1 <= hexLength && hexLength <= 8) { ------------------ | Branch (1571:17): [True: 63, False: 1] | Branch (1571:27): [True: 45, False: 18] | Branch (1571:46): [True: 44, False: 1] | Branch (1571:64): [True: 42, False: 2] ------------------ 1572| 42| uint32_t cIdx; 1573| | 1574| 42| lower[i] = 0; 1575| | 1576| 178| for (++i; i < limit; ++i) { ------------------ | Branch (1576:27): [True: 145, False: 33] ------------------ 1577| 145| if (lower[i] >= '0' && lower[i] <= '9') { ------------------ | Branch (1577:25): [True: 142, False: 3] | Branch (1577:44): [True: 59, False: 83] ------------------ 1578| 59| cp = (cp << 4) + lower[i] - '0'; 1579| 86| } else if (lower[i] >= 'a' && lower[i] <= 'f') { ------------------ | Branch (1579:32): [True: 82, False: 4] | Branch (1579:51): [True: 80, False: 2] ------------------ 1580| 80| cp = (cp << 4) + lower[i] - 'a' + 10; 1581| 80| } else { 1582| 6| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1583| 6| return error; 1584| 6| } 1585| | // Prevent signed-integer overflow and out-of-range code points. 1586| 139| if (cp > UCHAR_MAX_VALUE) { ------------------ | | 168| 139|#define UCHAR_MAX_VALUE 0x10ffff ------------------ | Branch (1586:25): [True: 3, False: 136] ------------------ 1587| 3| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1588| 3| return error; 1589| 3| } 1590| 139| } 1591| | 1592| | /* Now validate the category name. 1593| | We could use a binary search, or a trie, if 1594| | we really wanted to. */ 1595| 33| uint8_t cat = getCharCat(cp); 1596| 1.12k| for (lower[i] = 0, cIdx = 0; cIdx < UPRV_LENGTHOF(charCatNames); ++cIdx) { ------------------ | | 99| 1.12k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1596:46): [True: 1.08k, False: 33] ------------------ 1597| | 1598| 1.08k| if (!uprv_strcmp(lower + 1, charCatNames[cIdx])) { ------------------ | | 38| 1.08k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.08k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1598:25): [True: 0, False: 1.08k] ------------------ 1599| 0| if (cat == cIdx) { ------------------ | Branch (1599:29): [True: 0, False: 0] ------------------ 1600| 0| return cp; 1601| 0| } 1602| 0| break; 1603| 0| } 1604| 1.08k| } 1605| 33| } 1606| 64| } 1607| | 1608| 59| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1609| 59| return error; 1610| 68| } 1611| | 1612| | /* try algorithmic names now */ 1613| 8.53k| p=(uint32_t *)((uint8_t *)uCharNames+uCharNames->algNamesOffset); 1614| 8.53k| i=*p; 1615| 8.53k| algRange=(AlgorithmicRange *)(p+1); 1616| 119k| while(i>0) { ------------------ | Branch (1616:11): [True: 110k, False: 8.53k] ------------------ 1617| 110k| if((cp=findAlgName(algRange, nameChoice, upper))!=0xffff) { ------------------ | Branch (1617:12): [True: 0, False: 110k] ------------------ 1618| 0| return cp; 1619| 0| } 1620| 110k| algRange=(AlgorithmicRange *)((uint8_t *)algRange+algRange->size); 1621| 110k| --i; 1622| 110k| } 1623| | 1624| | /* normal character name */ 1625| 8.53k| findName.otherName=upper; 1626| 8.53k| findName.code=error; 1627| 8.53k| enumNames(uCharNames, 0, UCHAR_MAX_VALUE + 1, DO_FIND_NAME, &findName, nameChoice); ------------------ | | 168| 8.53k|#define UCHAR_MAX_VALUE 0x10ffff ------------------ enumNames(uCharNames, 0, UCHAR_MAX_VALUE + 1, DO_FIND_NAME, &findName, nameChoice); ------------------ | | 104| 8.53k|#define DO_FIND_NAME nullptr ------------------ 1628| 8.53k| if (findName.code == error) { ------------------ | Branch (1628:9): [True: 105, False: 8.42k] ------------------ 1629| 105| *pErrorCode = U_ILLEGAL_CHAR_FOUND; 1630| 105| } 1631| 8.53k| return findName.code; 1632| 8.53k|} unames.cpp:_ZN6icu_78L12isDataLoadedEP10UErrorCode: 210| 8.60k|isDataLoaded(UErrorCode *pErrorCode) { 211| 8.60k| umtx_initOnce(gCharNamesInitOnce, &loadCharNames, *pErrorCode); 212| 8.60k| return U_SUCCESS(*pErrorCode); 213| 8.60k|} 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| 8.53k|getGroup(UCharNames *names, uint32_t code) { 484| 8.53k| const uint16_t *groups=GET_GROUPS(names); ------------------ | | 97| 8.53k|#define GET_GROUPS(names) (const uint16_t *)((const char *)names+names->groupsOffset) ------------------ 485| 8.53k| uint16_t groupMSB = static_cast(code >> GROUP_SHIFT), ------------------ | | 41| 8.53k|#define GROUP_SHIFT 5 ------------------ 486| 8.53k| start=0, 487| 8.53k| limit=*groups++, 488| 8.53k| number; 489| | 490| | /* binary search for the group of names that contains the one for code */ 491| 93.8k| while(start((start + limit) / 2); 493| 85.3k| if(groupMSB=0xfdd0 && \ | | ------------------ | | | Branch (131:6): [True: 13, False: 20] | | ------------------ | | 132| 33| ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff) | | ------------------ | | | Branch (132:7): [True: 2, False: 11] | | | Branch (132:22): [True: 0, False: 11] | | | Branch (132:47): [True: 2, False: 0] | | ------------------ ------------------ 425| 2| return U_NONCHARACTER_CODE_POINT; ------------------ | | 121| 2|#define U_NONCHARACTER_CODE_POINT U_CHAR_CATEGORY_COUNT ------------------ 426| 2| } 427| | 428| 31| if ((cat = u_charType(cp)) == U_SURROGATE) { ------------------ | | 225| 31|#define u_charType U_ICU_ENTRY_POINT_RENAME(u_charType) | | ------------------ | | | | 123| 31|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 31|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 31|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (428:9): [True: 2, False: 29] ------------------ 429| 2| cat = U_IS_LEAD(cp) ? U_LEAD_SURROGATE : U_TRAIL_SURROGATE; ------------------ | | 177| 2|#define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (177:22): [True: 2, False: 0] | | ------------------ ------------------ cat = U_IS_LEAD(cp) ? U_LEAD_SURROGATE : U_TRAIL_SURROGATE; ------------------ | | 122| 2|#define U_LEAD_SURROGATE U_CHAR_CATEGORY_COUNT + 1 ------------------ cat = U_IS_LEAD(cp) ? U_LEAD_SURROGATE : U_TRAIL_SURROGATE; ------------------ | | 123| 2|#define U_TRAIL_SURROGATE U_CHAR_CATEGORY_COUNT + 2 ------------------ 430| 2| } 431| | 432| 31| return cat; 433| 33|} unames.cpp:_ZN6icu_78L11findAlgNameEPNS_16AlgorithmicRangeE15UCharNameChoicePKc: 1078| 110k|findAlgName(AlgorithmicRange *range, UCharNameChoice nameChoice, const char *otherName) { 1079| 110k| UChar32 code; 1080| | 1081| 110k| if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) { ------------------ | Branch (1081:8): [True: 110k, False: 0] | Branch (1081:43): [True: 0, False: 110k] ------------------ 1082| 0| return 0xffff; 1083| 0| } 1084| | 1085| 110k| switch(range->type) { 1086| 102k| case 0: { ------------------ | Branch (1086:5): [True: 102k, False: 8.53k] ------------------ 1087| | /* name = prefix hex-digits */ 1088| 102k| const char* s = reinterpret_cast(range + 1); 1089| 102k| char c; 1090| | 1091| 102k| uint16_t i, count; 1092| | 1093| | /* compare prefix */ 1094| 102k| while((c=*s++)!=0) { ------------------ | Branch (1094:15): [True: 102k, False: 0] ------------------ 1095| 102k| if (c != *otherName++) { ------------------ | Branch (1095:17): [True: 102k, False: 58] ------------------ 1096| 102k| return 0xffff; 1097| 102k| } 1098| 102k| } 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| 8.53k| case 1: { ------------------ | Branch (1120:5): [True: 8.53k, False: 102k] ------------------ 1121| 8.53k| char buffer[64]; 1122| 8.53k| uint16_t indexes[8]; 1123| 8.53k| const char *elementBases[8], *elements[8]; 1124| 8.53k| const uint16_t* factors = reinterpret_cast(range + 1); 1125| 8.53k| uint16_t count=range->variant; 1126| 8.53k| const char *s = reinterpret_cast(factors + count), *t; 1127| 8.53k| UChar32 start, limit; 1128| 8.53k| uint16_t i, idx; 1129| | 1130| 8.53k| char c; 1131| | 1132| | /* name = prefix factorized-elements */ 1133| | 1134| | /* compare prefix */ 1135| 8.53k| while((c=*s++)!=0) { ------------------ | Branch (1135:15): [True: 8.53k, False: 0] ------------------ 1136| 8.53k| if (c != *otherName++) { ------------------ | Branch (1136:17): [True: 8.53k, False: 6] ------------------ 1137| 8.53k| return 0xffff; 1138| 8.53k| } 1139| 8.53k| } 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| 8.53k|#define GROUP_SHIFT 5 ------------------ 675| 8.53k| endGroupMSB = static_cast((limit - 1) >> GROUP_SHIFT); ------------------ | | 41| 8.53k|#define GROUP_SHIFT 5 ------------------ 676| | 677| | /* find the group that contains start, or the highest before it */ 678| 8.53k| group=getGroup(names, start); 679| | 680| 8.53k| if(startGroupMSB(group[GROUP_MSB]) << GROUP_SHIFT; ------------------ | | 41| 8.53k|#define GROUP_SHIFT 5 ------------------ 683| 8.53k| if(extLimit>limit) { ------------------ | Branch (683:12): [True: 0, False: 8.53k] ------------------ 684| 0| extLimit=limit; 685| 0| } 686| 8.53k| if(!enumExtNames(start, extLimit-1, fn, context)) { ------------------ | Branch (686:12): [True: 0, False: 8.53k] ------------------ 687| 0| return false; 688| 0| } 689| 8.53k| start=extLimit; 690| 8.53k| } 691| | 692| 8.53k| if(startGroupMSB==endGroupMSB) { ------------------ | Branch (692:8): [True: 0, False: 8.53k] ------------------ 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| 8.53k| } else { 698| 8.53k| const uint16_t *groups=GET_GROUPS(names); ------------------ | | 97| 8.53k|#define GET_GROUPS(names) (const uint16_t *)((const char *)names+names->groupsOffset) ------------------ 699| 8.53k| groupCount=*groups++; 700| 8.53k| groupLimit=groups+groupCount*GROUP_LENGTH; 701| | 702| 8.53k| if(startGroupMSB==group[GROUP_MSB]) { ------------------ | Branch (702:12): [True: 0, False: 8.53k] ------------------ 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: 8.53k] ------------------ 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| 10.9M| while(group(group[GROUP_MSB]) << GROUP_SHIFT; ------------------ | | 41| 10.9M|#define GROUP_SHIFT 5 ------------------ 731| 10.9M| if(!enumGroupNames(names, group, start, start+LINES_PER_GROUP-1, fn, context, nameChoice)) { ------------------ | | 42| 10.9M|#define LINES_PER_GROUP (1L< group[GROUP_MSB] + 1 && nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (735:17): [True: 10.9M, False: 105] | Branch (735:43): [True: 528k, False: 10.3M] | Branch (735:90): [True: 528k, False: 0] ------------------ 736| 528k| UChar32 end = nextGroup[GROUP_MSB] << GROUP_SHIFT; ------------------ | | 41| 528k|#define GROUP_SHIFT 5 ------------------ 737| 528k| if (end > limit) { ------------------ | Branch (737:21): [True: 0, False: 528k] ------------------ 738| 0| end = limit; 739| 0| } 740| 528k| if (!enumExtNames((group[GROUP_MSB] + 1) << GROUP_SHIFT, end - 1, fn, context)) { ------------------ | | 41| 528k|#define GROUP_SHIFT 5 ------------------ | Branch (740:21): [True: 0, False: 528k] ------------------ 741| 0| return false; 742| 0| } 743| 528k| } 744| 10.9M| group=nextGroup; 745| 10.9M| } 746| | 747| | /* enumerate within the end group (group[GROUP_MSB]==endGroupMSB) */ 748| 105| if(group start) { ------------------ | Branch (752:17): [True: 105, False: 0] ------------------ 753| 105| start = next; 754| 105| } 755| 105| } else { 756| 0| return true; 757| 0| } 758| 105| } 759| | 760| | /* we have not found a group, which means everything is made of 761| | extended names. */ 762| 105| if (nameChoice == U_EXTENDED_CHAR_NAME) { ------------------ | Branch (762:9): [True: 105, False: 0] ------------------ 763| 105| if (limit > UCHAR_MAX_VALUE + 1) { ------------------ | | 168| 105|#define UCHAR_MAX_VALUE 0x10ffff ------------------ | Branch (763:13): [True: 0, False: 105] ------------------ 764| 0| limit = UCHAR_MAX_VALUE + 1; ------------------ | | 168| 0|#define UCHAR_MAX_VALUE 0x10ffff ------------------ 765| 0| } 766| 105| return enumExtNames(start, limit - 1, fn, context); 767| 105| } 768| | 769| 0| return true; 770| 105|} unames.cpp:_ZN6icu_78L12enumExtNamesEiiPFaPvi15UCharNameChoicePKciES0_: 646| 537k|{ 647| 537k| if(fn!=DO_FIND_NAME) { ------------------ | | 104| 537k|#define DO_FIND_NAME nullptr ------------------ | Branch (647:8): [True: 0, False: 537k] ------------------ 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| 537k| return true; 664| 537k|} unames.cpp:_ZN6icu_78L14enumGroupNamesEPNS_10UCharNamesEPKtiiPFaPvi15UCharNameChoicePKciES4_S5_: 602| 10.9M| UCharNameChoice nameChoice) { 603| 10.9M| uint16_t offsets[LINES_PER_GROUP+2], lengths[LINES_PER_GROUP+2]; 604| 10.9M| const uint8_t* s = reinterpret_cast(names) + names->groupStringOffset + GET_GROUP_OFFSET(group); ------------------ | | 73| 10.9M|#define GET_GROUP_OFFSET(group) ((int32_t)(group)[GROUP_OFFSET_HIGH]<<16|(group)[GROUP_OFFSET_LOW]) ------------------ 605| | 606| 10.9M| s=expandGroupLengths(s, offsets, lengths); 607| 10.9M| if(fn!=DO_FIND_NAME) { ------------------ | | 104| 10.9M|#define DO_FIND_NAME nullptr ------------------ | Branch (607:8): [True: 0, False: 10.9M] ------------------ 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| 10.9M| } else { 625| 10.9M| const char* otherName = static_cast(context)->otherName; 626| 360M| while(start<=end) { ------------------ | Branch (626:15): [True: 349M, False: 10.9M] ------------------ 627| 349M| if(compareName(names, s+offsets[start&GROUP_MASK], lengths[start&GROUP_MASK], nameChoice, otherName)) { ------------------ | | 43| 349M|#define GROUP_MASK (LINES_PER_GROUP-1) | | ------------------ | | | | 42| 349M|#define LINES_PER_GROUP (1L<(context)->code = start; 629| 8.42k| return false; 630| 8.42k| } 631| 349M| ++start; 632| 349M| } 633| 10.9M| } 634| 10.9M| return true; 635| 10.9M|} unames.cpp:_ZN6icu_78L11compareNameEPNS_10UCharNamesEPKht15UCharNameChoicePKc: 333| 349M| const char *otherName) { 334| 349M| uint16_t* tokens = reinterpret_cast(names) + 8; 335| 349M| uint16_t token, tokenCount=*tokens++; 336| 349M| uint8_t* tokenStrings = reinterpret_cast(names) + names->tokenStringOffset; 337| 349M| uint8_t c; 338| 349M| const char *origOtherName = otherName; 339| | 340| 349M| if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) { ------------------ | Branch (340:8): [True: 349M, False: 0] | Branch (340:43): [True: 0, False: 349M] ------------------ 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| 349M| while(nameLength>0) { ------------------ | Branch (366:11): [True: 319M, False: 30.6M] ------------------ 367| 319M| --nameLength; 368| 319M| c=*name++; 369| | 370| 319M| if(c>=tokenCount) { ------------------ | Branch (370:12): [True: 0, False: 319M] ------------------ 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| 319M| } else { 381| 319M| token=tokens[c]; 382| 319M| if (token == static_cast(-2)) { ------------------ | Branch (382:17): [True: 60.7M, False: 258M] ------------------ 383| | /* this is a lead byte for a double-byte token */ 384| 60.7M| token=tokens[c<<8|*name++]; 385| 60.7M| --nameLength; 386| 60.7M| } 387| 319M| if (token == static_cast(-1)) { ------------------ | Branch (387:17): [True: 5.42M, False: 313M] ------------------ 388| 5.42M| if(c!=';') { ------------------ | Branch (388:20): [True: 5.42M, False: 0] ------------------ 389| | /* explicit letter */ 390| 5.42M| if (static_cast(c) != *otherName++) { ------------------ | Branch (390:25): [True: 5.10M, False: 315k] ------------------ 391| 5.10M| return false; 392| 5.10M| } 393| 5.42M| } 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| 313M| } else { 406| | /* write token word */ 407| 313M| uint8_t *tokenString=tokenStrings+token; 408| 331M| while((c=*tokenString++)!=0) { ------------------ | Branch (408:23): [True: 331M, False: 573] ------------------ 409| 331M| if (static_cast(c) != *otherName++) { ------------------ | Branch (409:25): [True: 313M, False: 17.8M] ------------------ 410| 313M| return false; 411| 313M| } 412| 331M| } 413| 313M| } 414| 319M| } 415| 319M| } 416| | 417| | /* complete match? */ 418| 30.6M| return *otherName == 0; 419| 349M|} unames.cpp:_ZN6icu_78L18expandGroupLengthsEPKhPtS2_: 516| 10.9M| 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| 10.9M| uint16_t i=0, offset=0, length=0; 519| 10.9M| uint8_t lengthByte; 520| | 521| | /* all 32 lengths must be read to get the offset of the first group string */ 522| 195M| while(i=12) { ------------------ | Branch (526:12): [True: 7.39M, False: 177M] ------------------ 527| | /* double-nibble length spread across two bytes */ 528| 7.39M| length = static_cast(((length & 0x3) << 4 | lengthByte >> 4) + 12); 529| 7.39M| lengthByte&=0xf; 530| 177M| } else if((lengthByte /* &0xf0 */)>=0xc0) { ------------------ | Branch (530:19): [True: 10.1M, False: 167M] ------------------ 531| | /* double-nibble length spread across this one byte */ 532| 10.1M| length = static_cast((lengthByte & 0x3f) + 12); 533| 167M| } else { 534| | /* single-nibble length in MSBs */ 535| 167M| length = static_cast(lengthByte >> 4); 536| 167M| lengthByte&=0xf; 537| 167M| } 538| | 539| 184M| *offsets++=offset; 540| 184M| *lengths++=length; 541| | 542| 184M| offset+=length; 543| 184M| ++i; 544| | 545| | /* read odd nibble - LSBs of lengthByte */ 546| 184M| if((lengthByte&0xf0)==0) { ------------------ | Branch (546:12): [True: 174M, False: 10.1M] ------------------ 547| | /* this nibble was not consumed for a double-nibble length above */ 548| 174M| length=lengthByte; 549| 174M| if(length<12) { ------------------ | Branch (549:16): [True: 167M, False: 7.39M] ------------------ 550| | /* single-nibble length in LSBs */ 551| 167M| *offsets++=offset; 552| 167M| *lengths++=length; 553| | 554| 167M| offset+=length; 555| 167M| ++i; 556| 167M| } 557| 174M| } else { 558| 10.1M| length=0; /* prevent double-nibble detection in the next iteration */ 559| 10.1M| } 560| 184M| } 561| | 562| | /* now, s is at the first group string */ 563| 10.9M| return s; 564| 10.9M|} _ZN6icu_789BytesTrieC2EPKv: 72| 223k| : ownedArray_(nullptr), bytes_(static_cast(trieBytes)), 73| 223k| pos_(bytes_), remainingMatchLength_(-1) {} _ZNK6icu_789BytesTrie8getValueEv: 246| 151k| inline int32_t getValue() const { 247| 151k| const uint8_t *pos=pos_; 248| 151k| int32_t leadByte=*pos++; 249| | // U_ASSERT(leadByte>=kMinValueLead); 250| 151k| return readValue(pos, leadByte>>1); 251| 151k| } _ZN6icu_789BytesTrie4stopEv: 399| 61.6k| inline void stop() { 400| 61.6k| pos_=nullptr; 401| 61.6k| } _ZN6icu_789BytesTrie9skipValueEPKhi: 406| 418k| static inline const uint8_t *skipValue(const uint8_t *pos, int32_t leadByte) { 407| | // U_ASSERT(leadByte>=kMinValueLead); 408| 418k| if(leadByte>=(kMinTwoByteValueLead<<1)) { ------------------ | Branch (408:12): [True: 277k, False: 141k] ------------------ 409| 277k| if(leadByte<(kMinThreeByteValueLead<<1)) { ------------------ | Branch (409:16): [True: 246k, False: 31.0k] ------------------ 410| 246k| ++pos; 411| 246k| } else if(leadByte<(kFourByteValueLead<<1)) { ------------------ | Branch (411:23): [True: 13.0k, False: 18.0k] ------------------ 412| 13.0k| pos+=2; 413| 18.0k| } else { 414| 18.0k| pos+=3+((leadByte>>1)&1); 415| 18.0k| } 416| 277k| } 417| 418k| return pos; 418| 418k| } _ZN6icu_789BytesTrie9skipValueEPKh: 419| 375k| static inline const uint8_t *skipValue(const uint8_t *pos) { 420| 375k| int32_t leadByte=*pos++; 421| 375k| return skipValue(pos, leadByte); 422| 375k| } _ZN6icu_789BytesTrie9skipDeltaEPKh: 427| 242k| static inline const uint8_t *skipDelta(const uint8_t *pos) { 428| 242k| int32_t delta=*pos++; 429| 242k| if(delta>=kMinTwoByteDeltaLead) { ------------------ | Branch (429:12): [True: 191k, False: 51.5k] ------------------ 430| 191k| if(delta(USTRINGTRIE_INTERMEDIATE_VALUE - (node & kValueIsFinal)); 443| 164k| } _ZN6icu_7814ConstChar16PtrC2EPKDs: 229| 207k|ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) : p_(p) {} _ZN6icu_7814ConstChar16PtrD2Ev: 237| 207k|ConstChar16Ptr::~ConstChar16Ptr() { 238| 207k| U_ALIASING_BARRIER(p_); ------------------ | | 35| 207k|# define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory") ------------------ 239| 207k|} _ZNK6icu_7814ConstChar16PtrcvPKDsEv: 205| 218k| inline operator const char16_t *() const { return get(); } _ZNK6icu_7814ConstChar16Ptr3getEv: 241| 218k|const char16_t *ConstChar16Ptr::get() const { return p_; } _ZN6icu_788internal15toU16StringViewENSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 400| 47.6k|inline std::u16string_view toU16StringView(std::u16string_view sv) { return sv; } _ZN6icu_788internal23toU16StringViewNullableIA6_DsvEENSt3__117basic_string_viewIDsNS3_11char_traitsIDsEEEERKT_: 430| 8.41k|inline std::u16string_view toU16StringViewNullable(const T& text) { 431| 8.41k| return toU16StringView(text); 432| 8.41k|} _ZN6icu_788internal23toU16StringViewNullableIA40_DsvEENSt3__117basic_string_viewIDsNS3_11char_traitsIDsEEEERKT_: 430| 8.41k|inline std::u16string_view toU16StringViewNullable(const T& text) { 431| 8.41k| return toU16StringView(text); 432| 8.41k|} _ZN6icu_788internal23toU16StringViewNullableIA14_DsvEENSt3__117basic_string_viewIDsNS3_11char_traitsIDsEEEERKT_: 430| 8.41k|inline std::u16string_view toU16StringViewNullable(const T& text) { 431| 8.41k| return toU16StringView(text); 432| 8.41k|} _ZN6icu_788internal23toU16StringViewNullableIA9_DsvEENSt3__117basic_string_viewIDsNS3_11char_traitsIDsEEEERKT_: 430| 8.41k|inline std::u16string_view toU16StringViewNullable(const T& text) { 431| 8.41k| return toU16StringView(text); 432| 8.41k|} _ZN6icu_788internal23toU16StringViewNullableIA4_DsvEENSt3__117basic_string_viewIDsNS3_11char_traitsIDsEEEERKT_: 430| 5.35k|inline std::u16string_view toU16StringViewNullable(const T& text) { 431| 5.35k| return toU16StringView(text); 432| 5.35k|} _ZN6icu_7824ForwardCharacterIteratoraSERKS0_: 189| 2.63k| ForwardCharacterIterator &operator=(const ForwardCharacterIterator&) { return *this; } _ZN6icu_7812LocalPointerINS_22RuleBasedBreakIteratorEEC2EPS1_: 200| 8.41k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIteratorEEC2EPS1_: 82| 8.41k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_22RuleBasedBreakIteratorEED2Ev: 245| 8.41k| ~LocalPointer() { 246| 8.41k| delete LocalPointerBase::ptr; 247| 8.41k| } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIteratorEED2Ev: 88| 8.41k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7812LocalPointerINS_7UVectorEEC2EPS1_R10UErrorCode: 214| 2.67k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 2.67k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 2.67k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 2.67k| } _ZN6icu_7816LocalPointerBaseINS_7UVectorEEC2EPS1_: 82| 2.67k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_7UVectorEED2Ev: 245| 2.67k| ~LocalPointer() { 246| 2.67k| delete LocalPointerBase::ptr; 247| 2.67k| } _ZN6icu_7816LocalPointerBaseINS_7UVectorEED2Ev: 88| 2.67k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7812LocalPointerINS_13UnicodeStringEEC2EPS1_R10UErrorCode: 214| 78.6k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 78.6k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 78.6k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 78.6k| } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEEC2EPS1_: 82| 177k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_13UnicodeStringEED2Ev: 245| 177k| ~LocalPointer() { 246| 177k| delete LocalPointerBase::ptr; 247| 177k| } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEED2Ev: 88| 177k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7816LocalPointerBaseINS_13UnicodeStringEE6orphanEv: 141| 177k| T *orphan() { 142| 177k| T *p=ptr; 143| 177k| ptr=nullptr; 144| 177k| return p; 145| 177k| } _ZN6icu_7816LocalPointerBaseINS_7UVectorEE6orphanEv: 141| 2.63k| T *orphan() { 142| 2.63k| T *p=ptr; 143| 2.63k| ptr=nullptr; 144| 2.63k| return p; 145| 2.63k| } _ZN6icu_7812LocalPointerINS_22RuleBasedBreakIterator15DictionaryCacheEEC2EPS2_R10UErrorCode: 214| 11.0k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 11.0k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 11.0k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 11.0k| } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIterator15DictionaryCacheEEC2EPS2_: 82| 11.0k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_22RuleBasedBreakIterator15DictionaryCacheEED2Ev: 245| 11.0k| ~LocalPointer() { 246| 11.0k| delete LocalPointerBase::ptr; 247| 11.0k| } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIterator15DictionaryCacheEED2Ev: 88| 11.0k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7812LocalPointerINS_22RuleBasedBreakIterator10BreakCacheEEC2EPS2_R10UErrorCode: 214| 11.0k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 11.0k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 11.0k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 11.0k| } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIterator10BreakCacheEEC2EPS2_: 82| 11.0k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_22RuleBasedBreakIterator10BreakCacheEED2Ev: 245| 11.0k| ~LocalPointer() { 246| 11.0k| delete LocalPointerBase::ptr; 247| 11.0k| } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIterator10BreakCacheEED2Ev: 88| 11.0k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIterator15DictionaryCacheEE6orphanEv: 141| 11.0k| T *orphan() { 142| 11.0k| T *p=ptr; 143| 11.0k| ptr=nullptr; 144| 11.0k| return p; 145| 11.0k| } _ZN6icu_7816LocalPointerBaseINS_22RuleBasedBreakIterator10BreakCacheEE6orphanEv: 141| 11.0k| T *orphan() { 142| 11.0k| T *p=ptr; 143| 11.0k| ptr=nullptr; 144| 11.0k| return p; 145| 11.0k| } _ZN6icu_7816LocalPointerBaseINS_14RBBIDataHeaderEEC2EPS1_: 82| 2.63k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7816LocalPointerBaseINS_14RBBIDataHeaderEED2Ev: 88| 2.63k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseINS_14RBBIDataHeaderEE6isNullEv: 94| 2.63k| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseINS_14RBBIDataHeaderEE8getAliasEv: 122| 15.8k| T *getAlias() const { return ptr; } _ZNK6icu_7816LocalPointerBaseINS_14RBBIDataHeaderEEptEv: 134| 79.0k| T *operator->() const { return ptr; } _ZN6icu_7816LocalPointerBaseINS_14RBBIDataHeaderEE6orphanEv: 141| 2.63k| T *orphan() { 142| 2.63k| T *p=ptr; 143| 2.63k| ptr=nullptr; 144| 2.63k| return p; 145| 2.63k| } _ZN6icu_7812LocalPointerINS_10UnicodeSetEEC2EPS1_R10UErrorCode: 214| 20.2k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 20.2k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 20.2k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 20.2k| } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEEC2EPS1_: 82| 20.3k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7812LocalPointerINS_10UnicodeSetEED2Ev: 245| 20.3k| ~LocalPointer() { 246| 20.3k| delete LocalPointerBase::ptr; 247| 20.3k| } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEED2Ev: 88| 20.3k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEEptEv: 134| 34.9k| T *operator->() const { return ptr; } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEEdeEv: 128| 16.3k| T &operator*() const { return *ptr; } _ZN6icu_7816LocalPointerBaseINS_10UnicodeSetEE6orphanEv: 141| 16.1k| T *orphan() { 142| 16.1k| T *p=ptr; 143| 16.1k| ptr=nullptr; 144| 16.1k| return p; 145| 16.1k| } umutablecptrie.cpp:_ZN6icu_7812LocalPointerINS_12_GLOBAL__N_120MutableCodePointTrieEEC2EPS2_R10UErrorCode: 214| 2.63k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 2.63k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 2.63k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 2.63k| } umutablecptrie.cpp:_ZN6icu_7816LocalPointerBaseINS_12_GLOBAL__N_120MutableCodePointTrieEEC2EPS2_: 82| 2.63k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} umutablecptrie.cpp:_ZN6icu_7812LocalPointerINS_12_GLOBAL__N_120MutableCodePointTrieEED2Ev: 245| 2.63k| ~LocalPointer() { 246| 2.63k| delete LocalPointerBase::ptr; 247| 2.63k| } umutablecptrie.cpp:_ZN6icu_7816LocalPointerBaseINS_12_GLOBAL__N_120MutableCodePointTrieEED2Ev: 88| 2.63k| ~LocalPointerBase() { /* delete ptr; */ } umutablecptrie.cpp:_ZN6icu_7816LocalPointerBaseINS_12_GLOBAL__N_120MutableCodePointTrieEE6orphanEv: 141| 2.63k| T *orphan() { 142| 2.63k| T *p=ptr; 143| 2.63k| ptr=nullptr; 144| 2.63k| return p; 145| 2.63k| } _ZN6icu_7812LocalPointerINS_13UnicodeStringEEC2EPS1_: 200| 98.4k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZNK6icu_7816LocalPointerBaseINS_13UnicodeStringEE6isNullEv: 94| 98.4k| UBool isNull() const { return ptr==nullptr; } _ZN6icu_7812LocalPointerINS_10UnicodeSetEEC2EPS1_: 200| 37| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEE6isNullEv: 94| 37| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseINS_10UnicodeSetEE8getAliasEv: 122| 7| T *getAlias() const { return ptr; } _ZN6icu_7813ParsePositionC2Ev: 59| 20.2k| : UObject(), 60| 20.2k| index(0), 61| 20.2k| errorIndex(-1) 62| 20.2k| {} _ZN6icu_7813ParsePositionC2Ei: 70| 192k| : UObject(), 71| 192k| index(newIndex), 72| 192k| errorIndex(-1) 73| 192k| {} _ZNK6icu_7813ParsePosition8getIndexEv: 212| 153M|{ 213| 153M| return index; 214| 153M|} _ZN6icu_7813ParsePosition8setIndexEi: 218| 54.1M|{ 219| 54.1M| this->index = offset; 220| 54.1M|} _ZN6icu_7811ReplaceableC2Ev: 243| 17.2M|inline Replaceable::Replaceable() {} _ZN6icu_7811StringPieceC2EPKci: 151| 2.63k| StringPiece(const char* offset, int32_t len) : ptr_(offset), length_(len) { } _ZNK6icu_7811StringPiece4dataEv: 200| 2.64k| const char* data() const { return ptr_; } _ZNK6icu_7811StringPiece6lengthEv: 212| 2.64k| int32_t length() const { return length_; } _ZN6icu_7810UnicodeSet10setPatternERKNS_13UnicodeStringE: 1830| 49.9k| void setPattern(const UnicodeString& newPat) { 1831| 49.9k| setPattern(newPat.getBuffer(), newPat.length()); 1832| 49.9k| } _ZNK6icu_7810UnicodeSet8isFrozenEv: 1848| 36.8M|inline UBool UnicodeSet::isFrozen() const { 1849| 36.8M| return bmpSet != nullptr || stringSpan != nullptr; ------------------ | Branch (1849:12): [True: 0, False: 36.8M] | Branch (1849:33): [True: 0, False: 36.8M] ------------------ 1850| 36.8M|} _ZNK6icu_7810UnicodeSet7isBogusEv: 1864| 36.5M|inline UBool UnicodeSet::isBogus() const { 1865| 36.5M| return fFlags & kIsBogus; 1866| 36.5M|} _ZN6icu_7810UnicodeSet8fromUSetEPK4USet: 1872| 4.33k|inline const UnicodeSet *UnicodeSet::fromUSet(const USet *uset) { 1873| 4.33k| return reinterpret_cast(uset); 1874| 4.33k|} _ZNK6icu_7810UnicodeSet6toUSetEv: 1880| 4.33k|inline const USet *UnicodeSet::toUSet() const { 1881| 4.33k| return reinterpret_cast(this); 1882| 4.33k|} _ZNK6icu_7813UnicodeString8doEqualsERKS0_i: 3773| 4.70M| inline UBool doEquals(const UnicodeString &text, int32_t len) const { 3774| 4.70M| return doEquals(text.getArrayStart(), len); 3775| 4.70M| } _ZNK6icu_7813UnicodeString8pinIndexERi: 4138| 10.0M|{ 4139| | // pin index 4140| 10.0M| if(start < 0) { ------------------ | Branch (4140:6): [True: 0, False: 10.0M] ------------------ 4141| 0| start = 0; 4142| 10.0M| } else if(start > length()) { ------------------ | Branch (4142:13): [True: 0, False: 10.0M] ------------------ 4143| 0| start = length(); 4144| 0| } 4145| 10.0M|} _ZNK6icu_7813UnicodeString10pinIndicesERiS1_: 4150| 6.69M|{ 4151| | // pin indices 4152| 6.69M| int32_t len = length(); 4153| 6.69M| if(start < 0) { ------------------ | Branch (4153:6): [True: 0, False: 6.69M] ------------------ 4154| 0| start = 0; 4155| 6.69M| } else if(start > len) { ------------------ | Branch (4155:13): [True: 0, False: 6.69M] ------------------ 4156| 0| start = len; 4157| 0| } 4158| 6.69M| if(_length < 0) { ------------------ | Branch (4158:6): [True: 0, False: 6.69M] ------------------ 4159| 0| _length = 0; 4160| 6.69M| } else if(_length > (len - start)) { ------------------ | Branch (4160:13): [True: 170k, False: 6.51M] ------------------ 4161| 170k| _length = (len - start); 4162| 170k| } 4163| 6.69M|} _ZN6icu_7813UnicodeString13getArrayStartEv: 4166| 895M|UnicodeString::getArrayStart() { 4167| 895M| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4167:10): [True: 9.00M, False: 886M] ------------------ 4168| 886M| fUnion.fStackFields.fBuffer : fUnion.fFields.fArray; 4169| 895M|} _ZNK6icu_7813UnicodeString13getArrayStartEv: 4172| 1.16G|UnicodeString::getArrayStart() const { 4173| 1.16G| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4173:10): [True: 18.8M, False: 1.14G] ------------------ 4174| 1.14G| fUnion.fStackFields.fBuffer : fUnion.fFields.fArray; 4175| 1.16G|} _ZNK6icu_7813UnicodeString14hasShortLengthEv: 4202| 2.40G|UnicodeString::hasShortLength() const { 4203| 2.40G| return fUnion.fFields.fLengthAndFlags>=0; 4204| 2.40G|} _ZNK6icu_7813UnicodeString14getShortLengthEv: 4207| 1.24G|UnicodeString::getShortLength() const { 4208| | // fLengthAndFlags must be non-negative -> short length >= 0 4209| | // and arithmetic or logical shift does not matter. 4210| 1.24G| return fUnion.fFields.fLengthAndFlags>>kLengthShift; 4211| 1.24G|} _ZNK6icu_7813UnicodeString6lengthEv: 4214| 2.40G|UnicodeString::length() const { 4215| 2.40G| return hasShortLength() ? getShortLength() : fUnion.fFields.fLength; ------------------ | Branch (4215:10): [True: 1.24G, False: 1.16G] ------------------ 4216| 2.40G|} _ZNK6icu_7813UnicodeString11getCapacityEv: 4219| 1.21G|UnicodeString::getCapacity() const { 4220| 1.21G| return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ? ------------------ | Branch (4220:10): [True: 10.6M, False: 1.20G] ------------------ 4221| 1.20G| US_STACKBUF_SIZE : fUnion.fFields.fCapacity; 4222| 1.21G|} _ZNK6icu_7813UnicodeString8hashCodeEv: 4226| 4.85M|{ return doHashCode(); } _ZNK6icu_7813UnicodeString7isBogusEv: 4230| 17.4M|{ return fUnion.fFields.fLengthAndFlags & kIsBogus; } _ZNK6icu_7813UnicodeString10isWritableEv: 4234| 900M|{ return !(fUnion.fFields.fLengthAndFlags & (kOpenGetBuffer | kIsBogus)); } _ZNK6icu_7813UnicodeString16isBufferWritableEv: 4238| 571M|{ 4239| 571M| return 4240| 571M| !(fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kIsBogus|kBufferIsReadonly)) && ------------------ | Branch (4240:7): [True: 571M, False: 0] ------------------ 4241| 571M| (!(fUnion.fFields.fLengthAndFlags&kRefCounted) || refCount()==1); ------------------ | Branch (4241:8): [True: 7.44M, False: 563M] | Branch (4241:57): [True: 563M, False: 5.57k] ------------------ 4242| 571M|} _ZNK6icu_7813UnicodeString9getBufferEv: 4245| 880k|UnicodeString::getBuffer() const { 4246| 880k| if(fUnion.fFields.fLengthAndFlags&(kIsBogus|kOpenGetBuffer)) { ------------------ | Branch (4246:6): [True: 0, False: 880k] ------------------ 4247| 0| return nullptr; 4248| 880k| } else if(fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) { ------------------ | Branch (4248:13): [True: 768k, False: 111k] ------------------ 4249| 768k| return fUnion.fStackFields.fBuffer; 4250| 768k| } else { 4251| 111k| return fUnion.fFields.fArray; 4252| 111k| } 4253| 880k|} _ZNK6icu_7813UnicodeString9doCompareEiiRKS0_ii: 4264| 278k|{ 4265| 278k| if(srcText.isBogus()) { ------------------ | Branch (4265:6): [True: 0, False: 278k] ------------------ 4266| 0| return static_cast(!isBogus()); // 0 if both are bogus, 1 otherwise 4267| 278k| } else { 4268| 278k| srcText.pinIndices(srcStart, srcLength); 4269| 278k| return doCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength); 4270| 278k| } 4271| 278k|} _ZNK6icu_7813UnicodeStringeqERKS0_: 4290| 7.50M|{ 4291| 7.50M| if(isBogus()) { ------------------ | Branch (4291:6): [True: 0, False: 7.50M] ------------------ 4292| 0| return text.isBogus(); 4293| 7.50M| } else { 4294| 7.50M| int32_t len = length(), textLength = text.length(); 4295| 7.50M| return !text.isBogus() && len == textLength && doEquals(text, len); ------------------ | Branch (4295:12): [True: 7.50M, False: 0] | Branch (4295:31): [True: 4.70M, False: 2.80M] | Branch (4295:52): [True: 4.52M, False: 180k] ------------------ 4296| 7.50M| } 4297| 7.50M|} _ZNK6icu_7813UnicodeString7compareERKS0_: 4321| 278k|{ return doCompare(0, length(), text, 0, text.length()); } _ZNK6icu_7813UnicodeString7compareENS_14ConstChar16PtrEi: 4332| 169k|{ return doCompare(0, length(), srcChars, 0, srcLength); } _ZNK6icu_7813UnicodeString7indexOfEPKDsii: 4536| 69.9k| int32_t start) const { 4537| 69.9k| pinIndex(start); 4538| 69.9k| return indexOf(srcChars, 0, srcLength, start, length() - start); 4539| 69.9k|} _ZNK6icu_7813UnicodeString7indexOfEDsi: 4570| 246k| int32_t start) const { 4571| 246k| pinIndex(start); 4572| 246k| return doIndexOf(c, start, length() - start); 4573| 246k|} _ZN6icu_7813UnicodeString7replaceEiiRKS0_ii: 4741| 5.36M|{ return doReplace(start, _length, srcText, srcStart, srcLength); } _ZNK6icu_7813UnicodeString9doExtractEiiRS0_: 4799| 5.36M|{ target.replace(0, target.length(), *this, start, _length); } _ZNK6icu_7813UnicodeString7extractEiiRS0_: 4812| 483k|{ doExtract(start, _length, target); } _ZNK6icu_7813UnicodeString8doCharAtEi: 4846| 858M|{ 4847| 858M| if (static_cast(offset) < static_cast(length())) { ------------------ | Branch (4847:7): [True: 858M, False: 0] ------------------ 4848| 858M| return getArrayStart()[offset]; 4849| 858M| } else { 4850| 0| return kInvalidUChar; 4851| 0| } 4852| 858M|} _ZNK6icu_7813UnicodeString6charAtEi: 4856| 858M|{ return doCharAt(offset); } _ZNK6icu_7813UnicodeString7isEmptyEv: 4863| 1.62M|UnicodeString::isEmpty() const { 4864| | // Arithmetic or logical right shift does not matter: only testing for 0. 4865| 1.62M| return (fUnion.fFields.fLengthAndFlags>>kLengthShift) == 0; 4866| 1.62M|} _ZN6icu_7813UnicodeString13setZeroLengthEv: 4872| 3.77k|UnicodeString::setZeroLength() { 4873| 3.77k| fUnion.fFields.fLengthAndFlags &= kAllStorageFlags; 4874| 3.77k|} _ZN6icu_7813UnicodeString14setShortLengthEi: 4877| 23.4M|UnicodeString::setShortLength(int32_t len) { 4878| | // requires 0 <= len <= kMaxShortLength 4879| 23.4M| fUnion.fFields.fLengthAndFlags = 4880| 23.4M| static_cast((fUnion.fFields.fLengthAndFlags & kAllStorageFlags) | (len << kLengthShift)); 4881| 23.4M|} _ZN6icu_7813UnicodeString9setLengthEi: 4884| 571M|UnicodeString::setLength(int32_t len) { 4885| 571M| if(len <= kMaxShortLength) { ------------------ | Branch (4885:6): [True: 18.8M, False: 552M] ------------------ 4886| 18.8M| setShortLength(len); 4887| 552M| } else { 4888| 552M| fUnion.fFields.fLengthAndFlags |= kLengthIsLarge; 4889| 552M| fUnion.fFields.fLength = len; 4890| 552M| } 4891| 571M|} _ZN6icu_7813UnicodeString10setToEmptyEv: 4894| 1.07M|UnicodeString::setToEmpty() { 4895| 1.07M| fUnion.fFields.fLengthAndFlags = kShortString; 4896| 1.07M|} _ZN6icu_7813UnicodeString8setArrayEPDsii: 4899| 23.0k|UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) { 4900| 23.0k| setLength(len); 4901| 23.0k| fUnion.fFields.fArray = array; 4902| 23.0k| fUnion.fFields.fCapacity = capacity; 4903| 23.0k|} _ZN6icu_7813UnicodeString5setToERKS0_ii: 4917| 2.35k|{ 4918| 2.35k| unBogus(); 4919| 2.35k| return doReplace(0, length(), srcText, srcStart, srcLength); 4920| 2.35k|} _ZN6icu_7813UnicodeString6appendERKS0_ii: 4963| 157k|{ return doAppend(srcText, srcStart, srcLength); } _ZN6icu_7813UnicodeString6appendERKS0_: 4967| 111k|{ return doAppend(srcText, 0, srcText.length()); } _ZN6icu_7813UnicodeString6appendENS_14ConstChar16PtrEi: 4978| 4.46k|{ return doAppend(srcChars, 0, srcLength); } _ZN6icu_7813UnicodeString6appendEDs: 4982| 403M|{ return doAppend(&srcChar, 0, 1); } _ZN6icu_7813UnicodeString8truncateEi: 5069| 35.3k|{ 5070| 35.3k| if(isBogus() && targetLength == 0) { ------------------ | Branch (5070:6): [True: 0, False: 35.3k] | 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| 35.3k| } else if (static_cast(targetLength) < static_cast(length())) { ------------------ | Branch (5074:14): [True: 17.4k, False: 17.8k] ------------------ 5075| 17.4k| setLength(targetLength); 5076| 17.4k| return true; 5077| 17.8k| } else { 5078| 17.8k| return false; 5079| 17.8k| } 5080| 35.3k|} _ZN6icu_7813UnicodeStringC2Ev: 4182| 12.2M|UnicodeString::UnicodeString() { 4183| 12.2M| fUnion.fStackFields.fLengthAndFlags=kShortString; 4184| 12.2M|} _ZN6icu_7813UnicodeStringC2IA6_DsvEERKT_: 3274| 8.41k| UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text) { 3275| 8.41k| fUnion.fFields.fLengthAndFlags = kShortString; 3276| 8.41k| doAppend(internal::toU16StringViewNullable(text)); 3277| 8.41k| } _ZN6icu_7813UnicodeStringC2IA40_DsvEERKT_: 3274| 8.41k| UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text) { 3275| 8.41k| fUnion.fFields.fLengthAndFlags = kShortString; 3276| 8.41k| doAppend(internal::toU16StringViewNullable(text)); 3277| 8.41k| } _ZN6icu_7813UnicodeStringC2IA14_DsvEERKT_: 3274| 8.41k| UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text) { 3275| 8.41k| fUnion.fFields.fLengthAndFlags = kShortString; 3276| 8.41k| doAppend(internal::toU16StringViewNullable(text)); 3277| 8.41k| } _ZN6icu_7813UnicodeStringC2IA9_DsvEERKT_: 3274| 8.41k| UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text) { 3275| 8.41k| fUnion.fFields.fLengthAndFlags = kShortString; 3276| 8.41k| doAppend(internal::toU16StringViewNullable(text)); 3277| 8.41k| } _ZN6icu_7813UnicodeStringC2IA4_DsvEERKT_: 3274| 5.35k| UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text) { 3275| 5.35k| fUnion.fFields.fLengthAndFlags = kShortString; 3276| 5.35k| doAppend(internal::toU16StringViewNullable(text)); 3277| 5.35k| } _ZN6icu_7813UnicodeStringaSIA3_DsvEERS0_RKT_: 1960| 8.64k| inline UnicodeString &operator=(const S &src) { 1961| 8.64k| unBogus(); 1962| 8.64k| return doReplace(0, length(), internal::toU16StringView(src)); 1963| 8.64k| } rbbi.cpp:_ZL9U_FAILURE10UErrorCode: 737| 22.0k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbi.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 8.41k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } rbbidata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 5.27k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbirb.cpp:_ZL9U_FAILURE10UErrorCode: 737| 61.1k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbiscan.cpp:_ZL9U_FAILURE10UErrorCode: 737| 33.5M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbiscan.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 25.2M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } rbbisetb.cpp:_ZL9U_FAILURE10UErrorCode: 737| 4.40M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbisetb.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 817k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } rbbistbl.cpp:_ZL9U_FAILURE10UErrorCode: 737| 9.66k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbitblb.cpp:_ZL9U_FAILURE10UErrorCode: 737| 8.58M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbitblb.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2.67k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uchar.cpp:_ZL9U_FAILURE10UErrorCode: 737| 15.7M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucptrie.cpp:_ZL9U_FAILURE10UErrorCode: 737| 7.90k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udatamem.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uhash.cpp:_ZL9U_FAILURE10UErrorCode: 737| 262k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } umutablecptrie.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1.65M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset.cpp:_ZL9U_FAILURE10UErrorCode: 737| 137k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset_props.cpp:_ZL9U_FAILURE10UErrorCode: 737| 115M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uniset_props.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 328k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } unistr.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2.63k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uprops.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ustring.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 7.90k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ustrtrns.cpp:_ZL9U_FAILURE10UErrorCode: 737| 7.90k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } utext.cpp:_ZL9U_FAILURE10UErrorCode: 737| 35.2k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } utext.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 24.7k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uvector.cpp:_ZL9U_FAILURE10UErrorCode: 737| 53.0M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uvector.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2.80k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } characterproperties.cpp:_ZL9U_FAILURE10UErrorCode: 737| 504k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } characterproperties.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 4.33k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } charstr.cpp:_ZL9U_FAILURE10UErrorCode: 737| 632k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } locbased.cpp:_ZL9U_FAILURE10UErrorCode: 737| 7.90k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2.cpp:_ZL9U_FAILURE10UErrorCode: 737| 18.7M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } normalizer2.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 6.23M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } rbbinode.cpp:_ZL9U_FAILURE10UErrorCode: 737| 22.1M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } rbbinode.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 10.9M| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } ruleiter.cpp:_ZL9U_FAILURE10UErrorCode: 737| 137M| 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| 1| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } ucmndata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 6| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } unames.cpp:_ZL9U_FAILURE10UErrorCode: 737| 25.8k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } unames.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 8.60k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } _ZN6icu_7814UnicodeMatcherD2Ev: 23| 422k|UnicodeMatcher::~UnicodeMatcher() {} _ZN6icu_7813UnicodeFilterD2Ev: 25| 422k|UnicodeFilter::~UnicodeFilter() {} _ZN6icu_7814UnicodeFunctorD2Ev: 16| 422k|UnicodeFunctor::~UnicodeFunctor() {} _ZN6icu_7811SymbolTableD2Ev: 44| 8.41k|SymbolTable::~SymbolTable() {} _ZNK6icu_7810UnicodeSet10hasStringsEv: 120| 200k|UBool UnicodeSet::hasStrings() const { 121| 200k| return strings_ != nullptr && !strings_->isEmpty(); ------------------ | Branch (121:12): [True: 17.2k, False: 183k] | Branch (121:35): [True: 11.2k, False: 5.93k] ------------------ 122| 200k|} _ZNK6icu_7810UnicodeSet15stringsContainsERKNS_13UnicodeStringE: 128| 335k|UBool UnicodeSet::stringsContains(const UnicodeString &s) const { 129| 335k| return strings_ != nullptr && strings_->contains((void*) &s); ------------------ | Branch (129:12): [True: 101k, False: 234k] | Branch (129:35): [True: 16.9k, False: 84.1k] ------------------ 130| 335k|} _ZN6icu_7810UnicodeSetC2Ev: 139| 203k|UnicodeSet::UnicodeSet() { 140| 203k| list[0] = UNICODESET_HIGH; ------------------ | | 34| 203k|#define UNICODESET_HIGH 0x0110000 ------------------ 141| 203k| _dbgct(this); 142| 203k|} _ZN6icu_7810UnicodeSetC2Eii: 151| 168k|UnicodeSet::UnicodeSet(UChar32 start, UChar32 end) { 152| 168k| list[0] = UNICODESET_HIGH; ------------------ | | 34| 168k|#define UNICODESET_HIGH 0x0110000 ------------------ 153| 168k| add(start, end); 154| 168k| _dbgct(this); 155| 168k|} _ZN6icu_7810UnicodeSetC2ERKS0_: 160| 16.3k|UnicodeSet::UnicodeSet(const UnicodeSet& o) : UnicodeFilter(o) { 161| 16.3k| *this = o; 162| 16.3k| _dbgct(this); 163| 16.3k|} _ZN6icu_7810UnicodeSetD2Ev: 189| 422k|UnicodeSet::~UnicodeSet() { 190| 422k| _dbgdt(this); // first! 191| 422k| if (list != stackList) { ------------------ | Branch (191:9): [True: 142k, False: 280k] ------------------ 192| 142k| uprv_free(list); ------------------ | | 1503| 142k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 142k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 142k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 142k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 193| 142k| } 194| 422k| delete bmpSet; 195| 422k| if (buffer != stackList) { ------------------ | Branch (195:9): [True: 399k, False: 23.4k] ------------------ 196| 399k| uprv_free(buffer); ------------------ | | 1503| 399k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 399k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 399k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 399k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 197| 399k| } 198| 422k| delete strings_; 199| 422k| delete stringSpan; 200| 422k| releasePattern(); 201| 422k|} _ZN6icu_7810UnicodeSetaSERKS0_: 206| 57.4k|UnicodeSet& UnicodeSet::operator=(const UnicodeSet& o) { 207| 57.4k| return copyFrom(o, false); 208| 57.4k|} _ZN6icu_7810UnicodeSet8copyFromERKS0_a: 210| 61.8k|UnicodeSet& UnicodeSet::copyFrom(const UnicodeSet& o, UBool asThawed) { 211| 61.8k| if (this == &o) { ------------------ | Branch (211:9): [True: 0, False: 61.8k] ------------------ 212| 0| return *this; 213| 0| } 214| 61.8k| if (isFrozen()) { ------------------ | Branch (214:9): [True: 0, False: 61.8k] ------------------ 215| 0| return *this; 216| 0| } 217| 61.8k| if (o.isBogus()) { ------------------ | Branch (217:9): [True: 0, False: 61.8k] ------------------ 218| 0| setToBogus(); 219| 0| return *this; 220| 0| } 221| 61.8k| if (!ensureCapacity(o.len)) { ------------------ | Branch (221:9): [True: 0, False: 61.8k] ------------------ 222| | // ensureCapacity will mark the UnicodeSet as Bogus if OOM failure happens. 223| 0| return *this; 224| 0| } 225| 61.8k| len = o.len; 226| 61.8k| uprv_memcpy(list, o.list, (size_t)len*sizeof(UChar32)); ------------------ | | 42| 61.8k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 61.8k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 61.8k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 61.8k| _Pragma("clang diagnostic push") \ | | 45| 61.8k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 61.8k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 61.8k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 61.8k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 61.8k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 61.8k| _Pragma("clang diagnostic pop") \ | | 49| 61.8k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 61.8k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 61.8k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 61.8k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 227| 61.8k| if (o.bmpSet != nullptr && !asThawed) { ------------------ | Branch (227:9): [True: 4.33k, False: 57.4k] | Branch (227:32): [True: 0, False: 4.33k] ------------------ 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| 61.8k| if (o.hasStrings()) { ------------------ | Branch (234:9): [True: 2.80k, False: 59.0k] ------------------ 235| 2.80k| UErrorCode status = U_ZERO_ERROR; 236| 2.80k| if ((strings_ == nullptr && !allocateStrings(status)) || ------------------ | Branch (236:14): [True: 2.80k, False: 0] | Branch (236:37): [True: 0, False: 2.80k] ------------------ 237| 2.80k| (strings_->assign(*o.strings_, cloneUnicodeString, status), U_FAILURE(status))) { ------------------ | Branch (237:17): [True: 0, False: 2.80k] ------------------ 238| 0| setToBogus(); 239| 0| return *this; 240| 0| } 241| 59.0k| } else if (hasStrings()) { ------------------ | Branch (241:16): [True: 416, False: 58.6k] ------------------ 242| 416| strings_->removeAllElements(); 243| 416| } 244| 61.8k| if (o.stringSpan != nullptr && !asThawed) { ------------------ | Branch (244:9): [True: 0, False: 61.8k] | 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| 61.8k| releasePattern(); 252| 61.8k| if (o.pat) { ------------------ | Branch (252:9): [True: 49.9k, False: 11.8k] ------------------ 253| 49.9k| setPattern(o.pat, o.patLen); 254| 49.9k| } 255| 61.8k| return *this; 256| 61.8k|} _ZNK6icu_7810UnicodeSet7isEmptyEv: 331| 16.3k|UBool UnicodeSet::isEmpty() const { 332| 16.3k| return len == 1 && !hasStrings(); ------------------ | Branch (332:12): [True: 44, False: 16.3k] | Branch (332:24): [True: 44, False: 0] ------------------ 333| 16.3k|} _ZNK6icu_7810UnicodeSet8containsEi: 340| 23.3M|UBool UnicodeSet::contains(UChar32 c) const { 341| | // Set i to the index of the start item greater than ch 342| | // We know we will terminate without length test! 343| | // LATER: for large sets, add binary search 344| | //int32_t i = -1; 345| | //for (;;) { 346| | // if (c < list[++i]) break; 347| | //} 348| 23.3M| if (bmpSet != nullptr) { ------------------ | Branch (348:9): [True: 0, False: 23.3M] ------------------ 349| 0| return bmpSet->contains(c); 350| 0| } 351| 23.3M| if (stringSpan != nullptr) { ------------------ | Branch (351:9): [True: 0, False: 23.3M] ------------------ 352| 0| return stringSpan->contains(c); 353| 0| } 354| 23.3M| if (c >= UNICODESET_HIGH) { // Don't need to check LOW bound ------------------ | | 34| 23.3M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (354:9): [True: 0, False: 23.3M] ------------------ 355| 0| return false; 356| 0| } 357| 23.3M| int32_t i = findCodePoint(c); 358| 23.3M| return i & 1; // return true if odd 359| 23.3M|} _ZNK6icu_7810UnicodeSet13findCodePointEi: 370| 53.6M|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| 53.6M| if (c < list[0]) ------------------ | Branch (383:9): [True: 8.89M, False: 44.7M] ------------------ 384| 8.89M| return 0; 385| | // High runner test. c is often after the last range, so an 386| | // initial check for this condition pays off. 387| 44.7M| int32_t lo = 0; 388| 44.7M| int32_t hi = len - 1; 389| 44.7M| if (lo >= hi || c >= list[hi-1]) ------------------ | Branch (389:9): [True: 0, False: 44.7M] | Branch (389:21): [True: 15.0M, False: 29.7M] ------------------ 390| 15.0M| return hi; 391| | // invariant: c >= list[lo] 392| | // invariant: c < list[hi] 393| 227M| for (;;) { 394| 227M| int32_t i = (lo + hi) >> 1; 395| 227M| if (i == lo) { ------------------ | Branch (395:13): [True: 29.7M, False: 197M] ------------------ 396| 29.7M| break; // Found! 397| 197M| } else if (c < list[i]) { ------------------ | Branch (397:20): [True: 137M, False: 59.6M] ------------------ 398| 137M| hi = i; 399| 137M| } else { 400| 59.6M| lo = i; 401| 59.6M| } 402| 227M| } 403| 29.7M| return hi; 404| 44.7M|} _ZNK6icu_7810UnicodeSet8containsERKNS_13UnicodeStringE: 428| 221k|UBool UnicodeSet::contains(const UnicodeString& s) const { 429| 221k| int32_t cp = getSingleCP(s); 430| 221k| if (cp < 0) { ------------------ | Branch (430:9): [True: 221k, False: 0] ------------------ 431| 221k| return stringsContains(s); 432| 221k| } else { 433| 0| return contains(static_cast(cp)); 434| 0| } 435| 221k|} _ZN6icu_7810UnicodeSet3setEii: 748| 14.8k|UnicodeSet& UnicodeSet::set(UChar32 start, UChar32 end) { 749| 14.8k| clear(); 750| 14.8k| complement(start, end); 751| 14.8k| return *this; 752| 14.8k|} _ZN6icu_7810UnicodeSet3addEii: 765| 56.7M|UnicodeSet& UnicodeSet::add(UChar32 start, UChar32 end) { 766| 56.7M| if (pinCodePoint(start) < pinCodePoint(end)) { ------------------ | Branch (766:9): [True: 26.5M, False: 30.2M] ------------------ 767| 26.5M| UChar32 limit = end + 1; 768| | // Fast path for adding a new range after the last one. 769| | // Odd list length: [..., lastStart, lastLimit, HIGH] 770| 26.5M| if ((len & 1) != 0) { ------------------ | Branch (770:13): [True: 26.5M, False: 372] ------------------ 771| | // If the list is empty, set lastLimit low enough to not be adjacent to 0. 772| 26.5M| UChar32 lastLimit = len == 1 ? -2 : list[len - 2]; ------------------ | Branch (772:33): [True: 132k, False: 26.4M] ------------------ 773| 26.5M| if (lastLimit <= start && !isFrozen() && !isBogus()) { ------------------ | Branch (773:17): [True: 26.5M, False: 12.7k] | Branch (773:39): [True: 26.5M, False: 0] | Branch (773:54): [True: 26.5M, False: 0] ------------------ 774| 26.5M| if (lastLimit == start) { ------------------ | Branch (774:21): [True: 200, False: 26.5M] ------------------ 775| | // Extend the last range. 776| 200| list[len - 2] = limit; 777| 200| if (limit == UNICODESET_HIGH) { ------------------ | | 34| 200|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (777:25): [True: 77, False: 123] ------------------ 778| 77| --len; 779| 77| } 780| 26.5M| } else { 781| 26.5M| list[len - 1] = start; 782| 26.5M| if (limit < UNICODESET_HIGH) { ------------------ | | 34| 26.5M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (782:25): [True: 26.5M, False: 17.2k] ------------------ 783| 26.5M| if (ensureCapacity(len + 2)) { ------------------ | Branch (783:29): [True: 26.5M, False: 0] ------------------ 784| 26.5M| list[len++] = limit; 785| 26.5M| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 26.5M|#define UNICODESET_HIGH 0x0110000 ------------------ 786| 26.5M| } 787| 26.5M| } else { // limit == UNICODESET_HIGH 788| 17.2k| if (ensureCapacity(len + 1)) { ------------------ | Branch (788:29): [True: 17.2k, False: 0] ------------------ 789| 17.2k| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 17.2k|#define UNICODESET_HIGH 0x0110000 ------------------ 790| 17.2k| } 791| 17.2k| } 792| 26.5M| } 793| 26.5M| releasePattern(); 794| 26.5M| return *this; 795| 26.5M| } 796| 26.5M| } 797| | // This is slow. Could be much faster using findCodePoint(start) 798| | // and modifying the list, dealing with adjacent & overlapping ranges. 799| 13.1k| UChar32 range[3] = { start, limit, UNICODESET_HIGH }; ------------------ | | 34| 13.1k|#define UNICODESET_HIGH 0x0110000 ------------------ 800| 13.1k| add(range, 2, 0); 801| 30.2M| } else if (start == end) { ------------------ | Branch (801:16): [True: 30.2M, False: 0] ------------------ 802| 30.2M| add(start); 803| 30.2M| } 804| 30.2M| return *this; 805| 56.7M|} _ZN6icu_7810UnicodeSet3addEi: 833| 30.3M|UnicodeSet& UnicodeSet::add(UChar32 c) { 834| | // find smallest i such that c < list[i] 835| | // if odd, then it is IN the set 836| | // if even, then it is OUT of the set 837| 30.3M| int32_t i = findCodePoint(pinCodePoint(c)); 838| | 839| | // already in set? 840| 30.3M| if ((i & 1) != 0 || isFrozen() || isBogus()) return *this; ------------------ | Branch (840:9): [True: 21.3M, False: 8.99M] | Branch (840:26): [True: 0, False: 8.99M] | Branch (840:40): [True: 0, False: 8.99M] ------------------ 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| 8.99M| if (c == list[i]-1) { ------------------ | Branch (863:9): [True: 100k, False: 8.89M] ------------------ 864| | // c is before start of next range 865| 100k| list[i] = c; 866| | // if we touched the HIGH mark, then add a new one 867| 100k| if (c == (UNICODESET_HIGH - 1)) { ------------------ | | 34| 100k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (867:13): [True: 504, False: 100k] ------------------ 868| 504| if (!ensureCapacity(len+1)) { ------------------ | Branch (868:17): [True: 0, False: 504] ------------------ 869| | // ensureCapacity will mark the object as Bogus if OOM failure happens. 870| 0| return *this; 871| 0| } 872| 504| list[len++] = UNICODESET_HIGH; ------------------ | | 34| 504|#define UNICODESET_HIGH 0x0110000 ------------------ 873| 504| } 874| 100k| if (i > 0 && c == list[i-1]) { ------------------ | Branch (874:13): [True: 97.0k, False: 3.82k] | Branch (874:22): [True: 21.5k, False: 75.4k] ------------------ 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: 8.51M, False: 378k] | Branch (893:23): [True: 104k, False: 8.41M] ------------------ 894| | // c is after end of prior range 895| 104k| list[i-1]++; 896| | // no need to check for collapse here 897| 104k| } 898| | 899| 8.79M| 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| 8.79M| if (!ensureCapacity(len+2)) { ------------------ | Branch (912:13): [True: 0, False: 8.79M] ------------------ 913| | // ensureCapacity will mark the object as Bogus if OOM failure happens. 914| 0| return *this; 915| 0| } 916| | 917| 8.79M| UChar32 *p = list + i; 918| 8.79M| uprv_memmove(p + 2, p, (len - i) * sizeof(*p)); ------------------ | | 51| 8.79M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 8.79M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 8.79M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 8.79M| _Pragma("clang diagnostic push") \ | | 54| 8.79M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 8.79M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 8.79M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 8.79M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 8.79M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 8.79M| _Pragma("clang diagnostic pop") \ | | 58| 8.79M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 8.79M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 8.79M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 8.79M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 919| 8.79M| list[i] = c; 920| 8.79M| list[i+1] = c+1; 921| 8.79M| len += 2; 922| 8.79M| } 923| | 924| |#ifdef DEBUG_US_ADD 925| | dump(list, len); 926| | printf("\n"); 927| | 928| | for (i=1; i(cp)); 960| 2.79k| } 961| 35.0k| return *this; 962| 35.0k|} _ZN6icu_7810UnicodeSet4_addERKNS_13UnicodeStringE: 968| 98.4k|void UnicodeSet::_add(const UnicodeString& s) { 969| 98.4k| if (isFrozen() || isBogus()) { ------------------ | Branch (969:9): [True: 0, False: 98.4k] | Branch (969:23): [True: 0, False: 98.4k] ------------------ 970| 0| return; 971| 0| } 972| 98.4k| UErrorCode ec = U_ZERO_ERROR; 973| 98.4k| if (strings_ == nullptr && !allocateStrings(ec)) { ------------------ | Branch (973:9): [True: 15.1k, False: 83.2k] | Branch (973:32): [True: 0, False: 15.1k] ------------------ 974| 0| setToBogus(); 975| 0| return; 976| 0| } 977| 98.4k| LocalPointer t(new UnicodeString(s)); 978| 98.4k| if (t.isNull()) { // Check for memory allocation error. ------------------ | Branch (978:9): [True: 0, False: 98.4k] ------------------ 979| 0| setToBogus(); 980| 0| return; 981| 0| } 982| 98.4k| strings_->sortedInsert(t.orphan(), compareUnicodeString, ec); 983| 98.4k| if (U_FAILURE(ec)) { ------------------ | Branch (983:9): [True: 0, False: 98.4k] ------------------ 984| 0| setToBogus(); 985| 0| } 986| 98.4k|} _ZN6icu_7810UnicodeSet11getSingleCPERKNS_13UnicodeStringE: 993| 256k|int32_t UnicodeSet::getSingleCP(const UnicodeString& s) { 994| 256k| int32_t sLength = s.length(); 995| 256k| if (sLength == 1) return s.charAt(0); ------------------ | Branch (995:9): [True: 2.57k, False: 253k] ------------------ 996| 253k| if (sLength == 2) { ------------------ | Branch (996:9): [True: 9.37k, False: 244k] ------------------ 997| 9.37k| UChar32 cp = s.char32At(0); 998| 9.37k| if (cp > 0xFFFF) { // is surrogate pair ------------------ | Branch (998:13): [True: 228, False: 9.14k] ------------------ 999| 228| return cp; 1000| 228| } 1001| 9.37k| } 1002| 253k| return -1; 1003| 253k|} _ZN6icu_7810UnicodeSet16removeAllStringsEv: 1059| 51.5k|UnicodeSet& UnicodeSet::removeAllStrings() { 1060| 51.5k| if (!isFrozen() && hasStrings()) { ------------------ | Branch (1060:9): [True: 51.5k, False: 0] | Branch (1060:24): [True: 3.41k, False: 48.1k] ------------------ 1061| 3.41k| strings_->removeAllElements(); 1062| 3.41k| releasePattern(); 1063| 3.41k| } 1064| 51.5k| return *this; 1065| 51.5k|} _ZN6icu_7810UnicodeSet10complementEii: 1199| 14.8k|UnicodeSet& UnicodeSet::complement(UChar32 start, UChar32 end) { 1200| 14.8k| if (isFrozen() || isBogus()) { ------------------ | Branch (1200:9): [True: 0, False: 14.8k] | Branch (1200:23): [True: 0, False: 14.8k] ------------------ 1201| 0| return *this; 1202| 0| } 1203| 14.8k| if (pinCodePoint(start) <= pinCodePoint(end)) { ------------------ | Branch (1203:9): [True: 14.8k, False: 0] ------------------ 1204| 14.8k| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; ------------------ | | 34| 14.8k|#define UNICODESET_HIGH 0x0110000 ------------------ 1205| 14.8k| exclusiveOr(range, 2, 0); 1206| 14.8k| } 1207| 14.8k| releasePattern(); 1208| 14.8k| return *this; 1209| 14.8k|} _ZN6icu_7810UnicodeSet10complementEv: 1219| 35.1k|UnicodeSet& UnicodeSet::complement() { 1220| 35.1k| if (isFrozen() || isBogus()) { ------------------ | Branch (1220:9): [True: 0, False: 35.1k] | Branch (1220:23): [True: 0, False: 35.1k] ------------------ 1221| 0| return *this; 1222| 0| } 1223| 35.1k| if (list[0] == UNICODESET_LOW) { ------------------ | | 37| 35.1k|#define UNICODESET_LOW 0x000000 ------------------ | Branch (1223:9): [True: 7.20k, False: 27.9k] ------------------ 1224| 7.20k| uprv_memmove(list, list + 1, (size_t)(len-1)*sizeof(UChar32)); ------------------ | | 51| 7.20k|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 7.20k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 7.20k| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 7.20k| _Pragma("clang diagnostic push") \ | | 54| 7.20k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 7.20k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 7.20k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 7.20k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 7.20k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 7.20k| _Pragma("clang diagnostic pop") \ | | 58| 7.20k| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 7.20k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 7.20k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7.20k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1225| 7.20k| --len; 1226| 27.9k| } else { 1227| 27.9k| if (!ensureCapacity(len+1)) { ------------------ | Branch (1227:13): [True: 0, False: 27.9k] ------------------ 1228| 0| return *this; 1229| 0| } 1230| 27.9k| uprv_memmove(list + 1, list, (size_t)len*sizeof(UChar32)); ------------------ | | 51| 27.9k|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 27.9k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 27.9k| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 27.9k| _Pragma("clang diagnostic push") \ | | 54| 27.9k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 27.9k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 27.9k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 27.9k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 27.9k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 27.9k| _Pragma("clang diagnostic pop") \ | | 58| 27.9k| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 27.9k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 27.9k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 27.9k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1231| 27.9k| list[0] = UNICODESET_LOW; ------------------ | | 37| 27.9k|#define UNICODESET_LOW 0x000000 ------------------ 1232| 27.9k| ++len; 1233| 27.9k| } 1234| 35.1k| releasePattern(); 1235| 35.1k| return *this; 1236| 35.1k|} _ZN6icu_7810UnicodeSet6addAllERKS0_: 1272| 254k|UnicodeSet& UnicodeSet::addAll(const UnicodeSet& c) { 1273| 254k| if ( c.len>0 && c.list!=nullptr ) { ------------------ | Branch (1273:10): [True: 254k, False: 0] | Branch (1273:21): [True: 254k, False: 0] ------------------ 1274| 254k| add(c.list, c.len, 0); 1275| 254k| } 1276| | 1277| | // Add strings in order 1278| 254k| if ( c.strings_!=nullptr ) { ------------------ | Branch (1278:10): [True: 42.1k, False: 212k] ------------------ 1279| 124k| for (int32_t i=0; isize(); ++i) { ------------------ | Branch (1279:27): [True: 82.4k, False: 42.1k] ------------------ 1280| 82.4k| const UnicodeString* s = static_cast(c.strings_->elementAt(i)); 1281| 82.4k| if (!stringsContains(*s)) { ------------------ | Branch (1281:17): [True: 70.1k, False: 12.3k] ------------------ 1282| 70.1k| _add(*s); 1283| 70.1k| } 1284| 82.4k| } 1285| 42.1k| } 1286| 254k| return *this; 1287| 254k|} _ZN6icu_7810UnicodeSet9retainAllERKS0_: 1298| 1.86k|UnicodeSet& UnicodeSet::retainAll(const UnicodeSet& c) { 1299| 1.86k| if (isFrozen() || isBogus()) { ------------------ | Branch (1299:9): [True: 0, False: 1.86k] | Branch (1299:23): [True: 0, False: 1.86k] ------------------ 1300| 0| return *this; 1301| 0| } 1302| 1.86k| retain(c.list, c.len, 0); 1303| 1.86k| if (hasStrings()) { ------------------ | Branch (1303:9): [True: 701, False: 1.16k] ------------------ 1304| 701| if (!c.hasStrings()) { ------------------ | Branch (1304:13): [True: 286, False: 415] ------------------ 1305| 286| strings_->removeAllElements(); 1306| 415| } else { 1307| 415| strings_->retainAll(*c.strings_); 1308| 415| } 1309| 701| } 1310| 1.86k| return *this; 1311| 1.86k|} _ZN6icu_7810UnicodeSet9removeAllERKS0_: 1322| 20.4k|UnicodeSet& UnicodeSet::removeAll(const UnicodeSet& c) { 1323| 20.4k| if (isFrozen() || isBogus()) { ------------------ | Branch (1323:9): [True: 0, False: 20.4k] | Branch (1323:23): [True: 0, False: 20.4k] ------------------ 1324| 0| return *this; 1325| 0| } 1326| 20.4k| retain(c.list, c.len, 2); 1327| 20.4k| if (hasStrings() && c.hasStrings()) { ------------------ | Branch (1327:9): [True: 2.01k, False: 18.3k] | Branch (1327:25): [True: 1.16k, False: 848] ------------------ 1328| 1.16k| strings_->removeAll(*c.strings_); 1329| 1.16k| } 1330| 20.4k| return *this; 1331| 20.4k|} _ZN6icu_7810UnicodeSet5clearEv: 1362| 333k|UnicodeSet& UnicodeSet::clear() { 1363| 333k| if (isFrozen()) { ------------------ | Branch (1363:9): [True: 0, False: 333k] ------------------ 1364| 0| return *this; 1365| 0| } 1366| 333k| list[0] = UNICODESET_HIGH; ------------------ | | 34| 333k|#define UNICODESET_HIGH 0x0110000 ------------------ 1367| 333k| len = 1; 1368| 333k| releasePattern(); 1369| 333k| if (strings_ != nullptr) { ------------------ | Branch (1369:9): [True: 32.3k, False: 300k] ------------------ 1370| 32.3k| strings_->removeAllElements(); 1371| 32.3k| } 1372| | // Remove bogus 1373| 333k| fFlags = 0; 1374| 333k| return *this; 1375| 333k|} _ZNK6icu_7810UnicodeSet13getRangeCountEv: 1383| 240k|int32_t UnicodeSet::getRangeCount() const { 1384| 240k| return len/2; 1385| 240k|} _ZNK6icu_7810UnicodeSet13getRangeStartEi: 1393| 238M|UChar32 UnicodeSet::getRangeStart(int32_t index) const { 1394| 238M| return list[index*2]; 1395| 238M|} _ZNK6icu_7810UnicodeSet11getRangeEndEi: 1403| 238M|UChar32 UnicodeSet::getRangeEnd(int32_t index) const { 1404| 238M| return list[index*2 + 1] - 1; 1405| 238M|} _ZN6icu_7810UnicodeSet7compactEv: 1415| 37|UnicodeSet& UnicodeSet::compact() { 1416| 37| if (isFrozen() || isBogus()) { ------------------ | Branch (1416:9): [True: 0, False: 37] | Branch (1416:23): [True: 0, False: 37] ------------------ 1417| 0| return *this; 1418| 0| } 1419| | // Delete buffer first to defragment memory less. 1420| 37| if (buffer != stackList) { ------------------ | Branch (1420:9): [True: 37, False: 0] ------------------ 1421| 37| uprv_free(buffer); ------------------ | | 1503| 37|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1422| 37| buffer = nullptr; 1423| 37| bufferCapacity = 0; 1424| 37| } 1425| 37| if (list == stackList) { ------------------ | Branch (1425:9): [True: 8, False: 29] ------------------ 1426| | // pass 1427| 29| } else if (len <= INITIAL_CAPACITY) { ------------------ | Branch (1427:16): [True: 0, False: 29] ------------------ 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| 29| } else if ((len + 7) < capacity) { ------------------ | Branch (1432:16): [True: 29, False: 0] ------------------ 1433| | // If we have more than a little unused capacity, shrink it to len. 1434| 29| UChar32* temp = static_cast(uprv_realloc(list, sizeof(UChar32) * len)); ------------------ | | 1536| 29|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 29|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 29|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 29|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1435| 29| if (temp) { ------------------ | Branch (1435:13): [True: 29, False: 0] ------------------ 1436| 29| list = temp; 1437| 29| capacity = len; 1438| 29| } 1439| | // else what the heck happened?! We allocated less memory! 1440| | // Oh well. We'll keep our original array. 1441| 29| } 1442| 37| if (strings_ != nullptr && strings_->isEmpty()) { ------------------ | Branch (1442:9): [True: 0, False: 37] | Branch (1442:32): [True: 0, False: 0] ------------------ 1443| 0| delete strings_; 1444| 0| strings_ = nullptr; 1445| 0| } 1446| 37| return *this; 1447| 37|} _ZN6icu_7810UnicodeSet15allocateStringsER10UErrorCode: 1606| 17.9k|UBool UnicodeSet::allocateStrings(UErrorCode &status) { 1607| 17.9k| if (U_FAILURE(status)) { ------------------ | Branch (1607:9): [True: 0, False: 17.9k] ------------------ 1608| 0| return false; 1609| 0| } 1610| 17.9k| strings_ = new UVector(uprv_deleteUObject, ------------------ | | 1489| 17.9k|#define uprv_deleteUObject U_ICU_ENTRY_POINT_RENAME(uprv_deleteUObject) | | ------------------ | | | | 123| 17.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 17.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 17.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 17.9k| uhash_compareUnicodeString, 1, status); ------------------ | | 999| 17.9k|#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString) | | ------------------ | | | | 123| 17.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 17.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 17.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1612| 17.9k| if (strings_ == nullptr) { // Check for memory allocation error. ------------------ | Branch (1612:9): [True: 0, False: 17.9k] ------------------ 1613| 0| status = U_MEMORY_ALLOCATION_ERROR; 1614| 0| return false; 1615| 0| } 1616| 17.9k| if (U_FAILURE(status)) { ------------------ | Branch (1616:9): [True: 0, False: 17.9k] ------------------ 1617| 0| delete strings_; 1618| 0| strings_ = nullptr; 1619| 0| return false; 1620| 0| } 1621| 17.9k| return true; 1622| 17.9k|} _ZN6icu_7810UnicodeSet12nextCapacityEi: 1624| 281k|int32_t UnicodeSet::nextCapacity(int32_t minCapacity) { 1625| | // Grow exponentially to reduce the frequency of allocations. 1626| 281k| if (minCapacity < INITIAL_CAPACITY) { ------------------ | Branch (1626:9): [True: 34.6k, False: 247k] ------------------ 1627| 34.6k| return minCapacity + INITIAL_CAPACITY; 1628| 247k| } else if (minCapacity <= 2500) { ------------------ | Branch (1628:16): [True: 246k, False: 853] ------------------ 1629| 246k| return 5 * minCapacity; 1630| 246k| } else { 1631| 853| int32_t newCapacity = 2 * minCapacity; 1632| 853| if (newCapacity > MAX_LENGTH) { ------------------ | Branch (1632:13): [True: 0, False: 853] ------------------ 1633| 0| newCapacity = MAX_LENGTH; 1634| 0| } 1635| 853| return newCapacity; 1636| 853| } 1637| 281k|} _ZN6icu_7810UnicodeSet14ensureCapacityEi: 1639| 35.4M|bool UnicodeSet::ensureCapacity(int32_t newLen) { 1640| 35.4M| if (newLen > MAX_LENGTH) { ------------------ | Branch (1640:9): [True: 0, False: 35.4M] ------------------ 1641| 0| newLen = MAX_LENGTH; 1642| 0| } 1643| 35.4M| if (newLen <= capacity) { ------------------ | Branch (1643:9): [True: 35.2M, False: 169k] ------------------ 1644| 35.2M| return true; 1645| 35.2M| } 1646| 169k| int32_t newCapacity = nextCapacity(newLen); 1647| 169k| UChar32* temp = static_cast(uprv_malloc(newCapacity * sizeof(UChar32))); ------------------ | | 1524| 169k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 169k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 169k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 169k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1648| 169k| if (temp == nullptr) { ------------------ | Branch (1648:9): [True: 0, False: 169k] ------------------ 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| 169k| uprv_memcpy(temp, list, len * sizeof(UChar32)); ------------------ | | 42| 169k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 169k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 169k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 169k| _Pragma("clang diagnostic push") \ | | 45| 169k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 169k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 169k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 169k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 169k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 169k| _Pragma("clang diagnostic pop") \ | | 49| 169k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 169k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 169k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 169k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1654| 169k| if (list != stackList) { ------------------ | Branch (1654:9): [True: 81.2k, False: 87.9k] ------------------ 1655| 81.2k| uprv_free(list); ------------------ | | 1503| 81.2k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 81.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 81.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 81.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1656| 81.2k| } 1657| 169k| list = temp; 1658| 169k| capacity = newCapacity; 1659| 169k| return true; 1660| 169k|} _ZN6icu_7810UnicodeSet20ensureBufferCapacityEi: 1662| 304k|bool UnicodeSet::ensureBufferCapacity(int32_t newLen) { 1663| 304k| if (newLen > MAX_LENGTH) { ------------------ | Branch (1663:9): [True: 0, False: 304k] ------------------ 1664| 0| newLen = MAX_LENGTH; 1665| 0| } 1666| 304k| if (newLen <= bufferCapacity) { ------------------ | Branch (1666:9): [True: 192k, False: 112k] ------------------ 1667| 192k| return true; 1668| 192k| } 1669| 112k| int32_t newCapacity = nextCapacity(newLen); 1670| 112k| UChar32* temp = static_cast(uprv_malloc(newCapacity * sizeof(UChar32))); ------------------ | | 1524| 112k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 112k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 112k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 112k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1671| 112k| if (temp == nullptr) { ------------------ | Branch (1671:9): [True: 0, False: 112k] ------------------ 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| 112k| if (buffer != stackList) { ------------------ | Branch (1677:9): [True: 81.3k, False: 31.1k] ------------------ 1678| 81.3k| uprv_free(buffer); ------------------ | | 1503| 81.3k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 81.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 81.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 81.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1679| 81.3k| } 1680| 112k| buffer = temp; 1681| 112k| bufferCapacity = newCapacity; 1682| 112k| return true; 1683| 112k|} _ZN6icu_7810UnicodeSet11swapBuffersEv: 1688| 304k|void UnicodeSet::swapBuffers() { 1689| | // swap list and buffer 1690| 304k| UChar32* temp = list; 1691| 304k| list = buffer; 1692| 304k| buffer = temp; 1693| | 1694| 304k| int32_t c = capacity; 1695| 304k| capacity = bufferCapacity; 1696| 304k| bufferCapacity = c; 1697| 304k|} _ZN6icu_7810UnicodeSet11exclusiveOrEPKiia: 1715| 14.8k|void UnicodeSet::exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity) { 1716| 14.8k| if (isFrozen() || isBogus()) { ------------------ | Branch (1716:9): [True: 0, False: 14.8k] | Branch (1716:23): [True: 0, False: 14.8k] ------------------ 1717| 0| return; 1718| 0| } 1719| 14.8k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1719:9): [True: 0, False: 14.8k] ------------------ 1720| 0| return; 1721| 0| } 1722| | 1723| 14.8k| int32_t i = 0, j = 0, k = 0; 1724| 14.8k| UChar32 a = list[i++]; 1725| 14.8k| UChar32 b; 1726| 14.8k| if (polarity == 1 || polarity == 2) { ------------------ | Branch (1726:9): [True: 0, False: 14.8k] | Branch (1726:26): [True: 0, False: 14.8k] ------------------ 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| 14.8k| } else { 1733| 14.8k| b = other[j++]; 1734| 14.8k| } 1735| | // simplest of all the routines 1736| | // sort the values, discarding identicals! 1737| 30.2k| for (;;) { 1738| 30.2k| if (a < b) { ------------------ | Branch (1738:13): [True: 0, False: 30.2k] ------------------ 1739| 0| buffer[k++] = a; 1740| 0| a = list[i++]; 1741| 30.2k| } else if (b < a) { ------------------ | Branch (1741:20): [True: 15.3k, False: 14.8k] ------------------ 1742| 15.3k| buffer[k++] = b; 1743| 15.3k| b = other[j++]; 1744| 15.3k| } else if (a != UNICODESET_HIGH) { // at this point, a == b ------------------ | | 34| 14.8k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1744:20): [True: 0, False: 14.8k] ------------------ 1745| | // discard both values! 1746| 0| a = list[i++]; 1747| 0| b = other[j++]; 1748| 14.8k| } else { // DONE! 1749| 14.8k| buffer[k++] = UNICODESET_HIGH; ------------------ | | 34| 14.8k|#define UNICODESET_HIGH 0x0110000 ------------------ 1750| 14.8k| len = k; 1751| 14.8k| break; 1752| 14.8k| } 1753| 30.2k| } 1754| 14.8k| swapBuffers(); 1755| 14.8k| releasePattern(); 1756| 14.8k|} _ZN6icu_7810UnicodeSet3addEPKiia: 1763| 267k|void UnicodeSet::add(const UChar32* other, int32_t otherLen, int8_t polarity) { 1764| 267k| if (isFrozen() || isBogus() || other==nullptr) { ------------------ | Branch (1764:9): [True: 0, False: 267k] | Branch (1764:23): [True: 0, False: 267k] | Branch (1764:36): [True: 0, False: 267k] ------------------ 1765| 0| return; 1766| 0| } 1767| 267k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1767:9): [True: 0, False: 267k] ------------------ 1768| 0| return; 1769| 0| } 1770| | 1771| 267k| int32_t i = 0, j = 0, k = 0; 1772| 267k| UChar32 a = list[i++]; 1773| 267k| 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| 121M| for (;;) { 1777| 121M| switch (polarity) { ------------------ | Branch (1777:17): [True: 0, False: 121M] ------------------ 1778| 59.8M| case 0: // both first; take lower if unequal ------------------ | Branch (1778:11): [True: 59.8M, False: 61.7M] ------------------ 1779| 59.8M| if (a < b) { // take a ------------------ | Branch (1779:17): [True: 25.3M, False: 34.4M] ------------------ 1780| | // Back up over overlapping ranges in buffer[] 1781| 25.3M| if (k > 0 && a <= buffer[k-1]) { ------------------ | Branch (1781:21): [True: 25.2M, False: 104k] | Branch (1781:30): [True: 144k, False: 25.1M] ------------------ 1782| | // Pick latter end value in buffer[] vs. list[] 1783| 144k| a = max(list[i], buffer[--k]); 1784| 25.2M| } else { 1785| | // No overlap 1786| 25.2M| buffer[k++] = a; 1787| 25.2M| a = list[i]; 1788| 25.2M| } 1789| 25.3M| i++; // Common if/else code factored out 1790| 25.3M| polarity ^= 1; 1791| 34.4M| } else if (b < a) { // take b ------------------ | Branch (1791:24): [True: 25.4M, False: 9.02M] ------------------ 1792| 25.4M| if (k > 0 && b <= buffer[k-1]) { ------------------ | Branch (1792:21): [True: 25.3M, False: 85.0k] | Branch (1792:30): [True: 345k, False: 25.0M] ------------------ 1793| 345k| b = max(other[j], buffer[--k]); 1794| 25.0M| } else { 1795| 25.0M| buffer[k++] = b; 1796| 25.0M| b = other[j]; 1797| 25.0M| } 1798| 25.4M| j++; 1799| 25.4M| polarity ^= 2; 1800| 25.4M| } else { // a == b, take a, drop b 1801| 9.02M| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 9.02M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1801:21): [True: 161k, False: 8.86M] ------------------ 1802| | // This is symmetrical; it doesn't matter if 1803| | // we backtrack with a or b. - liu 1804| 8.86M| if (k > 0 && a <= buffer[k-1]) { ------------------ | Branch (1804:21): [True: 8.79M, False: 71.7k] | Branch (1804:30): [True: 0, False: 8.79M] ------------------ 1805| 0| a = max(list[i], buffer[--k]); 1806| 8.86M| } else { 1807| | // No overlap 1808| 8.86M| buffer[k++] = a; 1809| 8.86M| a = list[i]; 1810| 8.86M| } 1811| 8.86M| i++; 1812| 8.86M| polarity ^= 1; 1813| 8.86M| b = other[j++]; 1814| 8.86M| polarity ^= 2; 1815| 8.86M| } 1816| 59.6M| break; 1817| 59.6M| case 3: // both second; take higher if unequal, and drop other ------------------ | Branch (1817:11): [True: 9.74M, False: 111M] ------------------ 1818| 9.74M| if (b <= a) { // take a ------------------ | Branch (1818:17): [True: 9.68M, False: 67.8k] ------------------ 1819| 9.68M| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 9.68M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1819:21): [True: 64.6k, False: 9.61M] ------------------ 1820| 9.61M| buffer[k++] = a; 1821| 9.61M| } else { // take b 1822| 67.8k| if (b == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 67.8k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1822:21): [True: 4.19k, False: 63.6k] ------------------ 1823| 63.6k| buffer[k++] = b; 1824| 63.6k| } 1825| 9.67M| a = list[i++]; 1826| 9.67M| polarity ^= 1; // factored common code 1827| 9.67M| b = other[j++]; 1828| 9.67M| polarity ^= 2; 1829| 9.67M| break; 1830| 25.9M| case 1: // a second, b first; if b < a, overlap ------------------ | Branch (1830:11): [True: 25.9M, False: 95.6M] ------------------ 1831| 25.9M| if (a < b) { // no overlap, take a ------------------ | Branch (1831:17): [True: 24.5M, False: 1.44M] ------------------ 1832| 24.5M| buffer[k++] = a; a = list[i++]; polarity ^= 1; 1833| 24.5M| } else if (b < a) { // OVERLAP, drop b ------------------ | Branch (1833:24): [True: 838k, False: 607k] ------------------ 1834| 838k| b = other[j++]; 1835| 838k| polarity ^= 2; 1836| 838k| } else { // a == b, drop both! 1837| 607k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 607k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1837:21): [True: 26.3k, False: 581k] ------------------ 1838| 581k| a = list[i++]; 1839| 581k| polarity ^= 1; 1840| 581k| b = other[j++]; 1841| 581k| polarity ^= 2; 1842| 581k| } 1843| 25.9M| break; 1844| 26.0M| case 2: // a first, b second; if a < b, overlap ------------------ | Branch (1844:11): [True: 26.0M, False: 95.6M] ------------------ 1845| 26.0M| if (b < a) { // no overlap, take b ------------------ | Branch (1845:17): [True: 25.3M, False: 660k] ------------------ 1846| 25.3M| buffer[k++] = b; 1847| 25.3M| b = other[j++]; 1848| 25.3M| polarity ^= 2; 1849| 25.3M| } else if (a < b) { // OVERLAP, drop a ------------------ | Branch (1849:25): [True: 44.6k, False: 615k] ------------------ 1850| 44.6k| a = list[i++]; 1851| 44.6k| polarity ^= 1; 1852| 615k| } else { // a == b, drop both! 1853| 615k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 615k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1853:21): [True: 10.9k, False: 604k] ------------------ 1854| 604k| a = list[i++]; 1855| 604k| polarity ^= 1; 1856| 604k| b = other[j++]; 1857| 604k| polarity ^= 2; 1858| 604k| } 1859| 26.0M| break; 1860| 121M| } 1861| 121M| } 1862| 267k| loop_end: 1863| 267k| buffer[k++] = UNICODESET_HIGH; // terminate ------------------ | | 34| 267k|#define UNICODESET_HIGH 0x0110000 ------------------ 1864| 267k| len = k; 1865| 267k| swapBuffers(); 1866| 267k| releasePattern(); 1867| 267k|} _ZN6icu_7810UnicodeSet6retainEPKiia: 1874| 22.2k|void UnicodeSet::retain(const UChar32* other, int32_t otherLen, int8_t polarity) { 1875| 22.2k| if (isFrozen() || isBogus()) { ------------------ | Branch (1875:9): [True: 0, False: 22.2k] | Branch (1875:23): [True: 0, False: 22.2k] ------------------ 1876| 0| return; 1877| 0| } 1878| 22.2k| if (!ensureBufferCapacity(len + otherLen)) { ------------------ | Branch (1878:9): [True: 0, False: 22.2k] ------------------ 1879| 0| return; 1880| 0| } 1881| | 1882| 22.2k| int32_t i = 0, j = 0, k = 0; 1883| 22.2k| UChar32 a = list[i++]; 1884| 22.2k| 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| 14.5M| for (;;) { 1888| 14.5M| switch (polarity) { ------------------ | Branch (1888:17): [True: 0, False: 14.5M] ------------------ 1889| 7.03M| case 0: // both first; drop the smaller ------------------ | Branch (1889:11): [True: 7.03M, False: 7.49M] ------------------ 1890| 7.03M| if (a < b) { // drop a ------------------ | Branch (1890:17): [True: 67.0k, False: 6.96M] ------------------ 1891| 67.0k| a = list[i++]; 1892| 67.0k| polarity ^= 1; 1893| 6.96M| } else if (b < a) { // drop b ------------------ | Branch (1893:24): [True: 6.93M, False: 34.6k] ------------------ 1894| 6.93M| b = other[j++]; 1895| 6.93M| polarity ^= 2; 1896| 6.93M| } else { // a == b, take one, drop other 1897| 34.6k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 34.6k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1897:21): [True: 1.61k, False: 33.0k] ------------------ 1898| 33.0k| buffer[k++] = a; 1899| 33.0k| a = list[i++]; 1900| 33.0k| polarity ^= 1; 1901| 33.0k| b = other[j++]; 1902| 33.0k| polarity ^= 2; 1903| 33.0k| } 1904| 7.03M| break; 1905| 7.03M| case 3: // both second; take lower if unequal ------------------ | Branch (1905:11): [True: 247k, False: 14.2M] ------------------ 1906| 247k| if (a < b) { // take a ------------------ | Branch (1906:17): [True: 177k, False: 70.2k] ------------------ 1907| 177k| buffer[k++] = a; 1908| 177k| a = list[i++]; 1909| 177k| polarity ^= 1; 1910| 177k| } else if (b < a) { // take b ------------------ | Branch (1910:24): [True: 36.5k, False: 33.6k] ------------------ 1911| 36.5k| buffer[k++] = b; 1912| 36.5k| b = other[j++]; 1913| 36.5k| polarity ^= 2; 1914| 36.5k| } else { // a == b, take one, drop other 1915| 33.6k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 33.6k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1915:21): [True: 756, False: 32.9k] ------------------ 1916| 32.9k| buffer[k++] = a; 1917| 32.9k| a = list[i++]; 1918| 32.9k| polarity ^= 1; 1919| 32.9k| b = other[j++]; 1920| 32.9k| polarity ^= 2; 1921| 32.9k| } 1922| 246k| break; 1923| 246k| case 1: // a second, b first; ------------------ | Branch (1923:11): [True: 110k, False: 14.4M] ------------------ 1924| 110k| if (a < b) { // NO OVERLAP, drop a ------------------ | Branch (1924:17): [True: 66.7k, False: 44.2k] ------------------ 1925| 66.7k| a = list[i++]; 1926| 66.7k| polarity ^= 1; 1927| 66.7k| } else if (b < a) { // OVERLAP, take b ------------------ | Branch (1927:24): [True: 36.7k, False: 7.52k] ------------------ 1928| 36.7k| buffer[k++] = b; 1929| 36.7k| b = other[j++]; 1930| 36.7k| polarity ^= 2; 1931| 36.7k| } else { // a == b, drop both! 1932| 7.52k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 7.52k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1932:21): [True: 119, False: 7.40k] ------------------ 1933| 7.40k| a = list[i++]; 1934| 7.40k| polarity ^= 1; 1935| 7.40k| b = other[j++]; 1936| 7.40k| polarity ^= 2; 1937| 7.40k| } 1938| 110k| break; 1939| 7.13M| case 2: // a first, b second; if a < b, overlap ------------------ | Branch (1939:11): [True: 7.13M, False: 7.39M] ------------------ 1940| 7.13M| if (b < a) { // no overlap, drop b ------------------ | Branch (1940:17): [True: 6.93M, False: 204k] ------------------ 1941| 6.93M| b = other[j++]; 1942| 6.93M| polarity ^= 2; 1943| 6.93M| } else if (a < b) { // OVERLAP, take a ------------------ | Branch (1943:25): [True: 177k, False: 27.1k] ------------------ 1944| 177k| buffer[k++] = a; 1945| 177k| a = list[i++]; 1946| 177k| polarity ^= 1; 1947| 177k| } else { // a == b, drop both! 1948| 27.1k| if (a == UNICODESET_HIGH) goto loop_end; ------------------ | | 34| 27.1k|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (1948:21): [True: 19.7k, False: 7.36k] ------------------ 1949| 7.36k| a = list[i++]; 1950| 7.36k| polarity ^= 1; 1951| 7.36k| b = other[j++]; 1952| 7.36k| polarity ^= 2; 1953| 7.36k| } 1954| 7.11M| break; 1955| 14.5M| } 1956| 14.5M| } 1957| 22.2k| loop_end: 1958| 22.2k| buffer[k++] = UNICODESET_HIGH; // terminate ------------------ | | 34| 22.2k|#define UNICODESET_HIGH 0x0110000 ------------------ 1959| 22.2k| len = k; 1960| 22.2k| swapBuffers(); 1961| 22.2k| releasePattern(); 1962| 22.2k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringERKS1_a: 1968| 46.7k|void UnicodeSet::_appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable) { 1969| 46.7k| UChar32 cp; 1970| 101M| for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) { ------------------ | | 141| 101M|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 101M, False: 11.1k] | | ------------------ ------------------ | Branch (1970:25): [True: 101M, False: 46.7k] ------------------ 1971| 101M| _appendToPat(buf, cp = s.char32At(i), escapeUnprintable); 1972| 101M| } 1973| 46.7k|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringEia: 1979| 124M|void UnicodeSet::_appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable) { 1980| 124M| if (escapeUnprintable ? ICU_Utility::isUnprintable(c) : ICU_Utility::shouldAlwaysBeEscaped(c)) { ------------------ | Branch (1980:9): [True: 0, False: 124M] | Branch (1980:9): [True: 64.4M, False: 60.5M] ------------------ 1981| | // Use hex escape notation (\uxxxx or \Uxxxxxxxx) for anything 1982| | // unprintable 1983| 64.4M| ICU_Utility::escape(buf, c); 1984| 64.4M| return; 1985| 64.4M| } 1986| | // Okay to let ':' pass through 1987| 60.5M| switch (c) { 1988| 46.2k| case u'[': ------------------ | Branch (1988:5): [True: 46.2k, False: 60.5M] ------------------ 1989| 71.7k| case u']': ------------------ | Branch (1989:5): [True: 25.5k, False: 60.5M] ------------------ 1990| 77.3k| case u'-': ------------------ | Branch (1990:5): [True: 5.59k, False: 60.5M] ------------------ 1991| 87.9k| case u'^': ------------------ | Branch (1991:5): [True: 10.5k, False: 60.5M] ------------------ 1992| 89.1k| case u'&': ------------------ | Branch (1992:5): [True: 1.26k, False: 60.5M] ------------------ 1993| 90.7k| case u'\\': ------------------ | Branch (1993:5): [True: 1.58k, False: 60.5M] ------------------ 1994| 101k| case u'{': ------------------ | Branch (1994:5): [True: 10.6k, False: 60.5M] ------------------ 1995| 133k| case u'}': ------------------ | Branch (1995:5): [True: 31.8k, False: 60.5M] ------------------ 1996| 207k| case u':': ------------------ | Branch (1996:5): [True: 74.0k, False: 60.4M] ------------------ 1997| 215k| case SymbolTable::SYMBOL_REF: ------------------ | Branch (1997:5): [True: 7.80k, False: 60.5M] ------------------ 1998| 215k| buf.append(u'\\'); 1999| 215k| break; 2000| 60.3M| default: ------------------ | Branch (2000:5): [True: 60.3M, False: 215k] ------------------ 2001| | // Escape whitespace 2002| 60.3M| if (PatternProps::isWhiteSpace(c)) { ------------------ | Branch (2002:13): [True: 9.42k, False: 60.3M] ------------------ 2003| 9.42k| buf.append(u'\\'); 2004| 9.42k| } 2005| 60.3M| break; 2006| 60.5M| } 2007| 60.5M| buf.append(c); 2008| 60.5M|} _ZN6icu_7810UnicodeSet12_appendToPatERNS_13UnicodeStringEiia: 2011| 399k| UBool escapeUnprintable) { 2012| 399k| _appendToPat(result, start, escapeUnprintable); 2013| 399k| if (start != end) { ------------------ | Branch (2013:9): [True: 59.5k, False: 340k] ------------------ 2014| 59.5k| if ((start+1) != end || ------------------ | Branch (2014:13): [True: 36.8k, False: 22.6k] ------------------ 2015| | // Avoid writing what looks like a lead+trail surrogate pair. 2016| 59.5k| start == 0xdbff) { ------------------ | Branch (2016:17): [True: 269, False: 22.3k] ------------------ 2017| 37.1k| result.append(u'-'); 2018| 37.1k| } 2019| 59.5k| _appendToPat(result, end, escapeUnprintable); 2020| 59.5k| } 2021| 399k|} _ZNK6icu_7810UnicodeSet10_toPatternERNS_13UnicodeStringEa: 2030| 674|{ 2031| 674| if (pat != nullptr) { ------------------ | Branch (2031:9): [True: 478, False: 196] ------------------ 2032| 478| int32_t i; 2033| 478| int32_t backslashCount = 0; 2034| 3.75M| for (i=0; i= 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| 47.8k| if (len >= 4 && list[0] == 0 && limit == len && !hasStrings()) { ------------------ | Branch (2099:9): [True: 25.7k, False: 22.1k] | Branch (2099:21): [True: 11.1k, False: 14.5k] | Branch (2099:37): [True: 3.51k, False: 7.68k] | Branch (2099:53): [True: 3.17k, False: 336] ------------------ 2100| | // Emit the inverse 2101| 3.17k| result.append(u'^'); 2102| | // Offsetting the inversion list index by one lets us 2103| | // iterate over the ranges of the set complement. 2104| 3.17k| i = 1; 2105| 3.17k| --limit; 2106| 3.17k| } 2107| | 2108| | // Emit the ranges as pairs. 2109| 438k| while (i < limit) { ------------------ | Branch (2109:12): [True: 390k, False: 47.8k] ------------------ 2110| 390k| UChar32 start = list[i]; // getRangeStart() 2111| 390k| UChar32 end = list[i + 1] - 1; // getRangeEnd() = range limit minus one 2112| 390k| if (!(0xd800 <= end && end <= 0xdbff)) { ------------------ | Branch (2112:15): [True: 51.6k, False: 339k] | Branch (2112:32): [True: 1.57k, False: 50.0k] ------------------ 2113| 389k| _appendToPat(result, start, end, escapeUnprintable); 2114| 389k| i += 2; 2115| 389k| } 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.57k| int32_t firstLead = i; 2120| 5.68k| while ((i += 2) < limit && list[i] <= 0xdbff) {} ------------------ | Branch (2120:20): [True: 5.42k, False: 260] | Branch (2120:40): [True: 4.10k, False: 1.31k] ------------------ 2121| 1.57k| int32_t firstAfterLead = i; 2122| | // 2. Write following ranges that start with a trail surrogate code point. 2123| 6.51k| while (i < limit && (start = list[i]) <= 0xdfff) { ------------------ | Branch (2123:20): [True: 5.53k, False: 983] | Branch (2123:33): [True: 4.94k, False: 595] ------------------ 2124| 4.94k| _appendToPat(result, start, list[i + 1] - 1, escapeUnprintable); 2125| 4.94k| i += 2; 2126| 4.94k| } 2127| | // 3. Now write the postponed ranges. 2128| 7.26k| for (int j = firstLead; j < firstAfterLead; j += 2) { ------------------ | Branch (2128:37): [True: 5.68k, False: 1.57k] ------------------ 2129| 5.68k| _appendToPat(result, list[j], list[j + 1] - 1, escapeUnprintable); 2130| 5.68k| } 2131| 1.57k| } 2132| 390k| } 2133| | 2134| 47.8k| if (strings_ != nullptr) { ------------------ | Branch (2134:9): [True: 15.7k, False: 32.1k] ------------------ 2135| 27.3k| for (int32_t i = 0; isize(); ++i) { ------------------ | Branch (2135:29): [True: 11.6k, False: 15.7k] ------------------ 2136| 11.6k| result.append(u'{'); 2137| 11.6k| _appendToPat(result, 2138| 11.6k| *static_cast(strings_->elementAt(i)), 2139| 11.6k| escapeUnprintable); 2140| 11.6k| result.append(u'}'); 2141| 11.6k| } 2142| 15.7k| } 2143| 47.8k| return result.append(u']'); 2144| 47.8k|} _ZN6icu_7810UnicodeSet14releasePatternEv: 2149| 36.8M|void UnicodeSet::releasePattern() { 2150| 36.8M| if (pat) { ------------------ | Branch (2150:9): [True: 99.9k, False: 36.7M] ------------------ 2151| 99.9k| uprv_free(pat); ------------------ | | 1503| 99.9k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 99.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 99.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 99.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2152| 99.9k| pat = nullptr; 2153| 99.9k| patLen = 0; 2154| 99.9k| } 2155| 36.8M|} _ZN6icu_7810UnicodeSet10setPatternEPKDsi: 2160| 99.9k|void UnicodeSet::setPattern(const char16_t *newPat, int32_t newPatLen) { 2161| 99.9k| releasePattern(); 2162| 99.9k| pat = static_cast(uprv_malloc((newPatLen + 1) * sizeof(char16_t))); ------------------ | | 1524| 99.9k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 99.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 99.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 99.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2163| 99.9k| if (pat) { ------------------ | Branch (2163:9): [True: 99.9k, False: 0] ------------------ 2164| 99.9k| patLen = newPatLen; 2165| 99.9k| u_memcpy(pat, newPat, patLen); ------------------ | | 334| 99.9k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 99.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 99.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 99.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2166| 99.9k| pat[patLen] = 0; 2167| 99.9k| } 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| 99.9k|} _ZN6icu_7810UnicodeSet6freezeEv: 2172| 23|UnicodeSet *UnicodeSet::freeze() { 2173| 23| if(!isFrozen() && !isBogus()) { ------------------ | Branch (2173:8): [True: 23, False: 0] | Branch (2173:23): [True: 23, False: 0] ------------------ 2174| 23| compact(); 2175| | 2176| | // Optimize contains() and span() and similar functions. 2177| 23| if (hasStrings()) { ------------------ | Branch (2177:13): [True: 0, False: 23] ------------------ 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| 23| if (stringSpan == nullptr) { ------------------ | Branch (2192:13): [True: 23, False: 0] ------------------ 2193| | // No span-relevant strings: Optimize for code point spans. 2194| 23| bmpSet=new BMPSet(list, len); 2195| 23| if (bmpSet == nullptr) { // Check for memory allocation error. ------------------ | Branch (2195:17): [True: 0, False: 23] ------------------ 2196| 0| setToBogus(); 2197| 0| } 2198| 23| } 2199| 23| } 2200| 23| return this; 2201| 23|} uniset.cpp:_ZN6icu_78L18cloneUnicodeStringEP8UElementS1_: 110| 5.19k|static void U_CALLCONV cloneUnicodeString(UElement *dst, UElement *src) { 111| 5.19k| dst->pointer = new UnicodeString(*static_cast(src->pointer)); 112| 5.19k|} uniset.cpp:_ZN6icu_78L12pinCodePointERi: 54| 143M|static inline UChar32 pinCodePoint(UChar32& c) { 55| 143M| if (c < UNICODESET_LOW) { ------------------ | | 37| 143M|#define UNICODESET_LOW 0x000000 ------------------ | Branch (55:9): [True: 0, False: 143M] ------------------ 56| 0| c = UNICODESET_LOW; ------------------ | | 37| 0|#define UNICODESET_LOW 0x000000 ------------------ 57| 143M| } else if (c > (UNICODESET_HIGH-1)) { ------------------ | | 34| 143M|#define UNICODESET_HIGH 0x0110000 ------------------ | Branch (57:16): [True: 0, False: 143M] ------------------ 58| 0| c = (UNICODESET_HIGH-1); ------------------ | | 34| 0|#define UNICODESET_HIGH 0x0110000 ------------------ 59| 0| } 60| 143M| return c; 61| 143M|} uniset.cpp:_ZN6icu_78L20compareUnicodeStringE8UElementS0_: 114| 278k|static int32_t U_CALLCONV compareUnicodeString(UElement t1, UElement t2) { 115| 278k| const UnicodeString& a = *static_cast(t1.pointer); 116| 278k| const UnicodeString& b = *static_cast(t2.pointer); 117| 278k| return a.compare(b); 118| 278k|} uniset.cpp:_ZN6icu_78L3maxEii: 1708| 489k|static inline UChar32 max(UChar32 a, UChar32 b) { 1709| 489k| return (a > b) ? a : b; ------------------ | Branch (1709:12): [True: 8.65k, False: 481k] ------------------ 1710| 489k|} _ZN6icu_7810UnicodeSetC2ERKNS_13UnicodeStringER10UErrorCode: 156| 33.6k| UErrorCode& status) { 157| 33.6k| applyPattern(pattern, status); 158| 33.6k| _dbgct(this); 159| 33.6k|} _ZN6icu_7810UnicodeSet12applyPatternERKNS_13UnicodeStringER10UErrorCode: 166| 33.6k| UErrorCode& status) { 167| | // Equivalent to 168| | // return applyPattern(pattern, USET_IGNORE_SPACE, nullptr, status); 169| | // but without dependency on closeOver(). 170| 33.6k| ParsePosition pos(0); 171| 33.6k| applyPatternIgnoreSpace(pattern, pos, nullptr, status); 172| 33.6k| if (U_FAILURE(status)) return *this; ------------------ | Branch (172:9): [True: 0, False: 33.6k] ------------------ 173| | 174| 33.6k| int32_t i = pos.getIndex(); 175| | // Skip over trailing whitespace 176| 33.6k| ICU_Utility::skipWhitespace(pattern, i, true); 177| 33.6k| if (i != pattern.length()) { ------------------ | Branch (177:9): [True: 0, False: 33.6k] ------------------ 178| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 179| 0| } 180| 33.6k| return *this; 181| 33.6k|} _ZN6icu_7810UnicodeSet23applyPatternIgnoreSpaceERKNS_13UnicodeStringERNS_13ParsePositionEPKNS_11SymbolTableER10UErrorCode: 187| 53.9k| UErrorCode& status) { 188| 53.9k| if (U_FAILURE(status)) { ------------------ | Branch (188:9): [True: 0, False: 53.9k] ------------------ 189| 0| return; 190| 0| } 191| 53.9k| if (isFrozen()) { ------------------ | Branch (191:9): [True: 0, False: 53.9k] ------------------ 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| 53.9k| UnicodeString rebuiltPat; 198| 53.9k| RuleCharacterIterator chars(pattern, symbols, pos); 199| 53.9k| applyPattern(chars, symbols, rebuiltPat, USET_IGNORE_SPACE, nullptr, 0, status); 200| 53.9k| if (U_FAILURE(status)) return; ------------------ | Branch (200:9): [True: 3.92k, False: 50.0k] ------------------ 201| 50.0k| if (chars.inVariable()) { ------------------ | Branch (201:9): [True: 5, False: 49.9k] ------------------ 202| | // syntaxError(chars, "Extra chars in variable value"); 203| 5| status = U_MALFORMED_SET; 204| 5| return; 205| 5| } 206| 49.9k| setPattern(rebuiltPat); 207| 49.9k|} _ZN6icu_7810UnicodeSet12applyPatternERNS_21RuleCharacterIteratorEPKNS_11SymbolTableERNS_13UnicodeStringEjMS0_FRS0_iEiR10UErrorCode: 267| 179k| UErrorCode& ec) { 268| 179k| if (U_FAILURE(ec)) return; ------------------ | Branch (268:9): [True: 0, False: 179k] ------------------ 269| 179k| if (depth > MAX_DEPTH) { ------------------ | Branch (269:9): [True: 6, False: 179k] ------------------ 270| 6| ec = U_ILLEGAL_ARGUMENT_ERROR; 271| 6| return; 272| 6| } 273| | 274| | // Syntax characters: [ ] ^ - & { } 275| | 276| | // Recognized special forms for chars, sets: c-c s-s s&s 277| | 278| 179k| int32_t opts = RuleCharacterIterator::PARSE_VARIABLES | 279| 179k| RuleCharacterIterator::PARSE_ESCAPES; 280| 179k| if ((options & USET_IGNORE_SPACE) != 0) { ------------------ | Branch (280:9): [True: 179k, False: 0] ------------------ 281| 179k| opts |= RuleCharacterIterator::SKIP_WHITESPACE; 282| 179k| } 283| | 284| 179k| UnicodeString patLocal, buf; 285| 179k| UBool usePat = false; 286| 179k| UnicodeSetPointer scratch; 287| 179k| RuleCharacterIterator::Pos backup; 288| | 289| | // mode: 0=before [, 1=between [...], 2=after ] 290| | // lastItem: 0=none, 1=char, 2=set 291| 179k| int8_t lastItem = 0, mode = 0; 292| 179k| UChar32 lastChar = 0; 293| 179k| char16_t op = 0; 294| | 295| 179k| UBool invert = false; 296| | 297| 179k| clear(); 298| | 299| 23.6M| while (mode != 2 && !chars.atEnd()) { ------------------ | Branch (299:12): [True: 23.5M, False: 151k] | Branch (299:25): [True: 23.4M, False: 12.5k] ------------------ 300| 23.4M| U_ASSERT((lastItem == 0 && op == 0) || ------------------ | | 35| 23.4M|# define U_ASSERT(exp) (void)0 ------------------ 301| 23.4M| (lastItem == 1 && (op == 0 || op == u'-')) || 302| 23.4M| (lastItem == 2 && (op == 0 || op == u'-' || op == u'&'))); 303| | 304| 23.4M| UChar32 c = 0; 305| 23.4M| UBool literal = false; 306| 23.4M| 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| 23.4M| int8_t setMode = 0; 312| 23.4M| if (resemblesPropertyPattern(chars, opts)) { ------------------ | Branch (312:13): [True: 161k, False: 23.3M] ------------------ 313| 161k| setMode = 2; 314| 161k| } 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| 23.3M| else { 325| | // Prepare to backup if necessary 326| 23.3M| chars.getPos(backup); 327| 23.3M| c = chars.next(opts, literal, ec); 328| 23.3M| if (U_FAILURE(ec)) return; ------------------ | Branch (328:17): [True: 3.51k, False: 23.3M] ------------------ 329| | 330| 23.3M| if (c == u'[' && !literal) { ------------------ | Branch (330:17): [True: 298k, False: 23.0M] | Branch (330:30): [True: 297k, False: 862] ------------------ 331| 297k| if (mode == 1) { ------------------ | Branch (331:21): [True: 125k, False: 172k] ------------------ 332| 125k| chars.setPos(backup); // backup 333| 125k| setMode = 1; 334| 172k| } else { 335| | // Handle opening '[' delimiter 336| 172k| mode = 1; 337| 172k| patLocal.append(u'['); 338| 172k| chars.getPos(backup); // prepare to backup 339| 172k| c = chars.next(opts, literal, ec); 340| 172k| if (U_FAILURE(ec)) return; ------------------ | Branch (340:25): [True: 62, False: 171k] ------------------ 341| 171k| if (c == u'^' && !literal) { ------------------ | Branch (341:25): [True: 13.7k, False: 158k] | Branch (341:38): [True: 13.5k, False: 273] ------------------ 342| 13.5k| invert = true; 343| 13.5k| patLocal.append(u'^'); 344| 13.5k| chars.getPos(backup); // prepare to backup 345| 13.5k| c = chars.next(opts, literal, ec); 346| 13.5k| if (U_FAILURE(ec)) return; ------------------ | Branch (346:29): [True: 4, False: 13.5k] ------------------ 347| 13.5k| } 348| | // Fall through to handle special leading '-'; 349| | // otherwise restart loop for nested [], \p{}, etc. 350| 171k| if (c == u'-') { ------------------ | Branch (350:25): [True: 873, False: 171k] ------------------ 351| 873| literal = true; 352| | // Fall through to handle literal '-' below 353| 171k| } else { 354| 171k| chars.setPos(backup); // backup 355| 171k| continue; 356| 171k| } 357| 171k| } 358| 23.0M| } else if (symbols != nullptr) { ------------------ | Branch (358:24): [True: 22.8M, False: 143k] ------------------ 359| 22.8M| const UnicodeFunctor *m = symbols->lookupMatcher(c); 360| 22.8M| if (m != nullptr) { ------------------ | Branch (360:21): [True: 674, False: 22.8M] ------------------ 361| 674| const UnicodeSet *ms = dynamic_cast(m); 362| 674| if (ms == nullptr) { ------------------ | Branch (362:25): [True: 0, False: 674] ------------------ 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| 674| nested = const_cast(ms); 369| 674| setMode = 3; 370| 674| } 371| 22.8M| } 372| 23.3M| } 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| 23.3M| if (setMode != 0) { ------------------ | Branch (379:13): [True: 288k, False: 23.0M] ------------------ 380| 288k| if (lastItem == 1) { ------------------ | Branch (380:17): [True: 80.6k, False: 207k] ------------------ 381| 80.6k| if (op != 0) { ------------------ | Branch (381:21): [True: 12, False: 80.5k] ------------------ 382| | // syntaxError(chars, "Char expected after operator"); 383| 12| ec = U_MALFORMED_SET; 384| 12| return; 385| 12| } 386| 80.5k| add(lastChar, lastChar); 387| 80.5k| _appendToPat(patLocal, lastChar, false); 388| 80.5k| lastItem = 0; 389| 80.5k| op = 0; 390| 80.5k| } 391| | 392| 288k| if (op == u'-' || op == u'&') { ------------------ | Branch (392:17): [True: 20.4k, False: 267k] | Branch (392:31): [True: 1.86k, False: 265k] ------------------ 393| 22.2k| patLocal.append(op); 394| 22.2k| } 395| | 396| 288k| if (nested == nullptr) { ------------------ | Branch (396:17): [True: 287k, False: 674] ------------------ 397| | // lazy allocation 398| 287k| if (!scratch.allocate()) { ------------------ | Branch (398:21): [True: 0, False: 287k] ------------------ 399| 0| ec = U_MEMORY_ALLOCATION_ERROR; 400| 0| return; 401| 0| } 402| 287k| nested = scratch.pointer(); 403| 287k| } 404| 288k| switch (setMode) { ------------------ | Branch (404:21): [True: 0, False: 288k] ------------------ 405| 125k| case 1: ------------------ | Branch (405:13): [True: 125k, False: 162k] ------------------ 406| 125k| nested->applyPattern(chars, symbols, patLocal, options, caseClosure, depth + 1, ec); 407| 125k| break; 408| 161k| case 2: ------------------ | Branch (408:13): [True: 161k, False: 126k] ------------------ 409| 161k| chars.skipIgnored(opts); 410| 161k| nested->applyPropertyPattern(chars, patLocal, ec); 411| 161k| if (U_FAILURE(ec)) return; ------------------ | Branch (411:21): [True: 3.83k, False: 157k] ------------------ 412| 157k| break; 413| 157k| case 3: // `nested' already parsed ------------------ | Branch (413:13): [True: 674, False: 287k] ------------------ 414| 674| nested->_toPattern(patLocal, false); 415| 674| break; 416| 288k| } 417| | 418| 284k| usePat = true; 419| | 420| 284k| if (mode == 0) { ------------------ | Branch (420:17): [True: 7.49k, False: 276k] ------------------ 421| | // Entire pattern is a category; leave parse loop 422| 7.49k| *this = *nested; 423| 7.49k| mode = 2; 424| 7.49k| break; 425| 7.49k| } 426| | 427| 276k| switch (op) { ------------------ | Branch (427:21): [True: 0, False: 276k] ------------------ 428| 20.4k| case u'-': ------------------ | Branch (428:13): [True: 20.4k, False: 256k] ------------------ 429| 20.4k| removeAll(*nested); 430| 20.4k| break; 431| 1.86k| case u'&': ------------------ | Branch (431:13): [True: 1.86k, False: 274k] ------------------ 432| 1.86k| retainAll(*nested); 433| 1.86k| break; 434| 254k| case 0: ------------------ | Branch (434:13): [True: 254k, False: 22.2k] ------------------ 435| 254k| addAll(*nested); 436| 254k| break; 437| 276k| } 438| | 439| 276k| op = 0; 440| 276k| lastItem = 2; 441| | 442| 276k| continue; 443| 276k| } 444| | 445| 23.0M| if (mode == 0) { ------------------ | Branch (445:13): [True: 0, False: 23.0M] ------------------ 446| | // syntaxError(chars, "Missing '['"); 447| 0| ec = U_MALFORMED_SET; 448| 0| return; 449| 0| } 450| | 451| | // -------- Parse special (syntax) characters. If the 452| | // current character is not special, or if it is escaped, 453| | // then fall through and handle it below. 454| | 455| 23.0M| if (!literal) { ------------------ | Branch (455:13): [True: 22.9M, False: 88.3k] ------------------ 456| 22.9M| switch (c) { 457| 113k| case u']': ------------------ | Branch (457:13): [True: 113k, False: 22.8M] ------------------ 458| 113k| if (lastItem == 1) { ------------------ | Branch (458:21): [True: 45.7k, False: 67.8k] ------------------ 459| 45.7k| add(lastChar, lastChar); 460| 45.7k| _appendToPat(patLocal, lastChar, false); 461| 45.7k| } 462| | // Treat final trailing '-' as a literal 463| 113k| if (op == u'-') { ------------------ | Branch (463:21): [True: 1.19k, False: 112k] ------------------ 464| 1.19k| add(op, op); 465| 1.19k| patLocal.append(op); 466| 112k| } else if (op == u'&') { ------------------ | Branch (466:28): [True: 1, False: 112k] ------------------ 467| | // syntaxError(chars, "Trailing '&'"); 468| 1| ec = U_MALFORMED_SET; 469| 1| return; 470| 1| } 471| 113k| patLocal.append(u']'); 472| 113k| mode = 2; 473| 113k| continue; 474| 49.5k| case u'-': ------------------ | Branch (474:13): [True: 49.5k, False: 22.8M] ------------------ 475| 49.5k| if (op == 0) { ------------------ | Branch (475:21): [True: 49.5k, False: 1] ------------------ 476| 49.5k| if (lastItem != 0) { ------------------ | Branch (476:25): [True: 45.0k, False: 4.48k] ------------------ 477| 45.0k| op = static_cast(c); 478| 45.0k| continue; 479| 45.0k| } else { 480| | // Treat final trailing '-' as a literal 481| 4.48k| add(c, c); 482| 4.48k| c = chars.next(opts, literal, ec); 483| 4.48k| if (U_FAILURE(ec)) return; ------------------ | Branch (483:29): [True: 1, False: 4.48k] ------------------ 484| 4.48k| if (c == u']' && !literal) { ------------------ | Branch (484:29): [True: 4.46k, False: 22] | Branch (484:42): [True: 4.46k, False: 1] ------------------ 485| 4.46k| patLocal.append(u"-]", 2); 486| 4.46k| mode = 2; 487| 4.46k| continue; 488| 4.46k| } 489| 4.48k| } 490| 49.5k| } 491| | // syntaxError(chars, "'-' not after char or set"); 492| 24| ec = U_MALFORMED_SET; 493| 24| return; 494| 1.91k| case u'&': ------------------ | Branch (494:13): [True: 1.91k, False: 22.9M] ------------------ 495| 1.91k| if (lastItem == 2 && op == 0) { ------------------ | Branch (495:21): [True: 1.88k, False: 33] | Branch (495:38): [True: 1.88k, False: 1] ------------------ 496| 1.88k| op = static_cast(c); 497| 1.88k| continue; 498| 1.88k| } 499| | // syntaxError(chars, "'&' not after set"); 500| 34| ec = U_MALFORMED_SET; 501| 34| return; 502| 15| case u'^': ------------------ | Branch (502:13): [True: 15, False: 22.9M] ------------------ 503| | // syntaxError(chars, "'^' not after '['"); 504| 15| ec = U_MALFORMED_SET; 505| 15| return; 506| 35.3k| case u'{': ------------------ | Branch (506:13): [True: 35.3k, False: 22.9M] ------------------ 507| 35.3k| if (op != 0) { ------------------ | Branch (507:21): [True: 3, False: 35.3k] ------------------ 508| | // syntaxError(chars, "Missing operand after operator"); 509| 3| ec = U_MALFORMED_SET; 510| 3| return; 511| 3| } 512| 35.3k| if (lastItem == 1) { ------------------ | Branch (512:21): [True: 22.6k, False: 12.7k] ------------------ 513| 22.6k| add(lastChar, lastChar); 514| 22.6k| _appendToPat(patLocal, lastChar, false); 515| 22.6k| } 516| 35.3k| lastItem = 0; 517| 35.3k| buf.truncate(0); 518| 35.3k| { 519| 35.3k| UBool ok = false; 520| 90.2M| while (!chars.atEnd()) { ------------------ | Branch (520:28): [True: 90.2M, False: 193] ------------------ 521| 90.2M| c = chars.next(opts, literal, ec); 522| 90.2M| if (U_FAILURE(ec)) return; ------------------ | Branch (522:29): [True: 24, False: 90.2M] ------------------ 523| 90.2M| if (c == u'}' && !literal) { ------------------ | Branch (523:29): [True: 37.2k, False: 90.1M] | Branch (523:42): [True: 35.0k, False: 2.10k] ------------------ 524| 35.0k| ok = true; 525| 35.0k| break; 526| 35.0k| } 527| 90.1M| buf.append(c); 528| 90.1M| } 529| 35.2k| if (!ok) { ------------------ | Branch (529:25): [True: 193, False: 35.0k] ------------------ 530| | // syntaxError(chars, "Invalid multicharacter string"); 531| 193| ec = U_MALFORMED_SET; 532| 193| return; 533| 193| } 534| 35.2k| } 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| 35.0k| add(buf); 539| 35.0k| patLocal.append(u'{'); 540| 35.0k| _appendToPat(patLocal, buf, false); 541| 35.0k| patLocal.append(u'}'); 542| 35.0k| continue; 543| 33.8k| case SymbolTable::SYMBOL_REF: ------------------ | Branch (543:13): [True: 33.8k, False: 22.9M] ------------------ 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| 33.8k| { 551| 33.8k| chars.getPos(backup); 552| 33.8k| c = chars.next(opts, literal, ec); 553| 33.8k| if (U_FAILURE(ec)) return; ------------------ | Branch (553:25): [True: 5, False: 33.8k] ------------------ 554| 33.8k| UBool anchor = (c == u']' && !literal); ------------------ | Branch (554:37): [True: 33.6k, False: 188] | Branch (554:50): [True: 33.6k, False: 0] ------------------ 555| 33.8k| if (symbols == nullptr && !anchor) { ------------------ | Branch (555:25): [True: 0, False: 33.8k] | Branch (555:47): [True: 0, False: 0] ------------------ 556| 0| c = SymbolTable::SYMBOL_REF; 557| 0| chars.setPos(backup); 558| 0| break; // literal '$' 559| 0| } 560| 33.8k| if (anchor && op == 0) { ------------------ | Branch (560:25): [True: 33.6k, False: 188] | Branch (560:35): [True: 33.6k, False: 1] ------------------ 561| 33.6k| if (lastItem == 1) { ------------------ | Branch (561:29): [True: 1.63k, False: 32.0k] ------------------ 562| 1.63k| add(lastChar, lastChar); 563| 1.63k| _appendToPat(patLocal, lastChar, false); 564| 1.63k| } 565| 33.6k| add(U_ETHER); ------------------ | | 37| 33.6k|#define U_ETHER ((char16_t)0xFFFF) ------------------ 566| 33.6k| usePat = true; 567| 33.6k| patLocal.append(static_cast(SymbolTable::SYMBOL_REF)); 568| 33.6k| patLocal.append(u']'); 569| 33.6k| mode = 2; 570| 33.6k| continue; 571| 33.6k| } 572| | // syntaxError(chars, "Unquoted '$'"); 573| 189| ec = U_MALFORMED_SET; 574| 189| return; 575| 33.8k| } 576| 22.7M| default: ------------------ | Branch (576:13): [True: 22.7M, False: 234k] ------------------ 577| 22.7M| break; 578| 22.9M| } 579| 22.9M| } 580| | 581| | // -------- Parse literal characters. This includes both 582| | // escaped chars ("\u4E01") and non-syntax characters 583| | // ("a"). 584| | 585| 22.7M| switch (lastItem) { ------------------ | Branch (585:17): [True: 0, False: 22.7M] ------------------ 586| 97.9k| case 0: ------------------ | Branch (586:9): [True: 97.9k, False: 22.6M] ------------------ 587| 97.9k| lastItem = 1; 588| 97.9k| lastChar = c; 589| 97.9k| break; 590| 22.6M| case 1: ------------------ | Branch (590:9): [True: 22.6M, False: 175k] ------------------ 591| 22.6M| if (op == u'-') { ------------------ | Branch (591:17): [True: 23.4k, False: 22.5M] ------------------ 592| 23.4k| if (lastChar >= c) { ------------------ | Branch (592:21): [True: 31, False: 23.3k] ------------------ 593| | // Don't allow redundant (a-a) or empty (b-a) ranges; 594| | // these are most likely typos. 595| | // syntaxError(chars, "Invalid range"); 596| 31| ec = U_MALFORMED_SET; 597| 31| return; 598| 31| } 599| 23.3k| add(lastChar, c); 600| 23.3k| _appendToPat(patLocal, lastChar, false); 601| 23.3k| patLocal.append(op); 602| 23.3k| _appendToPat(patLocal, c, false); 603| 23.3k| lastItem = 0; 604| 23.3k| op = 0; 605| 22.5M| } else { 606| 22.5M| add(lastChar, lastChar); 607| 22.5M| _appendToPat(patLocal, lastChar, false); 608| 22.5M| lastChar = c; 609| 22.5M| } 610| 22.6M| break; 611| 22.6M| case 2: ------------------ | Branch (611:9): [True: 77.4k, False: 22.7M] ------------------ 612| 77.4k| if (op != 0) { ------------------ | Branch (612:17): [True: 14, False: 77.4k] ------------------ 613| | // syntaxError(chars, "Set expected after operator"); 614| 14| ec = U_MALFORMED_SET; 615| 14| return; 616| 14| } 617| 77.4k| lastChar = c; 618| 77.4k| lastItem = 1; 619| 77.4k| break; 620| 22.7M| } 621| 22.7M| } 622| | 623| 171k| if (mode != 2) { ------------------ | Branch (623:9): [True: 12.5k, False: 159k] ------------------ 624| | // syntaxError(chars, "Missing ']'"); 625| 12.5k| ec = U_MALFORMED_SET; 626| 12.5k| return; 627| 12.5k| } 628| | 629| 159k| 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| 159k| if ((options & USET_CASE_MASK) != 0) { ------------------ | Branch (637:9): [True: 0, False: 159k] ------------------ 638| 0| (this->*caseClosure)(options); 639| 0| } 640| 159k| if (invert) { ------------------ | Branch (640:9): [True: 13.1k, False: 146k] ------------------ 641| 13.1k| complement().removeAllStrings(); // code point complement 642| 13.1k| } 643| | 644| | // Use the rebuilt pattern (patLocal) only if necessary. Prefer the 645| | // generated pattern. 646| 159k| if (usePat) { ------------------ | Branch (646:9): [True: 111k, False: 47.6k] ------------------ 647| 111k| rebuiltPat.append(patLocal); 648| 111k| } else { 649| 47.6k| _generatePattern(rebuiltPat, false); 650| 47.6k| } 651| 159k| if (isBogus() && U_SUCCESS(ec)) { ------------------ | Branch (651:9): [True: 0, False: 159k] | 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| 159k|} _ZN6icu_7810UnicodeSet11applyFilterEPFaiPvES1_PKS0_R10UErrorCode: 706| 130k| UErrorCode &status) { 707| 130k| if (U_FAILURE(status)) return; ------------------ | Branch (707:9): [True: 0, False: 130k] ------------------ 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| 130k| clear(); 720| | 721| 130k| UChar32 startHasProperty = -1; 722| 130k| int32_t limitRange = inclusions->getRangeCount(); 723| | 724| 237M| for (int j=0; jgetRangeStart(j); 727| 237M| UChar32 end = inclusions->getRangeEnd(j); 728| | 729| | // for all the code points in the range, process 730| 927M| for (UChar32 ch = start; ch <= end; ++ch) { ------------------ | Branch (730:34): [True: 690M, False: 237M] ------------------ 731| | // only add to this UnicodeSet on inflection points -- 732| | // where the hasProperty value changes to false 733| 690M| if ((*filter)(ch, context)) { ------------------ | Branch (733:17): [True: 134M, False: 556M] ------------------ 734| 134M| if (startHasProperty < 0) { ------------------ | Branch (734:21): [True: 33.7M, False: 100M] ------------------ 735| 33.7M| startHasProperty = ch; 736| 33.7M| } 737| 556M| } else if (startHasProperty >= 0) { ------------------ | Branch (737:24): [True: 33.7M, False: 522M] ------------------ 738| 33.7M| add(startHasProperty, ch-1); 739| 33.7M| startHasProperty = -1; 740| 33.7M| } 741| 690M| } 742| 237M| } 743| 130k| if (startHasProperty >= 0) { ------------------ | Branch (743:9): [True: 16.2k, False: 113k] ------------------ 744| 16.2k| add(startHasProperty, static_cast(0x10FFFF)); 745| 16.2k| } 746| 130k| if (isBogus() && U_SUCCESS(status)) { ------------------ | Branch (746:9): [True: 0, False: 130k] | 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| 130k|} _ZN6icu_7810UnicodeSet21applyIntPropertyValueE9UPropertyiR10UErrorCode: 783| 128k|UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode& ec) { 784| 128k| if (U_FAILURE(ec) || isFrozen()) { return *this; } ------------------ | Branch (784:9): [True: 0, False: 128k] | Branch (784:26): [True: 0, False: 128k] ------------------ 785| 128k| if (prop == UCHAR_GENERAL_CATEGORY_MASK) { ------------------ | Branch (785:9): [True: 97.0k, False: 31.0k] ------------------ 786| 97.0k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 787| 97.0k| applyFilter(generalCategoryMaskFilter, &value, inclusions, ec); 788| 97.0k| } else if (prop == UCHAR_SCRIPT_EXTENSIONS) { ------------------ | Branch (788:16): [True: 6.52k, False: 24.5k] ------------------ 789| 6.52k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 790| 6.52k| UScriptCode script = static_cast(value); 791| 6.52k| applyFilter(scriptExtensionsFilter, &script, inclusions, ec); 792| 24.5k| } else if (prop == UCHAR_IDENTIFIER_TYPE) { ------------------ | Branch (792:16): [True: 0, False: 24.5k] ------------------ 793| 0| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 794| 0| UIdentifierType idType = static_cast(value); 795| 0| applyFilter(idTypeFilter, &idType, inclusions, ec); 796| 24.5k| } else if (0 <= prop && prop < UCHAR_BINARY_LIMIT) { ------------------ | Branch (796:16): [True: 24.5k, False: 0] | Branch (796:29): [True: 4.33k, False: 20.2k] ------------------ 797| 4.33k| if (value == 0 || value == 1) { ------------------ | Branch (797:13): [True: 201, False: 4.13k] | Branch (797:27): [True: 4.13k, False: 0] ------------------ 798| 4.33k| const USet *set = u_getBinaryPropertySet(prop, &ec); ------------------ | | 269| 4.33k|#define u_getBinaryPropertySet U_ICU_ENTRY_POINT_RENAME(u_getBinaryPropertySet) | | ------------------ | | | | 123| 4.33k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.33k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.33k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 799| 4.33k| if (U_FAILURE(ec)) { return *this; } ------------------ | Branch (799:17): [True: 0, False: 4.33k] ------------------ 800| 4.33k| copyFrom(*UnicodeSet::fromUSet(set), true); 801| 4.33k| if (value == 0) { ------------------ | Branch (801:17): [True: 201, False: 4.13k] ------------------ 802| 201| complement().removeAllStrings(); // code point complement 803| 201| } 804| 4.33k| } else { 805| 0| clear(); 806| 0| } 807| 20.2k| } else if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { ------------------ | Branch (807:16): [True: 20.2k, False: 0] | Branch (807:43): [True: 20.2k, False: 0] ------------------ 808| 20.2k| const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec); 809| 20.2k| IntPropertyContext c = {prop, value}; 810| 20.2k| applyFilter(intPropertyFilter, &c, inclusions, ec); 811| 20.2k| } else { 812| 0| ec = U_ILLEGAL_ARGUMENT_ERROR; 813| 0| } 814| 128k| return *this; 815| 128k|} _ZN6icu_7810UnicodeSet18applyPropertyAliasERKNS_13UnicodeStringES3_R10UErrorCode: 820| 158k| UErrorCode& ec) { 821| 158k| if (U_FAILURE(ec) || isFrozen()) return *this; ------------------ | Branch (821:9): [True: 0, False: 158k] | Branch (821:26): [True: 0, False: 158k] ------------------ 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| 158k| if( !uprv_isInvariantUString(prop.getBuffer(), prop.length()) || ------------------ | | 1518| 158k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 158k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 158k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 158k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (829:9): [True: 95, False: 158k] ------------------ 830| 158k| !uprv_isInvariantUString(value.getBuffer(), value.length()) ------------------ | | 1518| 158k|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 158k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 158k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 158k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (830:9): [True: 49, False: 158k] ------------------ 831| 158k| ) { 832| 144| FAIL(ec); ------------------ | | 777| 144|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 144|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 144| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 144| return *this; \ | | 780| 144|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 144|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 833| 144| } 834| 158k| CharString pname, vname; 835| 158k| pname.appendInvariantChars(prop, ec); 836| 158k| vname.appendInvariantChars(value, ec); 837| 158k| if (U_FAILURE(ec)) return *this; ------------------ | Branch (837:9): [True: 0, False: 158k] ------------------ 838| | 839| 158k| UProperty p; 840| 158k| int32_t v; 841| 158k| UBool invert = false; 842| | 843| 158k| if (value.length() > 0) { ------------------ | Branch (843:9): [True: 33.1k, False: 125k] ------------------ 844| 33.1k| p = u_getPropertyEnum(pname.data()); ------------------ | | 283| 33.1k|#define u_getPropertyEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyEnum) | | ------------------ | | | | 123| 33.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 33.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 33.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 845| 33.1k| if (p == UCHAR_INVALID_CODE) 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] | | | | ------------------ | | ------------------ ------------------ | Branch (845:13): [True: 8, False: 33.1k] ------------------ 846| | 847| | // Treat gc as gcm 848| 33.1k| if (p == UCHAR_GENERAL_CATEGORY) { ------------------ | Branch (848:13): [True: 364, False: 32.7k] ------------------ 849| 364| p = UCHAR_GENERAL_CATEGORY_MASK; 850| 364| } 851| | 852| 33.1k| if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) || ------------------ | Branch (852:14): [True: 33.1k, False: 0] | Branch (852:41): [True: 205, False: 32.9k] ------------------ 853| 33.1k| (p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) || ------------------ | Branch (853:14): [True: 32.9k, False: 0] | Branch (853:38): [True: 11.0k, False: 21.8k] ------------------ 854| 33.1k| (p >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) { ------------------ | Branch (854:14): [True: 21.8k, False: 0] | Branch (854:39): [True: 364, False: 21.5k] ------------------ 855| 11.6k| v = u_getPropertyValueEnum(p, vname.data()); ------------------ | | 285| 11.6k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 11.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 856| 11.6k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (856:17): [True: 10.2k, False: 1.37k] ------------------ 857| | // Handle numeric CCC 858| 10.2k| if (p == UCHAR_CANONICAL_COMBINING_CLASS || ------------------ | Branch (858:21): [True: 4.15k, False: 6.06k] ------------------ 859| 10.2k| p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS || ------------------ | Branch (859:21): [True: 443, False: 5.62k] ------------------ 860| 10.2k| p == UCHAR_LEAD_CANONICAL_COMBINING_CLASS) { ------------------ | Branch (860:21): [True: 5.61k, False: 9] ------------------ 861| 10.2k| char* end; 862| 10.2k| double val = uprv_strtod(vname.data(), &end); ------------------ | | 75| 10.2k|#define uprv_strtod(source, end) U_STANDARD_CPP_NAMESPACE strtod(source, end) | | ------------------ | | | | 393| 10.2k|#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| 10.2k| if (*end != 0 || !(0 <= val && val <= 255) || ------------------ | Branch (867:25): [True: 5, False: 10.2k] | Branch (867:40): [True: 10.2k, False: 0] | Branch (867:52): [True: 10.2k, False: 1] ------------------ 868| 10.2k| (v = static_cast(val)) != val) { ------------------ | Branch (868:29): [True: 1, False: 10.2k] ------------------ 869| | // non-integral value or outside 0..255, or trailing junk 870| 7| FAIL(ec); ------------------ | | 777| 7|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 7|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 7| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 7| return *this; \ | | 780| 7|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 871| 7| } 872| 10.2k| } else { 873| 9| FAIL(ec); ------------------ | | 777| 9|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 9|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 9| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 9| return *this; \ | | 780| 9|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 9|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 874| 9| } 875| 10.2k| } 876| 11.6k| } 877| | 878| 21.5k| else { 879| | 880| 21.5k| switch (p) { 881| 6.37k| case UCHAR_NUMERIC_VALUE: ------------------ | Branch (881:13): [True: 6.37k, False: 15.1k] ------------------ 882| 6.37k| { 883| 6.37k| char* end; 884| 6.37k| double val = uprv_strtod(vname.data(), &end); ------------------ | | 75| 6.37k|#define uprv_strtod(source, end) U_STANDARD_CPP_NAMESPACE strtod(source, end) | | ------------------ | | | | 393| 6.37k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 885| 6.37k| if (*end != 0) { ------------------ | Branch (885:25): [True: 1, False: 6.37k] ------------------ 886| 1| FAIL(ec); ------------------ | | 777| 1|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 1| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 1| return *this; \ | | 780| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 887| 1| } 888| 6.37k| applyFilter(numericValueFilter, &val, 889| 6.37k| CharacterProperties::getInclusionsForProperty(p, ec), ec); 890| 6.37k| return *this; 891| 6.37k| } 892| 8.61k| case UCHAR_NAME: ------------------ | Branch (892:13): [True: 8.61k, False: 12.9k] ------------------ 893| 8.61k| { 894| | // Must munge name, since u_charFromName() does not do 895| | // 'loose' matching. 896| 8.61k| char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength 897| 8.61k| if (!mungeCharName(buf, vname.data(), sizeof(buf))) 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] | | | | ------------------ | | ------------------ ------------------ | Branch (897:25): [True: 2, False: 8.60k] ------------------ 898| 8.60k| UChar32 ch = u_charFromName(U_EXTENDED_CHAR_NAME, buf, &ec); ------------------ | | 222| 8.60k|#define u_charFromName U_ICU_ENTRY_POINT_RENAME(u_charFromName) | | ------------------ | | | | 123| 8.60k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.60k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.60k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 899| 8.60k| if (U_SUCCESS(ec)) { ------------------ | Branch (899:25): [True: 8.42k, False: 184] ------------------ 900| 8.42k| clear(); 901| 8.42k| add(ch); 902| 8.42k| return *this; 903| 8.42k| } else { 904| 184| FAIL(ec); ------------------ | | 777| 184|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 184|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 184| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 184| return *this; \ | | 780| 184|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 184|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 905| 184| } 906| 8.60k| } 907| 0| case UCHAR_UNICODE_1_NAME: ------------------ | Branch (907:13): [True: 0, False: 21.5k] ------------------ 908| | // ICU 49 deprecates the Unicode_1_Name property APIs. 909| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 910| 0| case UCHAR_AGE: ------------------ | Branch (910:13): [True: 0, False: 21.5k] ------------------ 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| 6.52k| case UCHAR_SCRIPT_EXTENSIONS: ------------------ | Branch (922:13): [True: 6.52k, False: 14.9k] ------------------ 923| 6.52k| v = u_getPropertyValueEnum(UCHAR_SCRIPT, vname.data()); ------------------ | | 285| 6.52k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 6.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 924| 6.52k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (924:21): [True: 5, False: 6.52k] ------------------ 925| 5| FAIL(ec); ------------------ | | 777| 5|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 5| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 5| return *this; \ | | 780| 5|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 926| 5| } 927| | // fall through to calling applyIntPropertyValue() 928| 6.52k| break; 929| 6.52k| case UCHAR_IDENTIFIER_TYPE: ------------------ | Branch (929:13): [True: 0, False: 21.5k] ------------------ 930| 0| v = u_getPropertyValueEnum(p, vname.data()); ------------------ | | 285| 0|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 931| 0| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (931:21): [True: 0, False: 0] ------------------ 932| 0| FAIL(ec); ------------------ | | 777| 0|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 0| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 0| return *this; \ | | 780| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 933| 0| } 934| | // fall through to calling applyIntPropertyValue() 935| 0| break; 936| 1| default: ------------------ | Branch (936:13): [True: 1, False: 21.5k] ------------------ 937| | // p is a non-binary, non-enumerated property that we 938| | // don't support (yet). 939| 1| FAIL(ec); ------------------ | | 777| 1|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 1| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 1| return *this; \ | | 780| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 940| 21.5k| } 941| 21.5k| } 942| 33.1k| } 943| | 944| 125k| else { 945| | // value is empty. Interpret as General Category, Script, or 946| | // Binary property. 947| 125k| p = UCHAR_GENERAL_CATEGORY_MASK; 948| 125k| v = u_getPropertyValueEnum(p, pname.data()); ------------------ | | 285| 125k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 125k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 125k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 125k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 949| 125k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (949:13): [True: 28.3k, False: 96.6k] ------------------ 950| 28.3k| p = UCHAR_SCRIPT; 951| 28.3k| v = u_getPropertyValueEnum(p, pname.data()); ------------------ | | 285| 28.3k|#define u_getPropertyValueEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyValueEnum) | | ------------------ | | | | 123| 28.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 28.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 28.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 952| 28.3k| if (v == UCHAR_INVALID_CODE) { ------------------ | Branch (952:17): [True: 19.1k, False: 9.19k] ------------------ 953| 19.1k| p = u_getPropertyEnum(pname.data()); ------------------ | | 283| 19.1k|#define u_getPropertyEnum U_ICU_ENTRY_POINT_RENAME(u_getPropertyEnum) | | ------------------ | | | | 123| 19.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 19.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 19.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| 19.1k| if (p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) { ------------------ | Branch (954:21): [True: 4.13k, False: 15.0k] | Branch (954:48): [True: 4.13k, False: 5] ------------------ 955| 4.13k| v = 1; 956| 15.0k| } else if (0 == uprv_comparePropertyNames(ANY, pname.data())) { ------------------ | | 60| 15.0k|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 15.0k|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 15.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 15.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 15.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (956:28): [True: 14.3k, False: 672] ------------------ 957| 14.3k| set(MIN_VALUE, MAX_VALUE); 958| 14.3k| return *this; 959| 14.3k| } else if (0 == uprv_comparePropertyNames(ASCII, pname.data())) { ------------------ | | 60| 672|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 672|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 672|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 672|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 672|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (959:28): [True: 513, False: 159] ------------------ 960| 513| set(0, 0x7F); 961| 513| return *this; 962| 513| } else if (0 == uprv_comparePropertyNames(ASSIGNED, pname.data())) { ------------------ | | 60| 159|# define uprv_comparePropertyNames uprv_compareASCIIPropertyNames | | ------------------ | | | | 1400| 159|#define uprv_compareASCIIPropertyNames U_ICU_ENTRY_POINT_RENAME(uprv_compareASCIIPropertyNames) | | | | ------------------ | | | | | | 123| 159|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 159|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 159|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (962:28): [True: 0, False: 159] ------------------ 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| 159| } else { 968| 159| FAIL(ec); ------------------ | | 777| 159|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 159|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 159| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 159| return *this; \ | | 780| 159|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 159|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 969| 159| } 970| 19.1k| } 971| 28.3k| } 972| 125k| } 973| | 974| 128k| applyIntPropertyValue(p, v, ec); 975| 128k| if(invert) { ------------------ | Branch (975:8): [True: 0, False: 128k] ------------------ 976| 0| complement().removeAllStrings(); // code point complement 977| 0| } 978| | 979| 128k| if (isBogus() && U_SUCCESS(ec)) { ------------------ | Branch (979:9): [True: 0, False: 128k] | 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| 128k| return *this; 984| 158k|} _ZN6icu_7810UnicodeSet24resemblesPropertyPatternERNS_21RuleCharacterIteratorEi: 1014| 23.4M| int32_t iterOpts) { 1015| | // NOTE: literal will always be false, because we don't parse escapes. 1016| 23.4M| UBool result = false, literal; 1017| 23.4M| UErrorCode ec = U_ZERO_ERROR; 1018| 23.4M| iterOpts &= ~RuleCharacterIterator::PARSE_ESCAPES; 1019| 23.4M| RuleCharacterIterator::Pos pos; 1020| 23.4M| chars.getPos(pos); 1021| 23.4M| UChar32 c = chars.next(iterOpts, literal, ec); 1022| 23.4M| if (c == u'[' || c == u'\\') { ------------------ | Branch (1022:9): [True: 370k, False: 23.1M] | Branch (1022:22): [True: 178k, False: 22.9M] ------------------ 1023| 549k| UChar32 d = chars.next(iterOpts & ~RuleCharacterIterator::SKIP_WHITESPACE, 1024| 549k| literal, ec); 1025| 549k| result = (c == u'[') ? (d == u':') : ------------------ | Branch (1025:18): [True: 370k, False: 178k] ------------------ 1026| 549k| (d == u'N' || d == u'p' || d == u'P'); ------------------ | Branch (1026:33): [True: 9.14k, False: 169k] | Branch (1026:46): [True: 61.4k, False: 108k] | Branch (1026:59): [True: 20.8k, False: 87.5k] ------------------ 1027| 549k| } 1028| 23.4M| chars.setPos(pos); 1029| 23.4M| return result && U_SUCCESS(ec); ------------------ | Branch (1029:12): [True: 161k, False: 23.3M] | Branch (1029:22): [True: 161k, False: 0] ------------------ 1030| 23.4M|} _ZN6icu_7810UnicodeSet20applyPropertyPatternERKNS_13UnicodeStringERNS_13ParsePositionER10UErrorCode: 1037| 158k| UErrorCode &ec) { 1038| 158k| int32_t pos = ppos.getIndex(); 1039| | 1040| 158k| UBool posix = false; // true for [:pat:], false for \p{pat} \P{pat} \N{pat} 1041| 158k| UBool isName = false; // true for \N{pat}, o/w false 1042| 158k| UBool invert = false; 1043| | 1044| 158k| if (U_FAILURE(ec)) return *this; ------------------ | Branch (1044:9): [True: 0, False: 158k] ------------------ 1045| | 1046| | // Minimum length is 5 characters, e.g. \p{L} 1047| 158k| if ((pos+5) > pattern.length()) { ------------------ | Branch (1047:9): [True: 118, False: 158k] ------------------ 1048| 118| FAIL(ec); ------------------ | | 777| 118|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 118|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 118| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 118| return *this; \ | | 780| 118|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 118|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1049| 118| } 1050| | 1051| | // On entry, ppos should point to one of the following locations: 1052| | // Look for an opening [:, [:^, \p, or \P 1053| 158k| if (isPOSIXOpen(pattern, pos)) { ------------------ | Branch (1053:9): [True: 69.9k, False: 88.5k] ------------------ 1054| 69.9k| posix = true; 1055| 69.9k| pos += 2; 1056| 69.9k| pos = ICU_Utility::skipWhitespace(pattern, pos); 1057| 69.9k| if (pos < pattern.length() && pattern.charAt(pos) == u'^') { ------------------ | Branch (1057:13): [True: 69.8k, False: 12] | Branch (1057:39): [True: 3.26k, False: 66.6k] ------------------ 1058| 3.26k| ++pos; 1059| 3.26k| invert = true; 1060| 3.26k| } 1061| 88.5k| } else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) { ------------------ | Branch (1061:16): [True: 79.8k, False: 8.67k] | Branch (1061:44): [True: 8.67k, False: 1] ------------------ 1062| 88.5k| char16_t c = pattern.charAt(pos+1); 1063| 88.5k| invert = (c == u'P'); 1064| 88.5k| isName = (c == u'N'); 1065| 88.5k| pos += 2; 1066| 88.5k| pos = ICU_Utility::skipWhitespace(pattern, pos); 1067| 88.5k| if (pos == pattern.length() || pattern.charAt(pos++) != u'{') { ------------------ | Branch (1067:13): [True: 3, False: 88.5k] | Branch (1067:40): [True: 38, False: 88.5k] ------------------ 1068| | // Syntax error; "\p" or "\P" not followed by "{" 1069| 41| FAIL(ec); ------------------ | | 777| 41|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 41|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 41| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 41| return *this; \ | | 780| 41|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 41|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1070| 41| } 1071| 88.5k| } else { 1072| | // Open delimiter not seen 1073| 1| FAIL(ec); ------------------ | | 777| 1|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 1| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 1| return *this; \ | | 780| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1074| 1| } 1075| | 1076| | // Look for the matching close delimiter, either :] or } 1077| 158k| int32_t close; 1078| 158k| if (posix) { ------------------ | Branch (1078:9): [True: 69.9k, False: 88.5k] ------------------ 1079| 69.9k| close = pattern.indexOf(u":]", 2, pos); 1080| 88.5k| } else { 1081| 88.5k| close = pattern.indexOf(u'}', pos); 1082| 88.5k| } 1083| 158k| if (close < 0) { ------------------ | Branch (1083:9): [True: 127, False: 158k] ------------------ 1084| | // Syntax error; close delimiter missing 1085| 127| FAIL(ec); ------------------ | | 777| 127|#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 127|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 778| 127| ec=U_ILLEGAL_ARGUMENT_ERROR; \ | | 779| 127| return *this; \ | | 780| 127|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 127|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1086| 127| } 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| 158k| int32_t equals = pattern.indexOf(u'=', pos); 1092| 158k| UnicodeString propName, valueName; 1093| 158k| if (equals >= 0 && equals < close && !isName) { ------------------ | Branch (1093:9): [True: 36.0k, False: 122k] | Branch (1093:24): [True: 25.5k, False: 10.4k] | Branch (1093:42): [True: 25.2k, False: 285] ------------------ 1094| | // Equals seen; parse medium/long pattern 1095| 25.2k| pattern.extractBetween(pos, equals, propName); 1096| 25.2k| pattern.extractBetween(equals+1, close, valueName); 1097| 25.2k| } 1098| | 1099| 133k| else { 1100| | // Handle case where no '=' is seen, and \N{} 1101| 133k| pattern.extractBetween(pos, close, propName); 1102| | 1103| | // Handle \N{name} 1104| 133k| if (isName) { ------------------ | Branch (1104:13): [True: 8.64k, False: 124k] ------------------ 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| 8.64k| valueName = propName; 1111| 8.64k| propName = NAME_PROP; 1112| 8.64k| } 1113| 133k| } 1114| | 1115| 158k| applyPropertyAlias(propName, valueName, ec); 1116| | 1117| 158k| if (U_SUCCESS(ec)) { ------------------ | Branch (1117:9): [True: 157k, False: 520] ------------------ 1118| 157k| if (invert) { ------------------ | Branch (1118:13): [True: 21.8k, False: 135k] ------------------ 1119| 21.8k| complement().removeAllStrings(); // code point complement 1120| 21.8k| } 1121| | 1122| | // Move to the limit position after the close delimiter if the 1123| | // parse succeeded. 1124| 157k| ppos.setIndex(close + (posix ? 2 : 1)); ------------------ | Branch (1124:32): [True: 69.5k, False: 88.2k] ------------------ 1125| 157k| } 1126| | 1127| 158k| return *this; 1128| 158k|} _ZN6icu_7810UnicodeSet20applyPropertyPatternERNS_21RuleCharacterIteratorERNS_13UnicodeStringER10UErrorCode: 1141| 161k| UErrorCode& ec) { 1142| 161k| if (U_FAILURE(ec)) return; ------------------ | Branch (1142:9): [True: 3.03k, False: 158k] ------------------ 1143| 158k| UnicodeString pattern; 1144| 158k| chars.lookahead(pattern); 1145| 158k| ParsePosition pos(0); 1146| 158k| applyPropertyPattern(pattern, pos, ec); 1147| 158k| if (U_FAILURE(ec)) return; ------------------ | Branch (1147:9): [True: 807, False: 157k] ------------------ 1148| 157k| if (pos.getIndex() == 0) { ------------------ | Branch (1148:9): [True: 0, False: 157k] ------------------ 1149| | // syntaxError(chars, "Invalid property pattern"); 1150| 0| ec = U_MALFORMED_SET; 1151| 0| return; 1152| 0| } 1153| 157k| chars.jumpahead(pos.getIndex()); 1154| 157k| rebuiltPat.append(pattern, 0, pos.getIndex()); 1155| 157k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointerC2Ev: 232| 179k| inline UnicodeSetPointer() : p(nullptr) {} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointer8allocateEv: 235| 287k| inline UBool allocate() { 236| 287k| if (p == nullptr) { ------------------ | Branch (236:13): [True: 99.5k, False: 187k] ------------------ 237| 99.5k| p = new UnicodeSet(); 238| 99.5k| } 239| 287k| return p != nullptr; 240| 287k| } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointer7pointerEv: 234| 287k| inline UnicodeSet* pointer() { return p; } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117UnicodeSetPointerD2Ev: 233| 179k| inline ~UnicodeSetPointer() { delete p; } uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_125generalCategoryMaskFilterEiPv: 667| 582M|UBool generalCategoryMaskFilter(UChar32 ch, void* context) { 668| 582M| int32_t value = *static_cast(context); 669| 582M| return (U_GET_GC_MASK((UChar32) ch) & value) != 0; ------------------ | | 3644| 582M|#define U_GET_GC_MASK(c) U_MASK(u_charType(c)) | | ------------------ | | | | 174| 582M|#define U_MASK(x) ((uint32_t)1<<(x)) | | ------------------ ------------------ 670| 582M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_122scriptExtensionsFilterEiPv: 690| 46.4M|UBool scriptExtensionsFilter(UChar32 ch, void* context) { 691| 46.4M| return uscript_hasScript(ch, *static_cast(context)); ------------------ | | 1710| 46.4M|#define uscript_hasScript U_ICU_ENTRY_POINT_RENAME(uscript_hasScript) | | ------------------ | | | | 123| 46.4M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 46.4M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 46.4M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 692| 46.4M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_117intPropertyFilterEiPv: 685| 22.8M|UBool intPropertyFilter(UChar32 ch, void* context) { 686| 22.8M| IntPropertyContext* c = static_cast(context); 687| 22.8M| return u_getIntPropertyValue(ch, c->prop) == c->value; ------------------ | | 280| 22.8M|#define u_getIntPropertyValue U_ICU_ENTRY_POINT_RENAME(u_getIntPropertyValue) | | ------------------ | | | | 123| 22.8M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 22.8M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 22.8M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 688| 22.8M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_118numericValueFilterEiPv: 663| 38.2M|UBool numericValueFilter(UChar32 ch, void* context) { 664| 38.2M| return u_getNumericValue(ch) == *static_cast(context); ------------------ | | 282| 38.2M|#define u_getNumericValue U_ICU_ENTRY_POINT_RENAME(u_getNumericValue) | | ------------------ | | | | 123| 38.2M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 38.2M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 38.2M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 665| 38.2M|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_113mungeCharNameEPcPKci: 754| 8.61k|UBool mungeCharName(char* dst, const char* src, int32_t dstCapacity) { 755| | /* Note: we use ' ' in compiler code page */ 756| 8.61k| int32_t j = 0; 757| 8.61k| char ch; 758| 8.61k| --dstCapacity; /* make room for term. zero */ 759| 49.9k| while ((ch = *src++) != 0) { ------------------ | Branch (759:12): [True: 41.3k, False: 8.60k] ------------------ 760| 41.3k| if (ch == ' ' && (j==0 || (j>0 && dst[j-1]==' '))) { ------------------ | Branch (760:13): [True: 16.5k, False: 24.8k] | Branch (760:27): [True: 15.8k, False: 715] | Branch (760:36): [True: 715, False: 0] | Branch (760:43): [True: 416, False: 299] ------------------ 761| 16.2k| continue; 762| 16.2k| } 763| 25.1k| if (j >= dstCapacity) return false; ------------------ | Branch (763:13): [True: 2, False: 25.1k] ------------------ 764| 25.1k| dst[j++] = ch; 765| 25.1k| } 766| 8.60k| if (j > 0 && dst[j-1] == ' ') --j; ------------------ | Branch (766:9): [True: 8.60k, False: 9] | Branch (766:18): [True: 218, False: 8.38k] ------------------ 767| 8.60k| dst[j] = 0; 768| 8.60k| return true; 769| 8.61k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_111isPOSIXOpenERKNS_13UnicodeStringEi: 129| 158k|isPOSIXOpen(const UnicodeString &pattern, int32_t pos) { 130| 158k| return pattern.charAt(pos)==u'[' && pattern.charAt(pos+1)==u':'; ------------------ | Branch (130:12): [True: 69.9k, False: 88.5k] | Branch (130:41): [True: 69.9k, False: 0] ------------------ 131| 158k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_110isPerlOpenERKNS_13UnicodeStringEi: 113| 88.5k|isPerlOpen(const UnicodeString &pattern, int32_t pos) { 114| 88.5k| char16_t c; 115| 88.5k| return pattern.charAt(pos)==u'\\' && ((c=pattern.charAt(pos+1))==u'p' || c==u'P'); ------------------ | Branch (115:12): [True: 88.5k, False: 1] | Branch (115:43): [True: 61.2k, False: 27.3k] | Branch (115:78): [True: 18.6k, False: 8.67k] ------------------ 116| 88.5k|} uniset_props.cpp:_ZN6icu_7812_GLOBAL__N_110isNameOpenERKNS_13UnicodeStringEi: 124| 8.67k|isNameOpen(const UnicodeString &pattern, int32_t pos) { 125| 8.67k| return pattern.charAt(pos)==u'\\' && pattern.charAt(pos+1)==u'N'; ------------------ | Branch (125:12): [True: 8.67k, False: 1] | Branch (125:42): [True: 8.67k, False: 0] ------------------ 126| 8.67k|} _ZN6icu_7811ReplaceableD2Ev: 106| 17.2M|Replaceable::~Replaceable() {} _ZN6icu_7813UnicodeString6addRefEv: 146| 99.9k|UnicodeString::addRef() { 147| 99.9k| umtx_atomic_inc(reinterpret_cast(fUnion.fFields.fArray) - 1); 148| 99.9k|} _ZN6icu_7813UnicodeString9removeRefEv: 151| 318k|UnicodeString::removeRef() { 152| 318k| return umtx_atomic_dec(reinterpret_cast(fUnion.fFields.fArray) - 1); 153| 318k|} _ZNK6icu_7813UnicodeString8refCountEv: 156| 886M|UnicodeString::refCount() const { 157| 886M| return umtx_loadAcquire(*(reinterpret_cast(fUnion.fFields.fArray) - 1)); 158| 886M|} _ZN6icu_7813UnicodeString12releaseArrayEv: 161| 18.8M|UnicodeString::releaseArray() { 162| 18.8M| if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) { ------------------ | Branch (162:6): [True: 318k, False: 18.5M] | Branch (162:56): [True: 277k, False: 40.9k] ------------------ 163| 277k| uprv_free(reinterpret_cast(fUnion.fFields.fArray) - 1); ------------------ | | 1503| 277k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 277k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 277k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 277k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 277k| } 165| 18.8M|} _ZN6icu_7813UnicodeStringC2Eiii: 175| 78.6k|UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) { 176| 78.6k| fUnion.fFields.fLengthAndFlags = 0; 177| 78.6k| if (count <= 0 || static_cast(c) > 0x10ffff) { ------------------ | Branch (177:7): [True: 0, False: 78.6k] | Branch (177:21): [True: 0, False: 78.6k] ------------------ 178| | // just allocate and do not do anything else 179| 0| allocate(capacity); 180| 78.6k| } else if(c <= 0xffff) { ------------------ | Branch (180:13): [True: 78.6k, False: 0] ------------------ 181| 78.6k| int32_t length = count; 182| 78.6k| if(capacity < length) { ------------------ | Branch (182:8): [True: 78.6k, False: 0] ------------------ 183| 78.6k| capacity = length; 184| 78.6k| } 185| 78.6k| if(allocate(capacity)) { ------------------ | Branch (185:8): [True: 78.6k, False: 0] ------------------ 186| 78.6k| char16_t *array = getArrayStart(); 187| 78.6k| char16_t unit = static_cast(c); 188| 10.1M| for(int32_t i = 0; i < length; ++i) { ------------------ | Branch (188:26): [True: 10.0M, False: 78.6k] ------------------ 189| 10.0M| array[i] = unit; 190| 10.0M| } 191| 78.6k| setLength(length); 192| 78.6k| } 193| 78.6k| } else { // supplementary code point, write surrogate pairs 194| 0| if(count > (INT32_MAX / 2)) { ------------------ | Branch (194:8): [True: 0, False: 0] ------------------ 195| | // We would get more than 2G UChars. 196| 0| allocate(capacity); 197| 0| return; 198| 0| } 199| 0| int32_t length = count * 2; 200| 0| if(capacity < length) { ------------------ | Branch (200:8): [True: 0, False: 0] ------------------ 201| 0| capacity = length; 202| 0| } 203| 0| if(allocate(capacity)) { ------------------ | Branch (203:8): [True: 0, False: 0] ------------------ 204| 0| char16_t *array = getArrayStart(); 205| 0| char16_t lead = U16_LEAD(c); ------------------ | | 123| 0|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 206| 0| char16_t trail = U16_TRAIL(c); ------------------ | | 132| 0|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 207| 0| for(int32_t i = 0; i < length; i += 2) { ------------------ | Branch (207:26): [True: 0, False: 0] ------------------ 208| 0| array[i] = lead; 209| 0| array[i + 1] = trail; 210| 0| } 211| 0| setLength(length); 212| 0| } 213| 0| } 214| 78.6k|} _ZN6icu_7813UnicodeStringC2EDs: 216| 8.41k|UnicodeString::UnicodeString(char16_t ch) { 217| 8.41k| fUnion.fFields.fLengthAndFlags = kLength1 | kShortString; 218| 8.41k| fUnion.fStackFields.fBuffer[0] = ch; 219| 8.41k|} _ZN6icu_7813UnicodeStringC2Ei: 221| 4.60M|UnicodeString::UnicodeString(UChar32 ch) { 222| 4.60M| fUnion.fFields.fLengthAndFlags = kShortString; 223| 4.60M| int32_t i = 0; 224| 4.60M| UBool isError = false; 225| 4.60M| U16_APPEND(fUnion.fStackFields.fBuffer, i, US_STACKBUF_SIZE, ch, isError); ------------------ | | 393| 4.60M|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.60M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 4.60M| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 4.59M, False: 2.23k] | | ------------------ | | 395| 4.59M| (s)[(i)++]=(uint16_t)(c); \ | | 396| 4.59M| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 2.23k, False: 0] | | | Branch (396:42): [True: 2.23k, False: 0] | | ------------------ | | 397| 2.23k| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 2.23k| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 2.23k| } else /* c>0x10ffff or not enough space */ { \ | | 400| 0| (isError)=true; \ | | 401| 0| } \ | | 402| 4.60M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.60M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 226| | // We test isError so that the compiler does not complain that we don't. 227| | // If isError then i==0 which is what we want anyway. 228| 4.60M| if(!isError) { ------------------ | Branch (228:6): [True: 4.60M, False: 0] ------------------ 229| 4.60M| setShortLength(i); 230| 4.60M| } 231| 4.60M|} _ZN6icu_7813UnicodeStringC2EaNS_14ConstChar16PtrEi: 241| 23.0k| int32_t textLength) { 242| 23.0k| fUnion.fFields.fLengthAndFlags = kReadonlyAlias; 243| 23.0k| const char16_t *text = textPtr; 244| 23.0k| if(text == nullptr) { ------------------ | Branch (244:6): [True: 0, False: 23.0k] ------------------ 245| | // treat as an empty string, do not alias 246| 0| setToEmpty(); 247| 23.0k| } else if(textLength < -1 || ------------------ | Branch (247:13): [True: 0, False: 23.0k] ------------------ 248| 23.0k| (textLength == -1 && !isTerminated) || ------------------ | Branch (248:14): [True: 0, False: 23.0k] | Branch (248:34): [True: 0, False: 0] ------------------ 249| 23.0k| (textLength >= 0 && isTerminated && text[textLength] != 0) ------------------ | Branch (249:14): [True: 23.0k, False: 0] | Branch (249:33): [True: 14.6k, False: 8.41k] | Branch (249:49): [True: 0, False: 14.6k] ------------------ 250| 23.0k| ) { 251| 0| setToBogus(); 252| 23.0k| } else { 253| 23.0k| if(textLength == -1) { ------------------ | Branch (253:8): [True: 0, False: 23.0k] ------------------ 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| 23.0k| setArray(const_cast(text), textLength, 258| 23.0k| isTerminated ? textLength + 1 : textLength); ------------------ | Branch (258:14): [True: 14.6k, False: 8.41k] ------------------ 259| 23.0k| } 260| 23.0k|} _ZN6icu_7813UnicodeStringC2ERKS0_: 345| 286k|UnicodeString::UnicodeString(const UnicodeString& that) { 346| 286k| fUnion.fFields.fLengthAndFlags = kShortString; 347| 286k| copyFrom(that); 348| 286k|} _ZN6icu_7813UnicodeStringC2ERKS0_ii: 362| 2.35k| int32_t srcLength) { 363| 2.35k| fUnion.fFields.fLengthAndFlags = kShortString; 364| 2.35k| setTo(that, srcStart, srcLength); 365| 2.35k|} _ZN6icu_7813UnicodeString8allocateEi: 409| 433k|UnicodeString::allocate(int32_t capacity) { 410| 433k| if(capacity <= US_STACKBUF_SIZE) { ------------------ | Branch (410:6): [True: 31.2k, False: 401k] ------------------ 411| 31.2k| fUnion.fFields.fLengthAndFlags = kShortString; 412| 31.2k| return true; 413| 31.2k| } 414| 401k| if(capacity <= kMaxCapacity) { ------------------ | Branch (414:6): [True: 401k, False: 0] ------------------ 415| 401k| ++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| 401k| size_t numBytes = sizeof(int32_t) + static_cast(capacity) * U_SIZEOF_UCHAR; ------------------ | | 352| 401k|#define U_SIZEOF_UCHAR 2 ------------------ 419| | // Round up to a multiple of 16. 420| 401k| numBytes = (numBytes + 15) & ~15; 421| 401k| int32_t* array = static_cast(uprv_malloc(numBytes)); ------------------ | | 1524| 401k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 401k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 401k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 401k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 422| 401k| if(array != nullptr) { ------------------ | Branch (422:8): [True: 401k, False: 0] ------------------ 423| | // set initial refCount and point behind the refCount 424| 401k| *array++ = 1; 425| 401k| numBytes -= sizeof(int32_t); 426| | 427| | // have fArray point to the first char16_t 428| 401k| fUnion.fFields.fArray = reinterpret_cast(array); 429| 401k| fUnion.fFields.fCapacity = static_cast(numBytes / U_SIZEOF_UCHAR); ------------------ | | 352| 401k|#define U_SIZEOF_UCHAR 2 ------------------ 430| 401k| fUnion.fFields.fLengthAndFlags = kLongString; 431| 401k| return true; 432| 401k| } 433| 401k| } 434| 0| fUnion.fFields.fLengthAndFlags = kIsBogus; 435| 0| fUnion.fFields.fArray = nullptr; 436| 0| fUnion.fFields.fCapacity = 0; 437| 0| return false; 438| 401k|} _ZN6icu_7813UnicodeStringD2Ev: 462| 17.2M|{ 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| 17.2M| releaseArray(); 478| 17.2M|} _ZN6icu_7813UnicodeString8fromUTF8ENS_11StringPieceE: 484| 2.63k|UnicodeString UnicodeString::fromUTF8(StringPiece utf8) { 485| 2.63k| UnicodeString result; 486| 2.63k| result.setToUTF8(utf8); 487| 2.63k| return result; 488| 2.63k|} _ZN6icu_7813UnicodeStringaSERKS0_: 527| 1.33M|UnicodeString::operator=(const UnicodeString &src) { 528| 1.33M| return copyFrom(src); 529| 1.33M|} _ZN6icu_7813UnicodeString8copyFromERKS0_a: 537| 1.62M|UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) { 538| | // if assigning to ourselves, do nothing 539| 1.62M| if(this == &src) { ------------------ | Branch (539:6): [True: 0, False: 1.62M] ------------------ 540| 0| return *this; 541| 0| } 542| | 543| | // is the right side bogus? 544| 1.62M| if(src.isBogus()) { ------------------ | Branch (544:6): [True: 0, False: 1.62M] ------------------ 545| 0| setToBogus(); 546| 0| return *this; 547| 0| } 548| | 549| | // delete the current contents 550| 1.62M| releaseArray(); 551| | 552| 1.62M| if(src.isEmpty()) { ------------------ | Branch (552:6): [True: 1.07M, False: 550k] ------------------ 553| | // empty string - use the stack buffer 554| 1.07M| setToEmpty(); 555| 1.07M| return *this; 556| 1.07M| } 557| | 558| | // fLength>0 and not an "open" src.getBuffer(minCapacity) 559| 550k| fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags; 560| 550k| switch(src.fUnion.fFields.fLengthAndFlags & kAllStorageFlags) { 561| 439k| case kShortString: ------------------ | Branch (561:3): [True: 439k, False: 110k] ------------------ 562| | // short string using the stack buffer, do the same 563| 439k| uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer, ------------------ | | 42| 439k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 439k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 439k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 439k| _Pragma("clang diagnostic push") \ | | 45| 439k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 439k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 439k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 439k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 439k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 439k| _Pragma("clang diagnostic pop") \ | | 49| 439k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 439k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 439k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 439k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 564| 439k| getShortLength() * U_SIZEOF_UCHAR); 565| 439k| break; 566| 99.9k| case kLongString: ------------------ | Branch (566:3): [True: 99.9k, False: 450k] ------------------ 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| 99.9k| const_cast(src).addRef(); 570| | // copy all fields, share the reference-counted buffer 571| 99.9k| fUnion.fFields.fArray = src.fUnion.fFields.fArray; 572| 99.9k| fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity; 573| 99.9k| if(!hasShortLength()) { ------------------ | Branch (573:8): [True: 5.41k, False: 94.5k] ------------------ 574| 5.41k| fUnion.fFields.fLength = src.fUnion.fFields.fLength; 575| 5.41k| } 576| 99.9k| break; 577| 10.3k| case kReadonlyAlias: ------------------ | Branch (577:3): [True: 10.3k, False: 539k] ------------------ 578| 10.3k| if(fastCopy) { ------------------ | Branch (578:8): [True: 0, False: 10.3k] ------------------ 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| 10.3k| U_FALLTHROUGH; ------------------ | | 511| 10.3k|# define U_FALLTHROUGH [[clang::fallthrough]] ------------------ 591| 10.3k| case kWritableAlias: { ------------------ | Branch (591:3): [True: 0, False: 550k] ------------------ 592| | // src is a writable alias; we make a copy of that instead 593| 10.3k| int32_t srcLength = src.length(); 594| 10.3k| if(allocate(srcLength)) { ------------------ | Branch (594:8): [True: 10.3k, False: 0] ------------------ 595| 10.3k| u_memcpy(getArrayStart(), src.getArrayStart(), srcLength); ------------------ | | 334| 10.3k|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 123| 10.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 10.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 10.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 596| 10.3k| setLength(srcLength); 597| 10.3k| break; 598| 10.3k| } 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: 550k] ------------------ 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| 550k| } 610| | 611| 550k| return *this; 612| 550k|} _ZN6icu_7813UnicodeStringaSEOS0_: 614| 5.27k|UnicodeString &UnicodeString::operator=(UnicodeString &&src) noexcept { 615| | // No explicit check for self move assignment, consistent with standard library. 616| | // Self move assignment causes no crash nor leak but might make the object bogus. 617| 5.27k| releaseArray(); 618| 5.27k| copyFieldsFrom(src, true); 619| 5.27k| return *this; 620| 5.27k|} _ZN6icu_7813UnicodeString14copyFieldsFromERS0_a: 623| 5.27k|void UnicodeString::copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) noexcept { 624| 5.27k| int16_t lengthAndFlags = fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags; 625| 5.27k| if(lengthAndFlags & kUsingStackBuffer) { ------------------ | Branch (625:6): [True: 2.87k, False: 2.39k] ------------------ 626| | // Short string using the stack buffer, copy the contents. 627| | // Check for self assignment to prevent "overlap in memcpy" warnings, 628| | // although it should be harmless to copy a buffer to itself exactly. 629| 2.87k| if(this != &src) { ------------------ | Branch (629:8): [True: 2.87k, False: 0] ------------------ 630| 2.87k| uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer, ------------------ | | 42| 2.87k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.87k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.87k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.87k| _Pragma("clang diagnostic push") \ | | 45| 2.87k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.87k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.87k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.87k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.87k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.87k| _Pragma("clang diagnostic pop") \ | | 49| 2.87k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.87k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.87k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.87k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 631| 2.87k| getShortLength() * U_SIZEOF_UCHAR); 632| 2.87k| } 633| 2.87k| } else { 634| | // In all other cases, copy all fields. 635| 2.39k| fUnion.fFields.fArray = src.fUnion.fFields.fArray; 636| 2.39k| fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity; 637| 2.39k| if(!hasShortLength()) { ------------------ | Branch (637:8): [True: 360, False: 2.03k] ------------------ 638| 360| fUnion.fFields.fLength = src.fUnion.fFields.fLength; 639| 360| } 640| 2.39k| if(setSrcToBogus) { ------------------ | Branch (640:8): [True: 2.39k, False: 0] ------------------ 641| | // Set src to bogus without releasing any memory. 642| 2.39k| src.fUnion.fFields.fLengthAndFlags = kIsBogus; 643| 2.39k| src.fUnion.fFields.fArray = nullptr; 644| 2.39k| src.fUnion.fFields.fCapacity = 0; 645| 2.39k| } 646| 2.39k| } 647| 5.27k|} _ZNK6icu_7813UnicodeString10unescapeAtERi: 690| 403k|UChar32 UnicodeString::unescapeAt(int32_t &offset) const { 691| 403k| return u_unescapeAt(UnicodeString_charAt, &offset, length(), (void*)this); ------------------ | | 416| 403k|#define u_unescapeAt U_ICU_ENTRY_POINT_RENAME(u_unescapeAt) | | ------------------ | | | | 123| 403k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 403k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 403k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 692| 403k|} _ZNK6icu_7813UnicodeString8doEqualsEPKDsi: 698| 4.70M|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| 4.70M| return uprv_memcmp(getArrayStart(), text, len * U_SIZEOF_UCHAR) == 0; ------------------ | | 101| 4.70M|#define uprv_memcmp(buffer1, buffer2, size) U_STANDARD_CPP_NAMESPACE memcmp(buffer1, buffer2,size) | | ------------------ | | | | 393| 4.70M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 702| 4.70M|} _ZNK6icu_7813UnicodeString9doCompareEiiPKDsii: 752| 448k|{ 753| | // compare illegal string values 754| 448k| if(isBogus()) { ------------------ | Branch (754:6): [True: 0, False: 448k] ------------------ 755| 0| return -1; 756| 0| } 757| | 758| | // pin indices to legal values 759| 448k| pinIndices(start, length); 760| | 761| 448k| if(srcChars == nullptr) { ------------------ | Branch (761:6): [True: 0, False: 448k] ------------------ 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| 448k| const char16_t *chars = getArrayStart(); 768| | 769| 448k| chars += start; 770| 448k| srcChars += srcStart; 771| | 772| 448k| int32_t minLength; 773| 448k| int8_t lengthResult; 774| | 775| | // get the srcLength if necessary 776| 448k| if(srcLength < 0) { ------------------ | Branch (776:6): [True: 169k, False: 278k] ------------------ 777| 169k| srcLength = u_strlen(srcChars + srcStart); ------------------ | | 393| 169k|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 169k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 169k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 169k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 778| 169k| } 779| | 780| | // are we comparing different lengths? 781| 448k| if(length != srcLength) { ------------------ | Branch (781:6): [True: 417k, False: 30.7k] ------------------ 782| 417k| if(length < srcLength) { ------------------ | Branch (782:8): [True: 294k, False: 123k] ------------------ 783| 294k| minLength = length; 784| 294k| lengthResult = -1; 785| 294k| } else { 786| 123k| minLength = srcLength; 787| 123k| lengthResult = 1; 788| 123k| } 789| 417k| } else { 790| 30.7k| minLength = length; 791| 30.7k| lengthResult = 0; 792| 30.7k| } 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| 448k| if(minLength > 0 && chars != srcChars) { ------------------ | Branch (802:6): [True: 443k, False: 4.37k] | Branch (802:23): [True: 442k, False: 955] ------------------ 803| 442k| 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| 11.2M| do { 814| 11.2M| result = static_cast(*(chars++)) - static_cast(*(srcChars++)); 815| 11.2M| if(result != 0) { ------------------ | Branch (815:12): [True: 437k, False: 10.7M] ------------------ 816| 437k| return static_cast(result >> 15 | 1); 817| 437k| } 818| 11.2M| } while(--minLength > 0); ------------------ | Branch (818:15): [True: 10.7M, False: 4.81k] ------------------ 819| 442k|# endif 820| 442k| } 821| 10.1k| return lengthResult; 822| 448k|} _ZNK6icu_7813UnicodeString8char32AtEi: 871| 264M|{ 872| 264M| int32_t len = length(); 873| 264M| if (static_cast(offset) < static_cast(len)) { ------------------ | Branch (873:7): [True: 264M, False: 18] ------------------ 874| 264M| const char16_t *array = getArrayStart(); 875| 264M| UChar32 c; 876| 264M| U16_GET(array, 0, offset, len, c); ------------------ | | 201| 264M|#define U16_GET(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 264M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 202| 264M| (c)=(s)[i]; \ | | 203| 264M| if(U16_IS_SURROGATE(c)) { \ | | ------------------ | | | | 75| 264M|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | | | ------------------ | | | | | | 193| 264M|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | | | ------------------ | | | | | | | Branch (193:27): [True: 235k, False: 264M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 204| 235k| uint16_t __c2; \ | | 205| 235k| if(U16_IS_SURROGATE_LEAD(c)) { \ | | ------------------ | | | | 84| 235k|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | | | ------------------ | | | | | Branch (84:34): [True: 181k, False: 53.6k] | | | | ------------------ | | ------------------ | | 206| 181k| if((i)+1!=(length) && U16_IS_TRAIL(__c2=(s)[(i)+1])) { \ | | ------------------ | | | | 67| 181k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | ------------------ | | | | | Branch (67:25): [True: 96.1k, False: 84.8k] | | | | ------------------ | | ------------------ | | | Branch (206:16): [True: 181k, False: 887] | | ------------------ | | 207| 96.1k| (c)=U16_GET_SUPPLEMENTARY((c), __c2); \ | | ------------------ | | | | 113| 96.1k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | | | ------------------ | | | | | | 99| 96.1k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | | | ------------------ | | ------------------ | | 208| 96.1k| } \ | | 209| 181k| } else { \ | | 210| 53.6k| if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \ | | ------------------ | | | | 59| 53.2k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | ------------------ | | | | | Branch (59:24): [True: 0, False: 53.2k] | | | | ------------------ | | ------------------ | | | Branch (210:16): [True: 53.2k, False: 382] | | ------------------ | | 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| 53.6k| } \ | | 214| 235k| } \ | | 215| 264M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 264M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 877| 264M| return c; 878| 264M| } else { 879| 18| return kInvalidUChar; 880| 18| } 881| 264M|} _ZNK6icu_7813UnicodeString11moveIndex32Eii: 921| 24.0M|UnicodeString::moveIndex32(int32_t index, int32_t delta) const { 922| | // pin index 923| 24.0M| int32_t len = length(); 924| 24.0M| if(index<0) { ------------------ | Branch (924:6): [True: 0, False: 24.0M] ------------------ 925| 0| index=0; 926| 24.0M| } else if(index>len) { ------------------ | Branch (926:13): [True: 0, False: 24.0M] ------------------ 927| 0| index=len; 928| 0| } 929| | 930| 24.0M| const char16_t *array = getArrayStart(); 931| 24.0M| if(delta>0) { ------------------ | Branch (931:6): [True: 24.0M, False: 0] ------------------ 932| 24.0M| U16_FWD_N(array, index, len, delta); ------------------ | | 474| 24.0M|#define U16_FWD_N(s, i, length, n) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 24.0M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 475| 24.0M| int32_t __N=(n); \ | | 476| 48.1M| while(__N>0 && ((i)<(length) || ((length)<0 && (s)[i]!=0))) { \ | | ------------------ | | | Branch (476:11): [True: 24.0M, False: 24.0M] | | | Branch (476:21): [True: 24.0M, False: 0] | | | Branch (476:38): [True: 0, False: 0] | | | Branch (476:52): [True: 0, False: 0] | | ------------------ | | 477| 24.0M| U16_FWD_1(s, i, length); \ | | ------------------ | | | | 433| 24.0M|#define U16_FWD_1(s, i, length) UPRV_BLOCK_MACRO_BEGIN { \ | | | | ------------------ | | | | | | 169| 24.0M|#define UPRV_BLOCK_MACRO_BEGIN do | | | | ------------------ | | | | 434| 24.0M| if(U16_IS_LEAD((s)[(i)++]) && (i)!=(length) && U16_IS_TRAIL((s)[i])) { \ | | | | ------------------ | | | | | | 59| 48.1M|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | | | ------------------ | | | | | | | Branch (59:24): [True: 34.3k, False: 24.0M] | | | | | | ------------------ | | | | ------------------ | | | | if(U16_IS_LEAD((s)[(i)++]) && (i)!=(length) && U16_IS_TRAIL((s)[i])) { \ | | | | ------------------ | | | | | | 67| 34.3k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | | | ------------------ | | | | | | | Branch (67:25): [True: 33.9k, False: 402] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (434:35): [True: 34.3k, False: 0] | | | | ------------------ | | | | 435| 33.9k| ++(i); \ | | | | 436| 33.9k| } \ | | | | 437| 24.0M|} UPRV_BLOCK_MACRO_END | | | | ------------------ | | | | | | 178| 24.0M|#define UPRV_BLOCK_MACRO_END while (false) | | | | | | ------------------ | | | | | | | Branch (178:37): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 478| 24.0M| --__N; \ | | 479| 24.0M| } \ | | 480| 24.0M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 24.0M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 933| 24.0M| } else { 934| 0| U16_BACK_N(array, 0, index, -delta); ------------------ | | 684| 0|#define U16_BACK_N(s, start, i, n) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 685| 0| int32_t __N=(n); \ | | 686| 0| while(__N>0 && (i)>(start)) { \ | | ------------------ | | | Branch (686:11): [True: 0, False: 0] | | | Branch (686:20): [True: 0, False: 0] | | ------------------ | | 687| 0| U16_BACK_1(s, start, i); \ | | ------------------ | | | | 643| 0|#define U16_BACK_1(s, start, i) UPRV_BLOCK_MACRO_BEGIN { \ | | | | ------------------ | | | | | | 169| 0|#define UPRV_BLOCK_MACRO_BEGIN do | | | | ------------------ | | | | 644| 0| if(U16_IS_TRAIL((s)[--(i)]) && (i)>(start) && U16_IS_LEAD((s)[(i)-1])) { \ | | | | ------------------ | | | | | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | | | | | ------------------ | | | | | | | Branch (67:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | if(U16_IS_TRAIL((s)[--(i)]) && (i)>(start) && U16_IS_LEAD((s)[(i)-1])) { \ | | | | ------------------ | | | | | | 59| 0|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | | | | | ------------------ | | | | | | | Branch (59:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (644:36): [True: 0, False: 0] | | | | ------------------ | | | | 645| 0| --(i); \ | | | | 646| 0| } \ | | | | 647| 0|} UPRV_BLOCK_MACRO_END | | | | ------------------ | | | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | | | ------------------ | | | | | | | Branch (178:37): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 688| 0| --__N; \ | | 689| 0| } \ | | 690| 0|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 0|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 935| 0| } 936| | 937| 24.0M| return index; 938| 24.0M|} _ZNK6icu_7813UnicodeString14extractBetweenEiiRS0_: 1040| 4.88M| UnicodeString& target) const { 1041| 4.88M| pinIndex(start); 1042| 4.88M| pinIndex(limit); 1043| 4.88M| doExtract(start, limit - start, target); 1044| 4.88M|} _ZNK6icu_7813UnicodeString7indexOfEPKDsiiii: 1112| 69.9k|{ 1113| 69.9k| if (isBogus() || srcChars == nullptr || srcStart < 0 || srcLength == 0) { ------------------ | Branch (1113:7): [True: 0, False: 69.9k] | Branch (1113:20): [True: 0, False: 69.9k] | Branch (1113:43): [True: 0, False: 69.9k] | Branch (1113:59): [True: 0, False: 69.9k] ------------------ 1114| 0| return -1; 1115| 0| } 1116| | 1117| | // UnicodeString does not find empty substrings 1118| 69.9k| if(srcLength < 0 && srcChars[srcStart] == 0) { ------------------ | Branch (1118:6): [True: 0, False: 69.9k] | Branch (1118:23): [True: 0, False: 0] ------------------ 1119| 0| return -1; 1120| 0| } 1121| | 1122| | // get the indices within bounds 1123| 69.9k| pinIndices(start, length); 1124| | 1125| | // find the first occurrence of the substring 1126| 69.9k| const char16_t *array = getArrayStart(); 1127| 69.9k| const char16_t *match = u_strFindFirst(array + start, length, srcChars + srcStart, srcLength); ------------------ | | 361| 69.9k|#define u_strFindFirst U_ICU_ENTRY_POINT_RENAME(u_strFindFirst) | | ------------------ | | | | 123| 69.9k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 69.9k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 69.9k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1128| 69.9k| if(match == nullptr) { ------------------ | Branch (1128:6): [True: 103, False: 69.8k] ------------------ 1129| 103| return -1; 1130| 69.8k| } else { 1131| 69.8k| return static_cast(match - array); 1132| 69.8k| } 1133| 69.9k|} _ZNK6icu_7813UnicodeString9doIndexOfEDsii: 1139| 246k|{ 1140| | // pin indices 1141| 246k| pinIndices(start, length); 1142| | 1143| | // find the first occurrence of c 1144| 246k| const char16_t *array = getArrayStart(); 1145| 246k| const char16_t *match = u_memchr(array + start, c, length); ------------------ | | 330| 246k|#define u_memchr U_ICU_ENTRY_POINT_RENAME(u_memchr) | | ------------------ | | | | 123| 246k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 246k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 246k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1146| 246k| if(match == nullptr) { ------------------ | Branch (1146:6): [True: 122k, False: 124k] ------------------ 1147| 122k| return -1; 1148| 124k| } else { 1149| 124k| return static_cast(match - array); 1150| 124k| } 1151| 246k|} _ZN6icu_7813UnicodeString7unBogusEv: 1293| 13.6k|UnicodeString::unBogus() { 1294| 13.6k| if(fUnion.fFields.fLengthAndFlags & kIsBogus) { ------------------ | Branch (1294:6): [True: 0, False: 13.6k] ------------------ 1295| 0| setToEmpty(); 1296| 0| } 1297| 13.6k|} _ZN6icu_7813UnicodeString9setToUTF8ENS_11StringPieceE: 1411| 2.63k|UnicodeString &UnicodeString::setToUTF8(StringPiece utf8) { 1412| 2.63k| unBogus(); 1413| 2.63k| int32_t length = utf8.length(); 1414| 2.63k| int32_t capacity; 1415| | // The UTF-16 string will be at most as long as the UTF-8 string. 1416| 2.63k| if(length <= US_STACKBUF_SIZE) { ------------------ | Branch (1416:6): [True: 1.28k, False: 1.35k] ------------------ 1417| 1.28k| capacity = US_STACKBUF_SIZE; 1418| 1.35k| } else { 1419| 1.35k| capacity = length + 1; // +1 for the terminating NUL. 1420| 1.35k| } 1421| 2.63k| char16_t *utf16 = getBuffer(capacity); 1422| 2.63k| int32_t length16; 1423| 2.63k| UErrorCode errorCode = U_ZERO_ERROR; 1424| 2.63k| u_strFromUTF8WithSub(utf16, getCapacity(), &length16, ------------------ | | 370| 2.63k|#define u_strFromUTF8WithSub U_ICU_ENTRY_POINT_RENAME(u_strFromUTF8WithSub) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1425| 2.63k| utf8.data(), length, 1426| 2.63k| 0xfffd, // Substitution character. 1427| 2.63k| nullptr, // Don't care about number of substitutions. 1428| 2.63k| &errorCode); 1429| 2.63k| releaseBuffer(length16); 1430| 2.63k| if(U_FAILURE(errorCode)) { ------------------ | Branch (1430:6): [True: 0, False: 2.63k] ------------------ 1431| 0| setToBogus(); 1432| 0| } 1433| 2.63k| return *this; 1434| 2.63k|} _ZN6icu_7813UnicodeString9setCharAtEiDs: 1439| 324M|{ 1440| 324M| int32_t len = length(); 1441| 324M| if(cloneArrayIfNeeded() && len > 0) { ------------------ | Branch (1441:6): [True: 324M, False: 0] | Branch (1441:30): [True: 324M, False: 0] ------------------ 1442| 324M| if(offset < 0) { ------------------ | Branch (1442:8): [True: 0, False: 324M] ------------------ 1443| 0| offset = 0; 1444| 324M| } else if(offset >= len) { ------------------ | Branch (1444:15): [True: 0, False: 324M] ------------------ 1445| 0| offset = len - 1; 1446| 0| } 1447| | 1448| 324M| getArrayStart()[offset] = c; 1449| 324M| } 1450| 324M| return *this; 1451| 324M|} _ZN6icu_7813UnicodeString6appendEi: 1468| 162M|UnicodeString::append(UChar32 srcChar) { 1469| 162M| char16_t buffer[U16_MAX_LENGTH]; 1470| 162M| int32_t _length = 0; 1471| 162M| UBool isError = false; 1472| 162M| U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError); ------------------ | | 393| 162M|#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 162M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 394| 162M| if((uint32_t)(c)<=0xffff) { \ | | ------------------ | | | Branch (394:8): [True: 162M, False: 57.6k] | | ------------------ | | 395| 162M| (s)[(i)++]=(uint16_t)(c); \ | | 396| 162M| } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \ | | ------------------ | | | Branch (396:15): [True: 57.6k, False: 2] | | | Branch (396:42): [True: 57.6k, False: 0] | | ------------------ | | 397| 57.6k| (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \ | | 398| 57.6k| (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \ | | 399| 57.6k| } else /* c>0x10ffff or not enough space */ { \ | | 400| 2| (isError)=true; \ | | 401| 2| } \ | | 402| 162M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 162M|#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| 162M| return isError ? *this : doAppend(buffer, 0, _length); ------------------ | Branch (1475:10): [True: 2, False: 162M] ------------------ 1476| 162M|} _ZN6icu_7813UnicodeString9doReplaceEiiRKS0_ii: 1484| 5.36M|{ 1485| | // pin the indices to legal values 1486| 5.36M| src.pinIndices(srcStart, srcLength); 1487| | 1488| | // get the characters from src 1489| | // and replace the range in ourselves with them 1490| 5.36M| return doReplace(start, length, src.getArrayStart(), srcStart, srcLength); 1491| 5.36M|} _ZN6icu_7813UnicodeString9doReplaceEiiPKDsii: 1499| 5.37M|{ 1500| 5.37M| if(!isWritable()) { ------------------ | Branch (1500:6): [True: 0, False: 5.37M] ------------------ 1501| 0| return *this; 1502| 0| } 1503| | 1504| 5.37M| int32_t oldLength = this->length(); 1505| | 1506| | // optimize (read-only alias).remove(0, start) and .remove(start, end) 1507| 5.37M| if((fUnion.fFields.fLengthAndFlags&kBufferIsReadonly) && srcLength == 0) { ------------------ | Branch (1507:6): [True: 0, False: 5.37M] | 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| 5.37M| if(start == oldLength) { ------------------ | Branch (1526:6): [True: 5.36M, False: 8.85k] ------------------ 1527| 5.36M| return doAppend(srcChars, srcStart, srcLength); 1528| 5.36M| } 1529| | 1530| 8.85k| if (srcChars == nullptr) { ------------------ | Branch (1530:7): [True: 0, False: 8.85k] ------------------ 1531| 0| srcLength = 0; 1532| 8.85k| } else { 1533| | // Perform all remaining operations relative to srcChars + srcStart. 1534| | // From this point forward, do not use srcStart. 1535| 8.85k| srcChars += srcStart; 1536| 8.85k| if (srcLength < 0) { ------------------ | Branch (1536:9): [True: 0, False: 8.85k] ------------------ 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| 8.85k| } 1541| | 1542| | // pin the indices to legal values 1543| 8.85k| pinIndices(start, length); 1544| | 1545| | // Calculate the size of the string after the replace. 1546| | // Avoid int32_t overflow. 1547| 8.85k| int32_t newLength = oldLength - length; 1548| 8.85k| if(srcLength > (INT32_MAX - newLength)) { ------------------ | Branch (1548:6): [True: 0, False: 8.85k] ------------------ 1549| 0| setToBogus(); 1550| 0| return *this; 1551| 0| } 1552| 8.85k| newLength += srcLength; 1553| | 1554| | // Check for insertion into ourself 1555| 8.85k| const char16_t *oldArray = getArrayStart(); 1556| 8.85k| if (isBufferWritable() && ------------------ | Branch (1556:7): [True: 7.72k, False: 1.13k] ------------------ 1557| 8.85k| oldArray < srcChars + srcLength && ------------------ | Branch (1557:7): [True: 70, False: 7.65k] ------------------ 1558| 8.85k| srcChars < oldArray + oldLength) { ------------------ | Branch (1558:7): [True: 0, False: 70] ------------------ 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| 8.85k| char16_t oldStackBuffer[US_STACKBUF_SIZE]; 1571| 8.85k| if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) { ------------------ | Branch (1571:6): [True: 7.72k, False: 1.13k] | Branch (1571:60): [True: 10, False: 7.71k] ------------------ 1572| | // copy the stack buffer contents because it will be overwritten with 1573| | // fUnion.fFields values 1574| 10| u_memcpy(oldStackBuffer, oldArray, oldLength); ------------------ | | 334| 10|#define u_memcpy U_ICU_ENTRY_POINT_RENAME(u_memcpy) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1575| 10| oldArray = oldStackBuffer; 1576| 10| } 1577| | 1578| | // clone our array and allocate a bigger array if needed 1579| 8.85k| int32_t *bufferToDelete = nullptr; 1580| 8.85k| if(!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength), ------------------ | Branch (1580:6): [True: 0, False: 8.85k] ------------------ 1581| 8.85k| false, &bufferToDelete) 1582| 8.85k| ) { 1583| 0| return *this; 1584| 0| } 1585| | 1586| | // now do the replace 1587| | 1588| 8.85k| char16_t *newArray = getArrayStart(); 1589| 8.85k| if(newArray != oldArray) { ------------------ | Branch (1589:6): [True: 1.14k, False: 7.71k] ------------------ 1590| | // if fArray changed, then we need to copy everything except what will change 1591| 1.14k| us_arrayCopy(oldArray, 0, newArray, 0, start); 1592| 1.14k| us_arrayCopy(oldArray, start + length, 1593| 1.14k| newArray, start + srcLength, 1594| 1.14k| oldLength - (start + length)); 1595| 7.71k| } else if(length != srcLength) { ------------------ | Branch (1595:13): [True: 6.66k, False: 1.04k] ------------------ 1596| | // fArray did not change; copy only the portion that isn't changing, leaving a hole 1597| 6.66k| us_arrayCopy(oldArray, start + length, 1598| 6.66k| newArray, start + srcLength, 1599| 6.66k| oldLength - (start + length)); 1600| 6.66k| } 1601| | 1602| | // now fill in the hole with the new string 1603| 8.85k| us_arrayCopy(srcChars, 0, newArray, start, srcLength); 1604| | 1605| 8.85k| setLength(newLength); 1606| | 1607| | // delayed delete in case srcChars == fArray when we started, and 1608| | // to keep oldArray alive for the above operations 1609| 8.85k| if (bufferToDelete) { ------------------ | Branch (1609:7): [True: 0, False: 8.85k] ------------------ 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| 8.85k| return *this; 1614| 8.85k|} _ZN6icu_7813UnicodeString9doReplaceEiiNSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 1617| 8.64k|UnicodeString::doReplace(int32_t start, int32_t length, std::u16string_view src) { 1618| 8.64k| if (!isWritable()) { ------------------ | Branch (1618:7): [True: 0, False: 8.64k] ------------------ 1619| 0| return *this; 1620| 0| } 1621| 8.64k| if (src.length() > INT32_MAX) { ------------------ | Branch (1621:7): [True: 0, False: 8.64k] ------------------ 1622| 0| setToBogus(); 1623| 0| return *this; 1624| 0| } 1625| 8.64k| return doReplace(start, length, src.data(), 0, static_cast(src.length())); 1626| 8.64k|} _ZN6icu_7813UnicodeString8doAppendERKS0_ii: 1632| 269k|UnicodeString::doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength) { 1633| 269k| if(srcLength == 0) { ------------------ | Branch (1633:6): [True: 0, False: 269k] ------------------ 1634| 0| return *this; 1635| 0| } 1636| | 1637| | // pin the indices to legal values 1638| 269k| src.pinIndices(srcStart, srcLength); 1639| 269k| return doAppend(src.getArrayStart(), srcStart, srcLength); 1640| 269k|} _ZN6icu_7813UnicodeString8doAppendEPKDsii: 1643| 571M|UnicodeString::doAppend(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) { 1644| 571M| if(!isWritable() || srcLength == 0 || srcChars == nullptr) { ------------------ | Branch (1644:6): [True: 0, False: 571M] | Branch (1644:23): [True: 779, False: 571M] | Branch (1644:41): [True: 0, False: 571M] ------------------ 1645| 779| return *this; 1646| 779| } 1647| | 1648| | // Perform all remaining operations relative to srcChars + srcStart. 1649| | // From this point forward, do not use srcStart. 1650| 571M| srcChars += srcStart; 1651| | 1652| 571M| if(srcLength < 0) { ------------------ | Branch (1652:6): [True: 0, False: 571M] ------------------ 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| 571M| int32_t oldLength = length(); 1660| 571M| int32_t newLength; 1661| | 1662| 571M| if (srcLength <= getCapacity() - oldLength && isBufferWritable()) { ------------------ | Branch (1662:7): [True: 570M, False: 283k] | Branch (1662:49): [True: 570M, False: 2.22k] ------------------ 1663| 570M| newLength = oldLength + srcLength; 1664| | // Faster than a memmove 1665| 570M| if (srcLength <= 4) { ------------------ | Branch (1665:9): [True: 570M, False: 662k] ------------------ 1666| 570M| char16_t *arr = getArrayStart(); 1667| 570M| arr[oldLength] = srcChars[0]; 1668| 570M| if (srcLength > 1) arr[oldLength+1] = srcChars[1]; ------------------ | Branch (1668:11): [True: 314k, False: 569M] ------------------ 1669| 570M| if (srcLength > 2) arr[oldLength+2] = srcChars[2]; ------------------ | Branch (1669:11): [True: 73.6k, False: 570M] ------------------ 1670| 570M| if (srcLength > 3) arr[oldLength+3] = srcChars[3]; ------------------ | Branch (1670:11): [True: 17.9k, False: 570M] ------------------ 1671| 570M| setLength(newLength); 1672| 570M| return *this; 1673| 570M| } 1674| 570M| } else { 1675| 286k| if (uprv_add32_overflow(oldLength, srcLength, &newLength)) { ------------------ | | 1394| 286k|#define uprv_add32_overflow U_ICU_ENTRY_POINT_RENAME(uprv_add32_overflow) | | ------------------ | | | | 123| 286k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 286k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 286k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1675:9): [True: 0, False: 286k] ------------------ 1676| 0| setToBogus(); 1677| 0| return *this; 1678| 0| } 1679| | 1680| | // Check for append onto ourself 1681| 286k| const char16_t* oldArray = getArrayStart(); 1682| 286k| if (isBufferWritable() && ------------------ | Branch (1682:9): [True: 283k, False: 2.22k] ------------------ 1683| 286k| oldArray < srcChars + srcLength && ------------------ | Branch (1683:9): [True: 127k, False: 156k] ------------------ 1684| 286k| srcChars < oldArray + oldLength) { ------------------ | Branch (1684:9): [True: 0, False: 127k] ------------------ 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| 286k| if (!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength))) { ------------------ | Branch (1695:9): [True: 0, False: 286k] ------------------ 1696| 0| return *this; 1697| 0| } 1698| 286k| } 1699| | 1700| 948k| 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| 948k| if(srcChars != newArray + oldLength) { ------------------ | Branch (1708:6): [True: 948k, False: 0] ------------------ 1709| 948k| us_arrayCopy(srcChars, 0, newArray, oldLength, srcLength); 1710| 948k| } 1711| 948k| setLength(newLength); 1712| | 1713| 948k| return *this; 1714| 571M|} _ZN6icu_7813UnicodeString8doAppendENSt3__117basic_string_viewIDsNS1_11char_traitsIDsEEEE: 1717| 39.0k|UnicodeString::doAppend(std::u16string_view src) { 1718| 39.0k| if (!isWritable() || src.empty()) { ------------------ | Branch (1718:7): [True: 0, False: 39.0k] | Branch (1718:24): [True: 0, False: 39.0k] ------------------ 1719| 0| return *this; 1720| 0| } 1721| 39.0k| if (src.length() > INT32_MAX) { ------------------ | Branch (1721:7): [True: 0, False: 39.0k] ------------------ 1722| 0| setToBogus(); 1723| 0| return *this; 1724| 0| } 1725| 39.0k| return doAppend(src.data(), 0, static_cast(src.length())); 1726| 39.0k|} _ZNK6icu_7813UnicodeString10doHashCodeEv: 1864| 4.85M|{ 1865| | /* Delegate hash computation to uhash. This makes UnicodeString 1866| | * hashing consistent with char16_t* hashing. */ 1867| 4.85M| int32_t hashCode = ustr_hashUCharsN(getArrayStart(), length()); ------------------ | | 1880| 4.85M|#define ustr_hashUCharsN U_ICU_ENTRY_POINT_RENAME(ustr_hashUCharsN) | | ------------------ | | | | 123| 4.85M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.85M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.85M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1868| 4.85M| if (hashCode == kInvalidHashCode) { ------------------ | Branch (1868:9): [True: 2.81M, False: 2.04M] ------------------ 1869| 2.81M| hashCode = kEmptyHashCode; 1870| 2.81M| } 1871| 4.85M| return hashCode; 1872| 4.85M|} _ZN6icu_7813UnicodeString9getBufferEi: 1879| 2.63k|UnicodeString::getBuffer(int32_t minCapacity) { 1880| 2.63k| if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) { ------------------ | Branch (1880:6): [True: 2.63k, False: 0] | Branch (1880:25): [True: 2.63k, False: 0] ------------------ 1881| 2.63k| fUnion.fFields.fLengthAndFlags|=kOpenGetBuffer; 1882| 2.63k| setZeroLength(); 1883| 2.63k| return getArrayStart(); 1884| 2.63k| } else { 1885| 0| return nullptr; 1886| 0| } 1887| 2.63k|} _ZN6icu_7813UnicodeString13releaseBufferEi: 1890| 2.63k|UnicodeString::releaseBuffer(int32_t newLength) { 1891| 2.63k| if(fUnion.fFields.fLengthAndFlags&kOpenGetBuffer && newLength>=-1) { ------------------ | Branch (1891:6): [True: 2.63k, False: 0] | Branch (1891:55): [True: 2.63k, False: 0] ------------------ 1892| | // set the new fLength 1893| 2.63k| int32_t capacity=getCapacity(); 1894| 2.63k| if(newLength==-1) { ------------------ | Branch (1894:8): [True: 0, False: 2.63k] ------------------ 1895| | // the new length is the string length, capped by fCapacity 1896| 0| const char16_t *array=getArrayStart(), *p=array, *limit=array+capacity; 1897| 0| while(p(p - array); 1901| 2.63k| } else if(newLength>capacity) { ------------------ | Branch (1901:15): [True: 0, False: 2.63k] ------------------ 1902| 0| newLength=capacity; 1903| 0| } 1904| 2.63k| setLength(newLength); 1905| 2.63k| fUnion.fFields.fLengthAndFlags&=~kOpenGetBuffer; 1906| 2.63k| } 1907| 2.63k|} _ZN6icu_7813UnicodeString18cloneArrayIfNeededEiiaPPia: 1917| 324M| UBool forceClone) { 1918| | // default parameters need to be static, therefore 1919| | // the defaults are -1 to have convenience defaults 1920| 324M| if(newCapacity == -1) { ------------------ | Branch (1920:6): [True: 324M, False: 297k] ------------------ 1921| 324M| newCapacity = getCapacity(); 1922| 324M| } 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| 324M| if(!isWritable()) { ------------------ | Branch (1927:6): [True: 0, False: 324M] ------------------ 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| 324M| if(forceClone || ------------------ | Branch (1938:6): [True: 0, False: 324M] ------------------ 1939| 324M| fUnion.fFields.fLengthAndFlags & kBufferIsReadonly || ------------------ | Branch (1939:6): [True: 0, False: 324M] ------------------ 1940| 324M| (fUnion.fFields.fLengthAndFlags & kRefCounted && refCount() > 1) || ------------------ | Branch (1940:7): [True: 322M, False: 1.68M] | Branch (1940:55): [True: 59.0k, False: 322M] ------------------ 1941| 324M| newCapacity > getCapacity() ------------------ | Branch (1941:6): [True: 285k, False: 323M] ------------------ 1942| 324M| ) { 1943| | // check growCapacity for default value and use of the stack buffer 1944| 344k| if(growCapacity < 0) { ------------------ | Branch (1944:8): [True: 57.0k, False: 287k] ------------------ 1945| 57.0k| growCapacity = newCapacity; 1946| 287k| } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) { ------------------ | Branch (1946:15): [True: 3.27k, False: 283k] | Branch (1946:50): [True: 3.27k, False: 0] ------------------ 1947| 3.27k| growCapacity = US_STACKBUF_SIZE; 1948| 283k| } else if(newCapacity > growCapacity) { ------------------ | Branch (1948:15): [True: 0, False: 283k] ------------------ 1949| 0| setToBogus(); 1950| 0| return false; // bad inputs 1951| 0| } 1952| 344k| if(growCapacity > kMaxCapacity) { ------------------ | Branch (1952:8): [True: 0, False: 344k] ------------------ 1953| 0| setToBogus(); 1954| 0| return false; 1955| 0| } 1956| | 1957| | // save old values 1958| 344k| char16_t oldStackBuffer[US_STACKBUF_SIZE]; 1959| 344k| char16_t *oldArray; 1960| 344k| int32_t oldLength = length(); 1961| 344k| int16_t flags = fUnion.fFields.fLengthAndFlags; 1962| | 1963| 344k| if(flags&kUsingStackBuffer) { ------------------ | Branch (1963:8): [True: 160k, False: 183k] ------------------ 1964| 160k| U_ASSERT(!(flags&kRefCounted)); /* kRefCounted and kUsingStackBuffer are mutally exclusive */ ------------------ | | 35| 160k|# define U_ASSERT(exp) (void)0 ------------------ 1965| 160k| if(doCopyArray && growCapacity > US_STACKBUF_SIZE) { ------------------ | Branch (1965:10): [True: 160k, False: 10] | Branch (1965:25): [True: 160k, False: 0] ------------------ 1966| | // copy the stack buffer contents because it will be overwritten with 1967| | // fUnion.fFields values 1968| 160k| us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength); 1969| 160k| oldArray = oldStackBuffer; 1970| 160k| } else { 1971| 10| oldArray = nullptr; // no need to copy from the stack buffer to itself 1972| 10| } 1973| 183k| } else { 1974| 183k| oldArray = fUnion.fFields.fArray; 1975| 183k| U_ASSERT(oldArray!=nullptr); /* when stack buffer is not used, oldArray must have a non-nullptr reference */ ------------------ | | 35| 183k|# define U_ASSERT(exp) (void)0 ------------------ 1976| 183k| } 1977| | 1978| | // allocate a new array 1979| 344k| if(allocate(growCapacity) || ------------------ | Branch (1979:8): [True: 344k, False: 0] ------------------ 1980| 344k| (newCapacity < growCapacity && allocate(newCapacity)) ------------------ | Branch (1980:9): [True: 0, False: 0] | Branch (1980:39): [True: 0, False: 0] ------------------ 1981| 344k| ) { 1982| 344k| if(doCopyArray) { ------------------ | Branch (1982:10): [True: 343k, False: 1.14k] ------------------ 1983| | // copy the contents 1984| | // do not copy more than what fits - it may be smaller than before 1985| 343k| int32_t minLength = oldLength; 1986| 343k| newCapacity = getCapacity(); 1987| 343k| if(newCapacity < minLength) { ------------------ | Branch (1987:12): [True: 0, False: 343k] ------------------ 1988| 0| minLength = newCapacity; 1989| 0| } 1990| 343k| if(oldArray != nullptr) { ------------------ | Branch (1990:12): [True: 343k, False: 0] ------------------ 1991| 343k| us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength); 1992| 343k| } 1993| 343k| setLength(minLength); 1994| 343k| } else { 1995| 1.14k| setZeroLength(); 1996| 1.14k| } 1997| | 1998| | // release the old array 1999| 344k| if(flags & kRefCounted) { ------------------ | Branch (1999:10): [True: 183k, False: 160k] ------------------ 2000| | // the array is refCounted; decrement and release if 0 2001| 183k| u_atomic_int32_t* pRefCount = reinterpret_cast(oldArray) - 1; 2002| 183k| if(umtx_atomic_dec(pRefCount) == 0) { ------------------ | Branch (2002:12): [True: 124k, False: 59.0k] ------------------ 2003| 124k| if (pBufferToDelete == nullptr) { ------------------ | Branch (2003:15): [True: 124k, 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| 124k| uprv_free((void *)pRefCount); ------------------ | | 1503| 124k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2008| 124k| } else { 2009| | // the caller requested to delete it himself 2010| 0| *pBufferToDelete = reinterpret_cast(pRefCount); 2011| 0| } 2012| 124k| } 2013| 183k| } 2014| 344k| } 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| 344k| } 2025| 324M| return true; 2026| 324M|} uhash_hashUnicodeString_78: 2081| 4.85M|uhash_hashUnicodeString(const UElement key) { 2082| 4.85M| const UnicodeString *str = (const UnicodeString*) key.pointer; 2083| 4.85M| return (str == nullptr) ? 0 : str->hashCode(); ------------------ | Branch (2083:12): [True: 0, False: 4.85M] ------------------ 2084| 4.85M|} uhash_compareUnicodeString_78: 2089| 7.50M|uhash_compareUnicodeString(const UElement key1, const UElement key2) { 2090| 7.50M| const UnicodeString *str1 = (const UnicodeString*) key1.pointer; 2091| 7.50M| const UnicodeString *str2 = (const UnicodeString*) key2.pointer; 2092| 7.50M| if (str1 == str2) { ------------------ | Branch (2092:9): [True: 0, False: 7.50M] ------------------ 2093| 0| return true; 2094| 0| } 2095| 7.50M| if (str1 == nullptr || str2 == nullptr) { ------------------ | Branch (2095:9): [True: 0, False: 7.50M] | Branch (2095:28): [True: 0, False: 7.50M] ------------------ 2096| 0| return false; 2097| 0| } 2098| 7.50M| return *str1 == *str2; 2099| 7.50M|} unistr.cpp:_ZL20UnicodeString_charAtiPv: 96| 557k|UnicodeString_charAt(int32_t offset, void *context) { 97| 557k| return ((icu::UnicodeString*) context)->charAt(offset); 98| 557k|} unistr.cpp:_ZL12us_arrayCopyPKDsiPDsii: 87| 1.47M|{ 88| 1.47M| if(count>0) { ------------------ | Branch (88:6): [True: 1.23M, False: 232k] ------------------ 89| 1.23M| uprv_memmove(dst+dstStart, src+srcStart, (size_t)count*sizeof(*src)); ------------------ | | 51| 1.23M|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.23M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 1.23M| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 1.23M| _Pragma("clang diagnostic push") \ | | 54| 1.23M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 1.23M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.23M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 1.23M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.23M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 1.23M| _Pragma("clang diagnostic pop") \ | | 58| 1.23M| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 1.23M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 1.23M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.23M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 90| 1.23M| } 91| 1.47M|} unistr.cpp:_ZN6icu_7812_GLOBAL__N_115getGrowCapacityEi: 397| 294k|int32_t getGrowCapacity(int32_t newLength) { 398| 294k| int32_t growSize = (newLength >> 2) + kGrowSize; 399| 294k| if(growSize <= (kMaxCapacity - newLength)) { ------------------ | Branch (399:6): [True: 294k, False: 0] ------------------ 400| 294k| return newLength + growSize; 401| 294k| } else { 402| 0| return kMaxCapacity; 403| 0| } 404| 294k|} _ZN6icu_787UMemorynwEm: 61| 47.7M|void * U_EXPORT2 UMemory::operator new(size_t size) noexcept { 62| 47.7M| return uprv_malloc(size); ------------------ | | 1524| 47.7M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 47.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 47.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 47.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 47.7M|} _ZN6icu_787UMemorydlEPv: 65| 47.7M|void U_EXPORT2 UMemory::operator delete(void *p) noexcept { 66| 47.7M| if(p!=nullptr) { ------------------ | Branch (66:8): [True: 47.7M, False: 0] ------------------ 67| 47.7M| uprv_free(p); ------------------ | | 1503| 47.7M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 47.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 47.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 47.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 68| 47.7M| } 69| 47.7M|} _ZN6icu_787UObjectD2Ev: 94| 52.9M|UObject::~UObject() {} uprv_deleteUObject_78: 103| 182k|uprv_deleteUObject(void *obj) { 104| 182k| delete static_cast(obj); 105| 182k|} u_hasBinaryProperty_78: 487| 11.8M|u_hasBinaryProperty(UChar32 c, UProperty which) { 488| | /* c is range-checked in the functions that are called from here */ 489| 11.8M| 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| 1| if (src == UPROPS_SRC_MCM) { ------------------ | Branch (871:9): [True: 1, False: 0] ------------------ 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| 0| if (!ulayout_ensureData(*pErrorCode)) { return; } ------------------ | Branch (878:9): [True: 0, False: 0] ------------------ 879| 0| const UCPTrie *trie; 880| 0| switch (src) { 881| 0| case UPROPS_SRC_INPC: ------------------ | Branch (881:5): [True: 0, False: 0] ------------------ 882| 0| trie = gInpcTrie; 883| 0| break; 884| 0| case UPROPS_SRC_INSC: ------------------ | Branch (884:5): [True: 0, False: 0] ------------------ 885| 0| trie = gInscTrie; 886| 0| break; 887| 0| case UPROPS_SRC_VO: ------------------ | Branch (887:5): [True: 0, False: 0] ------------------ 888| 0| trie = gVoTrie; 889| 0| break; 890| 0| default: ------------------ | Branch (890:5): [True: 0, False: 0] ------------------ 891| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 892| 0| return; 893| 0| } 894| | 895| 0| if (trie == nullptr) { ------------------ | Branch (895:9): [True: 0, False: 0] ------------------ 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| 0| UChar32 start = 0, end; 902| 0| while ((end = ucptrie_getRange(trie, start, UCPMAP_RANGE_NORMAL, 0, ------------------ | | 806| 0|#define ucptrie_getRange U_ICU_ENTRY_POINT_RENAME(ucptrie_getRange) | | ------------------ | | | | 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 (902:12): [True: 0, False: 0] ------------------ 903| 0| nullptr, nullptr, nullptr)) >= 0) { 904| 0| sa->add(sa->set, start); 905| 0| start = end + 1; 906| 0| } 907| 0|} uprops.cpp:_ZL15defaultContainsRK14BinaryPropertyi9UProperty: 168| 11.7M|static UBool defaultContains(const BinaryProperty &prop, UChar32 c, UProperty /*which*/) { 169| | /* systematic, directly stored properties */ 170| 11.7M| return (u_getUnicodeProperties(c, prop.column)&prop.mask)!=0; ------------------ | | 288| 11.7M|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 11.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 11.7M|} uprops.cpp:_ZL26caseBinaryPropertyContainsRK14BinaryPropertyi9UProperty: 173| 21.6k|static UBool caseBinaryPropertyContains(const BinaryProperty &/*prop*/, UChar32 c, UProperty which) { 174| 21.6k| return ucase_hasBinaryProperty(c, which); ------------------ | | 577| 21.6k|#define ucase_hasBinaryProperty U_ICU_ENTRY_POINT_RENAME(ucase_hasBinaryProperty) | | ------------------ | | | | 123| 21.6k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 21.6k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 21.6k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 175| 21.6k|} uprops.cpp:_ZL13isPOSIX_alnumRK14BinaryPropertyi9UProperty: 302| 9.04k|static UBool isPOSIX_alnum(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 303| 9.04k| return u_isalnumPOSIX(c); ------------------ | | 309| 9.04k|#define u_isalnumPOSIX U_ICU_ENTRY_POINT_RENAME(u_isalnumPOSIX) | | ------------------ | | | | 123| 9.04k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.04k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.04k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 304| 9.04k|} uprops.cpp:_ZL13isPOSIX_blankRK14BinaryPropertyi9UProperty: 306| 6.00k|static UBool isPOSIX_blank(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 307| 6.00k| return u_isblank(c); ------------------ | | 312| 6.00k|#define u_isblank U_ICU_ENTRY_POINT_RENAME(u_isblank) | | ------------------ | | | | 123| 6.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 308| 6.00k|} uprops.cpp:_ZL13isPOSIX_graphRK14BinaryPropertyi9UProperty: 310| 6.00k|static UBool isPOSIX_graph(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 311| 6.00k| return u_isgraphPOSIX(c); ------------------ | | 317| 6.00k|#define u_isgraphPOSIX U_ICU_ENTRY_POINT_RENAME(u_isgraphPOSIX) | | ------------------ | | | | 123| 6.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 312| 6.00k|} uprops.cpp:_ZL13isPOSIX_printRK14BinaryPropertyi9UProperty: 314| 6.00k|static UBool isPOSIX_print(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 315| 6.00k| return u_isprintPOSIX(c); ------------------ | | 320| 6.00k|#define u_isprintPOSIX U_ICU_ENTRY_POINT_RENAME(u_isprintPOSIX) | | ------------------ | | | | 123| 6.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 316| 6.00k|} uprops.cpp:_ZL14isPOSIX_xdigitRK14BinaryPropertyi9UProperty: 318| 6.00k|static UBool isPOSIX_xdigit(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 319| 6.00k| return u_isxdigit(c); ------------------ | | 325| 6.00k|#define u_isxdigit U_ICU_ENTRY_POINT_RENAME(u_isxdigit) | | ------------------ | | | | 123| 6.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 320| 6.00k|} 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:_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| 806k|static int32_t getBiDiClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 558| 806k| return static_cast(u_charDirection(c)); ------------------ | | 221| 806k|#define u_charDirection U_ICU_ENTRY_POINT_RENAME(u_charDirection) | | ------------------ | | | | 123| 806k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 806k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 806k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 559| 806k|} uprops.cpp:_ZL17getCombiningClassRK11IntPropertyi9UProperty: 582| 2.45M|static int32_t getCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 583| 2.45M| return u_getCombiningClass(c); ------------------ | | 270| 2.45M|#define u_getCombiningClass U_ICU_ENTRY_POINT_RENAME(u_getCombiningClass) | | ------------------ | | | | 123| 2.45M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.45M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.45M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 584| 2.45M|} uprops.cpp:_ZL15defaultGetValueRK11IntPropertyi9UProperty: 544| 34.1k|static int32_t defaultGetValue(const IntProperty &prop, UChar32 c, UProperty /*which*/) { 545| | /* systematic, directly stored properties */ 546| 34.1k| return static_cast(u_getUnicodeProperties(c, prop.column) & prop.mask) >> prop.shift; ------------------ | | 288| 34.1k|#define u_getUnicodeProperties U_ICU_ENTRY_POINT_RENAME(u_getUnicodeProperties) | | ------------------ | | | | 123| 34.1k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 34.1k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 34.1k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 547| 34.1k|} uprops.cpp:_ZL14getJoiningTypeRK11IntPropertyi9UProperty: 595| 109k|static int32_t getJoiningType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 596| 109k| return ubidi_getJoiningType(c); ------------------ | | 445| 109k|#define ubidi_getJoiningType U_ICU_ENTRY_POINT_RENAME(ubidi_getJoiningType) | | ------------------ | | | | 123| 109k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 109k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 109k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 597| 109k|} uprops.cpp:_ZL9getScriptRK11IntPropertyi9UProperty: 604| 15.7M|static int32_t getScript(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 605| 15.7M| UErrorCode errorCode=U_ZERO_ERROR; 606| 15.7M| return static_cast(uscript_getScript(c, &errorCode)); ------------------ | | 1706| 15.7M|#define uscript_getScript U_ICU_ENTRY_POINT_RENAME(uscript_getScript) | | ------------------ | | | | 123| 15.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 15.7M|} uprops.cpp:_ZL21getLeadCombiningClassRK11IntPropertyi9UProperty: 668| 3.32M|static int32_t getLeadCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 669| 3.32M| return unorm_getFCD16(c)>>8; ------------------ | | 1288| 3.32M|#define unorm_getFCD16 U_ICU_ENTRY_POINT_RENAME(unorm_getFCD16) | | ------------------ | | | | 123| 3.32M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.32M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.32M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 670| 3.32M|} uprops.cpp:_ZL22getTrailCombiningClassRK11IntPropertyi9UProperty: 678| 460k|static int32_t getTrailCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 679| 460k| return unorm_getFCD16(c)&0xff; ------------------ | | 1288| 460k|#define unorm_getFCD16 U_ICU_ENTRY_POINT_RENAME(unorm_getFCD16) | | ------------------ | | | | 123| 460k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 460k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 460k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 680| 460k|} u_strFindFirst_78: 57| 69.9k| const char16_t *sub, int32_t subLength) { 58| 69.9k| const char16_t *start, *p, *q, *subLimit; 59| 69.9k| char16_t c, cs, cq; 60| | 61| 69.9k| if(sub==nullptr || subLength<-1) { ------------------ | Branch (61:8): [True: 0, False: 69.9k] | Branch (61:24): [True: 0, False: 69.9k] ------------------ 62| 0| return (char16_t *)s; 63| 0| } 64| 69.9k| if(s==nullptr || length<-1) { ------------------ | Branch (64:8): [True: 0, False: 69.9k] | Branch (64:22): [True: 0, False: 69.9k] ------------------ 65| 0| return nullptr; 66| 0| } 67| | 68| 69.9k| start=s; 69| | 70| 69.9k| if(length<0 && subLength<0) { ------------------ | Branch (70:8): [True: 0, False: 69.9k] | Branch (70:20): [True: 0, False: 0] ------------------ 71| | /* both strings are NUL-terminated */ 72| 0| if((cs=*sub++)==0) { ------------------ | Branch (72:12): [True: 0, False: 0] ------------------ 73| 0| return (char16_t *)s; 74| 0| } 75| 0| if(*sub==0 && !U16_IS_SURROGATE(cs)) { ------------------ | | 75| 0|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 0|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ ------------------ | Branch (75:12): [True: 0, False: 0] | Branch (75:23): [True: 0, False: 0] ------------------ 76| | /* the substring consists of a single, non-surrogate BMP code point */ 77| 0| return u_strchr(s, cs); ------------------ | | 385| 0|#define u_strchr U_ICU_ENTRY_POINT_RENAME(u_strchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 78| 0| } 79| | 80| 0| while((c=*s++)!=0) { ------------------ | Branch (80:15): [True: 0, False: 0] ------------------ 81| 0| if(c==cs) { ------------------ | Branch (81:16): [True: 0, False: 0] ------------------ 82| | /* found first substring char16_t, compare rest */ 83| 0| p=s; 84| 0| q=sub; 85| 0| for(;;) { 86| 0| if((cq=*q)==0) { ------------------ | Branch (86:24): [True: 0, False: 0] ------------------ 87| 0| if(isMatchAtCPBoundary(start, s-1, p, nullptr)) { ------------------ | Branch (87:28): [True: 0, False: 0] ------------------ 88| 0| return (char16_t *)(s-1); /* well-formed match */ 89| 0| } else { 90| 0| break; /* no match because surrogate pair is split */ 91| 0| } 92| 0| } 93| 0| if((c=*p)==0) { ------------------ | Branch (93:24): [True: 0, False: 0] ------------------ 94| 0| return nullptr; /* no match, and none possible after s */ 95| 0| } 96| 0| if(c!=cq) { ------------------ | Branch (96:24): [True: 0, False: 0] ------------------ 97| 0| break; /* no match */ 98| 0| } 99| 0| ++p; 100| 0| ++q; 101| 0| } 102| 0| } 103| 0| } 104| | 105| | /* not found */ 106| 0| return nullptr; 107| 0| } 108| | 109| 69.9k| if(subLength<0) { ------------------ | Branch (109:8): [True: 0, False: 69.9k] ------------------ 110| 0| subLength=u_strlen(sub); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 111| 0| } 112| 69.9k| if(subLength==0) { ------------------ | Branch (112:8): [True: 0, False: 69.9k] ------------------ 113| 0| return (char16_t *)s; 114| 0| } 115| | 116| | /* get sub[0] to search for it fast */ 117| 69.9k| cs=*sub++; 118| 69.9k| --subLength; 119| 69.9k| subLimit=sub+subLength; 120| | 121| 69.9k| if(subLength==0 && !U16_IS_SURROGATE(cs)) { ------------------ | | 75| 0|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 0|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ ------------------ | Branch (121:8): [True: 0, False: 69.9k] | Branch (121:24): [True: 0, False: 0] ------------------ 122| | /* the substring consists of a single, non-surrogate BMP code point */ 123| 0| return length<0 ? u_strchr(s, cs) : u_memchr(s, cs, length); ------------------ | | 385| 0|#define u_strchr U_ICU_ENTRY_POINT_RENAME(u_strchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return length<0 ? u_strchr(s, cs) : u_memchr(s, cs, length); ------------------ | | 330| 0|#define u_memchr U_ICU_ENTRY_POINT_RENAME(u_memchr) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (123:16): [True: 0, False: 0] ------------------ 124| 0| } 125| | 126| 69.9k| if(length<0) { ------------------ | Branch (126:8): [True: 0, False: 69.9k] ------------------ 127| | /* s is NUL-terminated */ 128| 0| while((c=*s++)!=0) { ------------------ | Branch (128:15): [True: 0, False: 0] ------------------ 129| 0| if(c==cs) { ------------------ | Branch (129:16): [True: 0, False: 0] ------------------ 130| | /* found first substring char16_t, compare rest */ 131| 0| p=s; 132| 0| q=sub; 133| 0| for(;;) { 134| 0| if(q==subLimit) { ------------------ | Branch (134:24): [True: 0, False: 0] ------------------ 135| 0| if(isMatchAtCPBoundary(start, s-1, p, nullptr)) { ------------------ | Branch (135:28): [True: 0, False: 0] ------------------ 136| 0| return (char16_t *)(s-1); /* well-formed match */ 137| 0| } else { 138| 0| break; /* no match because surrogate pair is split */ 139| 0| } 140| 0| } 141| 0| if((c=*p)==0) { ------------------ | Branch (141:24): [True: 0, False: 0] ------------------ 142| 0| return nullptr; /* no match, and none possible after s */ 143| 0| } 144| 0| if(c!=*q) { ------------------ | Branch (144:24): [True: 0, False: 0] ------------------ 145| 0| break; /* no match */ 146| 0| } 147| 0| ++p; 148| 0| ++q; 149| 0| } 150| 0| } 151| 0| } 152| 69.9k| } else { 153| 69.9k| const char16_t *limit, *preLimit; 154| | 155| | /* subLength was decremented above */ 156| 69.9k| if(length<=subLength) { ------------------ | Branch (156:12): [True: 20, False: 69.8k] ------------------ 157| 20| return nullptr; /* s is shorter than sub */ 158| 20| } 159| | 160| 69.8k| limit=s+length; 161| | 162| | /* the substring must start before preLimit */ 163| 69.8k| preLimit=limit-subLength; 164| | 165| 2.29M| while(s!=preLimit) { ------------------ | Branch (165:15): [True: 2.29M, False: 83] ------------------ 166| 2.29M| c=*s++; 167| 2.29M| if(c==cs) { ------------------ | Branch (167:16): [True: 70.5k, False: 2.22M] ------------------ 168| | /* found first substring char16_t, compare rest */ 169| 70.5k| p=s; 170| 70.5k| q=sub; 171| 140k| for(;;) { 172| 140k| if(q==subLimit) { ------------------ | Branch (172:24): [True: 69.8k, False: 70.5k] ------------------ 173| 69.8k| if(isMatchAtCPBoundary(start, s-1, p, limit)) { ------------------ | Branch (173:28): [True: 69.8k, False: 0] ------------------ 174| 69.8k| return (char16_t *)(s-1); /* well-formed match */ 175| 69.8k| } else { 176| 0| break; /* no match because surrogate pair is split */ 177| 0| } 178| 69.8k| } 179| 70.5k| if(*p!=*q) { ------------------ | Branch (179:24): [True: 789, False: 69.8k] ------------------ 180| 789| break; /* no match */ 181| 789| } 182| 69.8k| ++p; 183| 69.8k| ++q; 184| 69.8k| } 185| 70.5k| } 186| 2.29M| } 187| 69.8k| } 188| | 189| | /* not found */ 190| 83| return nullptr; 191| 69.9k|} u_memchr_78: 241| 246k|u_memchr(const char16_t *s, char16_t c, int32_t count) { 242| 246k| if(count<=0) { ------------------ | Branch (242:8): [True: 1, False: 246k] ------------------ 243| 1| return nullptr; /* no string */ 244| 246k| } else if(U16_IS_SURROGATE(c)) { ------------------ | | 75| 246k|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 246k|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | | | ------------------ | | | | | Branch (193:27): [True: 0, False: 246k] | | | | ------------------ | | ------------------ ------------------ 245| | /* make sure to not find half of a surrogate pair */ 246| 0| return u_strFindFirst(s, count, &c, 1); ------------------ | | 361| 0|#define u_strFindFirst U_ICU_ENTRY_POINT_RENAME(u_strFindFirst) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 246k| } else { 248| | /* trivial search for a BMP code point */ 249| 246k| const char16_t *limit=s+count; 250| 158M| do { 251| 158M| if(*s==c) { ------------------ | Branch (251:16): [True: 124k, False: 158M] ------------------ 252| 124k| return (char16_t *)s; 253| 124k| } 254| 158M| } while(++s!=limit); ------------------ | Branch (254:17): [True: 157M, False: 122k] ------------------ 255| 122k| return nullptr; 256| 246k| } 257| 246k|} u_strlen_78: 995| 169k|{ 996| |#if U_SIZEOF_WCHAR_T == U_SIZEOF_UCHAR 997| | return (int32_t)uprv_wcslen((const wchar_t *)s); 998| |#else 999| 169k| const char16_t *t = s; 1000| 678k| while(*t != 0) { ------------------ | Branch (1000:11): [True: 509k, False: 169k] ------------------ 1001| 509k| ++t; 1002| 509k| } 1003| 169k| return t - s; 1004| 169k|#endif 1005| 169k|} u_memcpy_78: 1117| 110k|u_memcpy(char16_t *dest, const char16_t *src, int32_t count) { 1118| 110k| if(count > 0) { ------------------ | Branch (1118:8): [True: 110k, False: 0] ------------------ 1119| 110k| uprv_memcpy(dest, src, (size_t)count*U_SIZEOF_UCHAR); ------------------ | | 42| 110k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 110k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 110k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 110k| _Pragma("clang diagnostic push") \ | | 45| 110k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 110k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 110k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 110k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 110k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 110k| _Pragma("clang diagnostic pop") \ | | 49| 110k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 110k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 110k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 110k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1120| 110k| } 1121| 110k| return dest; 1122| 110k|} u_unescapeAt_78: 1216| 406k| void *context) { 1217| | 1218| 406k| int32_t start = *offset; 1219| 406k| UChar32 c; 1220| 406k| UChar32 result = 0; 1221| 406k| int8_t n = 0; 1222| 406k| int8_t minDig = 0; 1223| 406k| int8_t maxDig = 0; 1224| 406k| int8_t bitsPerDigit = 4; 1225| 406k| int32_t dig; 1226| 406k| UBool braces = false; 1227| | 1228| | /* Check that offset is in range */ 1229| 406k| if (*offset < 0 || *offset >= length) { ------------------ | Branch (1229:9): [True: 0, False: 406k] | Branch (1229:24): [True: 41, False: 406k] ------------------ 1230| 41| goto err; 1231| 41| } 1232| | 1233| | /* Fetch first char16_t after '\\' */ 1234| 406k| c = charAt((*offset)++, context); 1235| | 1236| | /* Convert hexadecimal and octal escapes */ 1237| 406k| switch (c) { 1238| 22.6k| case u'u': ------------------ | Branch (1238:5): [True: 22.6k, False: 384k] ------------------ 1239| 22.6k| minDig = maxDig = 4; 1240| 22.6k| break; 1241| 360| case u'U': ------------------ | Branch (1241:5): [True: 360, False: 406k] ------------------ 1242| 360| minDig = maxDig = 8; 1243| 360| break; 1244| 2.17k| case u'x': ------------------ | Branch (1244:5): [True: 2.17k, False: 404k] ------------------ 1245| 2.17k| minDig = 1; 1246| 2.17k| if (*offset < length && charAt(*offset, context) == u'{') { ------------------ | Branch (1246:13): [True: 2.16k, False: 10] | Branch (1246:33): [True: 205, False: 1.96k] ------------------ 1247| 205| ++(*offset); 1248| 205| braces = true; 1249| 205| maxDig = 8; 1250| 1.97k| } else { 1251| 1.97k| maxDig = 2; 1252| 1.97k| } 1253| 2.17k| break; 1254| 381k| default: ------------------ | Branch (1254:5): [True: 381k, False: 25.1k] ------------------ 1255| 381k| dig = _digit8(c); 1256| 381k| if (dig >= 0) { ------------------ | Branch (1256:13): [True: 2.96k, False: 378k] ------------------ 1257| 2.96k| minDig = 1; 1258| 2.96k| maxDig = 3; 1259| 2.96k| n = 1; /* Already have first octal digit */ 1260| 2.96k| bitsPerDigit = 3; 1261| 2.96k| result = dig; 1262| 2.96k| } 1263| 381k| break; 1264| 406k| } 1265| 406k| if (minDig != 0) { ------------------ | Branch (1265:9): [True: 28.1k, False: 378k] ------------------ 1266| 124k| while (*offset < length && n < maxDig) { ------------------ | Branch (1266:16): [True: 123k, False: 1.04k] | Branch (1266:36): [True: 101k, False: 22.0k] ------------------ 1267| 101k| c = charAt(*offset, context); 1268| 101k| dig = (bitsPerDigit == 3) ? _digit8(c) : _digit16(c); ------------------ | Branch (1268:19): [True: 3.83k, False: 97.4k] ------------------ 1269| 101k| if (dig < 0) { ------------------ | Branch (1269:17): [True: 5.08k, False: 96.1k] ------------------ 1270| 5.08k| break; 1271| 5.08k| } 1272| 96.1k| result = (result << bitsPerDigit) | dig; 1273| 96.1k| ++(*offset); 1274| 96.1k| ++n; 1275| 96.1k| } 1276| 28.1k| if (n < minDig) { ------------------ | Branch (1276:13): [True: 175, False: 27.9k] ------------------ 1277| 175| goto err; 1278| 175| } 1279| 27.9k| if (braces) { ------------------ | Branch (1279:13): [True: 204, False: 27.7k] ------------------ 1280| 204| if (c != u'}') { ------------------ | Branch (1280:17): [True: 7, False: 197] ------------------ 1281| 7| goto err; 1282| 7| } 1283| 197| ++(*offset); 1284| 197| } 1285| 27.9k| if (result < 0 || result >= 0x110000) { ------------------ | Branch (1285:13): [True: 14, False: 27.9k] | Branch (1285:27): [True: 11, False: 27.9k] ------------------ 1286| 25| goto err; 1287| 25| } 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| 27.9k| if (*offset < length && U16_IS_LEAD(result)) { ------------------ | | 59| 27.0k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 4.79k, False: 22.2k] | | ------------------ ------------------ | Branch (1292:13): [True: 27.0k, False: 926] ------------------ 1293| 4.79k| int32_t ahead = *offset + 1; 1294| 4.79k| c = charAt(*offset, context); 1295| 4.79k| if (c == u'\\' && ahead < length) { ------------------ | Branch (1295:17): [True: 3.92k, False: 878] | Branch (1295:31): [True: 3.09k, False: 827] ------------------ 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| 3.09k| int32_t tailLimit = ahead + 11; 1300| 3.09k| if (tailLimit > length) { ------------------ | Branch (1300:21): [True: 1.99k, False: 1.09k] ------------------ 1301| 1.99k| tailLimit = length; 1302| 1.99k| } 1303| 3.09k| c = u_unescapeAt(charAt, &ahead, tailLimit, context); ------------------ | | 416| 3.09k|#define u_unescapeAt U_ICU_ENTRY_POINT_RENAME(u_unescapeAt) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1304| 3.09k| } 1305| 4.79k| if (U16_IS_TRAIL(c)) { ------------------ | | 67| 4.79k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 347, False: 4.45k] | | ------------------ ------------------ 1306| 347| *offset = ahead; 1307| 347| result = U16_GET_SUPPLEMENTARY(result, c); ------------------ | | 113| 347| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 347|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 1308| 347| } 1309| 4.79k| } 1310| 27.9k| return result; 1311| 27.9k| } 1312| | 1313| | /* Convert C-style escapes in table */ 1314| 3.13M| 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| 2.63k| } \ | | 1458| 2.63k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1471| 2.63k| return length; 1472| 2.63k|} u_terminateChars_78: 1475| 5.27k|u_terminateChars(char *dest, int32_t destCapacity, int32_t length, UErrorCode *pErrorCode) { 1476| 5.27k| __TERMINATE_STRING(dest, destCapacity, length, pErrorCode); ------------------ | | 1437| 5.27k|#define __TERMINATE_STRING(dest, destCapacity, length, pErrorCode) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5.27k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1438| 5.27k| if(pErrorCode!=nullptr && U_SUCCESS(*pErrorCode)) { \ | | ------------------ | | | Branch (1438:8): [True: 5.27k, False: 0] | | | Branch (1438:31): [True: 5.27k, False: 0] | | ------------------ | | 1439| 5.27k| /* not a public function, so no complete argument checking */ \ | | 1440| 5.27k| \ | | 1441| 5.27k| if(length<0) { \ | | ------------------ | | | Branch (1441:12): [True: 0, False: 5.27k] | | ------------------ | | 1442| 0| /* assume that the caller handles this */ \ | | 1443| 5.27k| } else if(lengthdestCapacity */ { \ | | 1454| 2.63k| /* even the string itself did not fit - set an error code */ \ | | 1455| 2.63k| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; \ | | 1456| 2.63k| } \ | | 1457| 5.27k| } \ | | 1458| 5.27k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5.27k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1477| 5.27k| return length; 1478| 5.27k|} ustr_hashUCharsN_78: 1523| 4.85M|ustr_hashUCharsN(const char16_t *str, int32_t length) { 1524| 4.85M| STRING_HASH(char16_t, str, length, *p); ------------------ | | 1506| 4.85M|#define STRING_HASH(TYPE, STR, STRLEN, DEREF) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4.85M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1507| 4.85M| uint32_t hash = 0; \ | | 1508| 4.85M| const TYPE *p = (const TYPE*) STR; \ | | 1509| 4.85M| if (p != nullptr) { \ | | ------------------ | | | Branch (1509:9): [True: 4.85M, False: 0] | | ------------------ | | 1510| 4.85M| int32_t len = (int32_t)(STRLEN); \ | | 1511| 4.85M| int32_t inc = ((len - 32) / 32) + 1; \ | | 1512| 4.85M| const TYPE *limit = p + len; \ | | 1513| 10.1M| while (p(hash); \ | | 1519| 4.85M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4.85M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1525| 4.85M|} ustring.cpp:_ZL19isMatchAtCPBoundaryPKDsS0_S0_S0_: 43| 69.8k|isMatchAtCPBoundary(const char16_t *start, const char16_t *match, const char16_t *matchLimit, const char16_t *limit) { 44| 69.8k| if(U16_IS_TRAIL(*match) && start!=match && U16_IS_LEAD(*(match-1))) { ------------------ | | 67| 139k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 69.8k] | | ------------------ ------------------ 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| 69.8k| if(U16_IS_LEAD(*(matchLimit-1)) && matchLimit!=limit && U16_IS_TRAIL(*matchLimit)) { ------------------ | | 59| 139k|#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) | | ------------------ | | | Branch (59:24): [True: 0, False: 69.8k] | | ------------------ ------------------ 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| 69.8k| return true; 53| 69.8k|} ustring.cpp:_ZL7_digit8Ds: 1188| 385k|static int32_t _digit8(char16_t c) { 1189| 385k| if (c >= u'0' && c <= u'7') { ------------------ | Branch (1189:9): [True: 379k, False: 6.38k] | Branch (1189:22): [True: 3.88k, False: 375k] ------------------ 1190| 3.88k| return c - u'0'; 1191| 3.88k| } 1192| 381k| return -1; 1193| 385k|} ustring.cpp:_ZL8_digit16Ds: 1196| 97.4k|static int32_t _digit16(char16_t c) { 1197| 97.4k| if (c >= u'0' && c <= u'9') { ------------------ | Branch (1197:9): [True: 97.1k, False: 219] | Branch (1197:22): [True: 67.7k, False: 29.4k] ------------------ 1198| 67.7k| return c - u'0'; 1199| 67.7k| } 1200| 29.6k| if (c >= u'A' && c <= u'F') { ------------------ | Branch (1200:9): [True: 29.4k, False: 223] | Branch (1200:22): [True: 17.1k, False: 12.2k] ------------------ 1201| 17.1k| return c - (u'A' - 10); 1202| 17.1k| } 1203| 12.4k| if (c >= u'a' && c <= u'f') { ------------------ | Branch (1203:9): [True: 11.4k, False: 979] | Branch (1203:22): [True: 10.2k, False: 1.19k] ------------------ 1204| 10.2k| return c - (u'a' - 10); 1205| 10.2k| } 1206| 2.17k| return -1; 1207| 12.4k|} u_strFromUTF8WithSub_78: 266| 2.63k| UErrorCode *pErrorCode){ 267| | /* args check */ 268| 2.63k| if(U_FAILURE(*pErrorCode)) { ------------------ | Branch (268:8): [True: 0, False: 2.63k] ------------------ 269| 0| return nullptr; 270| 0| } 271| 2.63k| if( (src==nullptr && srcLength!=0) || srcLength < -1 || ------------------ | Branch (271:10): [True: 0, False: 2.63k] | Branch (271:26): [True: 0, False: 0] | Branch (271:43): [True: 0, False: 2.63k] ------------------ 272| 2.63k| (destCapacity<0) || (dest == nullptr && destCapacity > 0) || ------------------ | Branch (272:9): [True: 0, False: 2.63k] | Branch (272:30): [True: 0, False: 2.63k] | Branch (272:49): [True: 0, False: 0] ------------------ 273| 2.63k| subchar > 0x10ffff || U_IS_SURROGATE(subchar) ------------------ | | 193| 2.63k|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ | | | Branch (193:27): [True: 0, False: 2.63k] | | ------------------ ------------------ | Branch (273:9): [True: 0, False: 2.63k] ------------------ 274| 2.63k| ) { 275| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 276| 0| return nullptr; 277| 0| } 278| | 279| 2.63k| if(pNumSubstitutions!=nullptr) { ------------------ | Branch (279:8): [True: 0, False: 2.63k] ------------------ 280| 0| *pNumSubstitutions=0; 281| 0| } 282| 2.63k| char16_t *pDest = dest; 283| 2.63k| char16_t *pDestLimit = dest+destCapacity; 284| 2.63k| int32_t reqLength = 0; 285| 2.63k| int32_t numSubstitutions=0; 286| | 287| | /* 288| | * Inline processing of UTF-8 byte sequences: 289| | * 290| | * Byte sequences for the most common characters are handled inline in 291| | * the conversion loops. In order to reduce the path lengths for those 292| | * characters, the tests are arranged in a kind of binary search. 293| | * ASCII (<=0x7f) is checked first, followed by the dividing point 294| | * between 2- and 3-byte sequences (0xe0). 295| | * The 3-byte branch is tested first to speed up CJK text. 296| | * The compiler should combine the subtractions for the two tests for 0xe0. 297| | * Each branch then tests for the other end of its range. 298| | */ 299| | 300| 2.63k| if(srcLength < 0){ ------------------ | Branch (300:8): [True: 0, False: 2.63k] ------------------ 301| | /* 302| | * Transform a NUL-terminated string. 303| | * The code explicitly checks for NULs only in the lead byte position. 304| | * A NUL byte in the trail byte position fails the trail byte range check anyway. 305| | */ 306| 0| int32_t i; 307| 0| UChar32 c; 308| 0| for(i = 0; (c = (uint8_t)src[i]) != 0 && (pDest < pDestLimit);) { ------------------ | Branch (308:20): [True: 0, False: 0] | Branch (308:50): [True: 0, False: 0] ------------------ 309| | // modified copy of U8_NEXT() 310| 0| ++i; 311| 0| if(U8_IS_SINGLE(c)) { ------------------ | | 173| 0|#define U8_IS_SINGLE(c) (((c)&0x80)==0) | | ------------------ | | | Branch (173:25): [True: 0, False: 0] | | ------------------ ------------------ 312| 0| *pDest++=(char16_t)c; 313| 0| } else { 314| 0| uint8_t __t1, __t2; 315| 0| if( /* handle U+0800..U+FFFF inline */ 316| 0| (0xe0<=(c) && (c)<0xf0) && ------------------ | Branch (316:26): [True: 0, False: 0] | Branch (316:39): [True: 0, False: 0] ------------------ 317| 0| U8_IS_VALID_LEAD3_AND_T1((c), src[i]) && ------------------ | | 98| 0|#define U8_IS_VALID_LEAD3_AND_T1(lead, t1) (U8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5))) | | ------------------ | | | | 91| 0|#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" | | ------------------ | | | Branch (98:44): [True: 0, False: 0] | | ------------------ ------------------ 318| 0| (__t2=src[(i)+1]-0x80)<=0x3f) { ------------------ | Branch (318:25): [True: 0, False: 0] ------------------ 319| 0| *pDest++ = (((c)&0xf)<<12)|((src[i]&0x3f)<<6)|__t2; 320| 0| i+=2; 321| 0| } else if( /* handle U+0080..U+07FF inline */ 322| 0| ((c)<0xe0 && (c)>=0xc2) && ------------------ | Branch (322:26): [True: 0, False: 0] | Branch (322:38): [True: 0, False: 0] ------------------ 323| 0| (__t1=src[i]-0x80)<=0x3f) { ------------------ | Branch (323:25): [True: 0, False: 0] ------------------ 324| 0| *pDest++ = (((c)&0x1f)<<6)|__t1; 325| 0| ++(i); 326| 0| } else { 327| | /* function call for "complicated" and error cases */ 328| 0| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), -1, c, -1); ------------------ | | 1920| 0|#define utf8_nextCharSafeBody U_ICU_ENTRY_POINT_RENAME(utf8_nextCharSafeBody) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 329| 0| if(c<0 && (++numSubstitutions, c = subchar) < 0) { ------------------ | Branch (329:24): [True: 0, False: 0] | Branch (329:31): [True: 0, False: 0] ------------------ 330| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 331| 0| return nullptr; 332| 0| } else if(c<=0xFFFF) { ------------------ | Branch (332:31): [True: 0, False: 0] ------------------ 333| 0| *(pDest++)=(char16_t)c; 334| 0| } else { 335| 0| *(pDest++)=U16_LEAD(c); ------------------ | | 123| 0|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 336| 0| if(pDest>5))) | | ------------------ | | | | 91| 0|#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" | | ------------------ | | | Branch (98:44): [True: 0, False: 0] | | ------------------ ------------------ 358| 0| (__t2=src[(i)+1]-0x80)<=0x3f) { ------------------ | Branch (358:25): [True: 0, False: 0] ------------------ 359| 0| ++reqLength; 360| 0| i+=2; 361| 0| } else if( /* handle U+0080..U+07FF inline */ 362| 0| ((c)<0xe0 && (c)>=0xc2) && ------------------ | Branch (362:26): [True: 0, False: 0] | Branch (362:38): [True: 0, False: 0] ------------------ 363| 0| (__t1=src[i]-0x80)<=0x3f) { ------------------ | Branch (363:25): [True: 0, False: 0] ------------------ 364| 0| ++reqLength; 365| 0| ++(i); 366| 0| } else { 367| | /* function call for "complicated" and error cases */ 368| 0| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), -1, c, -1); ------------------ | | 1920| 0|#define utf8_nextCharSafeBody U_ICU_ENTRY_POINT_RENAME(utf8_nextCharSafeBody) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 369| 0| if(c<0 && (++numSubstitutions, c = subchar) < 0) { ------------------ | Branch (369:24): [True: 0, False: 0] | Branch (369:31): [True: 0, False: 0] ------------------ 370| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 371| 0| return nullptr; 372| 0| } 373| 0| reqLength += U16_LENGTH(c); ------------------ | | 141| 0|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 0, False: 0] | | ------------------ ------------------ 374| 0| } 375| 0| } 376| 0| } 377| 2.63k| } else /* srcLength >= 0 */ { 378| | /* Faster loop without ongoing checking for srcLength and pDestLimit. */ 379| 2.63k| int32_t i = 0; 380| 2.63k| UChar32 c; 381| 7.73k| for(;;) { 382| | /* 383| | * Each iteration of the inner loop progresses by at most 3 UTF-8 384| | * bytes and one char16_t, for most characters. 385| | * For supplementary code points (4 & 2), which are rare, 386| | * there is an additional adjustment. 387| | */ 388| 7.73k| int32_t count = (int32_t)(pDestLimit - pDest); 389| 7.73k| int32_t count2 = (srcLength - i) / 3; 390| 7.73k| if(count > count2) { ------------------ | Branch (390:16): [True: 7.73k, False: 0] ------------------ 391| 7.73k| count = count2; /* min(remaining dest, remaining src/3) */ 392| 7.73k| } 393| 7.73k| if(count < 3) { ------------------ | Branch (393:16): [True: 2.63k, False: 5.09k] ------------------ 394| | /* 395| | * Too much overhead if we get near the end of the string, 396| | * continue with the next loop. 397| | */ 398| 2.63k| break; 399| 2.63k| } 400| | 401| 7.87M| do { 402| | // modified copy of U8_NEXT() 403| 7.87M| c = (uint8_t)src[i++]; 404| 7.87M| if(U8_IS_SINGLE(c)) { ------------------ | | 173| 7.87M|#define U8_IS_SINGLE(c) (((c)&0x80)==0) | | ------------------ | | | Branch (173:25): [True: 514k, False: 7.36M] | | ------------------ ------------------ 405| 514k| *pDest++=(char16_t)c; 406| 7.36M| } else { 407| 7.36M| uint8_t __t1, __t2; 408| 7.36M| if( /* handle U+0800..U+FFFF inline */ 409| 7.36M| (0xe0<=(c) && (c)<0xf0) && ------------------ | Branch (409:30): [True: 7.21M, False: 151k] | Branch (409:43): [True: 7.19M, False: 14.9k] ------------------ 410| 7.36M| ((i)+1)>5))) | | ------------------ | | | | 91| 7.19M|#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" | | ------------------ | | | Branch (98:44): [True: 7.19M, False: 0] | | ------------------ ------------------ 412| 7.36M| (__t2=src[(i)+1]-0x80)<=0x3f) { ------------------ | Branch (412:29): [True: 7.19M, False: 0] ------------------ 413| 7.19M| *pDest++ = (((c)&0xf)<<12)|((src[i]&0x3f)<<6)|__t2; 414| 7.19M| i+=2; 415| 7.19M| } else if( /* handle U+0080..U+07FF inline */ 416| 166k| ((c)<0xe0 && (c)>=0xc2) && ------------------ | Branch (416:30): [True: 151k, False: 14.9k] | Branch (416:42): [True: 151k, False: 0] ------------------ 417| 166k| ((i)!=srcLength) && ------------------ | Branch (417:29): [True: 151k, False: 0] ------------------ 418| 166k| (__t1=src[i]-0x80)<=0x3f) { ------------------ | Branch (418:29): [True: 151k, False: 0] ------------------ 419| 151k| *pDest++ = (((c)&0x1f)<<6)|__t1; 420| 151k| ++(i); 421| 151k| } else { 422| 14.9k| if(c >= 0xf0 || subchar > 0xffff) { ------------------ | Branch (422:28): [True: 14.9k, False: 0] | Branch (422:41): [True: 0, False: 0] ------------------ 423| | // We may read up to four bytes and write up to two UChars, 424| | // which we didn't account for with computing count, 425| | // so we adjust it here. 426| 14.9k| if(--count == 0) { ------------------ | Branch (426:32): [True: 146, False: 14.7k] ------------------ 427| 146| --i; // back out byte c 428| 146| break; 429| 146| } 430| 14.9k| } 431| | 432| | /* function call for "complicated" and error cases */ 433| 14.7k| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, c, -1); ------------------ | | 1920| 14.7k|#define utf8_nextCharSafeBody U_ICU_ENTRY_POINT_RENAME(utf8_nextCharSafeBody) | | ------------------ | | | | 123| 14.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 14.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 14.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 434| 14.7k| if(c<0 && (++numSubstitutions, c = subchar) < 0) { ------------------ | Branch (434:28): [True: 0, False: 14.7k] | Branch (434:35): [True: 0, False: 0] ------------------ 435| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 436| 0| return nullptr; 437| 14.7k| } else if(c<=0xFFFF) { ------------------ | Branch (437:35): [True: 0, False: 14.7k] ------------------ 438| 0| *(pDest++)=(char16_t)c; 439| 14.7k| } else { 440| 14.7k| *(pDest++)=U16_LEAD(c); ------------------ | | 123| 14.7k|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 441| 14.7k| *(pDest++)=U16_TRAIL(c); ------------------ | | 132| 14.7k|#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00) ------------------ 442| 14.7k| } 443| 14.7k| } 444| 7.36M| } 445| 7.87M| } while(--count > 0); ------------------ | Branch (445:21): [True: 7.87M, False: 4.95k] ------------------ 446| 5.09k| } 447| | 448| 11.6k| while(i < srcLength && (pDest < pDestLimit)) { ------------------ | Branch (448:15): [True: 9.01k, False: 2.63k] | Branch (448:32): [True: 9.01k, False: 0] ------------------ 449| | // modified copy of U8_NEXT() 450| 9.01k| c = (uint8_t)src[i++]; 451| 9.01k| if(U8_IS_SINGLE(c)) { ------------------ | | 173| 9.01k|#define U8_IS_SINGLE(c) (((c)&0x80)==0) | | ------------------ | | | Branch (173:25): [True: 6.95k, False: 2.05k] | | ------------------ ------------------ 452| 6.95k| *pDest++=(char16_t)c; 453| 6.95k| } else { 454| 2.05k| uint8_t __t1, __t2; 455| 2.05k| if( /* handle U+0800..U+FFFF inline */ 456| 2.05k| (0xe0<=(c) && (c)<0xf0) && ------------------ | Branch (456:26): [True: 1.60k, False: 445] | Branch (456:39): [True: 1.38k, False: 223] ------------------ 457| 2.05k| ((i)+1)>5))) | | ------------------ | | | | 91| 1.38k|#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" | | ------------------ | | | Branch (98:44): [True: 1.38k, False: 0] | | ------------------ ------------------ 459| 2.05k| (__t2=src[(i)+1]-0x80)<=0x3f) { ------------------ | Branch (459:25): [True: 1.38k, False: 0] ------------------ 460| 1.38k| *pDest++ = (((c)&0xf)<<12)|((src[i]&0x3f)<<6)|__t2; 461| 1.38k| i+=2; 462| 1.38k| } else if( /* handle U+0080..U+07FF inline */ 463| 668| ((c)<0xe0 && (c)>=0xc2) && ------------------ | Branch (463:26): [True: 445, False: 223] | Branch (463:38): [True: 445, False: 0] ------------------ 464| 668| ((i)!=srcLength) && ------------------ | Branch (464:25): [True: 445, False: 0] ------------------ 465| 668| (__t1=src[i]-0x80)<=0x3f) { ------------------ | Branch (465:25): [True: 445, False: 0] ------------------ 466| 445| *pDest++ = (((c)&0x1f)<<6)|__t1; 467| 445| ++(i); 468| 445| } else { 469| | /* function call for "complicated" and error cases */ 470| 223| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, c, -1); ------------------ | | 1920| 223|#define utf8_nextCharSafeBody U_ICU_ENTRY_POINT_RENAME(utf8_nextCharSafeBody) | | ------------------ | | | | 123| 223|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 223|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 223|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 471| 223| if(c<0 && (++numSubstitutions, c = subchar) < 0) { ------------------ | Branch (471:24): [True: 0, False: 223] | Branch (471:31): [True: 0, False: 0] ------------------ 472| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 473| 0| return nullptr; 474| 223| } else if(c<=0xFFFF) { ------------------ | Branch (474:31): [True: 0, False: 223] ------------------ 475| 0| *(pDest++)=(char16_t)c; 476| 223| } else { 477| 223| *(pDest++)=U16_LEAD(c); ------------------ | | 123| 223|#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0) ------------------ 478| 223| if(pDest>5))) | | ------------------ | | | | 91| 0|#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" | | ------------------ | | | Branch (98:44): [True: 0, False: 0] | | ------------------ ------------------ 501| 0| (__t2=src[(i)+1]-0x80)<=0x3f) { ------------------ | Branch (501:25): [True: 0, False: 0] ------------------ 502| 0| ++reqLength; 503| 0| i+=2; 504| 0| } else if( /* handle U+0080..U+07FF inline */ 505| 0| ((c)<0xe0 && (c)>=0xc2) && ------------------ | Branch (505:26): [True: 0, False: 0] | Branch (505:38): [True: 0, False: 0] ------------------ 506| 0| ((i)!=srcLength) && ------------------ | Branch (506:25): [True: 0, False: 0] ------------------ 507| 0| (__t1=src[i]-0x80)<=0x3f) { ------------------ | Branch (507:25): [True: 0, False: 0] ------------------ 508| 0| ++reqLength; 509| 0| ++(i); 510| 0| } else { 511| | /* function call for "complicated" and error cases */ 512| 0| (c)=utf8_nextCharSafeBody((const uint8_t *)src, &(i), srcLength, c, -1); ------------------ | | 1920| 0|#define utf8_nextCharSafeBody U_ICU_ENTRY_POINT_RENAME(utf8_nextCharSafeBody) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 513| 0| if(c<0 && (++numSubstitutions, c = subchar) < 0) { ------------------ | Branch (513:24): [True: 0, False: 0] | Branch (513:31): [True: 0, False: 0] ------------------ 514| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 515| 0| return nullptr; 516| 0| } 517| 0| reqLength += U16_LENGTH(c); ------------------ | | 141| 0|#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2) | | ------------------ | | | Branch (141:24): [True: 0, False: 0] | | ------------------ ------------------ 518| 0| } 519| 0| } 520| 0| } 521| 2.63k| } 522| | 523| 2.63k| reqLength+=(int32_t)(pDest - dest); 524| | 525| 2.63k| if(pNumSubstitutions!=nullptr) { ------------------ | Branch (525:8): [True: 0, False: 2.63k] ------------------ 526| 0| *pNumSubstitutions=numSubstitutions; 527| 0| } 528| | 529| 2.63k| if(pDestLength){ ------------------ | Branch (529:8): [True: 2.63k, False: 0] ------------------ 530| 2.63k| *pDestLength = reqLength; 531| 2.63k| } 532| | 533| | /* Terminate the buffer */ 534| 2.63k| u_terminateUChars(dest,destCapacity,reqLength,pErrorCode); ------------------ | | 408| 2.63k|#define u_terminateUChars U_ICU_ENTRY_POINT_RENAME(u_terminateUChars) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 535| | 536| 2.63k| return dest; 537| 2.63k|} u_strToUTF8WithSub_78: 799| 5.27k| UErrorCode *pErrorCode){ 800| 5.27k| int32_t reqLength=0; 801| 5.27k| uint32_t ch=0,ch2=0; 802| 5.27k| uint8_t *pDest = (uint8_t *)dest; 803| 5.27k| uint8_t *pDestLimit = (pDest!=nullptr)?(pDest + destCapacity):nullptr; ------------------ | Branch (803:27): [True: 2.63k, False: 2.63k] ------------------ 804| 5.27k| int32_t numSubstitutions; 805| | 806| | /* args check */ 807| 5.27k| if(U_FAILURE(*pErrorCode)){ ------------------ | Branch (807:8): [True: 0, False: 5.27k] ------------------ 808| 0| return nullptr; 809| 0| } 810| | 811| 5.27k| if( (pSrc==nullptr && srcLength!=0) || srcLength < -1 || ------------------ | Branch (811:10): [True: 0, False: 5.27k] | Branch (811:27): [True: 0, False: 0] | Branch (811:44): [True: 0, False: 5.27k] ------------------ 812| 5.27k| (destCapacity<0) || (dest == nullptr && destCapacity > 0) || ------------------ | Branch (812:9): [True: 0, False: 5.27k] | Branch (812:30): [True: 2.63k, False: 2.63k] | Branch (812:49): [True: 0, False: 2.63k] ------------------ 813| 5.27k| subchar > 0x10ffff || U_IS_SURROGATE(subchar) ------------------ | | 193| 5.27k|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ | | | Branch (193:27): [True: 0, False: 5.27k] | | ------------------ ------------------ | Branch (813:9): [True: 0, False: 5.27k] ------------------ 814| 5.27k| ) { 815| 0| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 816| 0| return nullptr; 817| 0| } 818| | 819| 5.27k| if(pNumSubstitutions!=nullptr) { ------------------ | Branch (819:8): [True: 0, False: 5.27k] ------------------ 820| 0| *pNumSubstitutions=0; 821| 0| } 822| 5.27k| numSubstitutions=0; 823| | 824| 5.27k| if(srcLength==-1) { ------------------ | Branch (824:8): [True: 0, False: 5.27k] ------------------ 825| 0| while((ch=*pSrc)!=0) { ------------------ | Branch (825:15): [True: 0, False: 0] ------------------ 826| 0| ++pSrc; 827| 0| if(ch <= 0x7f) { ------------------ | Branch (827:16): [True: 0, False: 0] ------------------ 828| 0| if(pDest= 2) { ------------------ | Branch (835:20): [True: 0, False: 0] ------------------ 836| 0| *pDest++=(uint8_t)((ch>>6)|0xc0); 837| 0| *pDest++=(uint8_t)((ch&0x3f)|0x80); 838| 0| } else { 839| 0| reqLength = 2; 840| 0| break; 841| 0| } 842| 0| } else if(ch <= 0xd7ff || ch >= 0xe000) { ------------------ | Branch (842:23): [True: 0, False: 0] | Branch (842:39): [True: 0, False: 0] ------------------ 843| 0| if((pDestLimit - pDest) >= 3) { ------------------ | Branch (843:20): [True: 0, False: 0] ------------------ 844| 0| *pDest++=(uint8_t)((ch>>12)|0xe0); 845| 0| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); 846| 0| *pDest++=(uint8_t)((ch&0x3f)|0x80); 847| 0| } else { 848| 0| reqLength = 3; 849| 0| break; 850| 0| } 851| 0| } else /* ch is a surrogate */ { 852| 0| int32_t length; 853| | 854| | /*need not check for NUL because NUL fails U16_IS_TRAIL() anyway*/ 855| 0| if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { ------------------ | | 84| 0|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | ------------------ | | | Branch (84:34): [True: 0, False: 0] | | ------------------ ------------------ if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ 856| 0| ++pSrc; 857| 0| ch=U16_GET_SUPPLEMENTARY(ch, ch2); ------------------ | | 113| 0| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 0|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 858| 0| } else if(subchar>=0) { ------------------ | Branch (858:27): [True: 0, False: 0] ------------------ 859| 0| ch=subchar; 860| 0| ++numSubstitutions; 861| 0| } else { 862| | /* Unicode 3.2 forbids surrogate code points in UTF-8 */ 863| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 864| 0| return nullptr; 865| 0| } 866| | 867| 0| length = U8_LENGTH(ch); ------------------ | | 200| 0| ((uint32_t)(c)<=0x7f ? 1 : \ | | ------------------ | | | Branch (200:6): [True: 0, False: 0] | | ------------------ | | 201| 0| ((uint32_t)(c)<=0x7ff ? 2 : \ | | ------------------ | | | Branch (201:10): [True: 0, False: 0] | | ------------------ | | 202| 0| ((uint32_t)(c)<=0xd7ff ? 3 : \ | | ------------------ | | | Branch (202:14): [True: 0, False: 0] | | ------------------ | | 203| 0| ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \ | | ------------------ | | | Branch (203:18): [True: 0, False: 0] | | | Branch (203:43): [True: 0, False: 0] | | ------------------ | | 204| 0| ((uint32_t)(c)<=0xffff ? 3 : 4)\ | | ------------------ | | | Branch (204:22): [True: 0, False: 0] | | ------------------ | | 205| 0| ) \ | | 206| 0| ) \ | | 207| 0| ) \ | | 208| 0| ) ------------------ 868| 0| if((pDestLimit - pDest) >= length) { ------------------ | Branch (868:20): [True: 0, False: 0] ------------------ 869| | /* convert and append*/ 870| 0| pDest=_appendUTF8(pDest, ch); 871| 0| } else { 872| 0| reqLength = length; 873| 0| break; 874| 0| } 875| 0| } 876| 0| } 877| 0| while((ch=*pSrc++)!=0) { ------------------ | Branch (877:15): [True: 0, False: 0] ------------------ 878| 0| if(ch<=0x7f) { ------------------ | Branch (878:16): [True: 0, False: 0] ------------------ 879| 0| ++reqLength; 880| 0| } else if(ch<=0x7ff) { ------------------ | Branch (880:23): [True: 0, False: 0] ------------------ 881| 0| reqLength+=2; 882| 0| } else if(!U16_IS_SURROGATE(ch)) { ------------------ | | 75| 0|#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c) | | ------------------ | | | | 193| 0|#define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800) | | ------------------ ------------------ | Branch (882:23): [True: 0, False: 0] ------------------ 883| 0| reqLength+=3; 884| 0| } else if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { ------------------ | | 84| 0|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | ------------------ | | | Branch (84:34): [True: 0, False: 0] | | ------------------ ------------------ } else if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { ------------------ | | 67| 0|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 0, False: 0] | | ------------------ ------------------ 885| 0| ++pSrc; 886| 0| reqLength+=4; 887| 0| } else if(subchar>=0) { ------------------ | Branch (887:23): [True: 0, False: 0] ------------------ 888| 0| reqLength+=U8_LENGTH(subchar); ------------------ | | 200| 0| ((uint32_t)(c)<=0x7f ? 1 : \ | | ------------------ | | | Branch (200:6): [True: 0, False: 0] | | ------------------ | | 201| 0| ((uint32_t)(c)<=0x7ff ? 2 : \ | | ------------------ | | | Branch (201:10): [True: 0, False: 0] | | ------------------ | | 202| 0| ((uint32_t)(c)<=0xd7ff ? 3 : \ | | ------------------ | | | Branch (202:14): [True: 0, False: 0] | | ------------------ | | 203| 0| ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \ | | ------------------ | | | Branch (203:18): [True: 0, False: 0] | | | Branch (203:43): [True: 0, False: 0] | | ------------------ | | 204| 0| ((uint32_t)(c)<=0xffff ? 3 : 4)\ | | ------------------ | | | Branch (204:22): [True: 0, False: 0] | | ------------------ | | 205| 0| ) \ | | 206| 0| ) \ | | 207| 0| ) \ | | 208| 0| ) ------------------ 889| 0| ++numSubstitutions; 890| 0| } else { 891| | /* Unicode 3.2 forbids surrogate code points in UTF-8 */ 892| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 893| 0| return nullptr; 894| 0| } 895| 0| } 896| 5.27k| } else { 897| 5.27k| const char16_t *pSrcLimit = (pSrc!=nullptr)?(pSrc+srcLength):nullptr; ------------------ | Branch (897:37): [True: 5.27k, False: 0] ------------------ 898| 5.27k| int32_t count; 899| | 900| | /* Faster loop without ongoing checking for pSrcLimit and pDestLimit. */ 901| 10.6k| for(;;) { 902| | /* 903| | * Each iteration of the inner loop progresses by at most 3 UTF-8 904| | * bytes and one char16_t, for most characters. 905| | * For supplementary code points (4 & 2), which are rare, 906| | * there is an additional adjustment. 907| | */ 908| 10.6k| count = (int32_t)((pDestLimit - pDest) / 3); 909| 10.6k| srcLength = (int32_t)(pSrcLimit - pSrc); 910| 10.6k| if(count > srcLength) { ------------------ | Branch (910:16): [True: 1.56k, False: 9.06k] ------------------ 911| 1.56k| count = srcLength; /* min(remaining dest/3, remaining src) */ 912| 1.56k| } 913| 10.6k| if(count < 3) { ------------------ | Branch (913:16): [True: 5.27k, False: 5.36k] ------------------ 914| | /* 915| | * Too much overhead if we get near the end of the string, 916| | * continue with the next loop. 917| | */ 918| 5.27k| break; 919| 5.27k| } 920| 7.88M| do { 921| 7.88M| ch=*pSrc++; 922| 7.88M| if(ch <= 0x7f) { ------------------ | Branch (922:20): [True: 518k, False: 7.36M] ------------------ 923| 518k| *pDest++ = (uint8_t)ch; 924| 7.36M| } else if(ch <= 0x7ff) { ------------------ | Branch (924:27): [True: 151k, False: 7.21M] ------------------ 925| 151k| *pDest++=(uint8_t)((ch>>6)|0xc0); 926| 151k| *pDest++=(uint8_t)((ch&0x3f)|0x80); 927| 7.21M| } else if(ch <= 0xd7ff || ch >= 0xe000) { ------------------ | Branch (927:27): [True: 6.60M, False: 610k] | Branch (927:43): [True: 594k, False: 15.6k] ------------------ 928| 7.19M| *pDest++=(uint8_t)((ch>>12)|0xe0); 929| 7.19M| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); 930| 7.19M| *pDest++=(uint8_t)((ch&0x3f)|0x80); 931| 7.19M| } else /* ch is a surrogate */ { 932| | /* 933| | * We will read two UChars and probably output four bytes, 934| | * which we didn't account for with computing count, 935| | * so we adjust it here. 936| | */ 937| 15.6k| if(--count == 0) { ------------------ | Branch (937:24): [True: 132, False: 15.5k] ------------------ 938| 132| --pSrc; /* undo ch=*pSrc++ for the lead surrogate */ 939| 132| break; /* recompute count */ 940| 132| } 941| | 942| 15.5k| if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { ------------------ | | 84| 31.0k|#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | ------------------ | | | Branch (84:34): [True: 15.3k, False: 217] | | ------------------ ------------------ if(U16_IS_SURROGATE_LEAD(ch) && U16_IS_TRAIL(ch2=*pSrc)) { ------------------ | | 67| 15.3k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) | | ------------------ | | | Branch (67:25): [True: 14.9k, False: 393] | | ------------------ ------------------ 943| 14.9k| ++pSrc; 944| 14.9k| ch=U16_GET_SUPPLEMENTARY(ch, ch2); ------------------ | | 113| 14.9k| (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET) | | ------------------ | | | | 99| 14.9k|#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000) | | ------------------ ------------------ 945| | 946| | /* writing 4 bytes per 2 UChars is ok */ 947| 14.9k| *pDest++=(uint8_t)((ch>>18)|0xf0); 948| 14.9k| *pDest++=(uint8_t)(((ch>>12)&0x3f)|0x80); 949| 14.9k| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); 950| 14.9k| *pDest++=(uint8_t)((ch&0x3f)|0x80); 951| 14.9k| } else { 952| | /* Unicode 3.2 forbids surrogate code points in UTF-8 */ 953| 610| if(subchar>=0) { ------------------ | Branch (953:28): [True: 610, False: 0] ------------------ 954| 610| ch=subchar; 955| 610| ++numSubstitutions; 956| 610| } else { 957| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 958| 0| return nullptr; 959| 0| } 960| | 961| | /* convert and append*/ 962| 610| pDest=_appendUTF8(pDest, ch); 963| 610| } 964| 15.5k| } 965| 7.88M| } while(--count > 0); ------------------ | Branch (965:21): [True: 7.87M, False: 5.22k] ------------------ 966| 5.36k| } 967| | 968| 9.41k| while(pSrc= 2) { ------------------ | Branch (978:20): [True: 164, False: 176] ------------------ 979| 164| *pDest++=(uint8_t)((ch>>6)|0xc0); 980| 164| *pDest++=(uint8_t)((ch&0x3f)|0x80); 981| 176| } else { 982| 176| reqLength = 2; 983| 176| break; 984| 176| } 985| 1.95k| } else if(ch <= 0xd7ff || ch >= 0xe000) { ------------------ | Branch (985:23): [True: 1.08k, False: 868] | Branch (985:39): [True: 612, False: 256] ------------------ 986| 1.69k| if((pDestLimit - pDest) >= 3) { ------------------ | Branch (986:20): [True: 420, False: 1.27k] ------------------ 987| 420| *pDest++=(uint8_t)((ch>>12)|0xe0); 988| 420| *pDest++=(uint8_t)(((ch>>6)&0x3f)|0x80); 989| 420| *pDest++=(uint8_t)((ch&0x3f)|0x80); 990| 1.27k| } else { 991| 1.27k| reqLength = 3; 992| 1.27k| break; 993| 1.27k| } 994| 1.69k| } else /* ch is a surrogate */ { 995| 256| int32_t length; 996| | 997| 256| if(U16_IS_SURROGATE_LEAD(ch) && pSrc=0) { ------------------ | Branch (1000:27): [True: 20, False: 0] ------------------ 1001| 20| ch=subchar; 1002| 20| ++numSubstitutions; 1003| 20| } else { 1004| | /* Unicode 3.2 forbids surrogate code points in UTF-8 */ 1005| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 1006| 0| return nullptr; 1007| 0| } 1008| | 1009| 256| length = U8_LENGTH(ch); ------------------ | | 200| 256| ((uint32_t)(c)<=0x7f ? 1 : \ | | ------------------ | | | Branch (200:6): [True: 0, False: 256] | | ------------------ | | 201| 256| ((uint32_t)(c)<=0x7ff ? 2 : \ | | ------------------ | | | Branch (201:10): [True: 0, False: 256] | | ------------------ | | 202| 256| ((uint32_t)(c)<=0xd7ff ? 3 : \ | | ------------------ | | | Branch (202:14): [True: 0, False: 256] | | ------------------ | | 203| 256| ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \ | | ------------------ | | | Branch (203:18): [True: 0, False: 256] | | | Branch (203:43): [True: 0, False: 256] | | ------------------ | | 204| 256| ((uint32_t)(c)<=0xffff ? 3 : 4)\ | | ------------------ | | | Branch (204:22): [True: 20, False: 236] | | ------------------ | | 205| 256| ) \ | | 206| 256| ) \ | | 207| 256| ) \ | | 208| 256| ) ------------------ 1010| 256| if((pDestLimit - pDest) >= length) { ------------------ | Branch (1010:20): [True: 122, False: 134] ------------------ 1011| | /* convert and append*/ 1012| 122| pDest=_appendUTF8(pDest, ch); 1013| 134| } else { 1014| 134| reqLength = length; 1015| 134| break; 1016| 134| } 1017| 256| } 1018| 6.77k| } 1019| 7.88M| while(pSrc=0) { ------------------ | Branch (1030:23): [True: 630, False: 0] ------------------ 1031| 630| reqLength+=U8_LENGTH(subchar); ------------------ | | 200| 630| ((uint32_t)(c)<=0x7f ? 1 : \ | | ------------------ | | | Branch (200:6): [True: 0, False: 630] | | ------------------ | | 201| 630| ((uint32_t)(c)<=0x7ff ? 2 : \ | | ------------------ | | | Branch (201:10): [True: 0, False: 630] | | ------------------ | | 202| 630| ((uint32_t)(c)<=0xd7ff ? 3 : \ | | ------------------ | | | Branch (202:14): [True: 0, False: 630] | | ------------------ | | 203| 630| ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \ | | ------------------ | | | Branch (203:18): [True: 0, False: 630] | | | Branch (203:43): [True: 0, False: 630] | | ------------------ | | 204| 630| ((uint32_t)(c)<=0xffff ? 3 : 4)\ | | ------------------ | | | Branch (204:22): [True: 630, False: 0] | | ------------------ | | 205| 630| ) \ | | 206| 630| ) \ | | 207| 630| ) \ | | 208| 630| ) ------------------ 1032| 630| ++numSubstitutions; 1033| 630| } else { 1034| | /* Unicode 3.2 forbids surrogate code points in UTF-8 */ 1035| 0| *pErrorCode = U_INVALID_CHAR_FOUND; 1036| 0| return nullptr; 1037| 0| } 1038| 7.88M| } 1039| 5.27k| } 1040| | 1041| 5.27k| reqLength+=(int32_t)(pDest - (uint8_t *)dest); 1042| | 1043| 5.27k| if(pNumSubstitutions!=nullptr) { ------------------ | Branch (1043:8): [True: 0, False: 5.27k] ------------------ 1044| 0| *pNumSubstitutions=numSubstitutions; 1045| 0| } 1046| | 1047| 5.27k| if(pDestLength){ ------------------ | Branch (1047:8): [True: 5.27k, False: 0] ------------------ 1048| 5.27k| *pDestLength = reqLength; 1049| 5.27k| } 1050| | 1051| | /* Terminate the buffer */ 1052| 5.27k| u_terminateChars(dest, destCapacity, reqLength, pErrorCode); ------------------ | | 406| 5.27k|#define u_terminateChars U_ICU_ENTRY_POINT_RENAME(u_terminateChars) | | ------------------ | | | | 123| 5.27k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.27k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.27k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1053| 5.27k| return dest; 1054| 5.27k|} ustrtrns.cpp:_ZL11_appendUTF8Phi: 771| 732|_appendUTF8(uint8_t *pDest, UChar32 c) { 772| | /* it is 0<=c<=0x10ffff and not a surrogate if called by a validating function */ 773| 732| if((c)<=0x7f) { ------------------ | Branch (773:8): [True: 0, False: 732] ------------------ 774| 0| *pDest++ = static_cast(c); 775| 732| } else if(c<=0x7ff) { ------------------ | Branch (775:15): [True: 0, False: 732] ------------------ 776| 0| *pDest++ = static_cast((c >> 6) | 0xc0); 777| 0| *pDest++ = static_cast((c & 0x3f) | 0x80); 778| 732| } else if(c<=0xffff) { ------------------ | Branch (778:15): [True: 630, False: 102] ------------------ 779| 630| *pDest++ = static_cast((c >> 12) | 0xe0); 780| 630| *pDest++ = static_cast(((c >> 6) & 0x3f) | 0x80); 781| 630| *pDest++ = static_cast(((c) & 0x3f) | 0x80); 782| 630| } else /* if((uint32_t)(c)<=0x10ffff) */ { 783| 102| *pDest++ = static_cast(((c) >> 18) | 0xf0); 784| 102| *pDest++ = static_cast((((c) >> 12) & 0x3f) | 0x80); 785| 102| *pDest++ = static_cast((((c) >> 6) & 0x3f) | 0x80); 786| 102| *pDest++ = static_cast(((c) & 0x3f) | 0x80); 787| 102| } 788| 732| return pDest; 789| 732|} utext_freeze_78: 473| 2.63k|utext_freeze(UText *ut) { 474| | // Zero out the WRITABLE flag. 475| 2.63k| ut->providerProperties &= ~(I32_FLAG(UTEXT_PROVIDER_WRITABLE)); ------------------ | | 37| 2.63k|#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) ------------------ 476| 2.63k|} utext_clone_78: 525| 2.63k|utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status) { 526| 2.63k| if (U_FAILURE(*status)) { ------------------ | Branch (526:9): [True: 0, False: 2.63k] ------------------ 527| 0| return dest; 528| 0| } 529| 2.63k| UText *result = src->pFuncs->clone(dest, src, deep, status); 530| 2.63k| if (U_FAILURE(*status)) { ------------------ | Branch (530:9): [True: 0, False: 2.63k] ------------------ 531| 0| return result; 532| 0| } 533| 2.63k| if (result == nullptr) { ------------------ | Branch (533:9): [True: 0, False: 2.63k] ------------------ 534| 0| *status = U_MEMORY_ALLOCATION_ERROR; 535| 0| return result; 536| 0| } 537| 2.63k| if (readOnly) { ------------------ | Branch (537:9): [True: 2.63k, False: 0] ------------------ 538| 2.63k| utext_freeze(result); ------------------ | | 1896| 2.63k|#define utext_freeze U_ICU_ENTRY_POINT_RENAME(utext_freeze) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 539| 2.63k| } 540| 2.63k| return result; 541| 2.63k|} utext_setup_78: 581| 13.6k|utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status) { 582| 13.6k| if (U_FAILURE(*status)) { ------------------ | Branch (582:9): [True: 0, False: 13.6k] ------------------ 583| 0| return ut; 584| 0| } 585| | 586| 13.6k| if (ut == nullptr) { ------------------ | Branch (586:9): [True: 0, False: 13.6k] ------------------ 587| | // We need to heap-allocate storage for the new UText 588| 0| int32_t spaceRequired = sizeof(UText); 589| 0| if (extraSpace > 0) { ------------------ | Branch (589:13): [True: 0, False: 0] ------------------ 590| 0| spaceRequired = sizeof(ExtendedUText) + extraSpace - sizeof(std::max_align_t); 591| 0| } 592| 0| ut = (UText *)uprv_malloc(spaceRequired); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 593| 0| if (ut == nullptr) { ------------------ | Branch (593:13): [True: 0, False: 0] ------------------ 594| 0| *status = U_MEMORY_ALLOCATION_ERROR; 595| 0| return nullptr; 596| 0| } else { 597| 0| *ut = emptyText; 598| 0| ut->flags |= UTEXT_HEAP_ALLOCATED; 599| 0| if (spaceRequired>0) { ------------------ | Branch (599:17): [True: 0, False: 0] ------------------ 600| 0| ut->extraSize = extraSpace; 601| 0| ut->pExtra = &((ExtendedUText *)ut)->extension; 602| 0| } 603| 0| } 604| 13.6k| } else { 605| | // We have been supplied with an already existing UText. 606| | // Verify that it really appears to be a UText. 607| 13.6k| if (ut->magic != UTEXT_MAGIC) { ------------------ | Branch (607:13): [True: 0, False: 13.6k] ------------------ 608| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 609| 0| return ut; 610| 0| } 611| | // If the ut is already open and there's a provider supplied close 612| | // function, call it. 613| 13.6k| if ((ut->flags & UTEXT_OPEN) && ut->pFuncs->close != nullptr) { ------------------ | Branch (613:13): [True: 2.63k, False: 11.0k] | Branch (613:41): [True: 2.63k, False: 0] ------------------ 614| 2.63k| ut->pFuncs->close(ut); 615| 2.63k| } 616| 13.6k| ut->flags &= ~UTEXT_OPEN; 617| | 618| | // If extra space was requested by our caller, check whether 619| | // sufficient already exists, and allocate new if needed. 620| 13.6k| if (extraSpace > ut->extraSize) { ------------------ | Branch (620:13): [True: 0, False: 13.6k] ------------------ 621| | // Need more space. If there is existing separately allocated space, 622| | // delete it first, then allocate new space. 623| 0| if (ut->flags & UTEXT_EXTRA_HEAP_ALLOCATED) { ------------------ | Branch (623:17): [True: 0, False: 0] ------------------ 624| 0| uprv_free(ut->pExtra); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 625| 0| ut->extraSize = 0; 626| 0| } 627| 0| ut->pExtra = uprv_malloc(extraSpace); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 628| 0| if (ut->pExtra == nullptr) { ------------------ | Branch (628:17): [True: 0, False: 0] ------------------ 629| 0| *status = U_MEMORY_ALLOCATION_ERROR; 630| 0| } else { 631| 0| ut->extraSize = extraSpace; 632| 0| ut->flags |= UTEXT_EXTRA_HEAP_ALLOCATED; 633| 0| } 634| 0| } 635| 13.6k| } 636| 13.6k| if (U_SUCCESS(*status)) { ------------------ | Branch (636:9): [True: 13.6k, False: 0] ------------------ 637| 13.6k| ut->flags |= UTEXT_OPEN; 638| | 639| | // Initialize all remaining fields of the UText. 640| | // 641| 13.6k| ut->context = nullptr; 642| 13.6k| ut->chunkContents = nullptr; 643| 13.6k| ut->p = nullptr; 644| 13.6k| ut->q = nullptr; 645| 13.6k| ut->r = nullptr; 646| 13.6k| ut->a = 0; 647| 13.6k| ut->b = 0; 648| 13.6k| ut->c = 0; 649| 13.6k| ut->chunkOffset = 0; 650| 13.6k| ut->chunkLength = 0; 651| 13.6k| ut->chunkNativeStart = 0; 652| 13.6k| ut->chunkNativeLimit = 0; 653| 13.6k| ut->nativeIndexingLimit = 0; 654| 13.6k| ut->providerProperties = 0; 655| 13.6k| ut->privA = 0; 656| 13.6k| ut->privB = 0; 657| 13.6k| ut->privC = 0; 658| 13.6k| ut->privP = nullptr; 659| 13.6k| if (ut->pExtra!=nullptr && ut->extraSize>0) ------------------ | Branch (659:13): [True: 0, False: 13.6k] | Branch (659:36): [True: 0, False: 0] ------------------ 660| 13.6k| uprv_memset(ut->pExtra, 0, ut->extraSize); ------------------ | | 100| 0|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 661| | 662| 13.6k| } 663| 13.6k| return ut; 664| 13.6k|} utext_close_78: 668| 11.0k|utext_close(UText *ut) { 669| 11.0k| if (ut==nullptr || ------------------ | Branch (669:9): [True: 0, False: 11.0k] ------------------ 670| 11.0k| ut->magic != UTEXT_MAGIC || ------------------ | Branch (670:9): [True: 0, False: 11.0k] ------------------ 671| 11.0k| (ut->flags & UTEXT_OPEN) == 0) ------------------ | Branch (671:9): [True: 0, False: 11.0k] ------------------ 672| 0| { 673| | // The supplied ut is not an open UText. 674| | // Do nothing. 675| 0| return ut; 676| 0| } 677| | 678| | // If the provider gave us a close function, call it now. 679| | // This will clean up anything allocated specifically by the provider. 680| 11.0k| if (ut->pFuncs->close != nullptr) { ------------------ | Branch (680:9): [True: 11.0k, False: 0] ------------------ 681| 11.0k| ut->pFuncs->close(ut); 682| 11.0k| } 683| 11.0k| ut->flags &= ~UTEXT_OPEN; 684| | 685| | // If we (the framework) allocated the UText or subsidiary storage, 686| | // delete it. 687| 11.0k| if (ut->flags & UTEXT_EXTRA_HEAP_ALLOCATED) { ------------------ | Branch (687:9): [True: 0, False: 11.0k] ------------------ 688| 0| uprv_free(ut->pExtra); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 689| 0| ut->pExtra = nullptr; 690| 0| ut->flags &= ~UTEXT_EXTRA_HEAP_ALLOCATED; 691| 0| ut->extraSize = 0; 692| 0| } 693| | 694| | // Zero out function table of the closed UText. This is a defensive move, 695| | // intended to cause applications that inadvertently use a closed 696| | // utext to crash with null pointer errors. 697| 11.0k| ut->pFuncs = nullptr; 698| | 699| 11.0k| if (ut->flags & UTEXT_HEAP_ALLOCATED) { ------------------ | Branch (699:9): [True: 0, False: 11.0k] ------------------ 700| | // This UText was allocated by UText setup. We need to free it. 701| | // Clear magic, so we can detect if the user messes up and immediately 702| | // tries to reopen another UText using the deleted storage. 703| 0| ut->magic = 0; 704| 0| uprv_free(ut); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 705| 0| ut = nullptr; 706| 0| } 707| 11.0k| return ut; 708| 11.0k|} utext_openUChars_78: 2617| 11.0k|utext_openUChars(UText *ut, const char16_t *s, int64_t length, UErrorCode *status) { 2618| 11.0k| if (U_FAILURE(*status)) { ------------------ | Branch (2618:9): [True: 0, False: 11.0k] ------------------ 2619| 0| return nullptr; 2620| 0| } 2621| 11.0k| if(s==nullptr && length==0) { ------------------ | Branch (2621:8): [True: 11.0k, False: 0] | Branch (2621:22): [True: 11.0k, False: 0] ------------------ 2622| 11.0k| s = gEmptyUString; 2623| 11.0k| } 2624| 11.0k| if (s==nullptr || length < -1 || length>INT32_MAX) { ------------------ | Branch (2624:9): [True: 0, False: 11.0k] | Branch (2624:23): [True: 0, False: 11.0k] | Branch (2624:38): [True: 0, False: 11.0k] ------------------ 2625| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2626| 0| return nullptr; 2627| 0| } 2628| 11.0k| ut = utext_setup(ut, 0, status); ------------------ | | 1916| 11.0k|#define utext_setup U_ICU_ENTRY_POINT_RENAME(utext_setup) | | ------------------ | | | | 123| 11.0k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 11.0k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 11.0k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2629| 11.0k| if (U_SUCCESS(*status)) { ------------------ | Branch (2629:9): [True: 11.0k, False: 0] ------------------ 2630| 11.0k| ut->pFuncs = &ucstrFuncs; 2631| 11.0k| ut->context = s; 2632| 11.0k| ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS); ------------------ | | 37| 11.0k|#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) ------------------ 2633| 11.0k| if (length==-1) { ------------------ | Branch (2633:13): [True: 0, False: 11.0k] ------------------ 2634| 0| ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); ------------------ | | 37| 0|#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) ------------------ 2635| 0| } 2636| 11.0k| ut->a = length; 2637| 11.0k| ut->chunkContents = s; 2638| 11.0k| ut->chunkNativeStart = 0; 2639| 11.0k| ut->chunkNativeLimit = length>=0? length : 0; ------------------ | Branch (2639:36): [True: 11.0k, False: 0] ------------------ 2640| 11.0k| ut->chunkLength = (int32_t)ut->chunkNativeLimit; 2641| 11.0k| ut->chunkOffset = 0; 2642| 11.0k| ut->nativeIndexingLimit = ut->chunkLength; 2643| 11.0k| } 2644| 11.0k| return ut; 2645| 11.0k|} utext.cpp:_ZL16shallowTextCloneP5UTextPKS_P10UErrorCode: 776| 2.63k|shallowTextClone(UText * dest, const UText * src, UErrorCode * status) { 777| 2.63k| if (U_FAILURE(*status)) { ------------------ | Branch (777:9): [True: 0, False: 2.63k] ------------------ 778| 0| return nullptr; 779| 0| } 780| 2.63k| int32_t srcExtraSize = src->extraSize; 781| | 782| | // 783| | // Use the generic text_setup to allocate storage if required. 784| | // 785| 2.63k| dest = utext_setup(dest, srcExtraSize, status); ------------------ | | 1916| 2.63k|#define utext_setup U_ICU_ENTRY_POINT_RENAME(utext_setup) | | ------------------ | | | | 123| 2.63k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.63k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.63k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 786| 2.63k| if (U_FAILURE(*status)) { ------------------ | Branch (786:9): [True: 0, False: 2.63k] ------------------ 787| 0| return dest; 788| 0| } 789| | 790| | // 791| | // flags (how the UText was allocated) and the pointer to the 792| | // extra storage must retain the values in the cloned utext that 793| | // were set up by utext_setup. Save them separately before 794| | // copying the whole struct. 795| | // 796| 2.63k| void *destExtra = dest->pExtra; 797| 2.63k| int32_t flags = dest->flags; 798| | 799| | 800| | // 801| | // Copy the whole UText struct by value. 802| | // Any "Extra" storage is copied also. 803| | // 804| 2.63k| int sizeToCopy = src->sizeOfStruct; 805| 2.63k| if (sizeToCopy > dest->sizeOfStruct) { ------------------ | Branch (805:9): [True: 0, False: 2.63k] ------------------ 806| 0| sizeToCopy = dest->sizeOfStruct; 807| 0| } 808| 2.63k| uprv_memcpy(dest, src, sizeToCopy); ------------------ | | 42| 2.63k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.63k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.63k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.63k| _Pragma("clang diagnostic push") \ | | 45| 2.63k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.63k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.63k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.63k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.63k| _Pragma("clang diagnostic pop") \ | | 49| 2.63k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.63k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.63k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.63k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 809| 2.63k| dest->pExtra = destExtra; 810| 2.63k| dest->flags = flags; 811| 2.63k| if (srcExtraSize > 0) { ------------------ | Branch (811:9): [True: 0, False: 2.63k] ------------------ 812| 0| uprv_memcpy(dest->pExtra, src->pExtra, srcExtraSize); ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 813| 0| } 814| | 815| | // 816| | // Relocate any pointers in the target that refer to the UText itself 817| | // to point to the cloned copy rather than the original source. 818| | // 819| 2.63k| adjustPointer(dest, &dest->context, src); 820| 2.63k| adjustPointer(dest, &dest->p, src); 821| 2.63k| adjustPointer(dest, &dest->q, src); 822| 2.63k| adjustPointer(dest, &dest->r, src); 823| 2.63k| adjustPointer(dest, (const void **)&dest->chunkContents, src); 824| | 825| | // The newly shallow-cloned UText does _not_ own the underlying storage for the text. 826| | // (The source for the clone may or may not have owned the text.) 827| | 828| 2.63k| dest->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); ------------------ | | 37| 2.63k|#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) ------------------ 829| | 830| 2.63k| return dest; 831| 2.63k|} utext.cpp:_ZL13adjustPointerP5UTextPPKvPKS_: 753| 13.1k|static void adjustPointer(UText *dest, const void **destPtr, const UText *src) { 754| | // convert all pointers to (char *) so that byte address arithmetic will work. 755| 13.1k| char *dptr = (char *)*destPtr; 756| 13.1k| char *dUText = (char *)dest; 757| 13.1k| char *sUText = (char *)src; 758| | 759| 13.1k| if (dptr >= (char *)src->pExtra && dptr < ((char*)src->pExtra)+src->extraSize) { ------------------ | Branch (759:9): [True: 13.1k, False: 0] | Branch (759:40): [True: 0, False: 13.1k] ------------------ 760| | // target ptr was to something within the src UText's pExtra storage. 761| | // relocate it into the target UText's pExtra region. 762| 0| *destPtr = ((char *)dest->pExtra) + (dptr - (char *)src->pExtra); 763| 13.1k| } else if (dptr>=sUText && dptr < sUText+src->sizeOfStruct) { ------------------ | Branch (763:16): [True: 0, False: 13.1k] | Branch (763:32): [True: 0, False: 0] ------------------ 764| | // target ptr was pointing to somewhere within the source UText itself. 765| | // Move it to the same offset within the target UText. 766| 0| *destPtr = dUText + (dptr-sUText); 767| 0| } 768| 13.1k|} utext.cpp:_ZL14ucstrTextCloneP5UTextPKS_aP10UErrorCode: 2351| 2.63k|ucstrTextClone(UText *dest, const UText * src, UBool deep, UErrorCode * status) { 2352| | // First do a generic shallow clone. 2353| 2.63k| dest = shallowTextClone(dest, src, status); 2354| | 2355| | // For deep clones, make a copy of the string. 2356| | // The copied storage is owned by the newly created clone. 2357| | // A non-nullptr pointer in UText.p is the signal to the close() function to delete 2358| | // it. 2359| | // 2360| 2.63k| if (deep && U_SUCCESS(*status)) { ------------------ | Branch (2360:9): [True: 0, False: 2.63k] | Branch (2360:17): [True: 0, False: 0] ------------------ 2361| 0| U_ASSERT(utext_nativeLength(dest) < INT32_MAX); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 2362| 0| int32_t len = (int32_t)utext_nativeLength(dest); ------------------ | | 1903| 0|#define utext_nativeLength U_ICU_ENTRY_POINT_RENAME(utext_nativeLength) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2363| | 2364| | // The cloned string IS going to be NUL terminated, whether or not the original was. 2365| 0| const char16_t *srcStr = (const char16_t *)src->context; 2366| 0| char16_t *copyStr = (char16_t *)uprv_malloc((len+1) * sizeof(char16_t)); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2367| 0| if (copyStr == nullptr) { ------------------ | Branch (2367:13): [True: 0, False: 0] ------------------ 2368| 0| *status = U_MEMORY_ALLOCATION_ERROR; 2369| 0| } else { 2370| 0| int64_t i; 2371| 0| for (i=0; icontext = copyStr; 2376| 0| dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); ------------------ | | 37| 0|#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) ------------------ 2377| 0| } 2378| 0| } 2379| 2.63k| return dest; 2380| 2.63k|} utext.cpp:_ZL14ucstrTextCloseP5UText: 2384| 13.6k|ucstrTextClose(UText *ut) { 2385| | // Most of the work of close is done by the generic UText framework close. 2386| | // All that needs to be done here is delete the string if the UText 2387| | // owns it. This occurs if the UText was created by cloning. 2388| 13.6k| if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) { ------------------ | | 37| 13.6k|#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) ------------------ | Branch (2388:9): [True: 0, False: 13.6k] ------------------ 2389| 0| char16_t *s = (char16_t *)ut->context; 2390| 0| uprv_free(s); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2391| 0| ut->context = nullptr; 2392| 0| } 2393| 13.6k|} utf8_nextCharSafeBody_78: 129| 15.0k|utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c, int8_t strict) { 130| | // *pi is one after byte c. 131| 15.0k| int32_t i=*pi; 132| | // length can be negative for NUL-terminated strings: Read and validate one byte at a time. 133| 15.0k| if(i==length || c>0xf4) { ------------------ | Branch (133:8): [True: 0, False: 15.0k] | Branch (133:21): [True: 0, False: 15.0k] ------------------ 134| | // end of string, or not a lead byte 135| 15.0k| } else if(c>=0xf0) { ------------------ | Branch (135:15): [True: 15.0k, False: 0] ------------------ 136| | // Test for 4-byte sequences first because 137| | // U8_NEXT() handles shorter valid sequences inline. 138| 15.0k| uint8_t t1=s[i], t2, t3; 139| 15.0k| c&=7; 140| 15.0k| if(U8_IS_VALID_LEAD4_AND_T1(c, t1) && ------------------ | | 115| 30.0k|#define U8_IS_VALID_LEAD4_AND_T1(lead, t1) (U8_LEAD4_T1_BITS[(uint8_t)(t1)>>4]&(1<<((lead)&7))) | | ------------------ | | | | 108| 15.0k|#define U8_LEAD4_T1_BITS "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00" | | ------------------ | | | Branch (115:44): [True: 15.0k, False: 0] | | ------------------ ------------------ 141| 15.0k| ++i!=length && (t2=s[i]-0x80)<=0x3f && ------------------ | Branch (141:17): [True: 15.0k, False: 0] | Branch (141:32): [True: 15.0k, False: 0] ------------------ 142| 15.0k| ++i!=length && (t3=s[i]-0x80)<=0x3f) { ------------------ | Branch (142:17): [True: 15.0k, False: 0] | Branch (142:32): [True: 15.0k, False: 0] ------------------ 143| 15.0k| ++i; 144| 15.0k| c=(c<<18)|((t1&0x3f)<<12)|(t2<<6)|t3; 145| | // strict: forbid non-characters like U+fffe 146| 15.0k| if(strict<=0 || !U_IS_UNICODE_NONCHAR(c)) { ------------------ | | 131| 0| ((c)>=0xfdd0 && \ | | ------------------ | | | Branch (131:6): [True: 0, False: 0] | | ------------------ | | 132| 0| ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff) | | ------------------ | | | Branch (132:7): [True: 0, False: 0] | | | Branch (132:22): [True: 0, False: 0] | | | Branch (132:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (146:16): [True: 15.0k, False: 0] ------------------ 147| 15.0k| *pi=i; 148| 15.0k| return c; 149| 15.0k| } 150| 15.0k| } 151| 15.0k| } else if(c>=0xe0) { ------------------ | Branch (151:15): [True: 0, False: 0] ------------------ 152| 0| c&=0xf; 153| 0| if(strict!=-2) { ------------------ | Branch (153:12): [True: 0, False: 0] ------------------ 154| 0| uint8_t t1=s[i], t2; 155| 0| if(U8_IS_VALID_LEAD3_AND_T1(c, t1) && ------------------ | | 98| 0|#define U8_IS_VALID_LEAD3_AND_T1(lead, t1) (U8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5))) | | ------------------ | | | | 91| 0|#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" | | ------------------ | | | Branch (98:44): [True: 0, False: 0] | | ------------------ ------------------ 156| 0| ++i!=length && (t2=s[i]-0x80)<=0x3f) { ------------------ | Branch (156:21): [True: 0, False: 0] | Branch (156:36): [True: 0, False: 0] ------------------ 157| 0| ++i; 158| 0| c=(c<<12)|((t1&0x3f)<<6)|t2; 159| | // strict: forbid non-characters like U+fffe 160| 0| if(strict<=0 || !U_IS_UNICODE_NONCHAR(c)) { ------------------ | | 131| 0| ((c)>=0xfdd0 && \ | | ------------------ | | | Branch (131:6): [True: 0, False: 0] | | ------------------ | | 132| 0| ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff) | | ------------------ | | | Branch (132:7): [True: 0, False: 0] | | | Branch (132:22): [True: 0, False: 0] | | | Branch (132:47): [True: 0, False: 0] | | ------------------ ------------------ | Branch (160:20): [True: 0, False: 0] ------------------ 161| 0| *pi=i; 162| 0| return c; 163| 0| } 164| 0| } 165| 0| } else { 166| | // strict=-2 -> lenient: allow surrogates 167| 0| uint8_t t1=s[i]-0x80, t2; 168| 0| if(t1<=0x3f && (c>0 || t1>=0x20) && ------------------ | Branch (168:16): [True: 0, False: 0] | Branch (168:29): [True: 0, False: 0] | Branch (168:36): [True: 0, False: 0] ------------------ 169| 0| ++i!=length && (t2=s[i]-0x80)<=0x3f) { ------------------ | Branch (169:21): [True: 0, False: 0] | Branch (169:36): [True: 0, False: 0] ------------------ 170| 0| *pi=i+1; 171| 0| return (c<<12)|(t1<<6)|t2; 172| 0| } 173| 0| } 174| 0| } else if(c>=0xc2) { ------------------ | Branch (174:15): [True: 0, False: 0] ------------------ 175| 0| uint8_t t1=s[i]-0x80; 176| 0| if(t1<=0x3f) { ------------------ | Branch (176:12): [True: 0, False: 0] ------------------ 177| 0| *pi=i+1; 178| 0| return ((c-0xc0)<<6)|t1; 179| 0| } 180| 0| } // else 0x80<=c<0xc2 is not a lead byte 181| | 182| | /* error handling */ 183| 0| c=errorValue(i-*pi, strict); 184| 0| *pi=i; 185| 0| return c; 186| 15.0k|} _ZN6icu_7811ICU_Utility21shouldAlwaysBeEscapedEi: 72| 128M|UBool ICU_Utility::shouldAlwaysBeEscaped(UChar32 c) { 73| 128M| if (c < 0x20) { ------------------ | Branch (73:9): [True: 62.7M, False: 65.9M] ------------------ 74| 62.7M| return true; // C0 control codes 75| 65.9M| } else if (c <= 0x7e) { ------------------ | Branch (75:16): [True: 4.74M, False: 61.1M] ------------------ 76| 4.74M| return false; // printable ASCII 77| 61.1M| } else if (c <= 0x9f) { ------------------ | Branch (77:16): [True: 35.6k, False: 61.1M] ------------------ 78| 35.6k| return true; // C1 control codes 79| 61.1M| } else if (c < 0xd800) { ------------------ | Branch (79:16): [True: 56.4M, False: 4.71M] ------------------ 80| 56.4M| return false; // most of the BMP 81| 56.4M| } else if (c <= 0xdfff || (0xfdd0 <= c && c <= 0xfdef) || (c & 0xfffe) == 0xfffe) { ------------------ | Branch (81:16): [True: 99.8k, False: 4.61M] | Branch (81:32): [True: 1.87M, False: 2.74M] | Branch (81:47): [True: 783, False: 1.87M] | Branch (81:63): [True: 1.48M, False: 3.13M] ------------------ 82| 1.58M| return true; // surrogate or noncharacter code points 83| 3.13M| } else if (c <= 0x10ffff) { ------------------ | Branch (83:16): [True: 3.13M, False: 0] ------------------ 84| 3.13M| return false; // all else 85| 3.13M| } else { 86| 0| return true; // not a code point 87| 0| } 88| 128M|} _ZN6icu_7811ICU_Utility6escapeERNS_13UnicodeStringEi: 98| 64.4M|UnicodeString &ICU_Utility::escape(UnicodeString& result, UChar32 c) { 99| 64.4M| result.append(BACKSLASH); 100| 64.4M| if (c & ~0xFFFF) { ------------------ | Branch (100:9): [True: 2.62k, False: 64.4M] ------------------ 101| 2.62k| result.append(UPPER_U); 102| 2.62k| result.append(DIGITS[0xF&(c>>28)]); 103| 2.62k| result.append(DIGITS[0xF&(c>>24)]); 104| 2.62k| result.append(DIGITS[0xF&(c>>20)]); 105| 2.62k| result.append(DIGITS[0xF&(c>>16)]); 106| 64.4M| } else { 107| 64.4M| result.append(LOWER_U); 108| 64.4M| } 109| 64.4M| result.append(DIGITS[0xF&(c>>12)]); 110| 64.4M| result.append(DIGITS[0xF&(c>>8)]); 111| 64.4M| result.append(DIGITS[0xF&(c>>4)]); 112| 64.4M| result.append(DIGITS[0xF&c]); 113| 64.4M| return result; 114| 64.4M|} _ZN6icu_7811ICU_Utility14skipWhitespaceERKNS_13UnicodeStringERia: 150| 192k| UBool advance) { 151| 192k| int32_t p = pos; 152| 192k| const char16_t* s = str.getBuffer(); 153| 192k| p = static_cast(PatternProps::skipWhiteSpace(s + p, str.length() - p) - s); 154| 192k| if (advance) { ------------------ | Branch (154:9): [True: 33.6k, False: 158k] ------------------ 155| 33.6k| pos = p; 156| 33.6k| } 157| 192k| return p; 158| 192k|} utrie2_enum_78: 622| 6| UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 623| 6| enumEitherTrie(trie, 0, 0x110000, enumValue, enumRange, context); 624| 6|} utrie2.cpp:_ZL14enumEitherTriePK6UTrie2iiPFjPKvjEPFaS3_iijES3_: 445| 6| UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 446| 6| const uint32_t *data32; 447| 6| const uint16_t *idx; 448| | 449| 6| uint32_t value, prevValue, initialValue; 450| 6| UChar32 c, prev, highStart; 451| 6| int32_t j, i2Block, prevI2Block, index2NullOffset, block, prevBlock, nullBlock; 452| | 453| 6| if(enumRange==nullptr) { ------------------ | Branch (453:8): [True: 0, False: 6] ------------------ 454| 0| return; 455| 0| } 456| 6| if(enumValue==nullptr) { ------------------ | Branch (456:8): [True: 6, False: 0] ------------------ 457| 6| enumValue=enumSameValue; 458| 6| } 459| | 460| 6| if(trie->newTrie==nullptr) { ------------------ | Branch (460:8): [True: 6, False: 0] ------------------ 461| | /* frozen trie */ 462| 6| idx=trie->index; 463| 6| U_ASSERT(idx!=nullptr); /* the following code assumes trie->newTrie is not nullptr when idx is nullptr */ ------------------ | | 35| 6|# define U_ASSERT(exp) (void)0 ------------------ 464| 6| data32=trie->data32; 465| | 466| 6| index2NullOffset=trie->index2NullOffset; 467| 6| nullBlock=trie->dataNullOffset; 468| 6| } 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| 6| highStart=trie->highStart; 479| | 480| | /* get the enumeration value that corresponds to an initial-value trie data entry */ 481| 6| initialValue=enumValue(context, trie->initialValue); 482| | 483| | /* set variables for previous range */ 484| 6| prevI2Block=-1; 485| 6| prevBlock=-1; 486| 6| prev=start; 487| 6| prevValue=0; 488| | 489| | /* enumerate index-2 blocks */ 490| 3.18k| for(c=start; c>UTRIE2_SHIFT_2; 499| 186| } else if(U_IS_SURROGATE_LEAD(c)) { ------------------ | | 202| 12|#define U_IS_SURROGATE_LEAD(c) (((c)&0x400)==0) | | ------------------ | | | Branch (202:32): [True: 6, False: 6] | | ------------------ ------------------ 500| | /* 501| | * Enumerate values for lead surrogate code points, not code units: 502| | * This special block has half the normal length. 503| | */ 504| 6| i2Block=UTRIE2_LSCP_INDEX_2_OFFSET; 505| 6| tempLimit=MIN_VALUE(0xdc00, limit); ------------------ | | 421| 6|#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) | | ------------------ | | | Branch (421:26): [True: 6, False: 0] | | ------------------ ------------------ 506| 6| } 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| 6| i2Block=0xd800>>UTRIE2_SHIFT_2; 512| 6| tempLimit=MIN_VALUE(0xe000, limit); ------------------ | | 421| 6|#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) | | ------------------ | | | Branch (421:26): [True: 6, False: 0] | | ------------------ ------------------ 513| 6| } 514| 2.97k| } else { 515| | /* supplementary code points */ 516| 2.97k| if(idx!=nullptr) { ------------------ | Branch (516:16): [True: 2.97k, False: 0] ------------------ 517| 2.97k| i2Block=idx[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ 518| 2.97k| (c>>UTRIE2_SHIFT_1)]; 519| 2.97k| } else { 520| 0| i2Block=trie->newTrie->index1[c>>UTRIE2_SHIFT_1]; 521| 0| } 522| 2.97k| if(i2Block==prevI2Block && (c-prev)>=UTRIE2_CP_PER_INDEX_1_ENTRY) { ------------------ | Branch (522:16): [True: 2.64k, False: 333] | Branch (522:40): [True: 2.64k, 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.64k| c+=UTRIE2_CP_PER_INDEX_1_ENTRY; 529| 2.64k| continue; 530| 2.64k| } 531| 2.97k| } 532| 531| prevI2Block=i2Block; 533| 531| if(i2Block==index2NullOffset) { ------------------ | Branch (533:12): [True: 65, False: 466] ------------------ 534| | /* this is the null index-2 block */ 535| 65| if(prevValue!=initialValue) { ------------------ | Branch (535:16): [True: 37, False: 28] ------------------ 536| 37| if(prev>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 548| 466| if((c>>UTRIE2_SHIFT_1)==(tempLimit>>UTRIE2_SHIFT_1)) { ------------------ | Branch (548:16): [True: 6, False: 460] ------------------ 549| 6| i2Limit=(tempLimit>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 550| 460| } else { 551| 460| i2Limit=UTRIE2_INDEX_2_BLOCK_LENGTH; 552| 460| } 553| 29.9k| for(; i2(idx[i2Block + i2]) << UTRIE2_INDEX_SHIFT; 556| 29.4k| } else { 557| 0| block=trie->newTrie->index2[i2Block+i2]; 558| 0| } 559| 29.4k| if(block==prevBlock && (c-prev)>=UTRIE2_DATA_BLOCK_LENGTH) { ------------------ | Branch (559:20): [True: 23.5k, False: 5.91k] | Branch (559:40): [True: 23.4k, False: 38] ------------------ 560| | /* the block is the same as the previous one, and filled with prevValue */ 561| 23.4k| c+=UTRIE2_DATA_BLOCK_LENGTH; 562| 23.4k| continue; 563| 23.4k| } 564| 5.95k| prevBlock=block; 565| 5.95k| if(block==nullBlock) { ------------------ | Branch (565:20): [True: 475, False: 5.47k] ------------------ 566| | /* this is the null data block */ 567| 475| if(prevValue!=initialValue) { ------------------ | Branch (567:24): [True: 66, False: 409] ------------------ 568| 66| if(prevlimit) { ------------------ | Branch (592:8): [True: 0, False: 6] ------------------ 593| 0| c=limit; /* could be higher if in the index2NullOffset */ 594| 6| } else if(chighValueIndex] : 601| 1| idx[trie->highValueIndex]; 602| 1| } else { 603| 0| highValue=trie->newTrie->data[trie->newTrie->dataLength-UTRIE2_DATA_GRANULARITY]; 604| 0| } 605| 1| value=enumValue(context, highValue); 606| 1| if(value!=prevValue) { ------------------ | Branch (606:12): [True: 0, False: 1] ------------------ 607| 0| if(prev static_cast(INT32_MAX / sizeof(UElement)))) { ------------------ | Branch (52:9): [True: 0, False: 34.7M] | Branch (52:34): [True: 0, False: 34.7M] ------------------ 53| 0| initialCapacity = DEFAULT_CAPACITY; 54| 0| } 55| 34.7M| elements = static_cast(uprv_malloc(sizeof(UElement) * initialCapacity)); ------------------ | | 1524| 34.7M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 34.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 34.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 34.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 56| 34.7M| if (elements == nullptr) { ------------------ | Branch (56:9): [True: 0, False: 34.7M] ------------------ 57| 0| status = U_MEMORY_ALLOCATION_ERROR; 58| 34.7M| } else { 59| 34.7M| capacity = initialCapacity; 60| 34.7M| } 61| 34.7M|} _ZN6icu_787UVectorD2Ev: 63| 34.7M|UVector::~UVector() { 64| 34.7M| removeAllElements(); 65| 34.7M| uprv_free(elements); ------------------ | | 1503| 34.7M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 34.7M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 34.7M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 34.7M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 66| 34.7M| elements = nullptr; 67| 34.7M|} _ZN6icu_787UVector6assignERKS0_PFvP8UElementS4_ER10UErrorCode: 73| 2.80k|void UVector::assign(const UVector& other, UElementAssigner *assign, UErrorCode &ec) { 74| 2.80k| if (ensureCapacity(other.count, ec)) { ------------------ | Branch (74:9): [True: 2.80k, False: 0] ------------------ 75| 2.80k| setSize(other.count, ec); 76| 2.80k| if (U_SUCCESS(ec)) { ------------------ | Branch (76:13): [True: 2.80k, False: 0] ------------------ 77| 7.99k| for (int32_t i=0; iindex; --i) { ------------------ | Branch (172:35): [True: 116k, False: 96.3k] ------------------ 173| 116k| elements[i] = elements[i-1]; 174| 116k| } 175| 96.3k| elements[index].pointer = nullptr; 176| 96.3k| elements[index].integer = elem; 177| 96.3k| ++count; 178| 96.3k| } else { 179| | /* index out of range */ 180| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 181| 0| } 182| 96.3k| } 183| 96.3k|} _ZNK6icu_787UVector9elementAtEi: 185| 5.86G|void* UVector::elementAt(int32_t index) const { 186| 5.86G| return (0 <= index && index < count) ? elements[index].pointer : nullptr; ------------------ | Branch (186:13): [True: 5.86G, False: 0] | Branch (186:27): [True: 5.86G, False: 13.7k] ------------------ 187| 5.86G|} _ZNK6icu_787UVector10elementAtiEi: 189| 2.28M|int32_t UVector::elementAti(int32_t index) const { 190| 2.28M| return (0 <= index && index < count) ? elements[index].integer : 0; ------------------ | Branch (190:13): [True: 2.28M, False: 0] | Branch (190:27): [True: 2.28M, False: 0] ------------------ 191| 2.28M|} _ZN6icu_787UVector9removeAllERKS0_: 211| 1.16k|UBool UVector::removeAll(const UVector& other) { 212| 1.16k| UBool changed = false; 213| 3.82k| for (int32_t i=0; i= 0) { ------------------ | Branch (215:13): [True: 1.16k, False: 1.49k] ------------------ 216| 1.16k| removeElementAt(j); 217| 1.16k| changed = true; 218| 1.16k| } 219| 2.66k| } 220| 1.16k| return changed; 221| 1.16k|} _ZN6icu_787UVector9retainAllERKS0_: 223| 415|UBool UVector::retainAll(const UVector& other) { 224| 415| UBool changed = false; 225| 2.08k| for (int32_t j=size()-1; j>=0; --j) { ------------------ | Branch (225:30): [True: 1.66k, False: 415] ------------------ 226| 1.66k| int32_t i = other.indexOf(elements[j]); 227| 1.66k| if (i < 0) { ------------------ | Branch (227:13): [True: 892, False: 776] ------------------ 228| 892| removeElementAt(j); 229| 892| changed = true; 230| 892| } 231| 1.66k| } 232| 415| return changed; 233| 415|} _ZN6icu_787UVector15removeElementAtEi: 235| 100M|void UVector::removeElementAt(int32_t index) { 236| 100M| void* e = orphanElementAt(index); 237| 100M| if (e != nullptr && deleter != nullptr) { ------------------ | Branch (237:9): [True: 40.3k, False: 100M] | Branch (237:25): [True: 26.3k, False: 14.0k] ------------------ 238| 26.3k| (*deleter)(e); 239| 26.3k| } 240| 100M|} _ZN6icu_787UVector17removeAllElementsEv: 251| 34.7M|void UVector::removeAllElements() { 252| 34.7M| if (deleter != nullptr) { ------------------ | Branch (252:9): [True: 57.1k, False: 34.6M] ------------------ 253| 213k| for (int32_t i=0; icount != other.count) { ------------------ | Branch (265:9): [True: 399M, False: 208M] ------------------ 266| 399M| return false; 267| 399M| } 268| 208M| if (comparer == nullptr) { ------------------ | Branch (268:9): [True: 208M, False: 0] ------------------ 269| 320M| for (i=0; i (INT32_MAX - 1) / 2) { // integer overflow check ------------------ | Branch (335:13): [True: 0, False: 3.23M] ------------------ 336| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 337| 0| return false; 338| 0| } 339| 3.23M| int32_t newCap = capacity * 2; 340| 3.23M| if (newCap < minimumCapacity) { ------------------ | Branch (340:13): [True: 1.10M, False: 2.13M] ------------------ 341| 1.10M| newCap = minimumCapacity; 342| 1.10M| } 343| 3.23M| if (newCap > static_cast(INT32_MAX / sizeof(UElement))) { // integer overflow check ------------------ | Branch (343:13): [True: 0, False: 3.23M] ------------------ 344| | // We keep the original memory contents on bad minimumCapacity. 345| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 346| 0| return false; 347| 0| } 348| 3.23M| UElement* newElems = static_cast(uprv_realloc(elements, sizeof(UElement) * newCap)); ------------------ | | 1536| 3.23M|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 3.23M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.23M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.23M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 349| 3.23M| if (newElems == nullptr) { ------------------ | Branch (349:13): [True: 0, False: 3.23M] ------------------ 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| 3.23M| elements = newElems; 355| 3.23M| capacity = newCap; 356| 3.23M| } 357| 18.3M| return true; 358| 18.3M|} _ZN6icu_787UVector7setSizeEiR10UErrorCode: 366| 15.3M|void UVector::setSize(int32_t newSize, UErrorCode &status) { 367| 15.3M| if (!ensureCapacity(newSize, status)) { ------------------ | Branch (367:9): [True: 0, False: 15.3M] ------------------ 368| 0| return; 369| 0| } 370| 15.3M| if (newSize > count) { ------------------ | Branch (370:9): [True: 7.65M, False: 7.65M] ------------------ 371| 7.65M| UElement empty; 372| 7.65M| empty.pointer = nullptr; 373| 7.65M| empty.integer = 0; 374| 303M| for (int32_t i=count; i=newSize; --i) { ------------------ | Branch (379:33): [True: 100M, False: 7.65M] ------------------ 380| 100M| removeElementAt(i); 381| 100M| } 382| 7.65M| } 383| 15.3M| count = newSize; 384| 15.3M|} _ZNK6icu_787UVector7toArrayEPPv: 389| 15.3M|void** UVector::toArray(void** result) const { 390| 15.3M| void** a = result; 391| 811M| for (int i=0; i 0) { ------------------ | Branch (471:13): [True: 41.1k, False: 237k] ------------------ 472| 41.1k| max = probe; 473| 237k| } else { 474| | // assert(c <= 0); 475| 237k| min = probe + 1; 476| 237k| } 477| 278k| } 478| 262k| for (int32_t i=count; i>min; --i) { ------------------ | Branch (478:27): [True: 163k, False: 98.4k] ------------------ 479| 163k| elements[i] = elements[i-1]; 480| 163k| } 481| 98.4k| elements[min] = e; 482| 98.4k| ++count; 483| 98.4k|} _ZNK6icu_787UVector4sizeEv: 190| 870M| inline int32_t size() const {return count;} _ZNK6icu_787UVector8containsEPv: 174| 196k| inline UBool contains(void* obj) const {return indexOf(obj) >= 0;} _ZNK6icu_787UVector7isEmptyEv: 192| 17.2k| inline UBool isEmpty() const {return count == 0;} _ZN6icu_789UVector32C2ER10UErrorCode: 30| 22.0k| count(0), 31| 22.0k| capacity(0), 32| 22.0k| maxCapacity(0), 33| 22.0k| elements(nullptr) 34| 22.0k|{ 35| 22.0k| _init(DEFAULT_CAPACITY, status); ------------------ | | 19| 22.0k|#define DEFAULT_CAPACITY 8 ------------------ 36| 22.0k|} _ZN6icu_789UVector32C2EiR10UErrorCode: 39| 252k| count(0), 40| 252k| capacity(0), 41| 252k| maxCapacity(0), 42| 252k| elements(nullptr) 43| 252k|{ 44| 252k| _init(initialCapacity, status); 45| 252k|} _ZN6icu_789UVector325_initEiR10UErrorCode: 49| 275k|void UVector32::_init(int32_t initialCapacity, UErrorCode &status) { 50| | // Fix bogus initialCapacity values; avoid malloc(0) 51| 275k| if (initialCapacity < 1) { ------------------ | Branch (51:9): [True: 0, False: 275k] ------------------ 52| 0| initialCapacity = DEFAULT_CAPACITY; ------------------ | | 19| 0|#define DEFAULT_CAPACITY 8 ------------------ 53| 0| } 54| 275k| if (maxCapacity>0 && maxCapacity static_cast(INT32_MAX / sizeof(int32_t))) { ------------------ | Branch (57:9): [True: 0, False: 275k] ------------------ 58| 0| initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); ------------------ | | 1529| 0|#define uprv_min U_ICU_ENTRY_POINT_RENAME(uprv_min) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity); ------------------ | | 19| 0|#define DEFAULT_CAPACITY 8 ------------------ 59| 0| } 60| 275k| elements = static_cast(uprv_malloc(sizeof(int32_t) * initialCapacity)); ------------------ | | 1524| 275k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 275k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 275k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 275k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 61| 275k| if (elements == nullptr) { ------------------ | Branch (61:9): [True: 0, False: 275k] ------------------ 62| 0| status = U_MEMORY_ALLOCATION_ERROR; 63| 275k| } else { 64| 275k| capacity = initialCapacity; 65| 275k| } 66| 275k|} _ZN6icu_789UVector32D2Ev: 68| 275k|UVector32::~UVector32() { 69| 275k| uprv_free(elements); ------------------ | | 1503| 275k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 275k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 275k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 275k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 70| 275k| elements = nullptr; 71| 275k|} _ZN6icu_789UVector3212setElementAtEii: 98| 166M|void UVector32::setElementAt(int32_t elem, int32_t index) { 99| 166M| if (0 <= index && index < count) { ------------------ | Branch (99:9): [True: 166M, False: 0] | Branch (99:23): [True: 166M, False: 0] ------------------ 100| 166M| elements[index] = elem; 101| 166M| } 102| | /* else index out of range */ 103| 166M|} _ZN6icu_789UVector3215removeElementAtEi: 159| 483k|void UVector32::removeElementAt(int32_t index) { 160| 483k| if (index >= 0) { ------------------ | Branch (160:9): [True: 483k, False: 0] ------------------ 161| 153M| for (int32_t i=index; i count) { ------------------ | Branch (283:9): [True: 252k, False: 0] ------------------ 284| 252k| UErrorCode ec = U_ZERO_ERROR; 285| 252k| if (!ensureCapacity(newSize, ec)) { ------------------ | Branch (285:13): [True: 0, False: 252k] ------------------ 286| 0| return; 287| 0| } 288| 18.2M| for (i=count; i= 0) && (capacity >= minimumCapacity)) { ------------------ | Branch (216:9): [True: 252k, False: 0] | Branch (216:35): [True: 252k, False: 0] ------------------ 217| 252k| return true; 218| 252k| } else { 219| 0| return expandCapacity(minimumCapacity, status); 220| 0| } 221| 252k|} _ZNK6icu_789UVector3210elementAtiEi: 223| 11.9G|inline int32_t UVector32::elementAti(int32_t index) const { 224| 11.9G| return (index >= 0 && count > 0 && count - index > 0) ? elements[index] : 0; ------------------ | Branch (224:13): [True: 11.9G, False: 0] | Branch (224:27): [True: 11.9G, False: 0] | Branch (224:40): [True: 11.9G, False: 0] ------------------ 225| 11.9G|} _ZN14IcuEnvironmentC2Ev: 14| 2| IcuEnvironment() { 15| | // nothing to initialize yet; 16| 2| } LLVMFuzzerTestOneInput: 13| 8.41k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 14| 8.41k| UErrorCode status = U_ZERO_ERROR; 15| | 16| 8.41k| size_t unistr_size = size/2; 17| 8.41k| std::unique_ptr fuzzbuff(new char16_t[unistr_size]); 18| 8.41k| std::memcpy(fuzzbuff.get(), data, unistr_size * 2); 19| 8.41k| icu::UnicodeString fuzzstr(false, fuzzbuff.get(), unistr_size); 20| | 21| 8.41k| UParseError parse; 22| 8.41k| icu::LocalPointer brk( 23| 8.41k| new icu::RuleBasedBreakIterator(fuzzstr, parse, status)); 24| | 25| 8.41k| return 0; 26| 8.41k|}