_ZN6icu_7818CharStringByteSinkC2EPNS_10CharStringE: 124| 4.66k|CharStringByteSink::CharStringByteSink(CharString* dest) : dest_(*dest) { 125| 4.66k|} _ZN6icu_7818CharStringByteSinkD2Ev: 127| 4.66k|CharStringByteSink::~CharStringByteSink() = default; _ZN6icu_7818CharStringByteSink6AppendEPKci: 130| 103k|CharStringByteSink::Append(const char* bytes, int32_t n) { 131| 103k| UErrorCode status = U_ZERO_ERROR; 132| 103k| dest_.append(bytes, n, status); 133| | // Any errors are silently ignored. 134| 103k|} uloc.cpp:_ZN6icu_7812ByteSinkUtil23viaByteSinkToCharStringIZ22ulocimp_getKeywords_78NSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEcbR10UErrorCodeE3$_0vEENS_10CharStringEOT_S8_: 141| 2.13k| static CharString viaByteSinkToCharString(F&& lambda, UErrorCode& status) { 142| 2.13k| if (U_FAILURE(status)) { return {}; } ------------------ | Branch (142:13): [True: 0, False: 2.13k] ------------------ 143| 2.13k| CharString result; 144| 2.13k| CharStringByteSink sink(&result); 145| 2.13k| lambda(sink, status); 146| 2.13k| return result; 147| 2.13k| } uloc_tag.cpp:_ZN6icu_7812ByteSinkUtil23viaByteSinkToCharStringIZ25ulocimp_forLanguageTag_78PKciPiR10UErrorCodeE3$_0vEENS_10CharStringEOT_S6_: 141| 2.52k| static CharString viaByteSinkToCharString(F&& lambda, UErrorCode& status) { 142| 2.52k| if (U_FAILURE(status)) { return {}; } ------------------ | Branch (142:13): [True: 0, False: 2.52k] ------------------ 143| 2.52k| CharString result; 144| 2.52k| CharStringByteSink sink(&result); 145| 2.52k| lambda(sink, status); 146| 2.52k| return result; 147| 2.52k| } _ZN6icu_788ByteSinkD2Ev: 15| 4.66k|ByteSink::~ByteSink() {} _ZN6icu_7810CharStringaSEOS0_: 34| 2.52k|CharString& CharString::operator=(CharString&& src) noexcept { 35| 2.52k| buffer = std::move(src.buffer); 36| 2.52k| len = src.len; 37| 2.52k| src.len = 0; // not strictly necessary because we make no guarantees on the source string 38| 2.52k| return *this; 39| 2.52k|} _ZN6icu_7810CharString6appendEcR10UErrorCode: 113| 2.18k|CharString &CharString::append(char c, UErrorCode &errorCode) { 114| 2.18k| if(ensureCapacity(len+2, 0, errorCode)) { ------------------ | Branch (114:8): [True: 2.18k, False: 0] ------------------ 115| 2.18k| buffer[len++]=c; 116| 2.18k| buffer[len]=0; 117| 2.18k| } 118| 2.18k| return *this; 119| 2.18k|} _ZN6icu_7810CharString6appendEPKciR10UErrorCode: 121| 2.86M|CharString &CharString::append(const char *s, int32_t sLength, UErrorCode &errorCode) { 122| 2.86M| if(U_FAILURE(errorCode)) { ------------------ | Branch (122:8): [True: 0, False: 2.86M] ------------------ 123| 0| return *this; 124| 0| } 125| 2.86M| if(sLength<-1 || (s==nullptr && sLength!=0)) { ------------------ | Branch (125:8): [True: 0, False: 2.86M] | Branch (125:23): [True: 0, False: 2.86M] | Branch (125:37): [True: 0, False: 0] ------------------ 126| 0| errorCode=U_ILLEGAL_ARGUMENT_ERROR; 127| 0| return *this; 128| 0| } 129| 2.86M| if(sLength<0) { ------------------ | Branch (129:8): [True: 0, False: 2.86M] ------------------ 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| 2.86M| if(sLength>0) { ------------------ | Branch (132:8): [True: 2.86M, False: 1] ------------------ 133| 2.86M| if(s==(buffer.getAlias()+len)) { ------------------ | Branch (133:12): [True: 0, False: 2.86M] ------------------ 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| 2.86M| } else if(buffer.getAlias()<=s && s<(buffer.getAlias()+len) && ------------------ | Branch (141:19): [True: 100k, False: 2.76M] | Branch (141:43): [True: 0, False: 100k] ------------------ 142| 2.86M| sLength>=(buffer.getCapacity()-len) ------------------ | Branch (142:19): [True: 0, False: 0] ------------------ 143| 2.86M| ) { 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| 2.86M| } else if(ensureCapacity(len+sLength+1, 0, errorCode)) { ------------------ | Branch (147:19): [True: 2.86M, False: 0] ------------------ 148| 2.86M| uprv_memcpy(buffer.getAlias()+len, s, sLength); ------------------ | | 42| 2.86M|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.86M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.86M| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.86M| _Pragma("clang diagnostic push") \ | | 45| 2.86M| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.86M| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.86M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.86M| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.86M|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.86M| _Pragma("clang diagnostic pop") \ | | 49| 2.86M| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.86M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.86M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.86M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 149| 2.86M| buffer[len+=sLength]=0; 150| 2.86M| } 151| 2.86M| } 152| 2.86M| return *this; 153| 2.86M|} _ZN6icu_7810CharString20appendInvariantCharsERKNS_13UnicodeStringER10UErrorCode: 208| 501|CharString &CharString::appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode) { 209| 501| return appendInvariantChars(s.getBuffer(), s.length(), errorCode); 210| 501|} _ZN6icu_7810CharString20appendInvariantCharsEPKDsiR10UErrorCode: 212| 504|CharString &CharString::appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode &errorCode) { 213| 504| if(U_FAILURE(errorCode)) { ------------------ | Branch (213:8): [True: 0, False: 504] ------------------ 214| 0| return *this; 215| 0| } 216| 504| if (!uprv_isInvariantUString(uchars, ucharsLen)) { ------------------ | | 1518| 504|#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUString) | | ------------------ | | | | 123| 504|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 504|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 504|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (216:9): [True: 0, False: 504] ------------------ 217| 0| errorCode = U_INVARIANT_CONVERSION_ERROR; 218| 0| return *this; 219| 0| } 220| 504| if(ensureCapacity(len+ucharsLen+1, 0, errorCode)) { ------------------ | Branch (220:8): [True: 504, False: 0] ------------------ 221| 504| u_UCharsToChars(uchars, buffer.getAlias()+len, ucharsLen); ------------------ | | 211| 504|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 123| 504|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 504|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 504|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 222| 504| len += ucharsLen; 223| 504| buffer[len] = 0; 224| 504| } 225| 504| return *this; 226| 504|} _ZN6icu_7810CharString14ensureCapacityEiiR10UErrorCode: 230| 2.86M| UErrorCode &errorCode) { 231| 2.86M| if(U_FAILURE(errorCode)) { ------------------ | Branch (231:8): [True: 0, False: 2.86M] ------------------ 232| 0| return false; 233| 0| } 234| 2.86M| if(capacity>buffer.getCapacity()) { ------------------ | Branch (234:8): [True: 2.47k, False: 2.86M] ------------------ 235| 2.47k| if(desiredCapacityHint==0) { ------------------ | Branch (235:12): [True: 2.47k, False: 0] ------------------ 236| 2.47k| desiredCapacityHint=capacity+buffer.getCapacity(); 237| 2.47k| } 238| 2.47k| if( (desiredCapacityHint<=capacity || buffer.resize(desiredCapacityHint, len+1)==nullptr) && ------------------ | Branch (238:14): [True: 0, False: 2.47k] | Branch (238:47): [True: 0, False: 2.47k] ------------------ 239| 2.47k| buffer.resize(capacity, len+1)==nullptr ------------------ | Branch (239:13): [True: 0, False: 0] ------------------ 240| 2.47k| ) { 241| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 242| 0| return false; 243| 0| } 244| 2.47k| } 245| 2.86M| return true; 246| 2.86M|} _ZN6icu_7810CharStringC2Ev: 43| 9.14k| CharString() : len(0) { buffer[0]=0; } _ZN6icu_7810CharStringD2Ev: 56| 2.76M| ~CharString() {} _ZNK6icu_7810CharString7isEmptyEv: 79| 2.52k| UBool isEmpty() const { return len==0; } _ZN6icu_7810CharString4dataEv: 85| 4.46M| char *data() { return buffer.getAlias(); } _ZNK6icu_7810CharString4dataEv: 84| 4| const char *data() const { return buffer.getAlias(); } _ZNK6icu_7810CharString13toStringPieceEv: 82| 109| StringPiece toStringPiece() const { return StringPiece(buffer.getAlias(), len); } _ZNK6icu_7810CharString6lengthEv: 80| 2.35k| int32_t length() const { return len; } _ZN6icu_7810CharString6appendERKS0_R10UErrorCode: 134| 4| CharString &append(const CharString &s, UErrorCode &errorCode) { 135| 4| return append(s.data(), s.length(), errorCode); 136| 4| } _ZN6icu_7810CharString6appendENS_11StringPieceER10UErrorCode: 131| 3.18k| CharString &append(StringPiece s, UErrorCode &errorCode) { 132| 3.18k| return append(s.data(), s.length(), errorCode); 133| 3.18k| } _ZN6icu_7810CharString5clearEv: 127| 1| CharString &clear() { len=0; buffer[0]=0; return *this; } _ZN6icu_7810CharStringC2ENS_11StringPieceER10UErrorCode: 44| 559| CharString(StringPiece s, UErrorCode &errorCode) : len(0) { 45| 559| buffer[0]=0; 46| 559| append(s, errorCode); 47| 559| } _ZN6icu_7810CharStringC2EPKciR10UErrorCode: 52| 2.75M| CharString(const char *s, int32_t sLength, UErrorCode &errorCode) : len(0) { 53| 2.75M| buffer[0]=0; 54| 2.75M| append(s, sLength, errorCode); 55| 2.75M| } _ZNK6icu_7810CharStringixEi: 81| 3| char operator[](int32_t index) const { return buffer[index]; } uprv_malloc_78: 45| 5.55M|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| 5.55M| if (s > 0) { ------------------ | Branch (54:9): [True: 5.55M, False: 0] ------------------ 55| 5.55M| if (pAlloc) { ------------------ | Branch (55:13): [True: 0, False: 5.55M] ------------------ 56| 0| return (*pAlloc)(pContext, s); 57| 5.55M| } else { 58| 5.55M| return uprv_default_malloc(s); ------------------ | | 615| 5.55M|# define uprv_default_malloc(x) malloc(x) ------------------ 59| 5.55M| } 60| 5.55M| } else { 61| 0| return (void *)zeroMem; 62| 0| } 63| 5.55M|} uprv_free_78: 90| 5.55M|uprv_free(void *buffer) { 91| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 92| | putchar('<'); 93| | fflush(stdout); 94| |#endif 95| 5.55M| if (buffer != zeroMem) { ------------------ | Branch (95:9): [True: 5.55M, False: 0] ------------------ 96| 5.55M| if (pFree) { ------------------ | Branch (96:13): [True: 0, False: 5.55M] ------------------ 97| 0| (*pFree)(pContext, buffer); 98| 5.55M| } else { 99| 5.55M| uprv_default_free(buffer); ------------------ | | 617| 5.55M|# define uprv_default_free(x) free(x) ------------------ 100| 5.55M| } 101| 5.55M| } 102| 5.55M|} _ZN6icu_7815MaybeStackArrayIcLi40EEC2Ev: 344| 2.76M| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7815MaybeStackArrayIcLi40EED2Ev: 363| 2.76M| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayIcLi40EEaSEOS1_: 490| 2.52k|MaybeStackArray::operator=(MaybeStackArray && src) noexcept { 491| 2.52k| releaseArray(); // in case this instance had its own memory allocated 492| 2.52k| capacity = src.capacity; 493| 2.52k| needToRelease = src.needToRelease; 494| 2.52k| if (src.ptr == src.stackArray) { ------------------ | Branch (494:9): [True: 1.86k, False: 663] ------------------ 495| 1.86k| ptr = stackArray; 496| 1.86k| uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity); ------------------ | | 42| 1.86k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.86k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.86k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.86k| _Pragma("clang diagnostic push") \ | | 45| 1.86k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.86k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.86k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.86k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.86k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.86k| _Pragma("clang diagnostic pop") \ | | 49| 1.86k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.86k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.86k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.86k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 497| 1.86k| } else { 498| 663| ptr = src.ptr; 499| 663| src.resetToStackArray(); // take ownership away from src 500| 663| } 501| 2.52k| return *this; 502| 2.52k|} _ZNK6icu_7815MaybeStackArrayIcLi40EE11getCapacityEv: 376| 2.87M| int32_t getCapacity() const { return capacity; } _ZNK6icu_7815MaybeStackArrayIcLi40EE8getAliasEv: 381| 13.1M| T *getAlias() const { return ptr; } _ZNK6icu_7815MaybeStackArrayIcLi40EEixEl: 395| 3| const T &operator[](ptrdiff_t i) const { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EEixEl: 402| 5.63M| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIcLi40EE6resizeEii: 505| 2.47k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 2.47k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 2.47k, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 2.47k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 2.47k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.47k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.47k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.47k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 2.47k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 2.47k, False: 0] ------------------ 512| 2.47k| if(length>0) { ------------------ | Branch (512:16): [True: 2.47k, False: 0] ------------------ 513| 2.47k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 2.47k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 2.47k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 2.47k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 2.47k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 2.47k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.47k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.47k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.47k| _Pragma("clang diagnostic push") \ | | 45| 2.47k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.47k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.47k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.47k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.47k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.47k| _Pragma("clang diagnostic pop") \ | | 49| 2.47k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.47k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.47k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.47k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 2.47k| } 521| 2.47k| releaseArray(); 522| 2.47k| ptr=p; 523| 2.47k| capacity=newCapacity; 524| 2.47k| needToRelease=true; 525| 2.47k| } 526| 2.47k| return p; 527| 2.47k| } else { 528| 0| return nullptr; 529| 0| } 530| 2.47k|} _ZN6icu_7815MaybeStackArrayIcLi40EE12releaseArrayEv: 458| 2.77M| void releaseArray() { 459| 2.77M| if(needToRelease) { ------------------ | Branch (459:12): [True: 2.47k, False: 2.77M] ------------------ 460| 2.47k| uprv_free(ptr); ------------------ | | 1503| 2.47k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.47k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.47k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.47k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 2.47k| } 462| 2.77M| } _ZN6icu_7815MaybeStackArrayIcLi40EE17resetToStackArrayEv: 463| 663| void resetToStackArray() { 464| 663| ptr=stackArray; 465| 663| capacity=stackCapacity; 466| 663| needToRelease=false; 467| 663| } _ZN6icu_7811LocalMemoryI16UKeywordsContextEC2EPS1_: 195| 1.79k| explicit LocalMemory(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7811LocalMemoryI16UKeywordsContextED2Ev: 206| 1.79k| ~LocalMemory() { 207| 1.79k| uprv_free(LocalPointerBase::ptr); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 1.79k| } _ZN6icu_7811LocalMemoryI12UEnumerationEC2EPS1_: 195| 1.79k| explicit LocalMemory(T *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7811LocalMemoryI12UEnumerationED2Ev: 206| 1.79k| ~LocalMemory() { 207| 1.79k| uprv_free(LocalPointerBase::ptr); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 1.79k| } _ZN6icu_7811LocalMemoryI16UKeywordsContextE12adoptInsteadEPS1_: 243| 1.79k| void adoptInstead(T *p) { 244| 1.79k| uprv_free(LocalPointerBase::ptr); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 245| 1.79k| LocalPointerBase::ptr=p; 246| 1.79k| } _ZN6icu_7811LocalMemoryI12UEnumerationE12adoptInsteadEPS1_: 243| 1.79k| void adoptInstead(T *p) { 244| 1.79k| uprv_free(LocalPointerBase::ptr); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 245| 1.79k| LocalPointerBase::ptr=p; 246| 1.79k| } _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EEixEl: 402| 37| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EE12releaseArrayEv: 458| 2| void releaseArray() { 459| 2| if(needToRelease) { ------------------ | Branch (459:12): [True: 1, False: 1] ------------------ 460| 1| uprv_free(ptr); ------------------ | | 1503| 1|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1| } 462| 2| } _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EEixEl: 402| 1.05k| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EE12releaseArrayEv: 458| 7| void releaseArray() { 459| 7| if(needToRelease) { ------------------ | Branch (459:12): [True: 6, False: 1] ------------------ 460| 6| uprv_free(ptr); ------------------ | | 1503| 6|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 6|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 6| } 462| 7| } _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EEixEl: 402| 178| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EE12releaseArrayEv: 458| 4| void releaseArray() { 459| 4| if(needToRelease) { ------------------ | Branch (459:12): [True: 3, False: 1] ------------------ 460| 3| uprv_free(ptr); ------------------ | | 1503| 3|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 3| } 462| 4| } _ZN6icu_7810MemoryPoolINS_10CharStringELi8EED2Ev: 762| 2.54k| ~MemoryPool() { 763| 2.76M| for (int32_t i = 0; i < fCount; ++i) { ------------------ | Branch (763:29): [True: 2.75M, False: 2.54k] ------------------ 764| 2.75M| delete fPool[i]; 765| 2.75M| } 766| 2.54k| } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EEixEl: 402| 5.51M| T &operator[](ptrdiff_t i) { return ptr[i]; } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EED2Ev: 363| 2.54k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EE12releaseArrayEv: 458| 3.96k| void releaseArray() { 459| 3.96k| if(needToRelease) { ------------------ | Branch (459:12): [True: 1.41k, False: 2.55k] ------------------ 460| 1.41k| uprv_free(ptr); ------------------ | | 1503| 1.41k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1.41k| } 462| 3.96k| } _ZN6icu_7810MemoryPoolINS_10CharStringELi8EEC2Ev: 760| 2.55k| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EEC2Ev: 344| 2.55k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolI13LocExtKeyDataLi8EEC2Ev: 760| 1| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EEC2Ev: 344| 1| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolI10LocExtTypeLi8EEC2Ev: 760| 1| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EEC2Ev: 344| 1| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolI9TypeAliasLi8EEC2Ev: 760| 1| MemoryPool() : fCount(0), fPool() {} _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EEC2Ev: 344| 1| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZN6icu_7810MemoryPoolINS_10CharStringELi8EE6createIJEEEPS1_DpOT_: 796| 923| T* create(Args&&... args) { 797| 923| int32_t capacity = fPool.getCapacity(); 798| 923| if (fCount == capacity && ------------------ | Branch (798:13): [True: 5, False: 918] ------------------ 799| 923| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 5] | Branch (799:26): [True: 1, False: 4] ------------------ 800| 5| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 923| return fPool[fCount++] = new T(std::forward(args)...); 804| 923| } _ZNK6icu_7815MaybeStackArrayIPNS_10CharStringELi8EE11getCapacityEv: 376| 2.76M| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIPNS_10CharStringELi8EE6resizeEii: 505| 1.41k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 1.41k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 1.41k, 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.41k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 1.41k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.41k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.41k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.41k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 1.41k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 1.41k, False: 0] ------------------ 512| 1.41k| if(length>0) { ------------------ | Branch (512:16): [True: 1.41k, False: 0] ------------------ 513| 1.41k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 1.41k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 1.41k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 1.41k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 1.41k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 1.41k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.41k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.41k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.41k| _Pragma("clang diagnostic push") \ | | 45| 1.41k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.41k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.41k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.41k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.41k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.41k| _Pragma("clang diagnostic pop") \ | | 49| 1.41k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.41k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.41k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.41k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 1.41k| } 521| 1.41k| releaseArray(); 522| 1.41k| ptr=p; 523| 1.41k| capacity=newCapacity; 524| 1.41k| needToRelease=true; 525| 1.41k| } 526| 1.41k| return p; 527| 1.41k| } else { 528| 0| return nullptr; 529| 0| } 530| 1.41k|} _ZN6icu_7810MemoryPoolINS_10CharStringELi8EE6createIJRPKcR10UErrorCodeEEEPS1_DpOT_: 796| 556| T* create(Args&&... args) { 797| 556| int32_t capacity = fPool.getCapacity(); 798| 556| if (fCount == capacity && ------------------ | Branch (798:13): [True: 2, False: 554] ------------------ 799| 556| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 2] | Branch (799:26): [True: 0, False: 2] ------------------ 800| 2| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 556| return fPool[fCount++] = new T(std::forward(args)...); 804| 556| } _ZN6icu_7810MemoryPoolI10LocExtTypeLi8EE6createIJEEEPS1_DpOT_: 796| 1.05k| T* create(Args&&... args) { 797| 1.05k| int32_t capacity = fPool.getCapacity(); 798| 1.05k| if (fCount == capacity && ------------------ | Branch (798:13): [True: 7, False: 1.04k] ------------------ 799| 1.05k| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 7] | Branch (799:26): [True: 1, False: 6] ------------------ 800| 7| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 1.05k| return fPool[fCount++] = new T(std::forward(args)...); 804| 1.05k| } _ZNK6icu_7815MaybeStackArrayIP10LocExtTypeLi8EE11getCapacityEv: 376| 1.05k| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIP10LocExtTypeLi8EE6resizeEii: 505| 7|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 7| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 7, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 7| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 7|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 7|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 7|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 7|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 7| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 7, False: 0] ------------------ 512| 7| if(length>0) { ------------------ | Branch (512:16): [True: 7, False: 0] ------------------ 513| 7| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 7] ------------------ 514| 0| length=capacity; 515| 0| } 516| 7| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 7] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 7| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 7|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 7|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 7| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 7| _Pragma("clang diagnostic push") \ | | 45| 7| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 7| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 7|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 7| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 7|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 7| _Pragma("clang diagnostic pop") \ | | 49| 7| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 7|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 7|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 7|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 7| } 521| 7| releaseArray(); 522| 7| ptr=p; 523| 7| capacity=newCapacity; 524| 7| needToRelease=true; 525| 7| } 526| 7| return p; 527| 7| } else { 528| 0| return nullptr; 529| 0| } 530| 7|} _ZN6icu_7810MemoryPoolI9TypeAliasLi8EE6createIJS1_EEEPS1_DpOT_: 796| 178| T* create(Args&&... args) { 797| 178| int32_t capacity = fPool.getCapacity(); 798| 178| if (fCount == capacity && ------------------ | Branch (798:13): [True: 4, False: 174] ------------------ 799| 178| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 4] | Branch (799:26): [True: 1, False: 3] ------------------ 800| 4| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 178| return fPool[fCount++] = new T(std::forward(args)...); 804| 178| } _ZNK6icu_7815MaybeStackArrayIP9TypeAliasLi8EE11getCapacityEv: 376| 178| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIP9TypeAliasLi8EE6resizeEii: 505| 4|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 4| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 4, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 4| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 4|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 4| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 4, False: 0] ------------------ 512| 4| if(length>0) { ------------------ | Branch (512:16): [True: 4, False: 0] ------------------ 513| 4| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 4] ------------------ 514| 0| length=capacity; 515| 0| } 516| 4| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 4] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 4| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 4|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 4|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 4| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 4| _Pragma("clang diagnostic push") \ | | 45| 4| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 4| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 4|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 4| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 4|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 4| _Pragma("clang diagnostic pop") \ | | 49| 4| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 4|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 4|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 4| } 521| 4| releaseArray(); 522| 4| ptr=p; 523| 4| capacity=newCapacity; 524| 4| needToRelease=true; 525| 4| } 526| 4| return p; 527| 4| } else { 528| 0| return nullptr; 529| 0| } 530| 4|} _ZN6icu_7810MemoryPoolI13LocExtKeyDataLi8EE6createIJEEEPS1_DpOT_: 796| 37| T* create(Args&&... args) { 797| 37| int32_t capacity = fPool.getCapacity(); 798| 37| if (fCount == capacity && ------------------ | Branch (798:13): [True: 2, False: 35] ------------------ 799| 37| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 2] | Branch (799:26): [True: 1, False: 1] ------------------ 800| 2| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 37| return fPool[fCount++] = new T(std::forward(args)...); 804| 37| } _ZNK6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EE11getCapacityEv: 376| 37| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayIP13LocExtKeyDataLi8EE6resizeEii: 505| 2|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 2| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 2, False: 0] ------------------ 507| |#if U_DEBUG && defined(UPRV_MALLOC_COUNT) 508| | ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T)); 509| |#endif 510| 2| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 2|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 2| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 2, False: 0] ------------------ 512| 2| if(length>0) { ------------------ | Branch (512:16): [True: 2, False: 0] ------------------ 513| 2| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 2] ------------------ 514| 0| length=capacity; 515| 0| } 516| 2| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 2] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 2| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 2|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2| _Pragma("clang diagnostic push") \ | | 45| 2| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2| _Pragma("clang diagnostic pop") \ | | 49| 2| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 2| } 521| 2| releaseArray(); 522| 2| ptr=p; 523| 2| capacity=newCapacity; 524| 2| needToRelease=true; 525| 2| } 526| 2| return p; 527| 2| } else { 528| 0| return nullptr; 529| 0| } 530| 2|} uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118AttributeListEntryELi8EEC2Ev: 760| 1.15k| MemoryPool() : fCount(0), fPool() {} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EEC2Ev: 344| 1.15k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118ExtensionListEntryELi8EEC2Ev: 760| 1.39k| MemoryPool() : fCount(0), fPool() {} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EEC2Ev: 344| 1.39k| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118AttributeListEntryELi8EE6createIJEEEPS2_DpOT_: 796| 1.06M| T* create(Args&&... args) { 797| 1.06M| int32_t capacity = fPool.getCapacity(); 798| 1.06M| if (fCount == capacity && ------------------ | Branch (798:13): [True: 370, False: 1.06M] ------------------ 799| 1.06M| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 370] | Branch (799:26): [True: 95, False: 275] ------------------ 800| 370| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 1.06M| return fPool[fCount++] = new T(std::forward(args)...); 804| 1.06M| } uloc_tag.cpp:_ZNK6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EE11getCapacityEv: 376| 1.06M| int32_t getCapacity() const { return capacity; } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EE6resizeEii: 505| 370|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 370| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 370, 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| 370| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 370|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 370|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 370|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 370|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 370| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 370, False: 0] ------------------ 512| 370| if(length>0) { ------------------ | Branch (512:16): [True: 370, False: 0] ------------------ 513| 370| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 370] ------------------ 514| 0| length=capacity; 515| 0| } 516| 370| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 370] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 370| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 370|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 370|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 370| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 370| _Pragma("clang diagnostic push") \ | | 45| 370| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 370| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 370|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 370| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 370|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 370| _Pragma("clang diagnostic pop") \ | | 49| 370| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 370|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 370|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 370|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 370| } 521| 370| releaseArray(); 522| 370| ptr=p; 523| 370| capacity=newCapacity; 524| 370| needToRelease=true; 525| 370| } 526| 370| return p; 527| 370| } else { 528| 0| return nullptr; 529| 0| } 530| 370|} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EE12releaseArrayEv: 458| 1.52k| void releaseArray() { 459| 1.52k| if(needToRelease) { ------------------ | Branch (459:12): [True: 370, False: 1.15k] ------------------ 460| 370| uprv_free(ptr); ------------------ | | 1503| 370|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 370|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 370|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 370|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 370| } 462| 1.52k| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EEixEl: 402| 2.12M| T &operator[](ptrdiff_t i) { return ptr[i]; } uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118ExtensionListEntryELi8EE6createIJEEEPS2_DpOT_: 796| 1.70M| T* create(Args&&... args) { 797| 1.70M| int32_t capacity = fPool.getCapacity(); 798| 1.70M| if (fCount == capacity && ------------------ | Branch (798:13): [True: 1.16k, False: 1.70M] ------------------ 799| 1.70M| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 1.16k] | Branch (799:26): [True: 424, False: 741] ------------------ 800| 1.16k| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 1.70M| return fPool[fCount++] = new T(std::forward(args)...); 804| 1.70M| } uloc_tag.cpp:_ZNK6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EE11getCapacityEv: 376| 1.70M| int32_t getCapacity() const { return capacity; } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EE6resizeEii: 505| 1.16k|inline T *MaybeStackArray::resize(int32_t newCapacity, int32_t length) { 506| 1.16k| if(newCapacity>0) { ------------------ | Branch (506:8): [True: 1.16k, 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.16k| T *p=(T *)uprv_malloc(newCapacity*sizeof(T)); ------------------ | | 1524| 1.16k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 511| 1.16k| if(p!=nullptr) { ------------------ | Branch (511:12): [True: 1.16k, False: 0] ------------------ 512| 1.16k| if(length>0) { ------------------ | Branch (512:16): [True: 1.16k, False: 0] ------------------ 513| 1.16k| if(length>capacity) { ------------------ | Branch (513:20): [True: 0, False: 1.16k] ------------------ 514| 0| length=capacity; 515| 0| } 516| 1.16k| if(length>newCapacity) { ------------------ | Branch (516:20): [True: 0, False: 1.16k] ------------------ 517| 0| length=newCapacity; 518| 0| } 519| 1.16k| uprv_memcpy(p, ptr, (size_t)length*sizeof(T)); ------------------ | | 42| 1.16k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.16k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.16k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.16k| _Pragma("clang diagnostic push") \ | | 45| 1.16k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.16k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.16k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.16k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.16k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.16k| _Pragma("clang diagnostic pop") \ | | 49| 1.16k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.16k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.16k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.16k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 520| 1.16k| } 521| 1.16k| releaseArray(); 522| 1.16k| ptr=p; 523| 1.16k| capacity=newCapacity; 524| 1.16k| needToRelease=true; 525| 1.16k| } 526| 1.16k| return p; 527| 1.16k| } else { 528| 0| return nullptr; 529| 0| } 530| 1.16k|} uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EE12releaseArrayEv: 458| 2.56k| void releaseArray() { 459| 2.56k| if(needToRelease) { ------------------ | Branch (459:12): [True: 1.16k, False: 1.39k] ------------------ 460| 1.16k| uprv_free(ptr); ------------------ | | 1503| 1.16k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 1.16k| } 462| 2.56k| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EEixEl: 402| 3.41M| T &operator[](ptrdiff_t i) { return ptr[i]; } uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118ExtensionListEntryELi8EED2Ev: 762| 1.39k| ~MemoryPool() { 763| 1.71M| for (int32_t i = 0; i < fCount; ++i) { ------------------ | Branch (763:29): [True: 1.70M, False: 1.39k] ------------------ 764| 1.70M| delete fPool[i]; 765| 1.70M| } 766| 1.39k| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118ExtensionListEntryELi8EED2Ev: 363| 1.39k| ~MaybeStackArray() { releaseArray(); } uloc_tag.cpp:_ZN6icu_7810MemoryPoolIN12_GLOBAL__N_118AttributeListEntryELi8EED2Ev: 762| 1.15k| ~MemoryPool() { 763| 1.06M| for (int32_t i = 0; i < fCount; ++i) { ------------------ | Branch (763:29): [True: 1.06M, False: 1.15k] ------------------ 764| 1.06M| delete fPool[i]; 765| 1.06M| } 766| 1.15k| } uloc_tag.cpp:_ZN6icu_7815MaybeStackArrayIPN12_GLOBAL__N_118AttributeListEntryELi8EED2Ev: 363| 1.15k| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7810MemoryPoolINS_10CharStringELi8EE6createIJRPKcRiR10UErrorCodeEEEPS1_DpOT_: 796| 2.75M| T* create(Args&&... args) { 797| 2.75M| int32_t capacity = fPool.getCapacity(); 798| 2.75M| if (fCount == capacity && ------------------ | Branch (798:13): [True: 1.40k, False: 2.75M] ------------------ 799| 2.75M| fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity, ------------------ | Branch (799:13): [True: 0, False: 1.40k] | Branch (799:26): [True: 436, False: 969] ------------------ 800| 1.40k| capacity) == nullptr) { 801| 0| return nullptr; 802| 0| } 803| 2.75M| return fPool[fCount++] = new T(std::forward(args)...); 804| 2.75M| } 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();} () _ZN6icu_7815MaybeStackArrayI11max_align_tLi7EEC2Ev: 344| 544| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZNK6icu_7815MaybeStackArrayI11max_align_tLi7EE11getCapacityEv: 376| 544| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi7EE12releaseArrayEv: 458| 544| void releaseArray() { 459| 544| if(needToRelease) { ------------------ | Branch (459:12): [True: 0, False: 544] ------------------ 460| 0| uprv_free(ptr); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 0| } 462| 544| } _ZNK6icu_7815MaybeStackArrayI11max_align_tLi7EE8getAliasEv: 381| 544| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi7EED2Ev: 363| 544| ~MaybeStackArray() { releaseArray(); } _ZN6icu_7815MaybeStackArrayI11max_align_tLi14EEC2Ev: 344| 318| MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {} _ZNK6icu_7815MaybeStackArrayI11max_align_tLi14EE11getCapacityEv: 376| 318| int32_t getCapacity() const { return capacity; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi14EE12releaseArrayEv: 458| 318| void releaseArray() { 459| 318| if(needToRelease) { ------------------ | Branch (459:12): [True: 0, False: 318] ------------------ 460| 0| uprv_free(ptr); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 461| 0| } 462| 318| } _ZNK6icu_7815MaybeStackArrayI11max_align_tLi14EE8getAliasEv: 381| 636| T *getAlias() const { return ptr; } _ZN6icu_7815MaybeStackArrayI11max_align_tLi14EED2Ev: 363| 318| ~MaybeStackArray() { releaseArray(); } uprv_isASCIILetter_78: 52| 36.3M|uprv_isASCIILetter(char c) { 53| |#if U_CHARSET_FAMILY==U_EBCDIC_FAMILY 54| | return 55| | ('a'<=c && c<='i') || ('j'<=c && c<='r') || ('s'<=c && c<='z') || 56| | ('A'<=c && c<='I') || ('J'<=c && c<='R') || ('S'<=c && c<='Z'); 57| |#else 58| 36.3M| return ('a'<=c && c<='z') || ('A'<=c && c<='Z'); ------------------ | Branch (58:13): [True: 25.3M, False: 10.9M] | Branch (58:23): [True: 25.3M, False: 19] | Branch (58:35): [True: 3.04M, False: 7.93M] | Branch (58:45): [True: 3.04M, False: 122] ------------------ 59| 36.3M|#endif 60| 36.3M|} uprv_toupper_78: 63| 14.7k|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| 14.7k| if('a'<=c && c<='z') { ------------------ | Branch (69:8): [True: 2.62k, False: 12.0k] | Branch (69:18): [True: 2.62k, False: 0] ------------------ 70| 2.62k| c=(char)(c+('A'-'a')); 71| 2.62k| } 72| 14.7k|#endif 73| 14.7k| return c; 74| 14.7k|} uprv_asciitolower_78: 103| 50.8M|uprv_asciitolower(char c) { 104| 50.8M| if(0x41<=c && c<=0x5a) { ------------------ | Branch (104:8): [True: 32.6M, False: 18.2M] | Branch (104:19): [True: 3.10M, False: 29.5M] ------------------ 105| 3.10M| c=(char)(c+0x20); 106| 3.10M| } 107| 50.8M| return c; 108| 50.8M|} T_CString_toLowerCase_78: 124| 1.70M|{ 125| 1.70M| char* origPtr = str; 126| | 127| 1.70M| if (str) { ------------------ | Branch (127:9): [True: 1.70M, False: 0] ------------------ 128| 1.70M| do 129| 42.9M| *str = uprv_tolower(*str); ------------------ | | 68| 42.9M|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 42.9M|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 42.9M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 42.9M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 42.9M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 130| 42.9M| while (*(str++)); ------------------ | Branch (130:16): [True: 41.2M, False: 1.70M] ------------------ 131| 1.70M| } 132| | 133| 1.70M| return origPtr; 134| 1.70M|} T_CString_toUpperCase_78: 138| 2.18k|{ 139| 2.18k| char* origPtr = str; 140| | 141| 2.18k| if (str) { ------------------ | Branch (141:9): [True: 2.18k, False: 0] ------------------ 142| 2.18k| do 143| 8.45k| *str = uprv_toupper(*str); ------------------ | | 1547| 8.45k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 8.45k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8.45k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8.45k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 144| 8.45k| while (*(str++)); ------------------ | Branch (144:16): [True: 6.26k, False: 2.18k] ------------------ 145| 2.18k| } 146| | 147| 2.18k| return origPtr; 148| 2.18k|} uprv_strnicmp_78: 274| 146k|uprv_strnicmp(const char *str1, const char *str2, uint32_t n) { 275| 146k| if(str1==nullptr) { ------------------ | Branch (275:8): [True: 0, False: 146k] ------------------ 276| 0| if(str2==nullptr) { ------------------ | Branch (276:12): [True: 0, False: 0] ------------------ 277| 0| return 0; 278| 0| } else { 279| 0| return -1; 280| 0| } 281| 146k| } else if(str2==nullptr) { ------------------ | Branch (281:15): [True: 0, False: 146k] ------------------ 282| 0| return 1; 283| 146k| } else { 284| | /* compare non-nullptr strings lexically with lowercase */ 285| 146k| int rc; 286| 146k| unsigned char c1, c2; 287| | 288| 265k| for(; n--;) { ------------------ | Branch (288:15): [True: 264k, False: 990] ------------------ 289| 264k| c1=(unsigned char)*str1; 290| 264k| c2=(unsigned char)*str2; 291| 264k| if(c1==0) { ------------------ | Branch (291:16): [True: 0, False: 264k] ------------------ 292| 0| if(c2==0) { ------------------ | Branch (292:20): [True: 0, False: 0] ------------------ 293| 0| return 0; 294| 0| } else { 295| 0| return -1; 296| 0| } 297| 264k| } else if(c2==0) { ------------------ | Branch (297:23): [True: 0, False: 264k] ------------------ 298| 0| return 1; 299| 264k| } else { 300| | /* compare non-zero characters with lowercase */ 301| 264k| rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2); ------------------ | | 68| 264k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 264k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 264k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 264k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 264k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2); ------------------ | | 68| 264k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 264k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 264k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 264k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 264k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 302| 264k| if(rc!=0) { ------------------ | Branch (302:20): [True: 145k, False: 118k] ------------------ 303| 145k| return rc; 304| 145k| } 305| 264k| } 306| 118k| ++str1; 307| 118k| ++str2; 308| 118k| } 309| 146k| } 310| | 311| 990| return 0; 312| 146k|} _ZN6icu_785MutexC2EPNS_6UMutexE: 58| 159k| Mutex(UMutex *mutex = nullptr) : fMutex(mutex) { 59| 159k| umtx_lock(fMutex); ------------------ | | 1250| 159k|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 159k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 159k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 159k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 60| 159k| } _ZN6icu_785MutexD2Ev: 61| 159k| ~Mutex() { 62| 159k| umtx_unlock(fMutex); ------------------ | | 1251| 159k|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 159k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 159k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 159k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 159k| } u_setDataDirectory_78: 1316| 1|u_setDataDirectory(const char *directory) { 1317| 1| char *newDataDir; 1318| 1| int32_t length; 1319| | 1320| 1| if(directory==nullptr || *directory==0) { ------------------ | Branch (1320:8): [True: 0, False: 1] | Branch (1320:30): [True: 1, False: 0] ------------------ 1321| | /* A small optimization to prevent the malloc and copy when the 1322| | shared library is used, and this is a way to make sure that nullptr 1323| | is never returned. 1324| | */ 1325| 1| newDataDir = (char *)""; 1326| 1| } 1327| 0| else { 1328| 0| length=(int32_t)uprv_strlen(directory); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1329| 0| newDataDir = (char *)uprv_malloc(length + 2); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1330| | /* Exit out if newDataDir could not be created. */ 1331| 0| if (newDataDir == nullptr) { ------------------ | Branch (1331:13): [True: 0, False: 0] ------------------ 1332| 0| return; 1333| 0| } 1334| 0| uprv_strcpy(newDataDir, directory); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1335| | 1336| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) 1337| | { 1338| | char *p; 1339| | while((p = uprv_strchr(newDataDir, U_FILE_ALT_SEP_CHAR)) != nullptr) { 1340| | *p = U_FILE_SEP_CHAR; 1341| | } 1342| | } 1343| |#endif 1344| 0| } 1345| | 1346| 1| if (gDataDirectory && *gDataDirectory) { ------------------ | Branch (1346:9): [True: 0, False: 1] | Branch (1346:27): [True: 0, False: 0] ------------------ 1347| 0| uprv_free(gDataDirectory); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1348| 0| } 1349| 1| gDataDirectory = newDataDir; 1350| 1| ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1351| 1|} u_getDataDirectory_78: 1499| 2|u_getDataDirectory() { 1500| 2| umtx_initOnce(gDataDirInitOnce, &dataDirectoryInitFn); 1501| 2| return gDataDirectory; 1502| 2|} u_getTimeZoneFilesDirectory_78: 1575| 1|u_getTimeZoneFilesDirectory(UErrorCode *status) { 1576| 1| umtx_initOnce(gTimeZoneFilesInitOnce, &TimeZoneDataDirInitFn, *status); ------------------ | | 122| 1|#define gTimeZoneFilesInitOnce U_ICU_ENTRY_POINT_RENAME(gTimeZoneFilesInitOnce) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1577| 1| return U_SUCCESS(*status) ? gTimeZoneFilesDirectory->data() : ""; ------------------ | Branch (1577:12): [True: 1, False: 0] ------------------ 1578| 1|} 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|} putil.cpp:_ZL21TimeZoneDataDirInitFnR10UErrorCode: 1521| 1|static void U_CALLCONV TimeZoneDataDirInitFn(UErrorCode &status) { 1522| 1| U_ASSERT(gTimeZoneFilesDirectory == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 1523| 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1524| 1| gTimeZoneFilesDirectory = new CharString(); 1525| 1| if (gTimeZoneFilesDirectory == nullptr) { ------------------ | Branch (1525:9): [True: 0, False: 1] ------------------ 1526| 0| status = U_MEMORY_ALLOCATION_ERROR; 1527| 0| return; 1528| 0| } 1529| | 1530| 1| const char *dir = ""; 1531| | 1532| |#if defined(ICU_TIMEZONE_FILES_DIR_PREFIX_ENV_VAR) 1533| | char timezonefilesdir_path_buffer[PATH_MAX]; 1534| | const char *prefix = getenv(ICU_TIMEZONE_FILES_DIR_PREFIX_ENV_VAR); 1535| |#endif 1536| | 1537| |#if U_PLATFORM_HAS_WINUWP_API == 1 1538| |// The UWP version does not support the environment variable setting. 1539| | 1540| |# if defined(ICU_DATA_DIR_WINDOWS) 1541| | // When using the Windows system data, we can possibly pick up time zone data from the Windows directory. 1542| | char datadir_path_buffer[MAX_PATH]; 1543| | if (getIcuDataDirectoryUnderWindowsDirectory(datadir_path_buffer, UPRV_LENGTHOF(datadir_path_buffer))) { 1544| | dir = datadir_path_buffer; 1545| | } 1546| |# endif 1547| | 1548| |#else 1549| 1| dir = getenv("ICU_TIMEZONE_FILES_DIR"); 1550| 1|#endif // U_PLATFORM_HAS_WINUWP_API 1551| | 1552| |#if defined(U_TIMEZONE_FILES_DIR) 1553| | if (dir == nullptr) { 1554| | // Build time configuration setting. 1555| | dir = TO_STRING(U_TIMEZONE_FILES_DIR); 1556| | } 1557| |#endif 1558| | 1559| 1| if (dir == nullptr) { ------------------ | Branch (1559:9): [True: 1, False: 0] ------------------ 1560| 1| dir = ""; 1561| 1| } 1562| | 1563| |#if defined(ICU_TIMEZONE_FILES_DIR_PREFIX_ENV_VAR) 1564| | if (prefix != nullptr) { 1565| | snprintf(timezonefilesdir_path_buffer, sizeof(timezonefilesdir_path_buffer), "%s%s", prefix, dir); 1566| | dir = timezonefilesdir_path_buffer; 1567| | } 1568| |#endif 1569| | 1570| 1| setTimeZoneFilesDir(dir, status); 1571| 1|} putil.cpp:_ZL19setTimeZoneFilesDirPKcR10UErrorCode: 1504| 1|static void setTimeZoneFilesDir(const char *path, UErrorCode &status) { 1505| 1| if (U_FAILURE(status)) { ------------------ | Branch (1505:9): [True: 0, False: 1] ------------------ 1506| 0| return; 1507| 0| } 1508| 1| gTimeZoneFilesDirectory->clear(); 1509| 1| gTimeZoneFilesDirectory->append(path, status); 1510| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) 1511| | char *p = gTimeZoneFilesDirectory->data(); 1512| | while ((p = uprv_strchr(p, U_FILE_ALT_SEP_CHAR)) != nullptr) { 1513| | *p = U_FILE_SEP_CHAR; 1514| | } 1515| |#endif 1516| 1|} _ZN6icu_7814ResourceTracerC2EPKv: 118| 159k| ResourceTracer(const void*) {} _ZNK6icu_7814ResourceTracer5traceEPKc: 128| 159k| void trace(const char*) const {} _ZNK6icu_7814ResourceTracer9traceOpenEv: 130| 4| void traceOpen() const {} _ZNK6icu_7814ResourceTracer10maybeTraceEPKc: 132| 3| void maybeTrace(const char*) const {} _ZN6icu_7810FileTracer9traceOpenEPKcS2_S2_: 140| 2| static void traceOpen(const char*, const char*, const char*) {} _ZN6icu_7811StringPieceC2EPKc: 19| 3.18k| : ptr_(str), length_((str == nullptr) ? 0 : static_cast(uprv_strlen(str))) { } ------------------ | | 37| 3.18k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 3.18k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (19:26): [True: 0, False: 3.18k] ------------------ uprv_stableBinarySearch_78: 76| 4.31k| UComparator *cmp, const void *context) { 77| 4.31k| int32_t start=0; 78| 4.31k| UBool found=false; 79| | 80| | /* Binary search until we get down to a tiny sub-array. */ 81| 4.31k| while((limit-start)>=MIN_QSORT) { ------------------ | Branch (81:11): [True: 0, False: 4.31k] ------------------ 82| 0| int32_t i=(start+limit)/2; 83| 0| int32_t diff=cmp(context, item, array+i*itemSize); 84| 0| if(diff==0) { ------------------ | Branch (84:12): [True: 0, False: 0] ------------------ 85| | /* 86| | * Found the item. We look for the *last* occurrence of such 87| | * an item, for stable sorting. 88| | * If we knew that there will be only few equal items, 89| | * we could break now and enter the linear search. 90| | * However, if there are many equal items, then it should be 91| | * faster to continue with the binary search. 92| | * It seems likely that we either have all unique items 93| | * (where found will never become true in the insertion sort) 94| | * or potentially many duplicates. 95| | */ 96| 0| found=true; 97| 0| start=i+1; 98| 0| } else if(diff<0) { ------------------ | Branch (98:19): [True: 0, False: 0] ------------------ 99| 0| limit=i; 100| 0| } else { 101| 0| start=i; 102| 0| } 103| 0| } 104| | 105| | /* Linear search over the remaining tiny sub-array. */ 106| 14.4k| while(start0 && array==nullptr) || length<0 || itemSize<=0 || cmp==nullptr) { ------------------ | Branch (262:9): [True: 1.75k, False: 39] | Branch (262:21): [True: 0, False: 1.75k] | Branch (262:40): [True: 0, False: 1.79k] | Branch (262:52): [True: 0, False: 1.79k] | Branch (262:67): [True: 0, False: 1.79k] ------------------ 263| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 264| 0| return; 265| 0| } 266| | 267| 1.79k| if(length<=1) { ------------------ | Branch (267:8): [True: 928, False: 862] ------------------ 268| 928| return; 269| 928| } else if(length v; 145| 544| if (sizeInMaxAlignTs(itemSize) > v.getCapacity() && ------------------ | Branch (145:9): [True: 0, False: 544] ------------------ 146| 544| v.resize(sizeInMaxAlignTs(itemSize)) == nullptr) { ------------------ | Branch (146:13): [True: 0, False: 0] ------------------ 147| 0| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 148| 0| return; 149| 0| } 150| | 151| 544| doInsertionSort(array, length, itemSize, cmp, context, v.getAlias()); 152| 544|} uarrsort.cpp:_ZL16sizeInMaxAlignTsi: 39| 1.18k|static constexpr int32_t sizeInMaxAlignTs(int32_t sizeInBytes) { 40| 1.18k| return (sizeInBytes + sizeof(std::max_align_t) - 1) / sizeof(std::max_align_t); 41| 1.18k|} uarrsort.cpp:_ZL15doInsertionSortPciiPFiPKvS1_S1_ES1_Pv: 120| 1.23k| UComparator *cmp, const void *context, void *pv) { 121| 1.23k| int32_t j; 122| | 123| 5.54k| for(j=1; j xw; 239| 318| if(sizeInMaxAlignTs(itemSize)*2 > xw.getCapacity() && ------------------ | Branch (239:8): [True: 0, False: 318] ------------------ 240| 318| xw.resize(sizeInMaxAlignTs(itemSize) * 2) == nullptr) { ------------------ | Branch (240:13): [True: 0, False: 0] ------------------ 241| 0| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 242| 0| return; 243| 0| } 244| | 245| 318| subQuickSort(array, 0, length, itemSize, cmp, context, 246| 318| xw.getAlias(), xw.getAlias() + sizeInMaxAlignTs(itemSize)); 247| 318|} uarrsort.cpp:_ZL12subQuickSortPciiiPFiPKvS1_S1_ES1_PvS4_: 171| 688| void *px, void *pw) { 172| 688| int32_t left, right; 173| | 174| | /* start and left are inclusive, limit and right are exclusive */ 175| 1.14k| do { 176| 1.14k| if((start+MIN_QSORT)>=limit) { ------------------ | Branch (176:12): [True: 688, False: 457] ------------------ 177| 688| doInsertionSort(array+start*itemSize, limit-start, itemSize, cmp, context, px); 178| 688| break; 179| 688| } 180| | 181| 457| left=start; 182| 457| right=limit; 183| | 184| | /* x=array[middle] */ 185| 457| uprv_memcpy(px, array+(size_t)((start+limit)/2)*itemSize, itemSize); ------------------ | | 42| 457|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 457|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 457| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 457| _Pragma("clang diagnostic push") \ | | 45| 457| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 457| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 457|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 457| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 457|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 457| _Pragma("clang diagnostic pop") \ | | 49| 457| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 457|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 457|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 457|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 186| | 187| 1.00k| do { 188| 1.00k| while(/* array[left]info.isBigEndian==U_IS_BIG_ENDIAN) { ------------------ | | 353| 3|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (39:15): [True: 3, False: 0] ------------------ 40| | /* same endianness */ 41| 3| return udh->dataHeader.headerSize; 42| 3| } else { 43| | /* opposite endianness */ 44| 0| uint16_t x=udh->dataHeader.headerSize; 45| 0| return (uint16_t)((x<<8)|(x>>8)); 46| 0| } 47| 3|} udata_checkCommonData_78: 326| 1|U_CFUNC void udata_checkCommonData(UDataMemory *udm, UErrorCode *err) { 327| 1| if (U_FAILURE(*err)) { ------------------ | Branch (327:9): [True: 0, False: 1] ------------------ 328| 0| return; 329| 0| } 330| | 331| 1| if(udm==nullptr || udm->pHeader==nullptr) { ------------------ | Branch (331:8): [True: 0, False: 1] | Branch (331:24): [True: 0, False: 1] ------------------ 332| 0| *err=U_INVALID_FORMAT_ERROR; 333| 1| } else if(!(udm->pHeader->dataHeader.magic1==0xda && ------------------ | Branch (333:17): [True: 1, False: 0] ------------------ 334| 1| udm->pHeader->dataHeader.magic2==0x27 && ------------------ | Branch (334:9): [True: 1, False: 0] ------------------ 335| 1| udm->pHeader->info.isBigEndian==U_IS_BIG_ENDIAN && ------------------ | | 353| 2|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (335:9): [True: 1, False: 0] ------------------ 336| 1| udm->pHeader->info.charsetFamily==U_CHARSET_FAMILY) ------------------ | | 588| 1|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 1|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (336:9): [True: 1, False: 0] ------------------ 337| 1| ) { 338| | /* header not valid */ 339| 0| *err=U_INVALID_FORMAT_ERROR; 340| 0| } 341| 1| else if (udm->pHeader->info.dataFormat[0]==0x43 && ------------------ | Branch (341:14): [True: 1, False: 0] ------------------ 342| 1| udm->pHeader->info.dataFormat[1]==0x6d && ------------------ | Branch (342:9): [True: 1, False: 0] ------------------ 343| 1| udm->pHeader->info.dataFormat[2]==0x6e && ------------------ | Branch (343:9): [True: 1, False: 0] ------------------ 344| 1| udm->pHeader->info.dataFormat[3]==0x44 && ------------------ | Branch (344:9): [True: 1, False: 0] ------------------ 345| 1| udm->pHeader->info.formatVersion[0]==1 ------------------ | Branch (345:9): [True: 1, False: 0] ------------------ 346| 1| ) { 347| | /* dataFormat="CmnD" */ 348| 1| udm->vFuncs = &CmnDFuncs; 349| 1| udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader); ------------------ | | 887| 1|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 350| 1| } 351| 0| else if(udm->pHeader->info.dataFormat[0]==0x54 && ------------------ | Branch (351:13): [True: 0, False: 0] ------------------ 352| 0| udm->pHeader->info.dataFormat[1]==0x6f && ------------------ | Branch (352:9): [True: 0, False: 0] ------------------ 353| 0| udm->pHeader->info.dataFormat[2]==0x43 && ------------------ | Branch (353:9): [True: 0, False: 0] ------------------ 354| 0| udm->pHeader->info.dataFormat[3]==0x50 && ------------------ | Branch (354:9): [True: 0, False: 0] ------------------ 355| 0| udm->pHeader->info.formatVersion[0]==1 ------------------ | Branch (355:9): [True: 0, False: 0] ------------------ 356| 0| ) { 357| | /* dataFormat="ToCP" */ 358| 0| udm->vFuncs = &ToCPFuncs; 359| 0| udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader); ------------------ | | 887| 0|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 360| 0| } 361| 0| else { 362| | /* dataFormat not recognized */ 363| 0| *err=U_INVALID_FORMAT_ERROR; 364| 0| } 365| | 366| 1| if (U_FAILURE(*err)) { ------------------ | Branch (366:9): [True: 0, False: 1] ------------------ 367| | /* If the data is no good and we memory-mapped it ourselves, 368| | * close the memory mapping so it doesn't leak. Note that this has 369| | * no effect on non-memory mapped data, other than clearing fields in udm. 370| | */ 371| 0| udata_close(udm); ------------------ | | 885| 0|#define udata_close U_ICU_ENTRY_POINT_RENAME(udata_close) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 372| 0| } 373| 1|} ucmndata.cpp:_ZL17offsetTOCLookupFnPK11UDataMemoryPKcPiP10UErrorCode: 229| 2| UErrorCode *pErrorCode) { 230| 2| (void)pErrorCode; 231| 2| const UDataOffsetTOC *toc = (UDataOffsetTOC *)pData->toc; 232| 2| if(toc!=nullptr) { ------------------ | Branch (232:8): [True: 2, False: 0] ------------------ 233| 2| const char *base=(const char *)toc; 234| 2| int32_t number, count=(int32_t)toc->count; 235| | 236| | /* perform a binary search for the data in the common data's table of contents */ 237| |#if defined (UDATA_DEBUG_DUMP) 238| | /* list the contents of the TOC each time .. not recommended */ 239| | for(number=0; numberentry[number].nameOffset]); 241| | } 242| |#endif 243| 2| number=offsetTOCPrefixBinarySearch(tocEntryName, base, toc->entry, count); 244| 2| if(number>=0) { ------------------ | Branch (244:12): [True: 2, False: 0] ------------------ 245| | /* found it */ 246| 2| const UDataOffsetTOCEntry *entry=toc->entry+number; 247| |#ifdef UDATA_DEBUG 248| | fprintf(stderr, "%s: Found.\n", tocEntryName); 249| |#endif 250| 2| if((number+1) < count) { ------------------ | Branch (250:16): [True: 2, False: 0] ------------------ 251| 2| *pLength = (int32_t)(entry[1].dataOffset - entry->dataOffset); 252| 2| } else { 253| 0| *pLength = -1; 254| 0| } 255| 2| return (const DataHeader *)(base+entry->dataOffset); 256| 2| } else { 257| |#ifdef UDATA_DEBUG 258| | fprintf(stderr, "%s: Not found.\n", tocEntryName); 259| |#endif 260| 0| return nullptr; 261| 0| } 262| 2| } else { 263| |#ifdef UDATA_DEBUG 264| | fprintf(stderr, "returning header\n"); 265| |#endif 266| | 267| 0| return pData->pHeader; 268| 0| } 269| 2|} ucmndata.cpp:_ZL27offsetTOCPrefixBinarySearchPKcS0_PK19UDataOffsetTOCEntryi: 125| 2| const UDataOffsetTOCEntry *toc, int32_t count) { 126| 2| int32_t start=0; 127| 2| int32_t limit=count; 128| | /* 129| | * Remember the shared prefix between s, start and limit, 130| | * and don't compare that shared prefix again. 131| | * The shared prefix should get longer as we narrow the [start, limit[ range. 132| | */ 133| 2| int32_t startPrefixLength=0; 134| 2| int32_t limitPrefixLength=0; 135| 2| if(count==0) { ------------------ | Branch (135:8): [True: 0, False: 2] ------------------ 136| 0| return -1; 137| 0| } 138| | /* 139| | * Prime the prefix lengths so that we don't keep prefixLength at 0 until 140| | * both the start and limit indexes have moved. 141| | * At the same time, we find if s is one of the start and (limit-1) names, 142| | * and if not, exclude them from the actual binary search. 143| | */ 144| 2| if(0==strcmpAfterPrefix(s, names+toc[0].nameOffset, &startPrefixLength)) { ------------------ | Branch (144:8): [True: 0, False: 2] ------------------ 145| 0| return 0; 146| 0| } 147| 2| ++start; 148| 2| --limit; 149| 2| if(0==strcmpAfterPrefix(s, names+toc[limit].nameOffset, &limitPrefixLength)) { ------------------ | Branch (149:8): [True: 0, False: 2] ------------------ 150| 0| return limit; 151| 0| } 152| 22| while(start(*s1++); 112| 98| int32_t c2 = static_cast(*s2++); 113| 98| cmp=c1-c2; 114| 98| if(cmp!=0 || c1==0) { /* different or done */ ------------------ | Branch (114:12): [True: 24, False: 74] | Branch (114:22): [True: 2, False: 72] ------------------ 115| 26| break; 116| 26| } 117| 72| ++pl; /* increment shared same-prefix length */ 118| 72| } 119| 26| *pPrefixLength=pl; 120| 26| return cmp; 121| 26|} udata_openChoice_78: 1406| 2| UErrorCode *pErrorCode) { 1407| |#ifdef UDATA_DEBUG 1408| | fprintf(stderr, "udata_openChoice(): Opening: %s : %s . %s\n", (path?path:"nullptr"), name, type); 1409| |#endif 1410| | 1411| 2| if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1411:8): [True: 0, False: 2] | Branch (1411:31): [True: 0, False: 2] ------------------ 1412| 0| return nullptr; 1413| 2| } else if(name==nullptr || *name==0 || isAcceptable==nullptr) { ------------------ | Branch (1413:15): [True: 0, False: 2] | Branch (1413:32): [True: 0, False: 2] | Branch (1413:44): [True: 0, False: 2] ------------------ 1414| 0| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1415| 0| return nullptr; 1416| 2| } else { 1417| 2| return doOpenChoice(path, type, name, isAcceptable, context, pErrorCode); 1418| 2| } 1419| 2|} udata.cpp:_ZL16setCommonICUDataP11UDataMemoryaP10UErrorCode: 174| 1|{ 175| 1| UDataMemory *newCommonData = UDataMemory_createNewInstance(pErr); ------------------ | | 79| 1|#define UDataMemory_createNewInstance U_ICU_ENTRY_POINT_RENAME(UDataMemory_createNewInstance) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 176| 1| int32_t i; 177| 1| UBool didUpdate = false; 178| 1| if (U_FAILURE(*pErr)) { ------------------ | Branch (178:9): [True: 0, False: 1] ------------------ 179| 0| return false; 180| 0| } 181| | 182| | /* For the assignment, other threads must cleanly see either the old */ 183| | /* or the new, not some partially initialized new. The old can not be */ 184| | /* deleted - someone may still have a pointer to it lying around in */ 185| | /* their locals. */ 186| 1| UDatamemory_assign(newCommonData, pData); ------------------ | | 84| 1|#define UDatamemory_assign U_ICU_ENTRY_POINT_RENAME(UDatamemory_assign) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 187| 1| umtx_lock(nullptr); ------------------ | | 1250| 1|#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 188| 1| for (i = 0; i < UPRV_LENGTHOF(gCommonICUDataArray); ++i) { ------------------ | | 99| 1|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (188:17): [True: 1, False: 0] ------------------ 189| 1| if (gCommonICUDataArray[i] == nullptr) { ------------------ | Branch (189:13): [True: 1, False: 0] ------------------ 190| 1| gCommonICUDataArray[i] = newCommonData; 191| 1| didUpdate = true; 192| 1| break; 193| 1| } else if (gCommonICUDataArray[i]->pHeader == pData->pHeader) { ------------------ | Branch (193:20): [True: 0, False: 0] ------------------ 194| | /* The same data pointer is already in the array. */ 195| 0| break; 196| 0| } 197| 1| } 198| 1| umtx_unlock(nullptr); ------------------ | | 1251| 1|#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 199| | 200| 1| if (i == UPRV_LENGTHOF(gCommonICUDataArray) && warn) { ------------------ | | 99| 2|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (200:9): [True: 0, False: 1] | Branch (200:52): [True: 0, False: 0] ------------------ 201| 0| *pErr = U_USING_DEFAULT_WARNING; 202| 0| } 203| 1| if (didUpdate) { ------------------ | Branch (203:9): [True: 1, False: 0] ------------------ 204| 1| ucln_common_registerCleanup(UCLN_COMMON_UDATA, udata_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 205| 1| } else { 206| 0| uprv_free(newCommonData); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 207| 0| } 208| 1| return didUpdate; 209| 1|} udata.cpp:_ZL12doOpenChoicePKcS0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCode: 1151| 2|{ 1152| 2| UDataMemory *retVal = nullptr; 1153| | 1154| 2| const char *dataPath; 1155| | 1156| 2| int32_t tocEntrySuffixIndex; 1157| 2| const char *tocEntryPathSuffix; 1158| 2| UErrorCode subErrorCode=U_ZERO_ERROR; 1159| 2| const char *treeChar; 1160| | 1161| 2| UBool isICUData = false; 1162| | 1163| | 1164| 2| FileTracer::traceOpen(path, type, name); 1165| | 1166| | 1167| | /* Is this path ICU data? */ 1168| 2| if(path == nullptr || ------------------ | Branch (1168:8): [True: 2, False: 0] ------------------ 1169| 2| !strcmp(path, U_ICUDATA_ALIAS) || /* "ICUDATA" */ ------------------ | | 74| 0|#define U_ICUDATA_ALIAS "ICUDATA" ------------------ | Branch (1169:8): [True: 0, False: 0] ------------------ 1170| 2| !uprv_strncmp(path, U_ICUDATA_NAME U_TREE_SEPARATOR_STRING, /* "icudt26e-" */ ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1170:8): [True: 0, False: 0] ------------------ 1171| 2| uprv_strlen(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING)) || 1172| 2| !uprv_strncmp(path, U_ICUDATA_ALIAS U_TREE_SEPARATOR_STRING, /* "ICUDATA-" */ ------------------ | | 44| 0|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1172:8): [True: 0, False: 0] ------------------ 1173| 2| uprv_strlen(U_ICUDATA_ALIAS U_TREE_SEPARATOR_STRING))) { 1174| 2| isICUData = true; 1175| 2| } 1176| | 1177| |#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR) /* Windows: try "foo\bar" and "foo/bar" */ 1178| | /* remap from alternate path char to the main one */ 1179| | CharString altSepPath; 1180| | if(path) { 1181| | if(uprv_strchr(path,U_FILE_ALT_SEP_CHAR) != nullptr) { 1182| | altSepPath.append(path, *pErrorCode); 1183| | char *p; 1184| | while ((p = uprv_strchr(altSepPath.data(), U_FILE_ALT_SEP_CHAR)) != nullptr) { 1185| | *p = U_FILE_SEP_CHAR; 1186| | } 1187| |#if defined (UDATA_DEBUG) 1188| | fprintf(stderr, "Changed path from [%s] to [%s]\n", path, altSepPath.data()); 1189| |#endif 1190| | path = altSepPath.data(); 1191| | } 1192| | } 1193| |#endif 1194| | 1195| 2| CharString tocEntryName; /* entry name in tree format. ex: 'icudt28b/coll/ar.res' */ 1196| 2| CharString tocEntryPath; /* entry name in path format. ex: 'icudt28b\\coll\\ar.res' */ 1197| | 1198| 2| CharString pkgName; 1199| 2| CharString treeName; 1200| | 1201| | /* ======= Set up strings */ 1202| 2| if(path==nullptr) { ------------------ | Branch (1202:8): [True: 2, False: 0] ------------------ 1203| 2| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 2|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 2|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1204| 2| } else { 1205| 0| const char *pkg; 1206| 0| const char *first; 1207| 0| pkg = uprv_strrchr(path, U_FILE_SEP_CHAR); ------------------ | | 42| 0|#define uprv_strrchr(s, c) U_STANDARD_CPP_NAMESPACE strrchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1208| 0| first = uprv_strchr(path, U_FILE_SEP_CHAR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1209| 0| if(uprv_pathIsAbsolute(path) || (pkg != first)) { /* more than one slash in the path- not a tree name */ ------------------ | | 1533| 0|#define uprv_pathIsAbsolute U_ICU_ENTRY_POINT_RENAME(uprv_pathIsAbsolute) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1209:12): [True: 0, False: 0] | Branch (1209:41): [True: 0, False: 0] ------------------ 1210| | /* see if this is an /absolute/path/to/package path */ 1211| 0| if(pkg) { ------------------ | Branch (1211:16): [True: 0, False: 0] ------------------ 1212| 0| pkgName.append(pkg+1, *pErrorCode); 1213| 0| } else { 1214| 0| pkgName.append(path, *pErrorCode); 1215| 0| } 1216| 0| } else { 1217| 0| treeChar = uprv_strchr(path, U_TREE_SEPARATOR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1218| 0| if(treeChar) { ------------------ | Branch (1218:16): [True: 0, False: 0] ------------------ 1219| 0| treeName.append(treeChar+1, *pErrorCode); /* following '-' */ 1220| 0| if(isICUData) { ------------------ | Branch (1220:20): [True: 0, False: 0] ------------------ 1221| 0| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 0|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 0|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1222| 0| } else { 1223| 0| pkgName.append(path, static_cast(treeChar - path), *pErrorCode); 1224| 0| if (first == nullptr) { ------------------ | Branch (1224:25): [True: 0, False: 0] ------------------ 1225| | /* 1226| | This user data has no path, but there is a tree name. 1227| | Look up the correct path from the data cache later. 1228| | */ 1229| 0| path = pkgName.data(); 1230| 0| } 1231| 0| } 1232| 0| } else { 1233| 0| if(isICUData) { ------------------ | Branch (1233:20): [True: 0, False: 0] ------------------ 1234| 0| pkgName.append(U_ICUDATA_NAME, *pErrorCode); ------------------ | | 154| 0|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | ------------------ | | | | 144| 0|# define U_ICUDATA_TYPE_LETTER "l" | | ------------------ ------------------ 1235| 0| } else { 1236| 0| pkgName.append(path, *pErrorCode); 1237| 0| } 1238| 0| } 1239| 0| } 1240| 0| } 1241| | 1242| |#ifdef UDATA_DEBUG 1243| | fprintf(stderr, " P=%s T=%s\n", pkgName.data(), treeName.data()); 1244| |#endif 1245| | 1246| | /* setting up the entry name and file name 1247| | * Make up a full name by appending the type to the supplied 1248| | * name, assuming that a type was supplied. 1249| | */ 1250| | 1251| | /* prepend the package */ 1252| 2| tocEntryName.append(pkgName, *pErrorCode); 1253| 2| tocEntryPath.append(pkgName, *pErrorCode); 1254| 2| tocEntrySuffixIndex = tocEntryName.length(); 1255| | 1256| 2| if(!treeName.isEmpty()) { ------------------ | Branch (1256:8): [True: 0, False: 2] ------------------ 1257| 0| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(treeName, *pErrorCode); ------------------ | | 62| 0|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1258| 0| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(treeName, *pErrorCode); ------------------ | | 130| 0|# define U_FILE_SEP_CHAR '/' ------------------ 1259| 0| } 1260| | 1261| 2| tocEntryName.append(U_TREE_ENTRY_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 62| 2|#define U_TREE_ENTRY_SEP_CHAR '/' ------------------ 1262| 2| tocEntryPath.append(U_FILE_SEP_CHAR, *pErrorCode).append(name, *pErrorCode); ------------------ | | 130| 2|# define U_FILE_SEP_CHAR '/' ------------------ 1263| 2| if(type!=nullptr && *type!=0) { ------------------ | Branch (1263:8): [True: 2, False: 0] | Branch (1263:25): [True: 2, False: 0] ------------------ 1264| 2| tocEntryName.append(".", *pErrorCode).append(type, *pErrorCode); 1265| 2| tocEntryPath.append(".", *pErrorCode).append(type, *pErrorCode); 1266| 2| } 1267| | // The +1 is for the U_FILE_SEP_CHAR that is always appended above. 1268| 2| tocEntryPathSuffix = tocEntryPath.data() + tocEntrySuffixIndex + 1; /* suffix starts here */ 1269| | 1270| |#ifdef UDATA_DEBUG 1271| | fprintf(stderr, " tocEntryName = %s\n", tocEntryName.data()); 1272| | fprintf(stderr, " tocEntryPath = %s\n", tocEntryName.data()); 1273| |#endif 1274| | 1275| 2|#if !defined(ICU_DATA_DIR_WINDOWS) 1276| 2| if(path == nullptr) { ------------------ | Branch (1276:8): [True: 2, False: 0] ------------------ 1277| 2| path = COMMON_DATA_NAME; /* "icudt26e" */ ------------------ | | 34| 2|#define COMMON_DATA_NAME U_ICUDATA_NAME | | ------------------ | | | | 154| 2|#define U_ICUDATA_NAME "icudt" U_ICU_VERSION_SHORT U_ICUDATA_TYPE_LETTER | | | | ------------------ | | | | | | 144| 2|# define U_ICUDATA_TYPE_LETTER "l" | | | | ------------------ | | ------------------ ------------------ 1278| 2| } 1279| |#else 1280| | // When using the Windows system data, we expects only a single data file. 1281| | path = COMMON_DATA_NAME; /* "icudt26e" */ 1282| |#endif 1283| | 1284| | /************************ Begin loop looking for ind. files ***************/ 1285| |#ifdef UDATA_DEBUG 1286| | fprintf(stderr, "IND: inBasename = %s, pkg=%s\n", "(n/a)", packageNameFromPath(path)); 1287| |#endif 1288| | 1289| | /* End of dealing with a null basename */ 1290| 2| dataPath = u_getDataDirectory(); ------------------ | | 271| 2|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1291| | 1292| | /**** Time zone individual files override */ 1293| 2| if (isICUData && isTimeZoneFile(name, type)) { ------------------ | Branch (1293:9): [True: 2, False: 0] | Branch (1293:22): [True: 1, False: 1] ------------------ 1294| 1| const char *tzFilesDir = u_getTimeZoneFilesDirectory(pErrorCode); ------------------ | | 287| 1|#define u_getTimeZoneFilesDirectory U_ICU_ENTRY_POINT_RENAME(u_getTimeZoneFilesDirectory) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1295| 1| if (tzFilesDir[0] != 0) { ------------------ | Branch (1295:13): [True: 0, False: 1] ------------------ 1296| |#ifdef UDATA_DEBUG 1297| | fprintf(stderr, "Trying Time Zone Files directory = %s\n", tzFilesDir); 1298| |#endif 1299| 0| retVal = doLoadFromIndividualFiles(/* pkgName.data() */ "", tzFilesDir, tocEntryPathSuffix, 1300| 0| /* path */ "", type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1301| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1301:16): [True: 0, False: 0] | Branch (1301:39): [True: 0, False: 0] ------------------ 1302| 0| return retVal; 1303| 0| } 1304| 0| } 1305| 1| } 1306| | 1307| | /**** COMMON PACKAGE - only if packages are first. */ 1308| 2| if(gDataFileAccess == UDATA_PACKAGES_FIRST) { ------------------ | Branch (1308:8): [True: 0, False: 2] ------------------ 1309| |#ifdef UDATA_DEBUG 1310| | fprintf(stderr, "Trying packages (UDATA_PACKAGES_FIRST)\n"); 1311| |#endif 1312| | /* #2 */ 1313| 0| retVal = doLoadFromCommonData(isICUData, 1314| 0| pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(), 1315| 0| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1316| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1316:12): [True: 0, False: 0] | Branch (1316:35): [True: 0, False: 0] ------------------ 1317| 0| return retVal; 1318| 0| } 1319| 0| } 1320| | 1321| | /**** INDIVIDUAL FILES */ 1322| 2| if((gDataFileAccess==UDATA_PACKAGES_FIRST) || ------------------ | Branch (1322:8): [True: 0, False: 2] ------------------ 1323| 2| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1323:8): [True: 2, False: 0] ------------------ 1324| |#ifdef UDATA_DEBUG 1325| | fprintf(stderr, "Trying individual files\n"); 1326| |#endif 1327| | /* Check to make sure that there is a dataPath to iterate over */ 1328| 2| if ((dataPath && *dataPath) || !isICUData) { ------------------ | Branch (1328:14): [True: 2, False: 0] | Branch (1328:26): [True: 0, False: 2] | Branch (1328:40): [True: 0, False: 2] ------------------ 1329| 0| retVal = doLoadFromIndividualFiles(pkgName.data(), dataPath, tocEntryPathSuffix, 1330| 0| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1331| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1331:16): [True: 0, False: 0] | Branch (1331:39): [True: 0, False: 0] ------------------ 1332| 0| return retVal; 1333| 0| } 1334| 0| } 1335| 2| } 1336| | 1337| | /**** COMMON PACKAGE */ 1338| 2| if((gDataFileAccess==UDATA_ONLY_PACKAGES) || ------------------ | Branch (1338:8): [True: 0, False: 2] ------------------ 1339| 2| (gDataFileAccess==UDATA_FILES_FIRST)) { ------------------ | Branch (1339:8): [True: 2, False: 0] ------------------ 1340| |#ifdef UDATA_DEBUG 1341| | fprintf(stderr, "Trying packages (UDATA_ONLY_PACKAGES || UDATA_FILES_FIRST)\n"); 1342| |#endif 1343| 2| retVal = doLoadFromCommonData(isICUData, 1344| 2| pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(), 1345| 2| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1346| 2| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1346:12): [True: 2, False: 0] | Branch (1346:35): [True: 0, False: 0] ------------------ 1347| 2| return retVal; 1348| 2| } 1349| 2| } 1350| | 1351| | /* Load from DLL. If we haven't attempted package load, we also haven't had any chance to 1352| | try a DLL (static or setCommonData/etc) load. 1353| | If we ever have a "UDATA_ONLY_FILES", add it to the or list here. */ 1354| 0| if(gDataFileAccess==UDATA_NO_FILES) { ------------------ | Branch (1354:8): [True: 0, False: 0] ------------------ 1355| |#ifdef UDATA_DEBUG 1356| | fprintf(stderr, "Trying common data (UDATA_NO_FILES)\n"); 1357| |#endif 1358| 0| retVal = doLoadFromCommonData(isICUData, 1359| 0| pkgName.data(), "", tocEntryPathSuffix, tocEntryName.data(), 1360| 0| path, type, name, isAcceptable, context, &subErrorCode, pErrorCode); 1361| 0| if((retVal != nullptr) || U_FAILURE(*pErrorCode)) { ------------------ | Branch (1361:12): [True: 0, False: 0] | Branch (1361:35): [True: 0, False: 0] ------------------ 1362| 0| return retVal; 1363| 0| } 1364| 0| } 1365| | 1366| | /* data not found */ 1367| 0| if(U_SUCCESS(*pErrorCode)) { ------------------ | Branch (1367:8): [True: 0, False: 0] ------------------ 1368| 0| if(U_SUCCESS(subErrorCode)) { ------------------ | Branch (1368:12): [True: 0, False: 0] ------------------ 1369| | /* file not found */ 1370| 0| *pErrorCode=U_FILE_ACCESS_ERROR; 1371| 0| } else { 1372| | /* entry point not found or rejected */ 1373| 0| *pErrorCode=subErrorCode; 1374| 0| } 1375| 0| } 1376| 0| return retVal; 1377| 0|} udata.cpp:_ZL14isTimeZoneFilePKcS0_: 1107| 2|static UBool isTimeZoneFile(const char *name, const char *type) { 1108| 2| return ((uprv_strcmp(type, "res") == 0) && ------------------ | | 38| 2|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1108:13): [True: 2, False: 0] ------------------ 1109| 2| (uprv_strcmp(name, "zoneinfo64") == 0 || ------------------ | | 38| 2|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1109:14): [True: 0, False: 2] ------------------ 1110| 2| uprv_strcmp(name, "timezoneTypes") == 0 || ------------------ | | 38| 2|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1110:14): [True: 1, False: 1] ------------------ 1111| 2| uprv_strcmp(name, "windowsZones") == 0 || ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1111:14): [True: 0, False: 1] ------------------ 1112| 2| uprv_strcmp(name, "metaZones") == 0)); ------------------ | | 38| 1|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1112:14): [True: 0, False: 1] ------------------ 1113| 2|} udata.cpp:_ZL13checkDataItemPK10DataHeaderPFaPvPKcS4_PK9UDataInfoES2_S4_S4_P10UErrorCodeSB_: 949| 2|{ 950| 2| UDataMemory *rDataMem = nullptr; /* the new UDataMemory, to be returned. */ 951| | 952| 2| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (952:9): [True: 0, False: 2] ------------------ 953| 0| return nullptr; 954| 0| } 955| | 956| 2| if(pHeader->dataHeader.magic1==0xda && ------------------ | Branch (956:8): [True: 2, False: 0] ------------------ 957| 2| pHeader->dataHeader.magic2==0x27 && ------------------ | Branch (957:9): [True: 2, False: 0] ------------------ 958| 2| (isAcceptable==nullptr || isAcceptable(context, type, name, &pHeader->info)) ------------------ | Branch (958:10): [True: 0, False: 2] | Branch (958:35): [True: 2, False: 0] ------------------ 959| 2| ) { 960| 2| rDataMem=UDataMemory_createNewInstance(fatalErr); ------------------ | | 79| 2|#define UDataMemory_createNewInstance U_ICU_ENTRY_POINT_RENAME(UDataMemory_createNewInstance) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 961| 2| if (U_FAILURE(*fatalErr)) { ------------------ | Branch (961:13): [True: 0, False: 2] ------------------ 962| 0| return nullptr; 963| 0| } 964| 2| rDataMem->pHeader = pHeader; 965| 2| } else { 966| | /* the data is not acceptable, look further */ 967| | /* If we eventually find something good, this errorcode will be */ 968| | /* cleared out. */ 969| 0| *nonFatalErr=U_INVALID_FORMAT_ERROR; 970| 0| } 971| 2| return rDataMem; 972| 2|} udata.cpp:_ZL20doLoadFromCommonDataaPKcS0_S0_S0_S0_S0_S0_PFaPvS0_S0_PK9UDataInfoES1_P10UErrorCodeS8_: 1042| 2|{ 1043| 2| UDataMemory *pEntryData; 1044| 2| const DataHeader *pHeader; 1045| 2| UDataMemory *pCommonData; 1046| 2| int32_t commonDataIndex; 1047| 2| UBool checkedExtendedICUData = false; 1048| | /* try to get common data. The loop is for platforms such as the 390 that do 1049| | * not initially load the full set of ICU data. If the lookup of an ICU data item 1050| | * fails, the full (but slower to load) set is loaded, the and the loop repeats, 1051| | * trying the lookup again. Once the full set of ICU data is loaded, the loop wont 1052| | * repeat because the full set will be checked the first time through. 1053| | * 1054| | * The loop also handles the fallback to a .dat file if the application linked 1055| | * to the stub data library rather than a real library. 1056| | */ 1057| 2| for (commonDataIndex = isICUData ? 0 : -1;;) { ------------------ | Branch (1057:28): [True: 2, False: 0] ------------------ 1058| 2| pCommonData=openCommonData(path, commonDataIndex, subErrorCode); /** search for pkg **/ 1059| | 1060| 2| if(U_SUCCESS(*subErrorCode) && pCommonData!=nullptr) { ------------------ | Branch (1060:12): [True: 2, False: 0] | Branch (1060:40): [True: 2, False: 0] ------------------ 1061| 2| int32_t length; 1062| | 1063| | /* look up the data piece in the common data */ 1064| 2| pHeader=pCommonData->vFuncs->Lookup(pCommonData, tocEntryName, &length, subErrorCode); 1065| |#ifdef UDATA_DEBUG 1066| | fprintf(stderr, "%s: pHeader=%p - %s\n", tocEntryName, (void*) pHeader, u_errorName(*subErrorCode)); 1067| |#endif 1068| | 1069| 2| if(pHeader!=nullptr) { ------------------ | Branch (1069:16): [True: 2, False: 0] ------------------ 1070| 2| pEntryData = checkDataItem(pHeader, isAcceptable, context, type, name, subErrorCode, pErrorCode); 1071| |#ifdef UDATA_DEBUG 1072| | fprintf(stderr, "pEntryData=%p\n", (void*) pEntryData); 1073| |#endif 1074| 2| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (1074:21): [True: 0, False: 2] ------------------ 1075| 0| return nullptr; 1076| 0| } 1077| 2| if (pEntryData != nullptr) { ------------------ | Branch (1077:21): [True: 2, False: 0] ------------------ 1078| 2| pEntryData->length = length; 1079| 2| return pEntryData; 1080| 2| } 1081| 2| } 1082| 2| } 1083| | // If we failed due to being out-of-memory, then stop early and report the error. 1084| 0| if (*subErrorCode == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (1084:13): [True: 0, False: 0] ------------------ 1085| 0| *pErrorCode = *subErrorCode; 1086| 0| return nullptr; 1087| 0| } 1088| | /* Data wasn't found. If we were looking for an ICUData item and there is 1089| | * more data available, load it and try again, 1090| | * otherwise break out of this loop. */ 1091| 0| if (!isICUData) { ------------------ | Branch (1091:13): [True: 0, False: 0] ------------------ 1092| 0| return nullptr; 1093| 0| } else if (pCommonData != nullptr) { ------------------ | Branch (1093:20): [True: 0, False: 0] ------------------ 1094| 0| ++commonDataIndex; /* try the next data package */ 1095| 0| } else if ((!checkedExtendedICUData) && extendICUData(subErrorCode)) { ------------------ | Branch (1095:20): [True: 0, False: 0] | Branch (1095:49): [True: 0, False: 0] ------------------ 1096| 0| checkedExtendedICUData = true; 1097| | /* try this data package slot again: it changed from nullptr to non-nullptr */ 1098| 0| } else { 1099| 0| return nullptr; 1100| 0| } 1101| 0| } 1102| 2|} udata.cpp:_ZL14openCommonDataPKciP10UErrorCode: 673| 2|{ 674| 2| UDataMemory tData; 675| 2| const char *pathBuffer; 676| 2| const char *inBasename; 677| | 678| 2| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (678:9): [True: 0, False: 2] ------------------ 679| 0| return nullptr; 680| 0| } 681| | 682| 2| UDataMemory_init(&tData); ------------------ | | 80| 2|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 683| | 684| | /* ??????? TODO revisit this */ 685| 2| if (commonDataIndex >= 0) { ------------------ | Branch (685:9): [True: 2, False: 0] ------------------ 686| | /* "mini-cache" for common ICU data */ 687| 2| if(commonDataIndex >= UPRV_LENGTHOF(gCommonICUDataArray)) { ------------------ | | 99| 2|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (687:12): [True: 0, False: 2] ------------------ 688| 0| return nullptr; 689| 0| } 690| 2| { 691| 2| Mutex lock; 692| 2| if(gCommonICUDataArray[commonDataIndex] != nullptr) { ------------------ | Branch (692:16): [True: 1, False: 1] ------------------ 693| 1| return gCommonICUDataArray[commonDataIndex]; 694| 1| } 695| 1|#if !defined(ICU_DATA_DIR_WINDOWS) 696| |// When using the Windows system data, we expect only a single data file. 697| 1| int32_t i; 698| 1| for(i = 0; i < commonDataIndex; ++i) { ------------------ | Branch (698:24): [True: 0, False: 1] ------------------ 699| 0| if(gCommonICUDataArray[i]->pHeader == &U_ICUDATA_ENTRY_POINT) { ------------------ | | 171| 0|#define U_ICUDATA_ENTRY_POINT U_DEF2_ICUDATA_ENTRY_POINT(U_ICU_VERSION_MAJOR_NUM,U_LIB_SUFFIX_C_NAME) | | ------------------ | | | | 178| 0|#define U_DEF2_ICUDATA_ENTRY_POINT(major,suff) U_DEF_ICUDATA_ENTRY_POINT(major,suff) | | | | ------------------ | | | | | | 187| 0|#define U_DEF_ICUDATA_ENTRY_POINT(major, suff) icudt##major##_dat | | | | ------------------ | | ------------------ ------------------ | Branch (699:20): [True: 0, False: 0] ------------------ 700| | /* The linked-in data is already in the list. */ 701| 0| return nullptr; 702| 0| } 703| 0| } 704| 1|#endif 705| 1| } 706| | 707| | /* Add the linked-in data to the list. */ 708| | /* 709| | * This is where we would check and call weakly linked partial-data-library 710| | * access functions. 711| | */ 712| | /* 713| | if (uprv_getICUData_collation) { 714| | setCommonICUDataPointer(uprv_getICUData_collation(), false, pErrorCode); 715| | } 716| | if (uprv_getICUData_conversion) { 717| | setCommonICUDataPointer(uprv_getICUData_conversion(), false, pErrorCode); 718| | } 719| | */ 720| 1|#if !defined(ICU_DATA_DIR_WINDOWS) 721| |// When using the Windows system data, we expect only a single data file. 722| 1| setCommonICUDataPointer(&U_ICUDATA_ENTRY_POINT, false, pErrorCode); ------------------ | | 171| 1|#define U_ICUDATA_ENTRY_POINT U_DEF2_ICUDATA_ENTRY_POINT(U_ICU_VERSION_MAJOR_NUM,U_LIB_SUFFIX_C_NAME) | | ------------------ | | | | 178| 1|#define U_DEF2_ICUDATA_ENTRY_POINT(major,suff) U_DEF_ICUDATA_ENTRY_POINT(major,suff) | | | | ------------------ | | | | | | 187| 1|#define U_DEF_ICUDATA_ENTRY_POINT(major, suff) icudt##major##_dat | | | | ------------------ | | ------------------ ------------------ 723| 1| { 724| 1| Mutex lock; 725| 1| return gCommonICUDataArray[commonDataIndex]; 726| 1| } 727| 1|#endif 728| 1| } 729| | 730| | 731| | /* request is NOT for ICU Data. */ 732| | 733| | /* Find the base name portion of the supplied path. */ 734| | /* inBasename will be left pointing somewhere within the original path string. */ 735| 0| inBasename = findBasename(path); 736| |#ifdef UDATA_DEBUG 737| | fprintf(stderr, "inBasename = %s\n", inBasename); 738| |#endif 739| | 740| 0| if(*inBasename==0) { ------------------ | Branch (740:8): [True: 0, False: 0] ------------------ 741| | /* no basename. This will happen if the original path was a directory name, */ 742| | /* like "a/b/c/". (Fallback to separate files will still work.) */ 743| |#ifdef UDATA_DEBUG 744| | fprintf(stderr, "ocd: no basename in %s, bailing.\n", path); 745| |#endif 746| 0| if (U_SUCCESS(*pErrorCode)) { ------------------ | Branch (746:13): [True: 0, False: 0] ------------------ 747| 0| *pErrorCode=U_FILE_ACCESS_ERROR; 748| 0| } 749| 0| return nullptr; 750| 0| } 751| | 752| | /* Is the requested common data file already open and cached? */ 753| | /* Note that the cache is keyed by the base name only. The rest of the path, */ 754| | /* if any, is not considered. */ 755| 0| UDataMemory *dataToReturn = udata_findCachedData(inBasename, *pErrorCode); 756| 0| if (dataToReturn != nullptr || U_FAILURE(*pErrorCode)) { ------------------ | Branch (756:9): [True: 0, False: 0] | Branch (756:36): [True: 0, False: 0] ------------------ 757| 0| return dataToReturn; 758| 0| } 759| | 760| | /* Requested item is not in the cache. 761| | * Hunt it down, trying all the path locations 762| | */ 763| | 764| 0| UDataPathIterator iter(u_getDataDirectory(), inBasename, path, ".dat", true, pErrorCode); ------------------ | | 271| 0|#define u_getDataDirectory U_ICU_ENTRY_POINT_RENAME(u_getDataDirectory) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 765| | 766| 0| while ((UDataMemory_isLoaded(&tData)==false) && (pathBuffer = iter.next(pErrorCode)) != nullptr) ------------------ | | 81| 0|#define UDataMemory_isLoaded U_ICU_ENTRY_POINT_RENAME(UDataMemory_isLoaded) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (766:12): [True: 0, False: 0] | Branch (766:53): [True: 0, False: 0] ------------------ 767| 0| { 768| |#ifdef UDATA_DEBUG 769| | fprintf(stderr, "ocd: trying path %s - ", pathBuffer); 770| |#endif 771| 0| uprv_mapFile(&tData, pathBuffer, pErrorCode); ------------------ | | 1525| 0|#define uprv_mapFile U_ICU_ENTRY_POINT_RENAME(uprv_mapFile) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 772| |#ifdef UDATA_DEBUG 773| | fprintf(stderr, "%s\n", UDataMemory_isLoaded(&tData)?"LOADED":"not loaded"); 774| |#endif 775| 0| } 776| 0| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (776:9): [True: 0, False: 0] ------------------ 777| 0| return nullptr; 778| 0| } 779| | 780| 0| if (U_FAILURE(*pErrorCode)) { ------------------ | Branch (780:9): [True: 0, False: 0] ------------------ 781| 0| return nullptr; 782| 0| } 783| 0| if (!UDataMemory_isLoaded(&tData)) { ------------------ | | 81| 0|#define UDataMemory_isLoaded U_ICU_ENTRY_POINT_RENAME(UDataMemory_isLoaded) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (783:9): [True: 0, False: 0] ------------------ 784| | /* no common data */ 785| 0| *pErrorCode=U_FILE_ACCESS_ERROR; 786| 0| return nullptr; 787| 0| } 788| | 789| | /* we have mapped a file, check its header */ 790| 0| udata_checkCommonData(&tData, pErrorCode); ------------------ | | 884| 0|#define udata_checkCommonData U_ICU_ENTRY_POINT_RENAME(udata_checkCommonData) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 791| | 792| | 793| | /* Cache the UDataMemory struct for this .dat file, 794| | * so we won't need to hunt it down and map it again next time 795| | * something is needed from it. */ 796| 0| return udata_cacheDataItem(inBasename, &tData, pErrorCode); 797| 0|} udata.cpp:_ZL23setCommonICUDataPointerPKvaP10UErrorCode: 214| 1|setCommonICUDataPointer(const void *pData, UBool /*warn*/, UErrorCode *pErrorCode) { 215| 1| UDataMemory tData; 216| 1| UDataMemory_init(&tData); ------------------ | | 80| 1|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 217| 1| UDataMemory_setData(&tData, pData); ------------------ | | 83| 1|#define UDataMemory_setData U_ICU_ENTRY_POINT_RENAME(UDataMemory_setData) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 218| 1| udata_checkCommonData(&tData, pErrorCode); ------------------ | | 884| 1|#define udata_checkCommonData U_ICU_ENTRY_POINT_RENAME(udata_checkCommonData) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 219| 1| return setCommonICUData(&tData, false, pErrorCode); 220| 1|} UDataMemory_init_78: 28| 6|U_CFUNC void UDataMemory_init(UDataMemory *This) { 29| 6| uprv_memset(This, 0, sizeof(UDataMemory)); ------------------ | | 100| 6|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 6|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 30| 6| This->length=-1; 31| 6|} UDatamemory_assign_78: 34| 1|U_CFUNC void UDatamemory_assign(UDataMemory *dest, UDataMemory *source) { 35| | /* UDataMemory Assignment. Destination UDataMemory must be initialized first. */ 36| 1| UBool mallocedFlag = dest->heapAllocated; 37| 1| uprv_memcpy(dest, source, sizeof(UDataMemory)); ------------------ | | 42| 1|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1| _Pragma("clang diagnostic push") \ | | 45| 1| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1| _Pragma("clang diagnostic pop") \ | | 49| 1| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 38| 1| dest->heapAllocated = mallocedFlag; 39| 1|} UDataMemory_createNewInstance_78: 41| 3|U_CFUNC UDataMemory *UDataMemory_createNewInstance(UErrorCode *pErr) { 42| 3| UDataMemory *This; 43| | 44| 3| if (U_FAILURE(*pErr)) { ------------------ | Branch (44:9): [True: 0, False: 3] ------------------ 45| 0| return nullptr; 46| 0| } 47| 3| This = (UDataMemory *)uprv_malloc(sizeof(UDataMemory)); ------------------ | | 1524| 3|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 48| 3| if (This == nullptr) { ------------------ | Branch (48:9): [True: 0, False: 3] ------------------ 49| 0| *pErr = U_MEMORY_ALLOCATION_ERROR; } 50| 3| else { 51| 3| UDataMemory_init(This); ------------------ | | 80| 3|#define UDataMemory_init U_ICU_ENTRY_POINT_RENAME(UDataMemory_init) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 52| 3| This->heapAllocated = true; 53| 3| } 54| 3| return This; 55| 3|} UDataMemory_normalizeDataPointer_78: 59| 1|UDataMemory_normalizeDataPointer(const void *p) { 60| | /* allow the data to be optionally prepended with an alignment-forcing double value */ 61| 1| const DataHeader *pdh = (const DataHeader *)p; 62| 1| if(pdh==nullptr || (pdh->dataHeader.magic1==0xda && pdh->dataHeader.magic2==0x27)) { ------------------ | Branch (62:8): [True: 0, False: 1] | Branch (62:25): [True: 1, False: 0] | Branch (62:57): [True: 1, False: 0] ------------------ 63| 1| return pdh; 64| 1| } else { 65| |#if U_PLATFORM == U_PF_OS400 66| | /* 67| | TODO: Fix this once the compiler implements this feature. Keep in sync with genccode.c 68| | 69| | This is here because this platform can't currently put 70| | const data into the read-only pages of an object or 71| | shared library (service program). Only strings are allowed in read-only 72| | pages, so we use char * strings to store the data. 73| | 74| | In order to prevent the beginning of the data from ever matching the 75| | magic numbers we must skip the initial double. 76| | [grhoten 4/24/2003] 77| | */ 78| | return (const DataHeader *)*((const void **)p+1); 79| |#else 80| 0| return (const DataHeader *)((const double *)p+1); 81| 0|#endif 82| 0| } 83| 1|} UDataMemory_setData_78: 86| 1|U_CFUNC void UDataMemory_setData (UDataMemory *This, const void *dataAddr) { 87| 1| This->pHeader = UDataMemory_normalizeDataPointer(dataAddr); ------------------ | | 82| 1|#define UDataMemory_normalizeDataPointer U_ICU_ENTRY_POINT_RENAME(UDataMemory_normalizeDataPointer) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 88| 1|} udata_getMemory_78: 104| 2|udata_getMemory(UDataMemory *pData) { 105| 2| if(pData!=nullptr && pData->pHeader!=nullptr) { ------------------ | Branch (105:8): [True: 2, False: 0] | Branch (105:26): [True: 2, False: 0] ------------------ 106| 2| return (char *)(pData->pHeader)+udata_getHeaderSize(pData->pHeader); ------------------ | | 887| 2|#define udata_getHeaderSize U_ICU_ENTRY_POINT_RENAME(udata_getHeaderSize) | | ------------------ | | | | 123| 2|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 2| } else { 108| 0| return nullptr; 109| 0| } 110| 2|} uenum_close_78: 60| 3.55k|{ 61| 3.55k| if (en) { ------------------ | Branch (61:9): [True: 1.79k, False: 1.76k] ------------------ 62| 1.79k| if (en->close != nullptr) { ------------------ | Branch (62:13): [True: 1.79k, False: 0] ------------------ 63| 1.79k| if (en->baseContext) { ------------------ | Branch (63:17): [True: 0, False: 1.79k] ------------------ 64| 0| uprv_free(en->baseContext); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 65| 0| } 66| 1.79k| en->close(en); 67| 1.79k| } else { /* this seems dangerous, but we better kill the object */ 68| 0| uprv_free(en); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 69| 0| } 70| 1.79k| } 71| 3.55k|} uhash_open_78: 547| 39| UErrorCode *status) { 548| | 549| 39| return _uhash_create(keyHash, keyComp, valueComp, DEFAULT_PRIME_INDEX, status); ------------------ | | 91| 39|#define DEFAULT_PRIME_INDEX 4 ------------------ 550| 39|} uhash_get_78: 665| 1.73M| const void* key) { 666| 1.73M| UHashTok keyholder; 667| 1.73M| keyholder.pointer = (void*) key; 668| 1.73M| return _uhash_find(hash, keyholder, hash->keyHasher(keyholder))->value.pointer; 669| 1.73M|} uhash_put_78: 721| 1.76k| UErrorCode *status) { 722| 1.76k| UHashTok keyholder, valueholder; 723| 1.76k| keyholder.pointer = key; 724| 1.76k| valueholder.pointer = value; 725| 1.76k| return _uhash_put(hash, keyholder, valueholder, 726| 1.76k| HINT_KEY_POINTER | HINT_VALUE_POINTER, ------------------ | | 139| 1.76k|#define HINT_KEY_POINTER (1) ------------------ HINT_KEY_POINTER | HINT_VALUE_POINTER, ------------------ | | 140| 1.76k|#define HINT_VALUE_POINTER (2) ------------------ 727| 1.76k| status).pointer; 728| 1.76k|} uhash_hashChars_78: 938| 16|uhash_hashChars(const UHashTok key) { 939| 16| const char *s = (const char *)key.pointer; 940| 16| return s == nullptr ? 0 : static_cast(ustr_hashCharsN(s, static_cast(uprv_strlen(s)))); ------------------ | | 1878| 8|#define ustr_hashCharsN U_ICU_ENTRY_POINT_RENAME(ustr_hashCharsN) | | ------------------ | | | | 123| 8|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return s == nullptr ? 0 : static_cast(ustr_hashCharsN(s, static_cast(uprv_strlen(s)))); ------------------ | | 37| 8|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 8|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (940:12): [True: 8, False: 8] ------------------ 941| 16|} uhash_hashIStringView_78: 950| 1.73M|uhash_hashIStringView(const UHashTok key) { 951| 1.73M| const std::string_view* s = static_cast(key.pointer); 952| 1.73M| return s == nullptr ? 0 : ustr_hashICharsN(s->data(), static_cast(s->size())); ------------------ | | 1879| 1.73M|#define ustr_hashICharsN U_ICU_ENTRY_POINT_RENAME(ustr_hashICharsN) | | ------------------ | | | | 123| 1.73M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.73M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.73M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (952:12): [True: 0, False: 1.73M] ------------------ 953| 1.73M|} uhash_compareChars_78: 1029| 4|uhash_compareChars(const UHashTok key1, const UHashTok key2) { 1030| 4| const char *p1 = (const char*) key1.pointer; 1031| 4| const char *p2 = (const char*) key2.pointer; 1032| 4| if (p1 == p2) { ------------------ | Branch (1032:9): [True: 2, False: 2] ------------------ 1033| 2| return true; 1034| 2| } 1035| 2| if (p1 == nullptr || p2 == nullptr) { ------------------ | Branch (1035:9): [True: 0, False: 2] | Branch (1035:26): [True: 0, False: 2] ------------------ 1036| 0| return false; 1037| 0| } 1038| 28| while (*p1 != 0 && *p1 == *p2) { ------------------ | Branch (1038:12): [True: 26, False: 2] | Branch (1038:24): [True: 26, False: 0] ------------------ 1039| 26| ++p1; 1040| 26| ++p2; 1041| 26| } 1042| 2| return *p1 == *p2; 1043| 2|} uhash_compareIStringView_78: 1063| 1.68M|uhash_compareIStringView(const UHashTok key1, const UHashTok key2) { 1064| 1.68M| const std::string_view* p1 = static_cast(key1.pointer); 1065| 1.68M| const std::string_view* p2 = static_cast(key2.pointer); 1066| 1.68M| if (p1 == p2) { ------------------ | Branch (1066:9): [True: 0, False: 1.68M] ------------------ 1067| 0| return true; 1068| 0| } 1069| 1.68M| if (p1 == nullptr || p2 == nullptr) { ------------------ | Branch (1069:9): [True: 0, False: 1.68M] | Branch (1069:26): [True: 0, False: 1.68M] ------------------ 1070| 0| return false; 1071| 0| } 1072| 1.68M| const std::string_view& v1 = *p1; 1073| 1.68M| const std::string_view& v2 = *p2; 1074| 1.68M| if (v1.size() != v2.size()) { ------------------ | Branch (1074:9): [True: 198, False: 1.68M] ------------------ 1075| 198| return false; 1076| 198| } 1077| 1.86M| for (size_t i = 0; i < v1.size(); ++i) { ------------------ | Branch (1077:24): [True: 1.82M, False: 39.0k] ------------------ 1078| 1.82M| if (uprv_tolower(v1[i]) != uprv_tolower(v2[i])) { ------------------ | | 68| 1.82M|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 1.82M|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 1.82M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 1.82M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.82M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (uprv_tolower(v1[i]) != uprv_tolower(v2[i])) { ------------------ | | 68| 1.82M|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 1.82M|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 1.82M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 1.82M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.82M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1078:13): [True: 1.64M, False: 181k] ------------------ 1079| 1.64M| return false; 1080| 1.64M| } 1081| 1.82M| } 1082| 39.0k| return true; 1083| 1.68M|} uhash.cpp:_ZL13_uhash_createPFi8UElementEPFaS_S_ES3_iP10UErrorCode: 287| 39| UErrorCode *status) { 288| 39| UHashtable *result; 289| | 290| 39| if (U_FAILURE(*status)) return nullptr; ------------------ | Branch (290:9): [True: 0, False: 39] ------------------ 291| | 292| 39| result = static_cast(uprv_malloc(sizeof(UHashtable))); ------------------ | | 1524| 39|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 39|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 39|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 39|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 293| 39| if (result == nullptr) { ------------------ | Branch (293:9): [True: 0, False: 39] ------------------ 294| 0| *status = U_MEMORY_ALLOCATION_ERROR; 295| 0| return nullptr; 296| 0| } 297| | 298| 39| _uhash_init(result, keyHash, keyComp, valueComp, primeIndex, status); 299| 39| result->allocated = true; 300| | 301| 39| if (U_FAILURE(*status)) { ------------------ | Branch (301:9): [True: 0, False: 39] ------------------ 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| 39| return result; 307| 39|} uhash.cpp:_ZL11_uhash_initP10UHashtablePFi8UElementEPFaS1_S1_ES5_iP10UErrorCode: 260| 39|{ 261| 39| if (U_FAILURE(*status)) return nullptr; ------------------ | Branch (261:9): [True: 0, False: 39] ------------------ 262| 39| U_ASSERT(keyHash != nullptr); ------------------ | | 35| 39|# define U_ASSERT(exp) (void)0 ------------------ 263| 39| U_ASSERT(keyComp != nullptr); ------------------ | | 35| 39|# define U_ASSERT(exp) (void)0 ------------------ 264| | 265| 39| result->keyHasher = keyHash; 266| 39| result->keyComparator = keyComp; 267| 39| result->valueComparator = valueComp; 268| 39| result->keyDeleter = nullptr; 269| 39| result->valueDeleter = nullptr; 270| 39| result->allocated = false; 271| 39| _uhash_internalSetResizePolicy(result, U_GROW); 272| | 273| 39| _uhash_allocate(result, primeIndex, status); 274| | 275| 39| if (U_FAILURE(*status)) { ------------------ | Branch (275:9): [True: 0, False: 39] ------------------ 276| 0| return nullptr; 277| 0| } 278| | 279| 39| return result; 280| 39|} uhash.cpp:_ZL15_uhash_allocateP10UHashtableiP10UErrorCode: 217| 48| UErrorCode *status) { 218| | 219| 48| UHashElement *p, *limit; 220| 48| UHashTok emptytok; 221| | 222| 48| if (U_FAILURE(*status)) return; ------------------ | Branch (222:9): [True: 0, False: 48] ------------------ 223| | 224| 48| U_ASSERT(primeIndex >= 0 && primeIndex < PRIMES_LENGTH); ------------------ | | 35| 48|# define U_ASSERT(exp) (void)0 ------------------ 225| | 226| 48| hash->primeIndex = static_cast(primeIndex); 227| 48| hash->length = PRIMES[primeIndex]; 228| | 229| 48| p = hash->elements = static_cast( 230| 48| uprv_malloc(sizeof(UHashElement) * hash->length)); ------------------ | | 1524| 48|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 48|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 48|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 48|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 231| | 232| 48| if (hash->elements == nullptr) { ------------------ | Branch (232:9): [True: 0, False: 48] ------------------ 233| 0| *status = U_MEMORY_ALLOCATION_ERROR; 234| 0| return; 235| 0| } 236| | 237| 48| emptytok.pointer = nullptr; /* Only one of these two is needed */ 238| 48| emptytok.integer = 0; /* but we don't know which one. */ 239| | 240| 48| limit = p + hash->length; 241| 14.9k| while (p < limit) { ------------------ | Branch (241:12): [True: 14.8k, False: 48] ------------------ 242| 14.8k| p->key = emptytok; 243| 14.8k| p->value = emptytok; 244| 14.8k| p->hashcode = HASH_EMPTY; ------------------ | | 118| 14.8k|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 14.8k|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ 245| 14.8k| ++p; 246| 14.8k| } 247| | 248| 48| hash->count = 0; 249| 48| hash->lowWaterMark = static_cast(hash->length * hash->lowWaterRatio); 250| 48| hash->highWaterMark = static_cast(hash->length * hash->highWaterRatio); 251| 48|} uhash.cpp:_ZL30_uhash_internalSetResizePolicyP10UHashtable17UHashResizePolicy: 197| 39|_uhash_internalSetResizePolicy(UHashtable *hash, enum UHashResizePolicy policy) { 198| 39| U_ASSERT(hash != nullptr); ------------------ | | 35| 39|# define U_ASSERT(exp) (void)0 ------------------ 199| 39| U_ASSERT(((int32_t)policy) >= 0); ------------------ | | 35| 39|# define U_ASSERT(exp) (void)0 ------------------ 200| 39| U_ASSERT(((int32_t)policy) < 3); ------------------ | | 35| 39|# define U_ASSERT(exp) (void)0 ------------------ 201| 39| hash->lowWaterRatio = RESIZE_POLICY_RATIO_TABLE[policy * 2]; 202| 39| hash->highWaterRatio = RESIZE_POLICY_RATIO_TABLE[policy * 2 + 1]; 203| 39|} uhash.cpp:_ZL13_uhash_rehashP10UHashtableP10UErrorCode: 399| 9|_uhash_rehash(UHashtable *hash, UErrorCode *status) { 400| | 401| 9| UHashElement *old = hash->elements; 402| 9| int32_t oldLength = hash->length; 403| 9| int32_t newPrimeIndex = hash->primeIndex; 404| 9| int32_t i; 405| | 406| 9| if (hash->count > hash->highWaterMark) { ------------------ | Branch (406:9): [True: 9, False: 0] ------------------ 407| 9| if (++newPrimeIndex >= PRIMES_LENGTH) { ------------------ | | 90| 9|#define PRIMES_LENGTH UPRV_LENGTHOF(PRIMES) | | ------------------ | | | | 99| 9|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) | | ------------------ ------------------ | Branch (407:13): [True: 0, False: 9] ------------------ 408| 0| return; 409| 0| } 410| 9| } 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| 9| _uhash_allocate(hash, newPrimeIndex, status); 419| | 420| 9| if (U_FAILURE(*status)) { ------------------ | Branch (420:9): [True: 0, False: 9] ------------------ 421| 0| hash->elements = old; 422| 0| hash->length = oldLength; 423| 0| return; 424| 0| } 425| | 426| 4.97k| for (i = oldLength - 1; i >= 0; --i) { ------------------ | Branch (426:29): [True: 4.96k, False: 9] ------------------ 427| 4.96k| if (!IS_EMPTY_OR_DELETED(old[i].hashcode)) { ------------------ | | 120| 4.96k|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (427:13): [True: 2.48k, False: 2.47k] ------------------ 428| 2.48k| UHashElement *e = _uhash_find(hash, old[i].key, old[i].hashcode); 429| 2.48k| U_ASSERT(e != nullptr); ------------------ | | 35| 2.48k|# define U_ASSERT(exp) (void)0 ------------------ 430| 2.48k| U_ASSERT(e->hashcode == HASH_EMPTY); ------------------ | | 35| 2.48k|# define U_ASSERT(exp) (void)0 ------------------ 431| 2.48k| e->key = old[i].key; 432| 2.48k| e->value = old[i].value; 433| 2.48k| e->hashcode = old[i].hashcode; 434| 2.48k| ++hash->count; 435| 2.48k| } 436| 4.96k| } 437| | 438| 9| uprv_free(old); ------------------ | | 1503| 9|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 9|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 439| 9|} uhash.cpp:_ZL11_uhash_findPK10UHashtable8UElementi: 339| 1.74M| int32_t hashcode) { 340| | 341| 1.74M| int32_t firstDeleted = -1; /* assume invalid index */ 342| 1.74M| int32_t theIndex, startIndex; 343| 1.74M| int32_t jump = 0; /* lazy evaluate */ 344| 1.74M| int32_t tableHash; 345| 1.74M| UHashElement *elements = hash->elements; 346| | 347| 1.74M| hashcode &= 0x7FFFFFFF; /* must be positive */ 348| 1.74M| startIndex = theIndex = (hashcode ^ 0x4000000) % hash->length; 349| | 350| 3.44M| do { 351| 3.44M| tableHash = elements[theIndex].hashcode; 352| 3.44M| if (tableHash == hashcode) { /* quick check */ ------------------ | Branch (352:13): [True: 1.68M, False: 1.75M] ------------------ 353| 1.68M| if ((*hash->keyComparator)(key, elements[theIndex].key)) { ------------------ | Branch (353:17): [True: 39.0k, False: 1.64M] ------------------ 354| 39.0k| return &(elements[theIndex]); 355| 39.0k| } 356| 1.75M| } else if (!IS_EMPTY_OR_DELETED(tableHash)) { ------------------ | | 120| 1.75M|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) ------------------ | Branch (356:20): [True: 53.3k, False: 1.70M] ------------------ 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| 1.70M| } else if (tableHash == HASH_EMPTY) { /* empty, end o' the line */ ------------------ | | 118| 1.70M|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 1.70M|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ | Branch (361:20): [True: 1.70M, False: 0] ------------------ 362| 1.70M| break; 363| 1.70M| } else if (firstDeleted < 0) { /* remember first deleted */ ------------------ | Branch (363:20): [True: 0, False: 0] ------------------ 364| 0| firstDeleted = theIndex; 365| 0| } 366| 1.69M| if (jump == 0) { /* lazy compute jump */ ------------------ | Branch (366:13): [True: 1.67M, False: 21.0k] ------------------ 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| 1.67M| jump = (hashcode % (hash->length - 1)) + 1; 372| 1.67M| } 373| 1.69M| theIndex = (theIndex + jump) % hash->length; 374| 1.69M| } while (theIndex != startIndex); ------------------ | Branch (374:14): [True: 1.69M, False: 0] ------------------ 375| | 376| 1.70M| if (firstDeleted >= 0) { ------------------ | Branch (376:9): [True: 0, False: 1.70M] ------------------ 377| 0| theIndex = firstDeleted; /* reset if had deleted slot */ 378| 1.70M| } else if (tableHash != HASH_EMPTY) { ------------------ | | 118| 1.70M|#define HASH_EMPTY ((int32_t) HASH_DELETED + 1) | | ------------------ | | | | 117| 1.70M|#define HASH_DELETED ((int32_t) 0x80000000) | | ------------------ ------------------ | Branch (378:16): [True: 0, False: 1.70M] ------------------ 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| 1.70M| return &(elements[theIndex]); 387| 1.70M|} uhash.cpp:_ZL10_uhash_putP10UHashtable8UElementS1_aP10UErrorCode: 471| 1.76k| 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| 1.76k| int32_t hashcode; 479| 1.76k| UHashElement* e; 480| 1.76k| UHashTok emptytok; 481| | 482| 1.76k| if (U_FAILURE(*status)) { ------------------ | Branch (482:9): [True: 0, False: 1.76k] ------------------ 483| 0| goto err; 484| 0| } 485| 1.76k| U_ASSERT(hash != nullptr); ------------------ | | 35| 1.76k|# define U_ASSERT(exp) (void)0 ------------------ 486| 1.76k| if ((hint & HINT_VALUE_POINTER) ? ------------------ | | 140| 1.76k|#define HINT_VALUE_POINTER (2) ------------------ | Branch (486:9): [True: 1.76k, False: 0] | Branch (486:9): [True: 0, False: 1.76k] ------------------ 487| 1.76k| value.pointer == nullptr : 488| 1.76k| 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| 1.76k| if (hash->count > hash->highWaterMark) { ------------------ | Branch (494:9): [True: 9, False: 1.76k] ------------------ 495| 9| _uhash_rehash(hash, status); 496| 9| if (U_FAILURE(*status)) { ------------------ | Branch (496:13): [True: 0, False: 9] ------------------ 497| 0| goto err; 498| 0| } 499| 9| } 500| | 501| 1.76k| hashcode = (*hash->keyHasher)(key); 502| 1.76k| e = _uhash_find(hash, key, hashcode); 503| 1.76k| U_ASSERT(e != nullptr); ------------------ | | 35| 1.76k|# define U_ASSERT(exp) (void)0 ------------------ 504| | 505| 1.76k| if (IS_EMPTY_OR_DELETED(e->hashcode)) { ------------------ | | 120| 1.76k|#define IS_EMPTY_OR_DELETED(x) ((x) < 0) | | ------------------ | | | Branch (120:32): [True: 1.76k, False: 6] | | ------------------ ------------------ 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| 1.76k| ++hash->count; 514| 1.76k| if (hash->count == hash->length) { ------------------ | Branch (514:13): [True: 0, False: 1.76k] ------------------ 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| 1.76k| } 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| 1.76k| 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| 1.76k|} uhash.cpp:_ZL17_uhash_setElementP10UHashtableP12UHashElementi8UElementS3_a: 150| 1.76k| UHashTok key, UHashTok value, int8_t hint) { 151| | 152| 1.76k| UHashTok oldValue = e->value; 153| 1.76k| if (hash->keyDeleter != nullptr && e->key.pointer != nullptr && ------------------ | Branch (153:9): [True: 0, False: 1.76k] | Branch (153:40): [True: 0, False: 0] ------------------ 154| 1.76k| 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| 1.76k| if (hash->valueDeleter != nullptr) { ------------------ | Branch (157:9): [True: 0, False: 1.76k] ------------------ 158| 0| if (oldValue.pointer != nullptr && ------------------ | Branch (158:13): [True: 0, False: 0] ------------------ 159| 0| oldValue.pointer != value.pointer) { /* Avoid double deletion */ ------------------ | Branch (159:13): [True: 0, False: 0] ------------------ 160| 0| (*hash->valueDeleter)(oldValue.pointer); 161| 0| } 162| 0| oldValue.pointer = nullptr; 163| 0| } 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| 1.76k| if (hint & HINT_KEY_POINTER) { ------------------ | | 139| 1.76k|#define HINT_KEY_POINTER (1) ------------------ | Branch (170:9): [True: 1.76k, False: 0] ------------------ 171| 1.76k| e->key.pointer = key.pointer; 172| 1.76k| } else { 173| 0| e->key = key; 174| 0| } 175| 1.76k| if (hint & HINT_VALUE_POINTER) { ------------------ | | 140| 1.76k|#define HINT_VALUE_POINTER (2) ------------------ | Branch (175:9): [True: 1.76k, False: 0] ------------------ 176| 1.76k| e->value.pointer = value.pointer; 177| 1.76k| } else { 178| 0| e->value = value; 179| 0| } 180| 1.76k| e->hashcode = hashcode; 181| 1.76k| return oldValue; 182| 1.76k|} u_UCharsToChars_78: 204| 504|u_UCharsToChars(const char16_t *us, char *cs, int32_t length) { 205| 504| char16_t u; 206| | 207| 3.15k| while(length>0) { ------------------ | Branch (207:11): [True: 2.65k, False: 504] ------------------ 208| 2.65k| u=*us++; 209| 2.65k| if(!UCHAR_IS_INVARIANT(u)) { ------------------ | | 168| 2.65k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 2.65k, False: 0] | | | Branch (168:47): [True: 2.65k, 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| 2.65k| *cs++=(char)UCHAR_TO_CHAR(u); ------------------ | | 175| 2.65k|#define UCHAR_TO_CHAR(c) c ------------------ 214| 2.65k| --length; 215| 2.65k| } 216| 504|} uprv_isInvariantUString_78: 263| 504|uprv_isInvariantUString(const char16_t *s, int32_t length) { 264| 504| char16_t c; 265| | 266| 3.15k| for(;;) { 267| 3.15k| if(length<0) { ------------------ | Branch (267:12): [True: 0, False: 3.15k] ------------------ 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.15k| } else { 274| | /* count length */ 275| 3.15k| if(length==0) { ------------------ | Branch (275:16): [True: 504, False: 2.65k] ------------------ 276| 504| break; 277| 504| } 278| 2.65k| --length; 279| 2.65k| c=*s++; 280| 2.65k| } 281| | 282| | /* 283| | * no assertions here because these functions are legitimately called 284| | * for strings with variant characters 285| | */ 286| 2.65k| if(!UCHAR_IS_INVARIANT(c)) { ------------------ | | 168| 2.65k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 2.65k, False: 0] | | | Branch (168:47): [True: 2.65k, False: 0] | | ------------------ ------------------ 287| 0| return false; /* found a variant char */ 288| 0| } 289| 2.65k| } 290| 504| return true; 291| 504|} uprv_compareInvAscii_78: 460| 78.6k| const char16_t *localString, int32_t localLength) { 461| 78.6k| (void)ds; 462| 78.6k| int32_t minLength; 463| 78.6k| UChar32 c1, c2; 464| 78.6k| uint8_t c; 465| | 466| 78.6k| if(outString==nullptr || outLength<-1 || localString==nullptr || localLength<-1) { ------------------ | Branch (466:8): [True: 0, False: 78.6k] | Branch (466:30): [True: 0, False: 78.6k] | Branch (466:46): [True: 0, False: 78.6k] | Branch (466:70): [True: 0, False: 78.6k] ------------------ 467| 0| return 0; 468| 0| } 469| | 470| 78.6k| if(outLength<0) { ------------------ | Branch (470:8): [True: 0, False: 78.6k] ------------------ 471| 0| outLength=(int32_t)uprv_strlen(outString); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 472| 0| } 473| 78.6k| if(localLength<0) { ------------------ | Branch (473:8): [True: 0, False: 78.6k] ------------------ 474| 0| localLength=u_strlen(localString); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 475| 0| } 476| | 477| 78.6k| minLength= outLength0) { ------------------ | Branch (479:11): [True: 203k, False: 413] ------------------ 480| 203k| c=(uint8_t)*outString++; 481| 203k| if(UCHAR_IS_INVARIANT(c)) { ------------------ | | 168| 203k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 203k, False: 0] | | | Branch (168:47): [True: 203k, False: 0] | | ------------------ ------------------ 482| 203k| c1=c; 483| 203k| } else { 484| 0| c1=-1; 485| 0| } 486| | 487| 203k| c2=*localString++; 488| 203k| if(!UCHAR_IS_INVARIANT(c2)) { ------------------ | | 168| 203k|#define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0) | | ------------------ | | | Branch (168:32): [True: 203k, False: 0] | | | Branch (168:47): [True: 203k, False: 0] | | ------------------ ------------------ 489| 0| c2=-2; 490| 0| } 491| | 492| 203k| if((c1-=c2)!=0) { ------------------ | Branch (492:12): [True: 78.2k, False: 125k] ------------------ 493| 78.2k| return c1; 494| 78.2k| } 495| | 496| 125k| --minLength; 497| 125k| } 498| | 499| | /* strings start with same prefix, compare lengths */ 500| 413| return outLength-localLength; 501| 78.6k|} locale_getKeywordsStart_78: 526| 3.33k|locale_getKeywordsStart(std::string_view localeID) { 527| 3.33k| if (size_t pos = localeID.find('@'); pos != std::string_view::npos) { ------------------ | Branch (527:42): [True: 2.13k, False: 1.19k] ------------------ 528| 2.13k| return localeID.data() + pos; 529| 2.13k| } 530| |#if (U_CHARSET_FAMILY == U_EBCDIC_FAMILY) 531| | else { 532| | /* We do this because the @ sign is variant, and the @ sign used on one 533| | EBCDIC machine won't be compiled the same way on other EBCDIC based 534| | machines. */ 535| | static const uint8_t ebcdicSigns[] = { 0x7C, 0x44, 0x66, 0x80, 0xAC, 0xAE, 0xAF, 0xB5, 0xEC, 0xEF, 0x00 }; 536| | const uint8_t *charToFind = ebcdicSigns; 537| | while(*charToFind) { 538| | if (size_t pos = localeID.find(*charToFind); pos != std::string_view::npos) { 539| | return localeID.data() + pos; 540| | } 541| | charToFind++; 542| | } 543| | } 544| |#endif 545| 1.19k| return nullptr; 546| 3.33k|} _Z22ulocimp_getKeywords_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEcbR10UErrorCode: 596| 2.13k|{ 597| 2.13k| return ByteSinkUtil::viaByteSinkToCharString( 598| 2.13k| [&](ByteSink& sink, UErrorCode& status) { 599| 2.13k| ulocimp_getKeywords(localeID, 600| 2.13k| prev, 601| 2.13k| sink, 602| 2.13k| valuesToo, 603| 2.13k| status); 604| 2.13k| }, 605| 2.13k| status); 606| 2.13k|} _Z22ulocimp_getKeywords_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEcRN6icu_788ByteSinkEbR10UErrorCode: 614| 2.13k|{ 615| 2.13k| if (U_FAILURE(status)) { return; } ------------------ | Branch (615:9): [True: 0, False: 2.13k] ------------------ 616| | 617| 2.13k| KeywordStruct keywordList[ULOC_MAX_NO_KEYWORDS]; 618| | 619| 2.13k| int32_t maxKeywords = ULOC_MAX_NO_KEYWORDS; ------------------ | | 523| 2.13k|#define ULOC_MAX_NO_KEYWORDS 25 ------------------ 620| 2.13k| int32_t numKeywords = 0; 621| 2.13k| size_t equalSign = std::string_view::npos; 622| 2.13k| size_t semicolon = std::string_view::npos; 623| 2.13k| int32_t i = 0, j, n; 624| | 625| 2.13k| if(prev == '@') { /* start of keyword definition */ ------------------ | Branch (625:8): [True: 2.13k, False: 0] ------------------ 626| | /* we will grab pairs, trim spaces, lowercase keywords, sort and return */ 627| 12.9k| do { 628| 12.9k| bool duplicate = false; 629| | /* skip leading spaces */ 630| 19.0k| while (localeID.front() == ' ') { ------------------ | Branch (630:20): [True: 6.02k, False: 12.9k] ------------------ 631| 6.02k| localeID.remove_prefix(1); 632| 6.02k| } 633| 12.9k| if (localeID.empty()) { /* handle trailing "; " */ ------------------ | Branch (633:17): [True: 46, False: 12.9k] ------------------ 634| 46| break; 635| 46| } 636| 12.9k| if(numKeywords == maxKeywords) { ------------------ | Branch (636:16): [True: 168, False: 12.7k] ------------------ 637| 168| status = U_INTERNAL_PROGRAM_ERROR; 638| 168| return; 639| 168| } 640| 12.7k| equalSign = localeID.find('='); 641| 12.7k| semicolon = localeID.find(';'); 642| | /* lack of '=' [foo@currency] is illegal */ 643| | /* ';' before '=' [foo@currency;collation=pinyin] is illegal */ 644| 12.7k| if (equalSign == std::string_view::npos || ------------------ | Branch (644:17): [True: 48, False: 12.7k] ------------------ 645| 12.7k| (semicolon != std::string_view::npos && semicolon < equalSign)) { ------------------ | Branch (645:18): [True: 10.9k, False: 1.79k] | Branch (645:57): [True: 14, False: 10.9k] ------------------ 646| 62| status = U_INVALID_FORMAT_ERROR; 647| 62| return; 648| 62| } 649| | /* zero-length keyword is an error. */ 650| 12.7k| if (equalSign == 0) { ------------------ | Branch (650:17): [True: 23, False: 12.6k] ------------------ 651| 23| status = U_INVALID_FORMAT_ERROR; 652| 23| return; 653| 23| } 654| | /* need to normalize both keyword and keyword name */ 655| 12.6k| if (equalSign >= ULOC_KEYWORD_BUFFER_LEN) { ------------------ | | 522| 12.6k|#define ULOC_KEYWORD_BUFFER_LEN 25 ------------------ | Branch (655:17): [True: 55, False: 12.6k] ------------------ 656| | /* keyword name too long for internal buffer */ 657| 55| status = U_INTERNAL_PROGRAM_ERROR; 658| 55| return; 659| 55| } 660| 55.3k| for (i = 0, n = 0; static_cast(i) < equalSign; ++i) { ------------------ | Branch (660:32): [True: 42.6k, False: 12.6k] ------------------ 661| 42.6k| if (localeID[i] != ' ') { ------------------ | Branch (661:21): [True: 42.2k, False: 367] ------------------ 662| 42.2k| keywordList[numKeywords].keyword[n++] = uprv_tolower(localeID[i]); ------------------ | | 68| 42.2k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 42.2k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 42.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 42.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 42.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 663| 42.2k| } 664| 42.6k| } 665| | 666| 12.6k| keywordList[numKeywords].keyword[n] = 0; 667| 12.6k| keywordList[numKeywords].keywordLen = n; 668| | /* now grab the value part. First we skip the '=' */ 669| 12.6k| equalSign++; 670| | /* then we leading spaces */ 671| 1.60M| while (equalSign < localeID.length() && localeID[equalSign] == ' ') { ------------------ | Branch (671:20): [True: 1.60M, False: 32] | Branch (671:53): [True: 1.59M, False: 12.6k] ------------------ 672| 1.59M| equalSign++; 673| 1.59M| } 674| | 675| | /* Premature end or zero-length value */ 676| 12.6k| if (equalSign == localeID.length() || equalSign == semicolon) { ------------------ | Branch (676:17): [True: 32, False: 12.6k] | Branch (676:51): [True: 7, False: 12.5k] ------------------ 677| 39| status = U_INVALID_FORMAT_ERROR; 678| 39| return; 679| 39| } 680| | 681| 12.5k| keywordList[numKeywords].valueStart = localeID.data() + equalSign; 682| | 683| 12.5k| std::string_view value = localeID; 684| 12.5k| if (semicolon != std::string_view::npos) { ------------------ | Branch (684:17): [True: 10.8k, False: 1.72k] ------------------ 685| 10.8k| value.remove_suffix(value.length() - semicolon); 686| 10.8k| localeID.remove_prefix(semicolon + 1); 687| 10.8k| } else { 688| 1.72k| localeID = {}; 689| 1.72k| } 690| 12.5k| value.remove_prefix(equalSign); 691| 12.5k| if (size_t last = value.find_last_not_of(' '); last != std::string_view::npos) { ------------------ | Branch (691:60): [True: 12.5k, False: 0] ------------------ 692| 12.5k| value.remove_suffix(value.length() - last - 1); 693| 12.5k| } 694| 12.5k| keywordList[numKeywords].valueLen = static_cast(value.length()); 695| | 696| | /* If this is a duplicate keyword, then ignore it */ 697| 96.3k| for (j=0; j 0) { ------------------ | Branch (1564:13): [True: 2.17k, False: 1.25k] ------------------ 1565| 2.17k| localeID.remove_prefix(len); 1566| 2.17k| } 1567| 3.43k| } 1568| | 1569| 3.43k| if (pEnd != nullptr) { ------------------ | Branch (1569:9): [True: 3.43k, False: 0] ------------------ 1570| 3.43k| *pEnd = localeID.data(); 1571| 3.43k| } else if (script == nullptr && ------------------ | Branch (1571:16): [True: 0, False: 0] ------------------ 1572| 0| region == nullptr && ------------------ | Branch (1572:16): [True: 0, False: 0] ------------------ 1573| 0| variant == nullptr) { ------------------ | Branch (1573:16): [True: 0, False: 0] ------------------ 1574| 0| return; 1575| 0| } 1576| | 1577| 3.43k| if (localeID.empty()) { return; } ------------------ | Branch (1577:9): [True: 456, False: 2.97k] ------------------ 1578| | 1579| 2.97k| if (_isIDSeparator(localeID.front())) { ------------------ | Branch (1579:9): [True: 1.01k, False: 1.96k] ------------------ 1580| 1.01k| std::string_view sub = localeID; 1581| 1.01k| sub.remove_prefix(1); 1582| 1.01k| size_t len = _getScript(sub, script); 1583| 1.01k| if (len > 0) { ------------------ | Branch (1583:13): [True: 40, False: 976] ------------------ 1584| 40| localeID.remove_prefix(len + 1); 1585| 40| if (pEnd != nullptr) { *pEnd = localeID.data(); } ------------------ | Branch (1585:17): [True: 40, False: 0] ------------------ 1586| 40| } 1587| 1.01k| } 1588| | 1589| 2.97k| if ((region == nullptr && variant == nullptr && pEnd == nullptr) || localeID.empty()) { return; } ------------------ | Branch (1589:10): [True: 2.97k, False: 0] | Branch (1589:31): [True: 2.97k, False: 0] | Branch (1589:53): [True: 0, False: 2.97k] | Branch (1589:73): [True: 11, False: 2.96k] ------------------ 1590| | 1591| 2.96k| if (_isIDSeparator(localeID.front())) { ------------------ | Branch (1591:9): [True: 979, False: 1.98k] ------------------ 1592| 979| std::string_view sub = localeID; 1593| 979| sub.remove_prefix(1); 1594| 979| size_t len = _getRegion(sub, region); 1595| 979| if (len > 0) { ------------------ | Branch (1595:13): [True: 47, False: 932] ------------------ 1596| 47| hasRegion = true; 1597| 47| localeID.remove_prefix(len + 1); 1598| 47| if (pEnd != nullptr) { *pEnd = localeID.data(); } ------------------ | Branch (1598:17): [True: 47, False: 0] ------------------ 1599| 47| } 1600| 979| } 1601| | 1602| 2.96k| if ((variant == nullptr && pEnd == nullptr) || localeID.empty()) { return; } ------------------ | Branch (1602:10): [True: 2.96k, False: 0] | Branch (1602:32): [True: 0, False: 2.96k] | Branch (1602:52): [True: 18, False: 2.95k] ------------------ 1603| | 1604| 2.95k| bool hasVariant = false; 1605| | 1606| 2.95k| if (_isIDSeparator(localeID.front()) && !_isBCP47Extension(localeID)) { ------------------ | Branch (1606:9): [True: 942, False: 2.00k] | Branch (1606:45): [True: 765, False: 177] ------------------ 1607| 765| std::string_view sub = localeID; 1608| | /* If there was no country ID, skip a possible extra IDSeparator */ 1609| 765| size_t skip = !hasRegion && localeID.size() > 1 && _isIDSeparator(localeID[1]) ? 2 : 1; ------------------ | Branch (1609:23): [True: 755, False: 10] | Branch (1609:37): [True: 710, False: 45] | Branch (1609:60): [True: 379, False: 331] ------------------ 1610| 765| sub.remove_prefix(skip); 1611| 765| size_t len = _getVariant(sub, localeID[0], variant, false, status); 1612| 765| if (U_FAILURE(status)) { return; } ------------------ | Branch (1612:13): [True: 106, False: 659] ------------------ 1613| 659| if (len > 0) { ------------------ | Branch (1613:13): [True: 593, False: 66] ------------------ 1614| 593| hasVariant = true; 1615| 593| localeID.remove_prefix(skip + len); 1616| 593| if (pEnd != nullptr) { *pEnd = localeID.data(); } ------------------ | Branch (1616:17): [True: 593, False: 0] ------------------ 1617| 593| } 1618| 659| } 1619| | 1620| 2.84k| if ((variant == nullptr && pEnd == nullptr) || localeID.empty()) { return; } ------------------ | Branch (1620:10): [True: 2.84k, False: 0] | Branch (1620:32): [True: 0, False: 2.84k] | Branch (1620:52): [True: 489, False: 2.35k] ------------------ 1621| | 1622| 2.35k| if (_isBCP47Extension(localeID)) { ------------------ | Branch (1622:9): [True: 198, False: 2.15k] ------------------ 1623| 198| localeID.remove_prefix(2); 1624| 198| constexpr char vaposix[] = "-va-posix"; 1625| 198| constexpr size_t length = sizeof vaposix - 1; 1626| 350k| for (size_t next;; localeID.remove_prefix(next)) { 1627| 350k| next = localeID.find('-', 1); 1628| 350k| if (next == std::string_view::npos) { break; } ------------------ | Branch (1628:17): [True: 71, False: 350k] ------------------ 1629| 350k| next = localeID.find('-', next + 1); 1630| 350k| bool finished = next == std::string_view::npos; 1631| 350k| std::string_view sub = localeID; 1632| 350k| if (!finished) { sub.remove_suffix(sub.length() - next); } ------------------ | Branch (1632:17): [True: 350k, False: 127] ------------------ 1633| | 1634| 350k| if (sub.length() == length && uprv_strnicmp(sub.data(), vaposix, length) == 0) { ------------------ | | 1544| 72.3k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 72.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 72.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 72.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1634:17): [True: 72.3k, False: 277k] | Branch (1634:43): [True: 807, False: 71.5k] ------------------ 1635| 807| if (variant != nullptr) { ------------------ | Branch (1635:21): [True: 0, False: 807] ------------------ 1636| 0| if (hasVariant) { variant->Append("_", 1); } ------------------ | Branch (1636:25): [True: 0, False: 0] ------------------ 1637| 0| constexpr char posix[] = "POSIX"; 1638| 0| variant->Append(posix, sizeof posix - 1); 1639| 0| } 1640| 807| if (pEnd != nullptr) { *pEnd = localeID.data() + length; } ------------------ | Branch (1640:21): [True: 807, False: 0] ------------------ 1641| 807| } 1642| | 1643| 350k| if (finished) { break; } ------------------ | Branch (1643:17): [True: 127, False: 350k] ------------------ 1644| 350k| } 1645| 198| } 1646| 2.35k|} uloc_openKeywordList_78: 1714| 1.79k|{ 1715| 1.79k| if (U_FAILURE(*status)) { return nullptr; } ------------------ | Branch (1715:9): [True: 0, False: 1.79k] ------------------ 1716| | 1717| 1.79k| LocalMemory myContext; 1718| 1.79k| LocalMemory result; 1719| | 1720| 1.79k| myContext.adoptInstead(static_cast(uprv_malloc(sizeof(UKeywordsContext)))); ------------------ | | 1524| 1.79k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1721| 1.79k| result.adoptInstead(static_cast(uprv_malloc(sizeof(UEnumeration)))); ------------------ | | 1524| 1.79k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1722| 1.79k| if (myContext.isNull() || result.isNull()) { ------------------ | Branch (1722:9): [True: 0, False: 1.79k] | Branch (1722:31): [True: 0, False: 1.79k] ------------------ 1723| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1724| 0| return nullptr; 1725| 0| } 1726| 1.79k| uprv_memcpy(result.getAlias(), &gKeywordsEnum, sizeof(UEnumeration)); ------------------ | | 42| 1.79k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.79k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.79k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.79k| _Pragma("clang diagnostic push") \ | | 45| 1.79k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.79k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.79k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.79k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.79k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.79k| _Pragma("clang diagnostic pop") \ | | 49| 1.79k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.79k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.79k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.79k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1727| 1.79k| myContext->keywords = static_cast(uprv_malloc(keywordListSize+1)); ------------------ | | 1524| 1.79k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1728| 1.79k| if (myContext->keywords == nullptr) { ------------------ | Branch (1728:9): [True: 0, False: 1.79k] ------------------ 1729| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1730| 0| return nullptr; 1731| 0| } 1732| 1.79k| uprv_memcpy(myContext->keywords, keywordList, keywordListSize); ------------------ | | 42| 1.79k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.79k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 1.79k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 1.79k| _Pragma("clang diagnostic push") \ | | 45| 1.79k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 1.79k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 1.79k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 1.79k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 1.79k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 1.79k| _Pragma("clang diagnostic pop") \ | | 49| 1.79k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 1.79k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 1.79k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.79k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1733| 1.79k| myContext->keywords[keywordListSize] = 0; 1734| 1.79k| myContext->current = myContext->keywords; 1735| 1.79k| result->context = myContext.orphan(); 1736| 1.79k| return result.orphan(); 1737| 1.79k|} uloc_openKeywords_78: 1742| 3.55k|{ 1743| 3.55k| if(status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (1743:8): [True: 0, False: 3.55k] | Branch (1743:27): [True: 0, False: 3.55k] ------------------ 1744| 0| return nullptr; 1745| 0| } 1746| | 1747| 3.55k| CharString tempBuffer; 1748| 3.55k| const char* tmpLocaleID; 1749| | 1750| 3.55k| if (localeID != nullptr && _hasBCP47Extension(localeID)) { ------------------ | Branch (1750:9): [True: 3.55k, False: 0] | Branch (1750:32): [True: 2.52k, False: 1.02k] ------------------ 1751| 2.52k| tempBuffer = ulocimp_forLanguageTag(localeID, -1, nullptr, *status); ------------------ | | 1198| 2.52k|#define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag) | | ------------------ | | | | 123| 2.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1752| 2.52k| tmpLocaleID = U_SUCCESS(*status) && !tempBuffer.isEmpty() ? tempBuffer.data() : localeID; ------------------ | Branch (1752:23): [True: 2.52k, False: 0] | Branch (1752:45): [True: 1.93k, False: 587] ------------------ 1753| 2.52k| } else { 1754| 1.02k| if (localeID==nullptr) { ------------------ | Branch (1754:13): [True: 0, False: 1.02k] ------------------ 1755| 0| localeID=uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1756| 0| } 1757| 1.02k| tmpLocaleID=localeID; 1758| 1.02k| } 1759| | 1760| 3.55k| ulocimp_getSubtags( ------------------ | | 1209| 3.55k|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 3.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1761| 3.55k| tmpLocaleID, 1762| 3.55k| nullptr, 1763| 3.55k| nullptr, 1764| 3.55k| nullptr, 1765| 3.55k| nullptr, 1766| 3.55k| &tmpLocaleID, 1767| 3.55k| *status); 1768| 3.55k| if (U_FAILURE(*status)) { ------------------ | Branch (1768:9): [True: 220, False: 3.33k] ------------------ 1769| 220| return nullptr; 1770| 220| } 1771| | 1772| | /* keywords are located after '@' */ 1773| 3.33k| if((tmpLocaleID = locale_getKeywordsStart(tmpLocaleID)) != nullptr) { ------------------ | | 138| 3.33k|#define locale_getKeywordsStart U_ICU_ENTRY_POINT_RENAME(locale_getKeywordsStart) | | ------------------ | | | | 123| 3.33k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.33k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.33k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1773:8): [True: 2.13k, False: 1.19k] ------------------ 1774| 2.13k| CharString keywords = ulocimp_getKeywords(tmpLocaleID + 1, '@', false, *status); ------------------ | | 1201| 2.13k|#define ulocimp_getKeywords U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywords) | | ------------------ | | | | 123| 2.13k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.13k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.13k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1775| 2.13k| if (U_FAILURE(*status)) { ------------------ | Branch (1775:13): [True: 347, False: 1.79k] ------------------ 1776| 347| return nullptr; 1777| 347| } 1778| 1.79k| return uloc_openKeywordList(keywords.data(), keywords.length(), status); ------------------ | | 1143| 1.79k|#define uloc_openKeywordList U_ICU_ENTRY_POINT_RENAME(uloc_openKeywordList) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1779| 2.13k| } 1780| 1.19k| return nullptr; 1781| 3.33k|} _Z34ulocimp_toLegacyKeyWithFallback_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEE: 2456| 1.70M|{ 2457| 1.70M| std::optional legacyKey = ulocimp_toLegacyKey(keyword); ------------------ | | 1219| 1.70M|#define ulocimp_toLegacyKey U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyKey) | | ------------------ | | | | 123| 1.70M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.70M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.70M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2458| 1.70M| if (!legacyKey.has_value() && isWellFormedLegacyKey(keyword)) { ------------------ | Branch (2458:9): [True: 1.68M, False: 25.7k] | Branch (2458:35): [True: 1.68M, False: 0] ------------------ 2459| | // Checks if the specified locale key is well-formed with the legacy locale syntax. 2460| | // 2461| | // Note: 2462| | // LDML/CLDR provides some definition of keyword syntax in 2463| | // * http://www.unicode.org/reports/tr35/#Unicode_locale_identifier and 2464| | // * http://www.unicode.org/reports/tr35/#Old_Locale_Extension_Syntax 2465| | // Keys can only consist of [0-9a-zA-Z]. 2466| 1.68M| return keyword; 2467| 1.68M| } 2468| 25.7k| return legacyKey; 2469| 1.70M|} _Z35ulocimp_toLegacyTypeWithFallback_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_: 2482| 16.2k|{ 2483| 16.2k| std::optional legacyType = ulocimp_toLegacyType(keyword, value); ------------------ | | 1221| 16.2k|#define ulocimp_toLegacyType U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyType) | | ------------------ | | | | 123| 16.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 16.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 16.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2484| 16.2k| if (!legacyType.has_value() && isWellFormedLegacyType(value)) { ------------------ | Branch (2484:9): [True: 13.4k, False: 2.77k] | Branch (2484:36): [True: 13.4k, False: 0] ------------------ 2485| | // Checks if the specified locale type is well-formed with the legacy locale syntax. 2486| | // 2487| | // Note: 2488| | // LDML/CLDR provides some definition of keyword syntax in 2489| | // * http://www.unicode.org/reports/tr35/#Unicode_locale_identifier and 2490| | // * http://www.unicode.org/reports/tr35/#Old_Locale_Extension_Syntax 2491| | // Values (types) can only consist of [0-9a-zA-Z], plus for legacy values 2492| | // we allow [/_-+] in the middle (e.g. "Etc/GMT+1", "Asia/Tel_Aviv") 2493| 13.4k| return value; 2494| 13.4k| } 2495| 2.77k| return legacyType; 2496| 16.2k|} uloc.cpp:_ZN12_GLOBAL__N_121compareKeywordStructsEPKvS1_S1_: 583| 18.1k|compareKeywordStructs(const void * /*context*/, const void *left, const void *right) { 584| 18.1k| const char* leftString = static_cast(left)->keyword; 585| 18.1k| const char* rightString = static_cast(right)->keyword; 586| 18.1k| return uprv_strcmp(leftString, rightString); ------------------ | | 38| 18.1k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 18.1k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 587| 18.1k|} uloc.cpp:_ZN12_GLOBAL__N_118_hasBCP47ExtensionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 510| 3.55k|inline bool _hasBCP47Extension(std::string_view id) { 511| 3.55k| return id.find('@') == std::string_view::npos && getShortestSubtagLength(id) == 1; ------------------ | Branch (511:12): [True: 2.78k, False: 762] | Branch (511:54): [True: 2.52k, False: 264] ------------------ 512| 3.55k|} uloc.cpp:_ZN12_GLOBAL__N_123getShortestSubtagLengthENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 485| 2.78k|int32_t getShortestSubtagLength(std::string_view localeID) { 486| 2.78k| int32_t localeIDLength = static_cast(localeID.length()); 487| 2.78k| int32_t length = localeIDLength; 488| 2.78k| int32_t tmpLength = 0; 489| 2.78k| int32_t i; 490| 2.78k| bool reset = true; 491| | 492| 94.0M| for (i = 0; i < localeIDLength; i++) { ------------------ | Branch (492:17): [True: 94.0M, False: 2.78k] ------------------ 493| 94.0M| if (localeID[i] != '_' && localeID[i] != '-') { ------------------ | Branch (493:13): [True: 94.0M, False: 24.0k] | Branch (493:35): [True: 82.8M, False: 11.2M] ------------------ 494| 82.8M| if (reset) { ------------------ | Branch (494:17): [True: 11.2M, False: 71.5M] ------------------ 495| 11.2M| tmpLength = 0; 496| 11.2M| reset = false; 497| 11.2M| } 498| 82.8M| tmpLength++; 499| 82.8M| } else { 500| 11.2M| if (tmpLength != 0 && tmpLength < length) { ------------------ | Branch (500:17): [True: 11.2M, False: 1.58k] | Branch (500:35): [True: 4.42k, False: 11.2M] ------------------ 501| 4.42k| length = tmpLength; 502| 4.42k| } 503| 11.2M| reset = true; 504| 11.2M| } 505| 94.0M| } 506| | 507| 2.78k| return length; 508| 2.78k|} uloc.cpp:_ZN12_GLOBAL__N_115UPRV_ISALPHANUMEc: 516| 4.01M|inline bool UPRV_ISALPHANUM(char c) { return uprv_isASCIILetter(c) || UPRV_ISDIGIT(c); } ------------------ | | 1514| 4.01M|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 4.01M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4.01M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4.01M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (516:46): [True: 3.41M, False: 602k] | Branch (516:71): [True: 602k, False: 0] ------------------ uloc.cpp:_ZN12_GLOBAL__N_112UPRV_ISDIGITEc: 515| 602k|inline bool UPRV_ISDIGIT(char c) { return c >= '0' && c <= '9'; } ------------------ | Branch (515:43): [True: 602k, False: 0] | Branch (515:55): [True: 602k, False: 0] ------------------ uloc.cpp:_ZN12_GLOBAL__N_112_getLanguageENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPN6icu_788ByteSinkER10UErrorCode: 1219| 3.54k|size_t _getLanguage(std::string_view localeID, ByteSink* sink, UErrorCode& status) { 1220| 3.54k| size_t skip = 0; 1221| 3.54k| if (localeID.size() == 4 && uprv_strnicmp(localeID.data(), "root", 4) == 0) { ------------------ | | 1544| 93|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 93|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 93|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 93|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1221:9): [True: 93, False: 3.45k] | Branch (1221:33): [True: 1, False: 92] ------------------ 1222| 1| skip = 4; 1223| 1| localeID.remove_prefix(skip); 1224| 3.54k| } else if (localeID.size() >= 3 && uprv_strnicmp(localeID.data(), "und", 3) == 0 && ------------------ | | 1544| 3.15k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 3.15k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.15k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.15k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1224:16): [True: 3.15k, False: 394] | Branch (1224:40): [True: 48, False: 3.10k] ------------------ 1225| 3.54k| (localeID.size() == 3 || ------------------ | Branch (1225:17): [True: 2, False: 46] ------------------ 1226| 48| localeID[3] == '-' || ------------------ | Branch (1226:17): [True: 2, False: 44] ------------------ 1227| 48| localeID[3] == '_' || ------------------ | Branch (1227:17): [True: 2, False: 42] ------------------ 1228| 48| localeID[3] == '@')) { ------------------ | Branch (1228:17): [True: 8, False: 34] ------------------ 1229| 14| skip = 3; 1230| 14| localeID.remove_prefix(skip); 1231| 14| } 1232| | 1233| 3.54k| constexpr int32_t MAXLEN = ULOC_LANG_CAPACITY - 1; // Minus NUL. ------------------ | | 251| 3.54k|#define ULOC_LANG_CAPACITY 12 ------------------ 1234| | 1235| | /* if it starts with i- or x- then copy that prefix */ 1236| 3.54k| size_t len = _isIDPrefix(localeID) ? 2 : 0; ------------------ | Branch (1236:18): [True: 189, False: 3.36k] ------------------ 1237| 9.82k| while (len < localeID.size() && !_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len])) { ------------------ | Branch (1237:12): [True: 9.36k, False: 456] | Branch (1237:37): [True: 7.40k, False: 1.96k] | Branch (1237:70): [True: 6.38k, False: 1.01k] ------------------ 1238| 6.38k| if (len == MAXLEN) { ------------------ | Branch (1238:13): [True: 114, False: 6.27k] ------------------ 1239| 114| status = U_ILLEGAL_ARGUMENT_ERROR; 1240| 114| return 0; 1241| 114| } 1242| 6.27k| len++; 1243| 6.27k| } 1244| | 1245| 3.43k| if (sink == nullptr || len == 0) { return skip + len; } ------------------ | Branch (1245:9): [True: 3.43k, False: 0] | Branch (1245:28): [True: 0, False: 0] ------------------ 1246| | 1247| 0| int32_t minCapacity = uprv_max(static_cast(len), 4); // Minimum 3 letters plus NUL. ------------------ | | 1526| 0|#define uprv_max U_ICU_ENTRY_POINT_RENAME(uprv_max) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1248| 0| char scratch[MAXLEN]; 1249| 0| int32_t capacity = 0; 1250| 0| char* buffer = sink->GetAppendBuffer( 1251| 0| minCapacity, minCapacity, scratch, UPRV_LENGTHOF(scratch), &capacity); ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1252| | 1253| 0| for (size_t i = 0; i < len; ++i) { ------------------ | Branch (1253:24): [True: 0, False: 0] ------------------ 1254| 0| buffer[i] = uprv_tolower(localeID[i]); ------------------ | | 68| 0|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 0|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 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 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1255| 0| } 1256| 0| if (localeID.size() >= 2 && _isIDSeparator(localeID[1])) { ------------------ | Branch (1256:9): [True: 0, False: 0] | Branch (1256:33): [True: 0, False: 0] ------------------ 1257| 0| buffer[1] = '-'; 1258| 0| } 1259| | 1260| 0| if (len == 3) { ------------------ | Branch (1260:9): [True: 0, False: 0] ------------------ 1261| | /* convert 3 character code to 2 character code if possible *CWB*/ 1262| 0| U_ASSERT(capacity >= 4); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1263| 0| buffer[3] = '\0'; 1264| 0| std::optional offset = _findIndex(LANGUAGES_3, buffer); 1265| 0| if (offset.has_value()) { ------------------ | Branch (1265:13): [True: 0, False: 0] ------------------ 1266| 0| const char* const alias = LANGUAGES[*offset]; 1267| 0| sink->Append(alias, static_cast(uprv_strlen(alias))); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1268| 0| return skip + len; 1269| 0| } 1270| 0| } 1271| | 1272| 0| sink->Append(buffer, static_cast(len)); 1273| 0| return skip + len; 1274| 0|} uloc.cpp:_ZN12_GLOBAL__N_111_isIDPrefixENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 1152| 3.54k|inline bool _isIDPrefix(std::string_view s) { 1153| 3.54k| return s.size() >= 2 && _isPrefixLetter(s[0]) && _isIDSeparator(s[1]); ------------------ | Branch (1153:12): [True: 3.51k, False: 36] | Branch (1153:29): [True: 448, False: 3.06k] | Branch (1153:54): [True: 189, False: 259] ------------------ 1154| 3.54k|} uloc.cpp:_ZN12_GLOBAL__N_115_isPrefixLetterEc: 1148| 3.51k|inline bool _isPrefixLetter(char a) { return a == 'x' || a == 'X' || a == 'i' || a == 'I'; } ------------------ | Branch (1148:46): [True: 237, False: 3.27k] | Branch (1148:58): [True: 115, False: 3.16k] | Branch (1148:70): [True: 93, False: 3.06k] | Branch (1148:82): [True: 3, False: 3.06k] ------------------ uloc.cpp:_ZN12_GLOBAL__N_113_isTerminatorEc: 1159| 17.2k|inline bool _isTerminator(char a) { return a == '.' || a == '@'; } ------------------ | Branch (1159:44): [True: 62, False: 17.1k] | Branch (1159:56): [True: 2.08k, False: 15.0k] ------------------ uloc.cpp:_ZN12_GLOBAL__N_110_getScriptENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPN6icu_788ByteSinkE: 1276| 1.01k|size_t _getScript(std::string_view localeID, ByteSink* sink) { 1277| 1.01k| constexpr int32_t LENGTH = 4; 1278| | 1279| 1.01k| size_t len = 0; 1280| 1.74k| while (len < localeID.size() && !_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len]) && ------------------ | Branch (1280:12): [True: 1.67k, False: 77] | Branch (1280:37): [True: 1.62k, False: 45] | Branch (1280:70): [True: 996, False: 631] ------------------ 1281| 1.74k| uprv_isASCIILetter(localeID[len])) { ------------------ | | 1514| 996|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 996|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 996|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 996|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1281:13): [True: 784, False: 212] ------------------ 1282| 784| if (len == LENGTH) { return 0; } ------------------ | Branch (1282:13): [True: 51, False: 733] ------------------ 1283| 733| len++; 1284| 733| } 1285| 965| if (len != LENGTH) { return 0; } ------------------ | Branch (1285:9): [True: 925, False: 40] ------------------ 1286| | 1287| 40| if (sink == nullptr) { return len; } ------------------ | Branch (1287:9): [True: 40, False: 0] ------------------ 1288| | 1289| 0| char scratch[LENGTH]; 1290| 0| int32_t capacity = 0; 1291| 0| char* buffer = sink->GetAppendBuffer( 1292| 0| LENGTH, LENGTH, scratch, UPRV_LENGTHOF(scratch), &capacity); ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1293| | 1294| 0| buffer[0] = uprv_toupper(localeID[0]); ------------------ | | 1547| 0|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1295| 0| for (int32_t i = 1; i < LENGTH; ++i) { ------------------ | Branch (1295:25): [True: 0, False: 0] ------------------ 1296| 0| buffer[i] = uprv_tolower(localeID[i]); ------------------ | | 68| 0|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 0|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 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 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 0| } 1298| | 1299| 0| sink->Append(buffer, LENGTH); 1300| 0| return len; 1301| 40|} uloc.cpp:_ZN12_GLOBAL__N_110_getRegionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPN6icu_788ByteSinkE: 1303| 979|size_t _getRegion(std::string_view localeID, ByteSink* sink) { 1304| 979| constexpr int32_t MINLEN = 2; 1305| 979| constexpr int32_t MAXLEN = ULOC_COUNTRY_CAPACITY - 1; // Minus NUL. ------------------ | | 258| 979|#define ULOC_COUNTRY_CAPACITY 4 ------------------ 1306| | 1307| 979| size_t len = 0; 1308| 1.83k| while (len < localeID.size() && !_isTerminator(localeID[len]) && !_isIDSeparator(localeID[len])) { ------------------ | Branch (1308:12): [True: 1.72k, False: 113] | Branch (1308:37): [True: 1.67k, False: 44] | Branch (1308:70): [True: 990, False: 689] ------------------ 1309| 990| if (len == MAXLEN) { return 0; } ------------------ | Branch (1309:13): [True: 133, False: 857] ------------------ 1310| 857| len++; 1311| 857| } 1312| 846| if (len < MINLEN) { return 0; } ------------------ | Branch (1312:9): [True: 799, False: 47] ------------------ 1313| | 1314| 47| if (sink == nullptr) { return len; } ------------------ | Branch (1314:9): [True: 47, False: 0] ------------------ 1315| | 1316| 0| char scratch[ULOC_COUNTRY_CAPACITY]; 1317| 0| int32_t capacity = 0; 1318| 0| char* buffer = sink->GetAppendBuffer( 1319| 0| ULOC_COUNTRY_CAPACITY, ------------------ | | 258| 0|#define ULOC_COUNTRY_CAPACITY 4 ------------------ 1320| 0| ULOC_COUNTRY_CAPACITY, ------------------ | | 258| 0|#define ULOC_COUNTRY_CAPACITY 4 ------------------ 1321| 0| scratch, 1322| 0| UPRV_LENGTHOF(scratch), ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1323| 0| &capacity); 1324| | 1325| 0| for (size_t i = 0; i < len; ++i) { ------------------ | Branch (1325:24): [True: 0, False: 0] ------------------ 1326| 0| buffer[i] = uprv_toupper(localeID[i]); ------------------ | | 1547| 0|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1327| 0| } 1328| | 1329| 0| if (len == 3) { ------------------ | Branch (1329:9): [True: 0, False: 0] ------------------ 1330| | /* convert 3 character code to 2 character code if possible *CWB*/ 1331| 0| U_ASSERT(capacity >= 4); ------------------ | | 35| 0|# define U_ASSERT(exp) (void)0 ------------------ 1332| 0| buffer[3] = '\0'; 1333| 0| std::optional offset = _findIndex(COUNTRIES_3, buffer); 1334| 0| if (offset.has_value()) { ------------------ | Branch (1334:13): [True: 0, False: 0] ------------------ 1335| 0| const char* const alias = COUNTRIES[*offset]; 1336| 0| sink->Append(alias, static_cast(uprv_strlen(alias))); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1337| 0| return len; 1338| 0| } 1339| 0| } 1340| | 1341| 0| sink->Append(buffer, static_cast(len)); 1342| 0| return len; 1343| 0|} uloc.cpp:_ZN12_GLOBAL__N_117_isBCP47ExtensionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 1161| 7.64k|inline bool _isBCP47Extension(std::string_view p) { 1162| 7.64k| return p.size() >= 3 && ------------------ | Branch (1162:12): [True: 7.37k, False: 267] ------------------ 1163| 7.64k| p[0] == '-' && ------------------ | Branch (1163:12): [True: 2.01k, False: 5.35k] ------------------ 1164| 7.64k| (p[1] == 't' || p[1] == 'T' || ------------------ | Branch (1164:13): [True: 147, False: 1.86k] | Branch (1164:28): [True: 135, False: 1.73k] ------------------ 1165| 2.01k| p[1] == 'u' || p[1] == 'U' || ------------------ | Branch (1165:13): [True: 329, False: 1.40k] | Branch (1165:28): [True: 170, False: 1.23k] ------------------ 1166| 2.01k| p[1] == 'x' || p[1] == 'X') && ------------------ | Branch (1166:13): [True: 112, False: 1.12k] | Branch (1166:28): [True: 133, False: 989] ------------------ 1167| 7.64k| p[2] == '-'; ------------------ | Branch (1167:12): [True: 397, False: 629] ------------------ 1168| 7.64k|} uloc.cpp:_ZN12_GLOBAL__N_111_getVariantENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEcPN6icu_788ByteSinkEbR10UErrorCode: 1354| 765| UErrorCode& status) { 1355| 765| if (U_FAILURE(status) || localeID.empty()) return 0; ------------------ | Branch (1355:9): [True: 0, False: 765] | Branch (1355:30): [True: 51, False: 714] ------------------ 1356| | 1357| | // Reasonable upper limit for variants 1358| | // There are no strict limitation of the syntax of variant in the legacy 1359| | // locale format. If the locale is constructed from unicode_locale_id 1360| | // as defined in UTS35, then we know each unicode_variant_subtag 1361| | // could have max length of 8 ((alphanum{5,8} | digit alphanum{3}) 1362| | // 179 would allow 20 unicode_variant_subtag with sep in the 1363| | // unicode_locale_id 1364| | // 8*20 + 1*(20-1) = 179 1365| 714| constexpr int32_t MAX_VARIANTS_LENGTH = 179; 1366| | 1367| | /* get one or more variant tags and separate them with '_' */ 1368| 714| size_t index = 0; 1369| 714| if (_isIDSeparator(prev)) { ------------------ | Branch (1369:9): [True: 714, False: 0] ------------------ 1370| | /* get a variant string after a '-' or '_' */ 1371| 5.03k| for (std::string_view sub = localeID;;) { 1372| 5.03k| size_t next = sub.find_first_of(".@_-"); 1373| | // For historical reasons, a trailing separator is included in the variant. 1374| 5.03k| bool finished = next == std::string_view::npos || next + 1 == sub.length(); ------------------ | Branch (1374:29): [True: 425, False: 4.61k] | Branch (1374:63): [True: 124, False: 4.48k] ------------------ 1375| 5.03k| size_t limit = finished ? sub.length() : next; ------------------ | Branch (1375:28): [True: 549, False: 4.48k] ------------------ 1376| 5.03k| index += limit; 1377| 5.03k| if (index > MAX_VARIANTS_LENGTH) { ------------------ | Branch (1377:17): [True: 106, False: 4.93k] ------------------ 1378| 106| status = U_ILLEGAL_ARGUMENT_ERROR; 1379| 106| return 0; 1380| 106| } 1381| | 1382| 4.93k| if (sink != nullptr) { ------------------ | Branch (1382:17): [True: 0, False: 4.93k] ------------------ 1383| 0| if (needSeparator) { ------------------ | Branch (1383:21): [True: 0, False: 0] ------------------ 1384| 0| sink->Append("_", 1); 1385| 0| } else { 1386| 0| needSeparator = true; 1387| 0| } 1388| | 1389| 0| int32_t length = static_cast(limit); 1390| 0| int32_t minCapacity = uprv_min(length, MAX_VARIANTS_LENGTH); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1391| 0| char scratch[MAX_VARIANTS_LENGTH]; 1392| 0| int32_t capacity = 0; 1393| 0| char* buffer = sink->GetAppendBuffer( 1394| 0| minCapacity, minCapacity, scratch, UPRV_LENGTHOF(scratch), &capacity); ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ 1395| | 1396| 0| for (size_t i = 0; i < limit; ++i) { ------------------ | Branch (1396:36): [True: 0, False: 0] ------------------ 1397| 0| buffer[i] = uprv_toupper(sub[i]); ------------------ | | 1547| 0|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1398| 0| } 1399| 0| sink->Append(buffer, length); 1400| 0| } 1401| | 1402| 4.93k| if (finished) { return index; } ------------------ | Branch (1402:17): [True: 489, False: 4.44k] ------------------ 1403| 4.44k| sub.remove_prefix(next); 1404| 4.44k| if (_isTerminator(sub.front()) || _isBCP47Extension(sub)) { return index; } ------------------ | Branch (1404:17): [True: 97, False: 4.34k] | Branch (1404:47): [True: 22, False: 4.32k] ------------------ 1405| 4.32k| sub.remove_prefix(1); 1406| 4.32k| index++; 1407| 4.32k| } 1408| 714| } 1409| | 1410| 0| size_t skip = 0; 1411| | /* if there is no variant tag after a '-' or '_' then look for '@' */ 1412| 0| if (prev == '@') { ------------------ | Branch (1412:9): [True: 0, False: 0] ------------------ 1413| | /* keep localeID */ 1414| 0| } else if (const char* p = locale_getKeywordsStart(localeID); p != nullptr) { ------------------ | | 138| 0|#define locale_getKeywordsStart U_ICU_ENTRY_POINT_RENAME(locale_getKeywordsStart) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1414:67): [True: 0, False: 0] ------------------ 1415| 0| skip = 1 + p - localeID.data(); /* point after the '@' */ 1416| 0| localeID.remove_prefix(skip); 1417| 0| } else { 1418| 0| return 0; 1419| 0| } 1420| 0| for (; index < localeID.size() && !_isTerminator(localeID[index]); index++) { ------------------ | Branch (1420:12): [True: 0, False: 0] | Branch (1420:39): [True: 0, False: 0] ------------------ 1421| 0| if (index >= MAX_VARIANTS_LENGTH) { // same as length > MAX_VARIANTS_LENGTH ------------------ | Branch (1421:13): [True: 0, False: 0] ------------------ 1422| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1423| 0| return 0; 1424| 0| } 1425| 0| if (needSeparator) { ------------------ | Branch (1425:13): [True: 0, False: 0] ------------------ 1426| 0| if (sink != nullptr) { ------------------ | Branch (1426:17): [True: 0, False: 0] ------------------ 1427| 0| sink->Append("_", 1); 1428| 0| } 1429| 0| needSeparator = false; 1430| 0| } 1431| 0| if (sink != nullptr) { ------------------ | Branch (1431:13): [True: 0, False: 0] ------------------ 1432| 0| char c = uprv_toupper(localeID[index]); ------------------ | | 1547| 0|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1433| 0| if (c == '-' || c == ',') c = '_'; ------------------ | Branch (1433:17): [True: 0, False: 0] | Branch (1433:29): [True: 0, False: 0] ------------------ 1434| 0| sink->Append(&c, 1); 1435| 0| } 1436| 0| } 1437| 0| return skip + index; 1438| 0|} uloc.cpp:_ZL21uloc_kw_closeKeywordsP12UEnumeration: 1658| 1.79k|uloc_kw_closeKeywords(UEnumeration *enumerator) { 1659| 1.79k| uprv_free(((UKeywordsContext *)enumerator->context)->keywords); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1660| 1.79k| uprv_free(enumerator->context); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1661| 1.79k| uprv_free(enumerator); ------------------ | | 1503| 1.79k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.79k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.79k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.79k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1662| 1.79k|} uloc.cpp:_ZN12_GLOBAL__N_121isWellFormedLegacyKeyENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 2421| 1.68M|{ 2422| 1.68M| return std::all_of(key.begin(), key.end(), UPRV_ISALPHANUM); 2423| 1.68M|} uloc.cpp:_ZN12_GLOBAL__N_122isWellFormedLegacyTypeENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 2427| 13.4k|{ 2428| 13.4k| int32_t alphaNumLen = 0; 2429| 931k| for (char c : legacyType) { ------------------ | Branch (2429:17): [True: 931k, False: 13.4k] ------------------ 2430| 931k| if (c == '_' || c == '/' || c == '-') { ------------------ | Branch (2430:13): [True: 0, False: 931k] | Branch (2430:25): [True: 0, False: 931k] | Branch (2430:37): [True: 281k, False: 650k] ------------------ 2431| 281k| if (alphaNumLen == 0) { ------------------ | Branch (2431:17): [True: 0, False: 281k] ------------------ 2432| 0| return false; 2433| 0| } 2434| 281k| alphaNumLen = 0; 2435| 650k| } else if (UPRV_ISALPHANUM(c)) { ------------------ | Branch (2435:20): [True: 650k, False: 0] ------------------ 2436| 650k| alphaNumLen++; 2437| 650k| } else { 2438| 0| return false; 2439| 0| } 2440| 931k| } 2441| 13.4k| return alphaNumLen != 0; 2442| 13.4k|} uloc.cpp:_ZZ22ulocimp_getKeywords_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEcbR10UErrorCodeENK3$_0clERN6icu_788ByteSinkES5_: 598| 2.13k| [&](ByteSink& sink, UErrorCode& status) { 599| 2.13k| ulocimp_getKeywords(localeID, ------------------ | | 1201| 2.13k|#define ulocimp_getKeywords U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywords) | | ------------------ | | | | 123| 2.13k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.13k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.13k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 600| 2.13k| prev, 601| 2.13k| sink, 602| 2.13k| valuesToo, 603| 2.13k| status); 604| 2.13k| }, _Z22ulocimp_toLegacyKey_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEE: 462| 1.70M|ulocimp_toLegacyKey(std::string_view key) { 463| 1.70M| if (!init()) { ------------------ | Branch (463:9): [True: 0, False: 1.70M] ------------------ 464| 0| return std::nullopt; 465| 0| } 466| | 467| 1.70M| LocExtKeyData* keyData = static_cast(uhash_get(gLocExtKeyMap, &key)); ------------------ | | 1007| 1.70M|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 1.70M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.70M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.70M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 468| 1.70M| if (keyData != nullptr) { ------------------ | Branch (468:9): [True: 25.7k, False: 1.68M] ------------------ 469| 25.7k| return keyData->legacyId; 470| 25.7k| } 471| | 472| 1.68M| return std::nullopt; 473| 1.70M|} _Z23ulocimp_toLegacyType_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_: 509| 16.2k|ulocimp_toLegacyType(std::string_view key, std::string_view type) { 510| 16.2k| if (!init()) { ------------------ | Branch (510:9): [True: 0, False: 16.2k] ------------------ 511| 0| return std::nullopt; 512| 0| } 513| | 514| 16.2k| LocExtKeyData* keyData = static_cast(uhash_get(gLocExtKeyMap, &key)); ------------------ | | 1007| 16.2k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 16.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 16.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 16.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 515| 16.2k| if (keyData != nullptr) { ------------------ | Branch (515:9): [True: 12.8k, False: 3.35k] ------------------ 516| 12.8k| LocExtType* t = static_cast(uhash_get(keyData->typeMap.getAlias(), &type)); ------------------ | | 1007| 12.8k|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 12.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 517| 12.8k| if (t != nullptr) { ------------------ | Branch (517:13): [True: 452, False: 12.3k] ------------------ 518| 452| return t->legacyId; 519| 452| } 520| 12.3k| if (keyData->specialTypes != SPECIALTYPE_NONE) { ------------------ | Branch (520:13): [True: 11.0k, False: 1.38k] ------------------ 521| 11.0k| bool matched = false; 522| 11.0k| if (keyData->specialTypes & SPECIALTYPE_CODEPOINTS) { ------------------ | Branch (522:17): [True: 9.64k, False: 1.36k] ------------------ 523| 9.64k| matched = isSpecialTypeCodepoints(type); 524| 9.64k| } 525| 11.0k| if (!matched && keyData->specialTypes & SPECIALTYPE_REORDER_CODE) { ------------------ | Branch (525:17): [True: 8.95k, False: 2.06k] | Branch (525:29): [True: 486, False: 8.46k] ------------------ 526| 486| matched = isSpecialTypeReorderCode(type); 527| 486| } 528| 11.0k| if (!matched && keyData->specialTypes & SPECIALTYPE_RG_KEY_VALUE) { ------------------ | Branch (528:17): [True: 8.69k, False: 2.31k] | Branch (528:29): [True: 878, False: 7.81k] ------------------ 529| 878| matched = isSpecialTypeRgKeyValue(type); 530| 878| } 531| 11.0k| if (matched) { ------------------ | Branch (531:17): [True: 2.32k, False: 8.69k] ------------------ 532| 2.32k| return type; 533| 2.32k| } 534| 11.0k| } 535| 12.3k| } 536| | 537| 13.4k| return std::nullopt; 538| 16.2k|} uloc_keytype.cpp:_ZN12_GLOBAL__N_14initEv: 384| 1.72M|init() { 385| 1.72M| UErrorCode sts = U_ZERO_ERROR; 386| 1.72M| umtx_initOnce(gLocExtKeyMapInitOnce, &initFromResourceBundle, sts); 387| 1.72M| if (U_FAILURE(sts)) { ------------------ | Branch (387:9): [True: 0, False: 1.72M] ------------------ 388| 0| return false; 389| 0| } 390| 1.72M| return true; 391| 1.72M|} uloc_keytype.cpp:_ZN12_GLOBAL__N_122initFromResourceBundleER10UErrorCode: 91| 1|initFromResourceBundle(UErrorCode& sts) { 92| 1| U_NAMESPACE_USE ------------------ | | 112| 1|# define U_NAMESPACE_USE using namespace U_ICU_NAMESPACE; ------------------ 93| 1| ucln_common_registerCleanup(UCLN_COMMON_LOCALE_KEY_TYPE, uloc_key_type_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 94| | 95| 1| gLocExtKeyMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1030| 1|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gLocExtKeyMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1013| 1|#define uhash_hashIStringView U_ICU_ENTRY_POINT_RENAME(uhash_hashIStringView) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ gLocExtKeyMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 995| 1|#define uhash_compareIStringView U_ICU_ENTRY_POINT_RENAME(uhash_compareIStringView) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 96| | 97| 1| LocalUResourceBundlePointer keyTypeDataRes(ures_openDirect(nullptr, "keyTypeData", &sts)); ------------------ | | 1693| 1|#define ures_openDirect U_ICU_ENTRY_POINT_RENAME(ures_openDirect) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 98| 1| LocalUResourceBundlePointer keyMapRes(ures_getByKey(keyTypeDataRes.getAlias(), "keyMap", nullptr, &sts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 99| 1| LocalUResourceBundlePointer typeMapRes(ures_getByKey(keyTypeDataRes.getAlias(), "typeMap", nullptr, &sts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 100| | 101| 1| if (U_FAILURE(sts)) { ------------------ | Branch (101:9): [True: 0, False: 1] ------------------ 102| 0| return; 103| 0| } 104| | 105| 1| UErrorCode tmpSts = U_ZERO_ERROR; 106| 1| LocalUResourceBundlePointer typeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "typeAlias", nullptr, &tmpSts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 107| 1| tmpSts = U_ZERO_ERROR; 108| 1| LocalUResourceBundlePointer bcpTypeAliasRes(ures_getByKey(keyTypeDataRes.getAlias(), "bcpTypeAlias", nullptr, &tmpSts)); ------------------ | | 1661| 1|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 109| | 110| | // initialize pools storing dynamically allocated objects 111| 1| gKeyTypeStringPool = new icu::MemoryPool; 112| 1| if (gKeyTypeStringPool == nullptr) { ------------------ | Branch (112:9): [True: 0, False: 1] ------------------ 113| 0| sts = U_MEMORY_ALLOCATION_ERROR; 114| 0| return; 115| 0| } 116| 1| gLocExtKeyDataEntries = new icu::MemoryPool; 117| 1| if (gLocExtKeyDataEntries == nullptr) { ------------------ | Branch (117:9): [True: 0, False: 1] ------------------ 118| 0| sts = U_MEMORY_ALLOCATION_ERROR; 119| 0| return; 120| 0| } 121| 1| gLocExtTypeEntries = new icu::MemoryPool; 122| 1| if (gLocExtTypeEntries == nullptr) { ------------------ | Branch (122:9): [True: 0, False: 1] ------------------ 123| 0| sts = U_MEMORY_ALLOCATION_ERROR; 124| 0| return; 125| 0| } 126| 1| gTypeAliasEntries = new icu::MemoryPool; 127| 1| if (gTypeAliasEntries == nullptr) { ------------------ | Branch (127:9): [True: 0, False: 1] ------------------ 128| 0| sts = U_MEMORY_ALLOCATION_ERROR; 129| 0| return; 130| 0| } 131| | 132| | // iterate through keyMap resource 133| 1| LocalUResourceBundlePointer keyMapEntry; 134| | 135| 38| while (ures_hasNext(keyMapRes.getAlias())) { ------------------ | | 1689| 38|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 38|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 38|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 38|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (135:12): [True: 37, False: 1] ------------------ 136| 37| keyMapEntry.adoptInstead(ures_getNextResource(keyMapRes.getAlias(), keyMapEntry.orphan(), &sts)); ------------------ | | 1672| 37|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 137| 37| if (U_FAILURE(sts)) { ------------------ | Branch (137:13): [True: 0, False: 37] ------------------ 138| 0| break; 139| 0| } 140| 37| const char* legacyKeyId = ures_getKey(keyMapEntry.getAlias()); ------------------ | | 1666| 37|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 141| 37| UnicodeString uBcpKeyId = ures_getUnicodeString(keyMapEntry.getAlias(), &sts); 142| 37| if (U_FAILURE(sts)) { ------------------ | Branch (142:13): [True: 0, False: 37] ------------------ 143| 0| break; 144| 0| } 145| | 146| | // empty value indicates that BCP key is same with the legacy key. 147| 37| const char* bcpKeyId = legacyKeyId; 148| 37| if (!uBcpKeyId.isEmpty()) { ------------------ | Branch (148:13): [True: 17, False: 20] ------------------ 149| 17| icu::CharString* bcpKeyIdBuf = gKeyTypeStringPool->create(); 150| 17| if (bcpKeyIdBuf == nullptr) { ------------------ | Branch (150:17): [True: 0, False: 17] ------------------ 151| 0| sts = U_MEMORY_ALLOCATION_ERROR; 152| 0| break; 153| 0| } 154| 17| bcpKeyIdBuf->appendInvariantChars(uBcpKeyId, sts); 155| 17| if (U_FAILURE(sts)) { ------------------ | Branch (155:17): [True: 0, False: 17] ------------------ 156| 0| break; 157| 0| } 158| 17| bcpKeyId = bcpKeyIdBuf->data(); 159| 17| } 160| | 161| 37| bool isTZ = uprv_strcmp(legacyKeyId, "timezone") == 0; ------------------ | | 38| 37|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 37|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 162| | 163| 37| UHashtable* typeDataMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1030| 37|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ UHashtable* typeDataMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 1013| 37|#define uhash_hashIStringView U_ICU_ENTRY_POINT_RENAME(uhash_hashIStringView) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ UHashtable* typeDataMap = uhash_open(uhash_hashIStringView, uhash_compareIStringView, nullptr, &sts); ------------------ | | 995| 37|#define uhash_compareIStringView U_ICU_ENTRY_POINT_RENAME(uhash_compareIStringView) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 37| if (U_FAILURE(sts)) { ------------------ | Branch (164:13): [True: 0, False: 37] ------------------ 165| 0| break; 166| 0| } 167| 37| uint32_t specialTypes = SPECIALTYPE_NONE; 168| | 169| 37| LocalUResourceBundlePointer typeAliasResByKey; 170| 37| LocalUResourceBundlePointer bcpTypeAliasResByKey; 171| | 172| 37| if (typeAliasRes.isValid()) { ------------------ | Branch (172:13): [True: 37, False: 0] ------------------ 173| 37| tmpSts = U_ZERO_ERROR; 174| 37| typeAliasResByKey.adoptInstead(ures_getByKey(typeAliasRes.getAlias(), legacyKeyId, nullptr, &tmpSts)); ------------------ | | 1661| 37|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 175| 37| if (U_FAILURE(tmpSts)) { ------------------ | Branch (175:17): [True: 35, False: 2] ------------------ 176| 35| typeAliasResByKey.orphan(); 177| 35| } 178| 37| } 179| 37| if (bcpTypeAliasRes.isValid()) { ------------------ | Branch (179:13): [True: 37, False: 0] ------------------ 180| 37| tmpSts = U_ZERO_ERROR; 181| 37| bcpTypeAliasResByKey.adoptInstead(ures_getByKey(bcpTypeAliasRes.getAlias(), bcpKeyId, nullptr, &tmpSts)); ------------------ | | 1661| 37|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 182| 37| if (U_FAILURE(tmpSts)) { ------------------ | Branch (182:17): [True: 35, False: 2] ------------------ 183| 35| bcpTypeAliasResByKey.orphan(); 184| 35| } 185| 37| } 186| | 187| | // look up type map for the key, and walk through the mapping data 188| 37| LocalUResourceBundlePointer typeMapResByKey(ures_getByKey(typeMapRes.getAlias(), legacyKeyId, nullptr, &sts)); ------------------ | | 1661| 37|#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 189| 37| if (U_FAILURE(sts)) { ------------------ | Branch (189:13): [True: 0, False: 37] ------------------ 190| | // We fail here if typeMap does not have an entry corresponding to every entry in keyMap (should 191| | // not happen for valid keyTypeData), or if ures_getByKeyfails fails for some other reason 192| | // (e.g. data file cannot be loaded, using stubdata, over-aggressive data filtering has removed 193| | // something like timezoneTypes.res, etc.). Error code is already set. See ICU-21669. 194| 0| UPRV_UNREACHABLE_ASSERT; ------------------ | | 55| 0|# define UPRV_UNREACHABLE_ASSERT (void)0 ------------------ 195| 37| } else { 196| 37| LocalUResourceBundlePointer typeMapEntry; 197| | 198| 1.09k| while (ures_hasNext(typeMapResByKey.getAlias())) { ------------------ | | 1689| 1.09k|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 1.09k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.09k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.09k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (198:20): [True: 1.05k, False: 37] ------------------ 199| 1.05k| typeMapEntry.adoptInstead(ures_getNextResource(typeMapResByKey.getAlias(), typeMapEntry.orphan(), &sts)); ------------------ | | 1672| 1.05k|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 1.05k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.05k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.05k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 1.05k| if (U_FAILURE(sts)) { ------------------ | Branch (200:21): [True: 0, False: 1.05k] ------------------ 201| 0| break; 202| 0| } 203| 1.05k| const char* legacyTypeId = ures_getKey(typeMapEntry.getAlias()); ------------------ | | 1666| 1.05k|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 1.05k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.05k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.05k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 204| | 205| | // special types 206| 1.05k| if (uprv_strcmp(legacyTypeId, "CODEPOINTS") == 0) { ------------------ | | 38| 1.05k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.05k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (206:21): [True: 1, False: 1.05k] ------------------ 207| 1| specialTypes |= SPECIALTYPE_CODEPOINTS; 208| 1| continue; 209| 1| } 210| 1.05k| if (uprv_strcmp(legacyTypeId, "REORDER_CODE") == 0) { ------------------ | | 38| 1.05k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.05k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (210:21): [True: 1, False: 1.05k] ------------------ 211| 1| specialTypes |= SPECIALTYPE_REORDER_CODE; 212| 1| continue; 213| 1| } 214| 1.05k| if (uprv_strcmp(legacyTypeId, "RG_KEY_VALUE") == 0) { ------------------ | | 38| 1.05k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.05k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (214:21): [True: 1, False: 1.05k] ------------------ 215| 1| specialTypes |= SPECIALTYPE_RG_KEY_VALUE; 216| 1| continue; 217| 1| } 218| | 219| 1.05k| if (isTZ) { ------------------ | Branch (219:21): [True: 447, False: 604] ------------------ 220| | // a timezone key uses a colon instead of a slash in the resource. 221| | // e.g. America:Los_Angeles 222| 447| if (uprv_strchr(legacyTypeId, ':') != nullptr) { ------------------ | | 40| 447|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 447|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (222:25): [True: 447, False: 0] ------------------ 223| 447| icu::CharString* legacyTypeIdBuf = 224| 447| gKeyTypeStringPool->create(legacyTypeId, sts); 225| 447| if (legacyTypeIdBuf == nullptr) { ------------------ | Branch (225:29): [True: 0, False: 447] ------------------ 226| 0| sts = U_MEMORY_ALLOCATION_ERROR; 227| 0| break; 228| 0| } 229| 447| if (U_FAILURE(sts)) { ------------------ | Branch (229:29): [True: 0, False: 447] ------------------ 230| 0| break; 231| 0| } 232| 447| std::replace( 233| 447| legacyTypeIdBuf->data(), 234| 447| legacyTypeIdBuf->data() + legacyTypeIdBuf->length(), 235| 447| ':', '/'); 236| 447| legacyTypeId = legacyTypeIdBuf->data(); 237| 447| } 238| 447| } 239| | 240| 1.05k| UnicodeString uBcpTypeId = ures_getUnicodeString(typeMapEntry.getAlias(), &sts); 241| 1.05k| if (U_FAILURE(sts)) { ------------------ | Branch (241:21): [True: 0, False: 1.05k] ------------------ 242| 0| break; 243| 0| } 244| | 245| | // empty value indicates that BCP type is same with the legacy type. 246| 1.05k| const char* bcpTypeId = legacyTypeId; 247| 1.05k| if (!uBcpTypeId.isEmpty()) { ------------------ | Branch (247:21): [True: 484, False: 567] ------------------ 248| 484| icu::CharString* bcpTypeIdBuf = gKeyTypeStringPool->create(); 249| 484| if (bcpTypeIdBuf == nullptr) { ------------------ | Branch (249:25): [True: 0, False: 484] ------------------ 250| 0| sts = U_MEMORY_ALLOCATION_ERROR; 251| 0| break; 252| 0| } 253| 484| bcpTypeIdBuf->appendInvariantChars(uBcpTypeId, sts); 254| 484| if (U_FAILURE(sts)) { ------------------ | Branch (254:25): [True: 0, False: 484] ------------------ 255| 0| break; 256| 0| } 257| 484| bcpTypeId = bcpTypeIdBuf->data(); 258| 484| } 259| | 260| | // Note: legacy type value should never be 261| | // equivalent to bcp type value of a different 262| | // type under the same key. So we use a single 263| | // map for lookup. 264| 1.05k| LocExtType* t = gLocExtTypeEntries->create(); 265| 1.05k| if (t == nullptr) { ------------------ | Branch (265:21): [True: 0, False: 1.05k] ------------------ 266| 0| sts = U_MEMORY_ALLOCATION_ERROR; 267| 0| break; 268| 0| } 269| 1.05k| t->bcpId = bcpTypeId; 270| 1.05k| t->legacyId = legacyTypeId; 271| | 272| 1.05k| uhash_put(typeDataMap, &t->legacyId, t, &sts); ------------------ | | 1032| 1.05k|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 1.05k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.05k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.05k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 273| 1.05k| if (bcpTypeId != legacyTypeId) { ------------------ | Branch (273:21): [True: 484, False: 567] ------------------ 274| | // different type value 275| 484| uhash_put(typeDataMap, &t->bcpId, t, &sts); ------------------ | | 1032| 484|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 484|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 484|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 484|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 276| 484| } 277| 1.05k| if (U_FAILURE(sts)) { ------------------ | Branch (277:21): [True: 0, False: 1.05k] ------------------ 278| 0| break; 279| 0| } 280| | 281| | // also put aliases in the map 282| 1.05k| if (typeAliasResByKey.isValid()) { ------------------ | Branch (282:21): [True: 452, False: 599] ------------------ 283| 452| LocalUResourceBundlePointer typeAliasDataEntry; 284| | 285| 452| ures_resetIterator(typeAliasResByKey.getAlias()); ------------------ | | 1698| 452|#define ures_resetIterator U_ICU_ENTRY_POINT_RENAME(ures_resetIterator) | | ------------------ | | | | 123| 452|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 452|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 452|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 286| 69.2k| while (ures_hasNext(typeAliasResByKey.getAlias()) && U_SUCCESS(sts)) { ------------------ | | 1689| 69.2k|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 69.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 69.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 69.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (286:28): [True: 68.8k, False: 452] | Branch (286:74): [True: 68.8k, False: 0] ------------------ 287| 68.8k| int32_t toLen; 288| 68.8k| typeAliasDataEntry.adoptInstead(ures_getNextResource(typeAliasResByKey.getAlias(), typeAliasDataEntry.orphan(), &sts)); ------------------ | | 1672| 68.8k|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 68.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 68.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 68.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 289| 68.8k| const char16_t* to = ures_getString(typeAliasDataEntry.getAlias(), &toLen, &sts); ------------------ | | 1675| 68.8k|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 68.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 68.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 68.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 290| 68.8k| if (U_FAILURE(sts)) { ------------------ | Branch (290:29): [True: 0, False: 68.8k] ------------------ 291| 0| break; 292| 0| } 293| | // check if this is an alias of canonical legacy type 294| 68.8k| if (uprv_compareInvWithUChar( ------------------ | | 329| 68.8k|# define uprv_compareInvWithUChar uprv_compareInvAscii | | ------------------ | | | | 1402| 68.8k|#define uprv_compareInvAscii U_ICU_ENTRY_POINT_RENAME(uprv_compareInvAscii) | | | | ------------------ | | | | | | 123| 68.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 68.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 68.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (294:29): [True: 155, False: 68.6k] ------------------ 295| 68.8k| nullptr, 296| 68.8k| t->legacyId.data(), 297| 68.8k| static_cast(t->legacyId.size()), 298| 68.8k| to, 299| 68.8k| toLen) == 0) { 300| 155| const char* from = ures_getKey(typeAliasDataEntry.getAlias()); ------------------ | | 1666| 155|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 155|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 155|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 155|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 301| 155| TypeAlias* alias = gTypeAliasEntries->create(TypeAlias{{}, from}); 302| 155| if (isTZ) { ------------------ | Branch (302:33): [True: 154, False: 1] ------------------ 303| | // replace colon with slash if necessary 304| 154| if (uprv_strchr(from, ':') != nullptr) { ------------------ | | 40| 154|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 154|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (304:37): [True: 109, False: 45] ------------------ 305| 109| icu::CharString* fromBuf = 306| 109| gKeyTypeStringPool->create(from, sts); 307| 109| if (fromBuf == nullptr) { ------------------ | Branch (307:41): [True: 0, False: 109] ------------------ 308| 0| sts = U_MEMORY_ALLOCATION_ERROR; 309| 0| break; 310| 0| } 311| 109| if (U_FAILURE(sts)) { ------------------ | Branch (311:41): [True: 0, False: 109] ------------------ 312| 0| break; 313| 0| } 314| 109| std::replace( 315| 109| fromBuf->data(), 316| 109| fromBuf->data() + fromBuf->length(), 317| 109| ':', '/'); 318| 109| alias->from = fromBuf->toStringPiece(); 319| 109| } 320| 154| } 321| 155| uhash_put(typeDataMap, &alias->from, t, &sts); ------------------ | | 1032| 155|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 155|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 155|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 155|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 322| 155| } 323| 68.8k| } 324| 452| if (U_FAILURE(sts)) { ------------------ | Branch (324:25): [True: 0, False: 452] ------------------ 325| 0| break; 326| 0| } 327| 452| } 328| | 329| 1.05k| if (bcpTypeAliasResByKey.isValid()) { ------------------ | Branch (329:21): [True: 465, False: 586] ------------------ 330| 465| LocalUResourceBundlePointer bcpTypeAliasDataEntry; 331| | 332| 465| ures_resetIterator(bcpTypeAliasResByKey.getAlias()); ------------------ | | 1698| 465|#define ures_resetIterator U_ICU_ENTRY_POINT_RENAME(ures_resetIterator) | | ------------------ | | | | 123| 465|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 465|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 465|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 333| 10.3k| while (ures_hasNext(bcpTypeAliasResByKey.getAlias()) && U_SUCCESS(sts)) { ------------------ | | 1689| 10.3k|#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext) | | ------------------ | | | | 123| 10.3k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 10.3k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 10.3k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (333:28): [True: 9.85k, False: 465] | Branch (333:77): [True: 9.85k, False: 0] ------------------ 334| 9.85k| int32_t toLen; 335| 9.85k| bcpTypeAliasDataEntry.adoptInstead(ures_getNextResource(bcpTypeAliasResByKey.getAlias(), bcpTypeAliasDataEntry.orphan(), &sts)); ------------------ | | 1672| 9.85k|#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource) | | ------------------ | | | | 123| 9.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 336| 9.85k| const char16_t* to = ures_getString(bcpTypeAliasDataEntry.getAlias(), &toLen, &sts); ------------------ | | 1675| 9.85k|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 9.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 337| 9.85k| if (U_FAILURE(sts)) { ------------------ | Branch (337:29): [True: 0, False: 9.85k] ------------------ 338| 0| break; 339| 0| } 340| | // check if this is an alias of bcp type 341| 9.85k| if (uprv_compareInvWithUChar( ------------------ | | 329| 9.85k|# define uprv_compareInvWithUChar uprv_compareInvAscii | | ------------------ | | | | 1402| 9.85k|#define uprv_compareInvAscii U_ICU_ENTRY_POINT_RENAME(uprv_compareInvAscii) | | | | ------------------ | | | | | | 123| 9.85k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 9.85k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 9.85k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (341:29): [True: 23, False: 9.82k] ------------------ 342| 9.85k| nullptr, 343| 9.85k| t->bcpId.data(), 344| 9.85k| static_cast(t->bcpId.size()), 345| 9.85k| to, 346| 9.85k| toLen) == 0) { 347| 23| const char* from = ures_getKey(bcpTypeAliasDataEntry.getAlias()); ------------------ | | 1666| 23|#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey) | | ------------------ | | | | 123| 23|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 23|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 23|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 348| 23| TypeAlias* alias = gTypeAliasEntries->create(TypeAlias{{}, from}); 349| 23| uhash_put(typeDataMap, &alias->from, t, &sts); ------------------ | | 1032| 23|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 23|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 23|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 23|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 350| 23| } 351| 9.85k| } 352| 465| if (U_FAILURE(sts)) { ------------------ | Branch (352:25): [True: 0, False: 465] ------------------ 353| 0| break; 354| 0| } 355| 465| } 356| 1.05k| } 357| 37| } 358| 37| if (U_FAILURE(sts)) { ------------------ | Branch (358:13): [True: 0, False: 37] ------------------ 359| 0| break; 360| 0| } 361| | 362| 37| LocExtKeyData* keyData = gLocExtKeyDataEntries->create(); 363| 37| if (keyData == nullptr) { ------------------ | Branch (363:13): [True: 0, False: 37] ------------------ 364| 0| sts = U_MEMORY_ALLOCATION_ERROR; 365| 0| break; 366| 0| } 367| 37| keyData->bcpId = bcpKeyId; 368| 37| keyData->legacyId = legacyKeyId; 369| 37| keyData->specialTypes = specialTypes; 370| 37| keyData->typeMap.adoptInstead(typeDataMap); 371| | 372| 37| uhash_put(gLocExtKeyMap, &keyData->legacyId, keyData, &sts); ------------------ | | 1032| 37|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 37|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 37|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 37|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 373| 37| if (legacyKeyId != bcpKeyId) { ------------------ | Branch (373:13): [True: 17, False: 20] ------------------ 374| | // different key value 375| 17| uhash_put(gLocExtKeyMap, &keyData->bcpId, keyData, &sts); ------------------ | | 1032| 17|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 123| 17|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 17|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 17|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 376| 17| } 377| 37| if (U_FAILURE(sts)) { ------------------ | Branch (377:13): [True: 0, False: 37] ------------------ 378| 0| break; 379| 0| } 380| 37| } 381| 1|} uloc_keytype.cpp:_ZN12_GLOBAL__N_123isSpecialTypeCodepointsENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 394| 9.64k|isSpecialTypeCodepoints(std::string_view val) { 395| 9.64k| int32_t subtagLen = 0; 396| 49.0k| for (char c : val) { ------------------ | Branch (396:17): [True: 49.0k, False: 5.65k] ------------------ 397| 49.0k| if (c == '-') { ------------------ | Branch (397:13): [True: 1.40k, False: 47.6k] ------------------ 398| 1.40k| if (subtagLen < 4 || subtagLen > 6) { ------------------ | Branch (398:17): [True: 227, False: 1.18k] | Branch (398:34): [True: 203, False: 979] ------------------ 399| 430| return false; 400| 430| } 401| 979| subtagLen = 0; 402| 47.6k| } else if ((c >= '0' && c <= '9') || ------------------ | Branch (402:21): [True: 47.6k, False: 0] | Branch (402:33): [True: 32.9k, False: 14.6k] ------------------ 403| 47.6k| (c >= 'A' && c <= 'F') || // A-F/a-f are contiguous ------------------ | Branch (403:22): [True: 14.6k, False: 0] | Branch (403:34): [True: 0, False: 14.6k] ------------------ 404| 47.6k| (c >= 'a' && c <= 'f')) { // also in EBCDIC ------------------ | Branch (404:22): [True: 14.6k, False: 0] | Branch (404:34): [True: 11.0k, False: 3.56k] ------------------ 405| 44.0k| subtagLen++; 406| 44.0k| } else { 407| 3.56k| return false; 408| 3.56k| } 409| 49.0k| } 410| 5.65k| return subtagLen >= 4 && subtagLen <= 6; ------------------ | Branch (410:12): [True: 5.34k, False: 302] | Branch (410:30): [True: 2.06k, False: 3.28k] ------------------ 411| 9.64k|} uloc_keytype.cpp:_ZN12_GLOBAL__N_124isSpecialTypeReorderCodeENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 414| 486|isSpecialTypeReorderCode(std::string_view val) { 415| 486| int32_t subtagLen = 0; 416| 4.57k| for (char c : val) { ------------------ | Branch (416:17): [True: 4.57k, False: 256] ------------------ 417| 4.57k| if (c == '-') { ------------------ | Branch (417:13): [True: 806, False: 3.76k] ------------------ 418| 806| if (subtagLen < 3 || subtagLen > 8) { ------------------ | Branch (418:17): [True: 0, False: 806] | Branch (418:34): [True: 0, False: 806] ------------------ 419| 0| return false; 420| 0| } 421| 806| subtagLen = 0; 422| 3.76k| } else if (uprv_isASCIILetter(c)) { ------------------ | | 1514| 3.76k|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 3.76k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.76k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.76k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (422:20): [True: 3.53k, False: 230] ------------------ 423| 3.53k| subtagLen++; 424| 3.53k| } else { 425| 230| return false; 426| 230| } 427| 4.57k| } 428| 256| return subtagLen >= 3 && subtagLen <= 8; ------------------ | Branch (428:12): [True: 256, False: 0] | Branch (428:30): [True: 256, False: 0] ------------------ 429| 486|} uloc_keytype.cpp:_ZN12_GLOBAL__N_123isSpecialTypeRgKeyValueENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 432| 878|isSpecialTypeRgKeyValue(std::string_view val) { 433| 878| int32_t subtagLen = 0; 434| 2.58k| for (char c : val) { ------------------ | Branch (434:17): [True: 2.58k, False: 256] ------------------ 435| 2.58k| if ((subtagLen < 2 && uprv_isASCIILetter(c)) || ------------------ | | 1514| 1.75k|#define uprv_isASCIILetter U_ICU_ENTRY_POINT_RENAME(uprv_isASCIILetter) | | ------------------ | | | | 123| 1.75k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.75k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.75k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (435:14): [True: 1.75k, False: 832] | Branch (435:31): [True: 1.40k, False: 346] ------------------ 436| 2.58k| (subtagLen >= 2 && (c == 'Z' || c == 'z'))) { ------------------ | Branch (436:14): [True: 832, False: 346] | Branch (436:33): [True: 0, False: 832] | Branch (436:45): [True: 556, False: 276] ------------------ 437| 1.96k| subtagLen++; 438| 1.96k| } else { 439| 622| return false; 440| 622| } 441| 2.58k| } 442| 256| return subtagLen == 6; 443| 878|} _Z25ultag_isLanguageSubtag_78PKci: 431| 2.49k|ultag_isLanguageSubtag(const char* s, int32_t len) { 432| | /* 433| | * unicode_language_subtag = alpha{2,3} | alpha{5,8}; 434| | * NOTE: Per ICUTC 2019/01/23- accepting alpha 4 435| | * See ICU-20372 436| | */ 437| 2.49k| if (len < 0) { ------------------ | Branch (437:9): [True: 0, False: 2.49k] ------------------ 438| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 439| 0| } 440| 2.49k| if (len >= 2 && len <= 8 && _isAlphaString(s, len)) { ------------------ | Branch (440:9): [True: 1.89k, False: 598] | Branch (440:21): [True: 1.82k, False: 74] | Branch (440:33): [True: 1.77k, False: 53] ------------------ 441| 1.77k| return true; 442| 1.77k| } 443| 725| return false; 444| 2.49k|} _Z23ultag_isScriptSubtag_78PKci: 466| 1.76k|ultag_isScriptSubtag(const char* s, int32_t len) { 467| | /* 468| | * script = 4ALPHA ; ISO 15924 code 469| | */ 470| 1.76k| if (len < 0) { ------------------ | Branch (470:9): [True: 0, False: 1.76k] ------------------ 471| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 472| 0| } 473| 1.76k| if (len == 4 && _isAlphaString(s, len)) { ------------------ | Branch (473:9): [True: 132, False: 1.63k] | Branch (473:21): [True: 12, False: 120] ------------------ 474| 12| return true; 475| 12| } 476| 1.75k| return false; 477| 1.76k|} _Z23ultag_isRegionSubtag_78PKci: 480| 1.76k|ultag_isRegionSubtag(const char* s, int32_t len) { 481| | /* 482| | * region = 2ALPHA ; ISO 3166-1 code 483| | * / 3DIGIT ; UN M.49 code 484| | */ 485| 1.76k| if (len < 0) { ------------------ | Branch (485:9): [True: 0, False: 1.76k] ------------------ 486| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 487| 0| } 488| 1.76k| if (len == 2 && _isAlphaString(s, len)) { ------------------ | Branch (488:9): [True: 36, False: 1.72k] | Branch (488:21): [True: 33, False: 3] ------------------ 489| 33| return true; 490| 33| } 491| 1.73k| if (len == 3 && _isNumericString(s, len)) { ------------------ | Branch (491:9): [True: 29, False: 1.70k] | Branch (491:21): [True: 1, False: 28] ------------------ 492| 1| return true; 493| 1| } 494| 1.72k| return false; 495| 1.73k|} _Z27ultag_isUnicodeLocaleKey_78PKci: 631| 3.06M|ultag_isUnicodeLocaleKey(const char* s, int32_t len) { 632| | /* 633| | * key = alphanum alpha ; 634| | */ 635| 3.06M| if (len < 0) { ------------------ | Branch (635:9): [True: 0, False: 3.06M] ------------------ 636| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 637| 0| } 638| 3.06M| if (len == 2 && (ISALPHA(*s) || ISNUMERIC(*s)) && ISALPHA(s[1])) { ------------------ | Branch (638:9): [True: 3.02M, False: 46.2k] | Branch (638:22): [True: 1.70M, False: 1.31M] | Branch (638:37): [True: 1.31M, False: 0] | Branch (638:55): [True: 1.70M, False: 1.31M] ------------------ 639| 1.70M| return true; 640| 1.70M| } 641| 1.35M| return false; 642| 3.06M|} _Z25ulocimp_forLanguageTag_78PKciPiR10UErrorCode: 2675| 2.52k| UErrorCode& status) { 2676| 2.52k| return icu::ByteSinkUtil::viaByteSinkToCharString( 2677| 2.52k| [&](icu::ByteSink& sink, UErrorCode& status) { 2678| 2.52k| ulocimp_forLanguageTag(langtag, tagLen, sink, parsedLength, status); 2679| 2.52k| }, 2680| 2.52k| status); 2681| 2.52k|} _Z25ulocimp_forLanguageTag_78PKciRN6icu_788ByteSinkEPiR10UErrorCode: 2688| 2.52k| UErrorCode& status) { 2689| 2.52k| if (U_FAILURE(status)) { return; } ------------------ | Branch (2689:9): [True: 0, False: 2.52k] ------------------ 2690| | 2691| 2.52k| bool isEmpty = true; 2692| 2.52k| const char *subtag, *p; 2693| 2.52k| int32_t len; 2694| 2.52k| int32_t i, n; 2695| 2.52k| bool noRegion = true; 2696| | 2697| 2.52k| icu::LocalULanguageTagPointer lt(ultag_parse(langtag, tagLen, parsedLength, status)); 2698| 2.52k| if (U_FAILURE(status)) { ------------------ | Branch (2698:9): [True: 0, False: 2.52k] ------------------ 2699| 0| return; 2700| 0| } 2701| | 2702| | /* language */ 2703| 2.52k| subtag = ultag_getExtlangSize(lt.getAlias()) > 0 ? ultag_getExtlang(lt.getAlias(), 0) : ultag_getLanguage(lt.getAlias()); ------------------ | Branch (2703:14): [True: 40, False: 2.48k] ------------------ 2704| 2.52k| if (uprv_compareInvCharsAsAscii(subtag, LANG_UND) != 0) { ------------------ | | 153| 2.52k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 2.52k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 2.52k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ | Branch (2704:9): [True: 2.51k, False: 8] ------------------ 2705| 2.51k| len = static_cast(uprv_strlen(subtag)); ------------------ | | 37| 2.51k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 2.51k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2706| 2.51k| if (len > 0) { ------------------ | Branch (2706:13): [True: 1.76k, False: 754] ------------------ 2707| 1.76k| sink.Append(subtag, len); 2708| 1.76k| isEmpty = false; 2709| 1.76k| } 2710| 2.51k| } 2711| | 2712| | /* script */ 2713| 2.52k| subtag = ultag_getScript(lt.getAlias()); 2714| 2.52k| len = static_cast(uprv_strlen(subtag)); ------------------ | | 37| 2.52k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 2.52k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2715| 2.52k| if (len > 0) { ------------------ | Branch (2715:9): [True: 12, False: 2.51k] ------------------ 2716| 12| sink.Append("_", 1); 2717| 12| isEmpty = false; 2718| | 2719| | /* write out the script in title case */ 2720| 12| char c = uprv_toupper(*subtag); ------------------ | | 1547| 12|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 12|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2721| 12| sink.Append(&c, 1); 2722| 12| sink.Append(subtag + 1, len - 1); 2723| 12| } 2724| | 2725| | /* region */ 2726| 2.52k| subtag = ultag_getRegion(lt.getAlias()); 2727| 2.52k| len = static_cast(uprv_strlen(subtag)); ------------------ | | 37| 2.52k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 2.52k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2728| 2.52k| if (len > 0) { ------------------ | Branch (2728:9): [True: 34, False: 2.49k] ------------------ 2729| 34| sink.Append("_", 1); 2730| 34| isEmpty = false; 2731| | 2732| | /* write out the region in upper case */ 2733| 34| p = subtag; 2734| 103| while (*p) { ------------------ | Branch (2734:16): [True: 69, False: 34] ------------------ 2735| 69| char c = uprv_toupper(*p); ------------------ | | 1547| 69|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 69|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 69|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 69|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2736| 69| sink.Append(&c, 1); 2737| 69| p++; 2738| 69| } 2739| 34| noRegion = false; 2740| 34| } 2741| | 2742| | /* variants */ 2743| 2.52k| _sortVariants(lt.getAlias()->variants); 2744| 2.52k| n = ultag_getVariantsSize(lt.getAlias()); 2745| 2.52k| if (n > 0) { ------------------ | Branch (2745:9): [True: 302, False: 2.22k] ------------------ 2746| 302| if (noRegion) { ------------------ | Branch (2746:13): [True: 299, False: 3] ------------------ 2747| 299| sink.Append("_", 1); 2748| 299| isEmpty = false; 2749| 299| } 2750| | 2751| 2.44k| for (i = 0; i < n; i++) { ------------------ | Branch (2751:21): [True: 2.14k, False: 302] ------------------ 2752| 2.14k| subtag = ultag_getVariant(lt.getAlias(), i); 2753| 2.14k| sink.Append("_", 1); 2754| | 2755| | /* write out the variant in upper case */ 2756| 2.14k| p = subtag; 2757| 8.30k| while (*p) { ------------------ | Branch (2757:20): [True: 6.16k, False: 2.14k] ------------------ 2758| 6.16k| char c = uprv_toupper(*p); ------------------ | | 1547| 6.16k|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 6.16k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6.16k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6.16k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2759| 6.16k| sink.Append(&c, 1); 2760| 6.16k| p++; 2761| 6.16k| } 2762| 2.14k| } 2763| 302| } 2764| | 2765| | /* keywords */ 2766| 2.52k| n = ultag_getExtensionsSize(lt.getAlias()); 2767| 2.52k| subtag = ultag_getPrivateUse(lt.getAlias()); 2768| 2.52k| if (n > 0 || uprv_strlen(subtag) > 0) { ------------------ | | 37| 1.30k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1.30k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (2768:9): [True: 1.22k, False: 1.30k] | Branch (2768:18): [True: 175, False: 1.12k] ------------------ 2769| 1.39k| if (isEmpty && n > 0) { ------------------ | Branch (2769:13): [True: 83, False: 1.31k] | Branch (2769:24): [True: 6, False: 77] ------------------ 2770| | /* need a language */ 2771| 6| sink.Append(LANG_UND, LANG_UND_LEN); ------------------ | | 87| 6|#define LANG_UND_LEN 3 ------------------ 2772| 6| } 2773| 1.39k| _appendKeywords(lt.getAlias(), sink, status); 2774| 1.39k| } 2775| 2.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_114_isAlphaStringEPKci: 385| 2.10k|_isAlphaString(const char* s, int32_t len) { 386| 2.10k| int32_t i; 387| 6.41k| for (i = 0; i < len; i++) { ------------------ | Branch (387:17): [True: 4.50k, False: 1.90k] ------------------ 388| 4.50k| if (!ISALPHA(*(s + i))) { ------------------ | Branch (388:13): [True: 205, False: 4.30k] ------------------ 389| 205| return false; 390| 205| } 391| 4.50k| } 392| 1.90k| return true; 393| 2.10k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116_isNumericStringEPKci: 396| 29|_isNumericString(const char* s, int32_t len) { 397| 29| int32_t i; 398| 36| for (i = 0; i < len; i++) { ------------------ | Branch (398:17): [True: 35, False: 1] ------------------ 399| 35| if (!ISNUMERIC(*(s + i))) { ------------------ | Branch (399:13): [True: 28, False: 7] ------------------ 400| 28| return false; 401| 28| } 402| 35| } 403| 1| return true; 404| 29|} uloc_tag.cpp:_ZN12_GLOBAL__N_116_isVariantSubtagEPKci: 500| 3.98k|_isVariantSubtag(const char* s, int32_t len) { 501| | /* 502| | * variant = 5*8alphanum ; registered variants 503| | * / (DIGIT 3alphanum) 504| | */ 505| 3.98k| if (len < 0) { ------------------ | Branch (505:9): [True: 0, False: 3.98k] ------------------ 506| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 507| 0| } 508| 3.98k| if (_isAlphaNumericStringLimitedLength(s, len, 5, 8)) { ------------------ | Branch (508:9): [True: 350, False: 3.63k] ------------------ 509| 350| return true; 510| 350| } 511| 3.63k| if (len == 4 && ISNUMERIC(*s) && _isAlphaNumericString(s + 1, 3)) { ------------------ | Branch (511:9): [True: 542, False: 3.09k] | Branch (511:21): [True: 372, False: 170] | Branch (511:38): [True: 349, False: 23] ------------------ 512| 349| return true; 513| 349| } 514| 3.28k| return false; 515| 3.63k|} uloc_tag.cpp:_ZN12_GLOBAL__N_121_isAlphaNumericStringEPKci: 407| 10.7M|_isAlphaNumericString(const char* s, int32_t len) { 408| 10.7M| int32_t i; 409| 36.9M| for (i = 0; i < len; i++) { ------------------ | Branch (409:17): [True: 26.2M, False: 10.7M] ------------------ 410| 26.2M| if (!ISALPHA(*(s + i)) && !ISNUMERIC(*(s + i))) { ------------------ | Branch (410:13): [True: 4.69M, False: 21.5M] | Branch (410:35): [True: 176, False: 4.69M] ------------------ 411| 176| return false; 412| 176| } 413| 26.2M| } 414| 10.7M| return true; 415| 10.7M|} uloc_tag.cpp:_ZN12_GLOBAL__N_118_isExtensionSubtagEPKci: 586| 5.50M|_isExtensionSubtag(const char* s, int32_t len) { 587| | /* 588| | * extension = singleton 1*("-" (2*8alphanum)) 589| | */ 590| 5.50M| return _isAlphaNumericStringLimitedLength(s, len, 2, 8); 591| 5.50M|} uloc_tag.cpp:_ZN12_GLOBAL__N_124_isPrivateuseValueSubtagEPKci: 603| 5.23M|_isPrivateuseValueSubtag(const char* s, int32_t len) { 604| | /* 605| | * privateuse = "x" 1*("-" (1*8alphanum)) 606| | */ 607| 5.23M| return _isAlphaNumericStringLimitedLength(s, len, 1, 8); 608| 5.23M|} uloc_tag.cpp:_ZN12_GLOBAL__N_134_isAlphaNumericStringLimitedLengthEPKciii: 418| 10.7M|_isAlphaNumericStringLimitedLength(const char* s, int32_t len, int32_t min, int32_t max) { 419| 10.7M| if (len < 0) { ------------------ | Branch (419:9): [True: 0, False: 10.7M] ------------------ 420| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 421| 0| } 422| 10.7M| if (len >= min && len <= max && _isAlphaNumericString(s, len)) { ------------------ | Branch (422:9): [True: 10.7M, False: 3.85k] | Branch (422:23): [True: 10.7M, False: 315] | Branch (422:37): [True: 10.7M, False: 153] ------------------ 423| 10.7M| return true; 424| 10.7M| } 425| 4.32k| return false; 426| 10.7M|} uloc_tag.cpp:_ZN12_GLOBAL__N_19ISNUMERICEc: 75| 6.01M|inline bool ISNUMERIC(char c) { return c >= '0' && c <= '9'; } ------------------ | Branch (75:40): [True: 6.01M, False: 163] | Branch (75:52): [True: 6.01M, False: 255] ------------------ uloc_tag.cpp:_ZN12_GLOBAL__N_117_addVariantToListEPPNS_16VariantListEntryEN6icu_7812LocalPointerIS0_EE: 872| 2.14k|_addVariantToList(VariantListEntry **first, icu::LocalPointer var) { 873| 2.14k| if (*first == nullptr) { ------------------ | Branch (873:9): [True: 302, False: 1.84k] ------------------ 874| 302| var->next = nullptr; 875| 302| *first = var.orphan(); 876| 1.84k| } else { 877| 1.84k| VariantListEntry *prev, *cur; 878| 1.84k| int32_t cmp; 879| | 880| | /* variants order should be preserved */ 881| 1.84k| prev = nullptr; 882| 1.84k| cur = *first; 883| 59.6k| while (true) { ------------------ | Branch (883:16): [Folded - Ignored] ------------------ 884| 59.6k| if (cur == nullptr) { ------------------ | Branch (884:17): [True: 1.83k, False: 57.8k] ------------------ 885| 1.83k| var->next = nullptr; 886| 1.83k| prev->next = var.orphan(); 887| 1.83k| break; 888| 1.83k| } 889| | 890| | /* Checking for duplicate variant */ 891| 57.8k| cmp = uprv_compareInvCharsAsAscii(var->variant, cur->variant); ------------------ | | 153| 57.8k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 57.8k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 57.8k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 892| 57.8k| if (cmp == 0) { ------------------ | Branch (892:17): [True: 8, False: 57.8k] ------------------ 893| | /* duplicated variant */ 894| 8| return false; 895| 8| } 896| 57.8k| prev = cur; 897| 57.8k| cur = cur->next; 898| 57.8k| } 899| 1.84k| } 900| | 901| 2.14k| return true; 902| 2.14k|} uloc_tag.cpp:_ZN12_GLOBAL__N_119_addAttributeToListEPPNS_18AttributeListEntryES1_: 905| 1.06M|_addAttributeToList(AttributeListEntry **first, AttributeListEntry *attr) { 906| 1.06M| bool bAdded = true; 907| | 908| 1.06M| if (*first == nullptr) { ------------------ | Branch (908:9): [True: 422, False: 1.06M] ------------------ 909| 422| attr->next = nullptr; 910| 422| *first = attr; 911| 1.06M| } else { 912| 1.06M| AttributeListEntry *prev, *cur; 913| 1.06M| int32_t cmp; 914| | 915| | /* reorder variants in alphabetical order */ 916| 1.06M| prev = nullptr; 917| 1.06M| cur = *first; 918| 19.3M| while (true) { ------------------ | Branch (918:16): [Folded - Ignored] ------------------ 919| 19.3M| if (cur == nullptr) { ------------------ | Branch (919:17): [True: 305, False: 19.3M] ------------------ 920| 305| prev->next = attr; 921| 305| attr->next = nullptr; 922| 305| break; 923| 305| } 924| 19.3M| cmp = uprv_compareInvCharsAsAscii(attr->attribute, cur->attribute); ------------------ | | 153| 19.3M|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 19.3M|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 19.3M|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 925| 19.3M| if (cmp < 0) { ------------------ | Branch (925:17): [True: 1.88k, False: 19.3M] ------------------ 926| 1.88k| if (prev == nullptr) { ------------------ | Branch (926:21): [True: 346, False: 1.53k] ------------------ 927| 346| *first = attr; 928| 1.53k| } else { 929| 1.53k| prev->next = attr; 930| 1.53k| } 931| 1.88k| attr->next = cur; 932| 1.88k| break; 933| 1.88k| } 934| 19.3M| if (cmp == 0) { ------------------ | Branch (934:17): [True: 1.05M, False: 18.3M] ------------------ 935| | /* duplicated variant */ 936| 1.05M| bAdded = false; 937| 1.05M| break; 938| 1.05M| } 939| 18.3M| prev = cur; 940| 18.3M| cur = cur->next; 941| 18.3M| } 942| 1.06M| } 943| | 944| 1.06M| return bAdded; 945| 1.06M|} uloc_tag.cpp:_ZN12_GLOBAL__N_121_isExtensionSingletonEPKci: 566| 5.50M|_isExtensionSingleton(const char* s, int32_t len) { 567| | /* 568| | * extension = singleton 1*("-" (2*8alphanum)) 569| | * 570| | * singleton = DIGIT ; 0 - 9 571| | * / %x41-57 ; A - W 572| | * / %x59-5A ; Y - Z 573| | * / %x61-77 ; a - w 574| | * / %x79-7A ; y - z 575| | */ 576| 5.50M| if (len < 0) { ------------------ | Branch (576:9): [True: 0, False: 5.50M] ------------------ 577| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 578| 0| } 579| 5.50M| if (len == 1 && (ISALPHA(*s) || ISNUMERIC(*s)) && (uprv_tolower(*s) != PRIVATEUSE)) { ------------------ | | 68| 3.08k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 3.08k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 3.08k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 3.08k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 3.08k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (len == 1 && (ISALPHA(*s) || ISNUMERIC(*s)) && (uprv_tolower(*s) != PRIVATEUSE)) { ------------------ | | 66| 3.08k|#define PRIVATEUSE 'x' ------------------ | Branch (579:9): [True: 3.13k, False: 5.49M] | Branch (579:22): [True: 2.54k, False: 586] | Branch (579:37): [True: 542, False: 44] | Branch (579:55): [True: 2.86k, False: 219] ------------------ 580| 2.86k| return true; 581| 2.86k| } 582| 5.49M| return false; 583| 5.50M|} uloc_tag.cpp:_ZN12_GLOBAL__N_119_addExtensionToListEPPNS_18ExtensionListEntryES1_b: 948| 1.73M|_addExtensionToList(ExtensionListEntry **first, ExtensionListEntry *ext, bool localeToBCP) { 949| 1.73M| bool bAdded = true; 950| | 951| 1.73M| if (*first == nullptr) { ------------------ | Branch (951:9): [True: 3.75k, False: 1.72M] ------------------ 952| 3.75k| ext->next = nullptr; 953| 3.75k| *first = ext; 954| 1.72M| } else { 955| 1.72M| ExtensionListEntry *prev, *cur; 956| 1.72M| int32_t cmp; 957| | 958| | /* reorder variants in alphabetical order */ 959| 1.72M| prev = nullptr; 960| 1.72M| cur = *first; 961| 15.4M| while (true) { ------------------ | Branch (961:16): [Folded - Ignored] ------------------ 962| 15.4M| if (cur == nullptr) { ------------------ | Branch (962:17): [True: 15.3k, False: 15.4M] ------------------ 963| 15.3k| prev->next = ext; 964| 15.3k| ext->next = nullptr; 965| 15.3k| break; 966| 15.3k| } 967| 15.4M| if (localeToBCP) { ------------------ | Branch (967:17): [True: 0, False: 15.4M] ------------------ 968| | /* special handling for locale to bcp conversion */ 969| 0| int32_t len, curlen; 970| | 971| 0| len = static_cast(uprv_strlen(ext->key)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 972| 0| curlen = static_cast(uprv_strlen(cur->key)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 973| | 974| 0| if (len == 1 && curlen == 1) { ------------------ | Branch (974:21): [True: 0, False: 0] | Branch (974:33): [True: 0, False: 0] ------------------ 975| 0| if (*(ext->key) == *(cur->key)) { ------------------ | Branch (975:25): [True: 0, False: 0] ------------------ 976| 0| cmp = 0; 977| 0| } else if (*(ext->key) == PRIVATEUSE) { ------------------ | | 66| 0|#define PRIVATEUSE 'x' ------------------ | Branch (977:32): [True: 0, False: 0] ------------------ 978| 0| cmp = 1; 979| 0| } else if (*(cur->key) == PRIVATEUSE) { ------------------ | | 66| 0|#define PRIVATEUSE 'x' ------------------ | Branch (979:32): [True: 0, False: 0] ------------------ 980| 0| cmp = -1; 981| 0| } else { 982| 0| cmp = *(ext->key) - *(cur->key); 983| 0| } 984| 0| } else if (len == 1) { ------------------ | Branch (984:28): [True: 0, False: 0] ------------------ 985| 0| cmp = *(ext->key) - LDMLEXT; ------------------ | | 67| 0|#define LDMLEXT 'u' ------------------ 986| 0| } else if (curlen == 1) { ------------------ | Branch (986:28): [True: 0, False: 0] ------------------ 987| 0| cmp = LDMLEXT - *(cur->key); ------------------ | | 67| 0|#define LDMLEXT 'u' ------------------ 988| 0| } else { 989| 0| cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); ------------------ | | 153| 0|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 990| | /* Both are u extension keys - we need special handling for 'attribute' */ 991| 0| if (cmp != 0) { ------------------ | Branch (991:25): [True: 0, False: 0] ------------------ 992| 0| if (uprv_strcmp(cur->key, LOCALE_ATTRIBUTE_KEY) == 0) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (992:29): [True: 0, False: 0] ------------------ 993| 0| cmp = 1; 994| 0| } else if (uprv_strcmp(ext->key, LOCALE_ATTRIBUTE_KEY) == 0) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (994:36): [True: 0, False: 0] ------------------ 995| 0| cmp = -1; 996| 0| } 997| 0| } 998| 0| } 999| 15.4M| } else { 1000| 15.4M| cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); ------------------ | | 153| 15.4M|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 15.4M|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 15.4M|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 1001| 15.4M| } 1002| 15.4M| if (cmp < 0) { ------------------ | Branch (1002:17): [True: 21.7k, False: 15.4M] ------------------ 1003| 21.7k| if (prev == nullptr) { ------------------ | Branch (1003:21): [True: 1.32k, False: 20.4k] ------------------ 1004| 1.32k| *first = ext; 1005| 20.4k| } else { 1006| 20.4k| prev->next = ext; 1007| 20.4k| } 1008| 21.7k| ext->next = cur; 1009| 21.7k| break; 1010| 21.7k| } 1011| 15.4M| if (cmp == 0) { ------------------ | Branch (1011:17): [True: 1.68M, False: 13.7M] ------------------ 1012| | /* duplicated extension key */ 1013| 1.68M| bAdded = false; 1014| 1.68M| break; 1015| 1.68M| } 1016| 13.7M| prev = cur; 1017| 13.7M| cur = cur->next; 1018| 13.7M| } 1019| 1.72M| } 1020| | 1021| 1.73M| return bAdded; 1022| 1.73M|} uloc_tag.cpp:_ZN12_GLOBAL__N_111ultag_parseEPKciPiR10UErrorCode: 1979| 2.52k|ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode& status) { 1980| 2.52k| if (U_FAILURE(status)) { return nullptr; } ------------------ | Branch (1980:9): [True: 0, False: 2.52k] ------------------ 1981| | 1982| 2.52k| char *tagBuf; 1983| 2.52k| int16_t next; 1984| 2.52k| char *pSubtag, *pNext, *pLastGoodPosition; 1985| 2.52k| int32_t subtagLen; 1986| 2.52k| int32_t extlangIdx; 1987| 2.52k| icu::LocalPointer pExtension; 1988| 2.52k| char *pExtValueSubtag, *pExtValueSubtagEnd; 1989| 2.52k| int32_t i; 1990| 2.52k| bool privateuseVar = false; 1991| 2.52k| int32_t legacyLen = 0; 1992| | 1993| 2.52k| if (parsedLen != nullptr) { ------------------ | Branch (1993:9): [True: 0, False: 2.52k] ------------------ 1994| 0| *parsedLen = 0; 1995| 0| } 1996| | 1997| 2.52k| if (tagLen < 0) { ------------------ | Branch (1997:9): [True: 2.52k, False: 0] ------------------ 1998| 2.52k| tagLen = static_cast(uprv_strlen(tag)); ------------------ | | 37| 2.52k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 2.52k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1999| 2.52k| } 2000| | 2001| | /* copy the entire string */ 2002| 2.52k| tagBuf = static_cast(uprv_malloc(tagLen + 1)); ------------------ | | 1524| 2.52k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2003| 2.52k| if (tagBuf == nullptr) { ------------------ | Branch (2003:9): [True: 0, False: 2.52k] ------------------ 2004| 0| status = U_MEMORY_ALLOCATION_ERROR; 2005| 0| return nullptr; 2006| 0| } 2007| | 2008| 2.52k| if (tagLen > 0) { ------------------ | Branch (2008:9): [True: 2.52k, False: 0] ------------------ 2009| 2.52k| uprv_memcpy(tagBuf, tag, tagLen); ------------------ | | 42| 2.52k|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2.52k|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2.52k| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2.52k| _Pragma("clang diagnostic push") \ | | 45| 2.52k| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2.52k| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2.52k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2.52k| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2.52k|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2.52k| _Pragma("clang diagnostic pop") \ | | 49| 2.52k| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2.52k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2.52k|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2.52k|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2010| 2.52k| } 2011| 2.52k| *(tagBuf + tagLen) = 0; 2012| | 2013| | /* create a ULanguageTag */ 2014| 2.52k| icu::LocalULanguageTagPointer t( 2015| 2.52k| static_cast(uprv_malloc(sizeof(ULanguageTag)))); ------------------ | | 1524| 2.52k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 2.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2016| 2.52k| if (t.isNull()) { ------------------ | Branch (2016:9): [True: 0, False: 2.52k] ------------------ 2017| 0| uprv_free(tagBuf); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2018| 0| status = U_MEMORY_ALLOCATION_ERROR; 2019| 0| return nullptr; 2020| 0| } 2021| 2.52k| _initializeULanguageTag(t.getAlias()); 2022| 2.52k| t->buf = tagBuf; 2023| | 2024| 2.52k| if (tagLen < MINLEN) { ------------------ | | 64| 2.52k|#define MINLEN 2 ------------------ | Branch (2024:9): [True: 29, False: 2.49k] ------------------ 2025| | /* the input tag is too short - return empty ULanguageTag */ 2026| 29| return t.orphan(); 2027| 29| } 2028| | 2029| 2.49k| size_t parsedLenDelta = 0; 2030| | // Legacy tag will be consider together. Legacy tag with intervening 2031| | // script and region such as art-DE-lojban or art-Latn-lojban won't be 2032| | // matched. 2033| | /* check if the tag is legacy */ 2034| 64.3k| for (i = 0; i < UPRV_LENGTHOF(LEGACY); i += 2) { ------------------ | | 99| 64.3k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (2034:17): [True: 61.9k, False: 2.38k] ------------------ 2035| 61.9k| int32_t checkLegacyLen = static_cast(uprv_strlen(LEGACY[i])); ------------------ | | 37| 61.9k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 61.9k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2036| 61.9k| if (tagLen < checkLegacyLen) { ------------------ | Branch (2036:13): [True: 7.04k, False: 54.9k] ------------------ 2037| 7.04k| continue; 2038| 7.04k| } 2039| 54.9k| if (tagLen > checkLegacyLen && tagBuf[checkLegacyLen] != '-') { ------------------ | Branch (2039:13): [True: 53.2k, False: 1.70k] | Branch (2039:40): [True: 45.7k, False: 7.45k] ------------------ 2040| | // make sure next char is '-'. 2041| 45.7k| continue; 2042| 45.7k| } 2043| 9.15k| if (uprv_strnicmp(LEGACY[i], tagBuf, checkLegacyLen) == 0) { ------------------ | | 1544| 9.15k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 9.15k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 9.15k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 9.15k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2043:13): [True: 116, False: 9.04k] ------------------ 2044| 116| int32_t newTagLength; 2045| | 2046| 116| legacyLen = checkLegacyLen; /* back up for output parsedLen */ 2047| 116| int32_t replacementLen = static_cast(uprv_strlen(LEGACY[i+1])); ------------------ | | 37| 116|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 116|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2048| 116| newTagLength = replacementLen + tagLen - checkLegacyLen; 2049| 116| int32_t oldTagLength = tagLen; 2050| 116| if (tagLen < newTagLength) { ------------------ | Branch (2050:17): [True: 97, False: 19] ------------------ 2051| 97| uprv_free(tagBuf); ------------------ | | 1503| 97|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 97|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 97|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 97|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2052| | // Change t->buf after the free and before return to avoid the second double free in 2053| | // the destructor of t when t is out of scope. 2054| 97| t->buf = tagBuf = static_cast(uprv_malloc(newTagLength + 1)); ------------------ | | 1524| 97|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 97|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 97|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 97|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2055| 97| if (tagBuf == nullptr) { ------------------ | Branch (2055:21): [True: 0, False: 97] ------------------ 2056| 0| status = U_MEMORY_ALLOCATION_ERROR; 2057| 0| return nullptr; 2058| 0| } 2059| 97| tagLen = newTagLength; 2060| 97| } 2061| 116| parsedLenDelta = checkLegacyLen - replacementLen; 2062| 116| uprv_strcpy(t->buf, LEGACY[i + 1]); ------------------ | | 36| 116|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 116|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2063| 116| if (checkLegacyLen != tagLen) { ------------------ | Branch (2063:17): [True: 109, False: 7] ------------------ 2064| 109| uprv_memcpy(t->buf + replacementLen, tag + checkLegacyLen, ------------------ | | 42| 109|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 109|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 109| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 109| _Pragma("clang diagnostic push") \ | | 45| 109| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 109| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 109|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 109| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 109|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 109| _Pragma("clang diagnostic pop") \ | | 49| 109| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 109|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 109|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 109|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2065| 109| oldTagLength - checkLegacyLen); 2066| | // NUL-terminate after memcpy(). 2067| 109| t->buf[replacementLen + oldTagLength - checkLegacyLen] = 0; 2068| 109| } 2069| 116| break; 2070| 116| } 2071| 9.15k| } 2072| | 2073| 2.49k| if (legacyLen == 0) { ------------------ | Branch (2073:9): [True: 2.38k, False: 116] ------------------ 2074| 64.1k| for (i = 0; i < UPRV_LENGTHOF(REDUNDANT); i += 2) { ------------------ | | 99| 64.1k|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (2074:21): [True: 61.7k, False: 2.37k] ------------------ 2075| 61.7k| const char* redundantTag = REDUNDANT[i]; 2076| 61.7k| size_t redundantTagLen = uprv_strlen(redundantTag); ------------------ | | 37| 61.7k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 61.7k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2077| | // The preferred tag for a redundant tag is always shorter than redundant 2078| | // tag. A redundant tag may or may not be followed by other subtags. 2079| | // (i.e. "zh-yue" or "zh-yue-u-co-pinyin"). 2080| 61.7k| if (uprv_strnicmp(redundantTag, tagBuf, static_cast(redundantTagLen)) == 0) { ------------------ | | 1544| 61.7k|#define uprv_strnicmp U_ICU_ENTRY_POINT_RENAME(uprv_strnicmp) | | ------------------ | | | | 123| 61.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 61.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 61.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2080:17): [True: 18, False: 61.7k] ------------------ 2081| 18| const char* redundantTagEnd = tagBuf + redundantTagLen; 2082| 18| if (*redundantTagEnd == '\0' || *redundantTagEnd == SEP) { ------------------ | | 65| 18|#define SEP '-' ------------------ | Branch (2082:21): [True: 0, False: 18] | Branch (2082:50): [True: 5, False: 13] ------------------ 2083| 5| const char* preferredTag = REDUNDANT[i + 1]; 2084| 5| size_t preferredTagLen = uprv_strlen(preferredTag); ------------------ | | 37| 5|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 5|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2085| 5| uprv_memcpy(t->buf, preferredTag, preferredTagLen); ------------------ | | 42| 5|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 5| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 5| _Pragma("clang diagnostic push") \ | | 45| 5| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 5| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 5| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 5| _Pragma("clang diagnostic pop") \ | | 49| 5| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 5|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 5|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2086| 5| if (*redundantTagEnd == SEP) { ------------------ | | 65| 5|#define SEP '-' ------------------ | Branch (2086:25): [True: 5, False: 0] ------------------ 2087| 5| uprv_memmove(tagBuf + preferredTagLen, ------------------ | | 51| 5|#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 5|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 52| 5| /* Suppress warnings about addresses that will never be NULL */ \ | | 53| 5| _Pragma("clang diagnostic push") \ | | 54| 5| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 55| 5| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 56| 5| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 5|# define U_ASSERT(exp) (void)0 | | ------------------ | | 57| 5| _Pragma("clang diagnostic pop") \ | | 58| 5| U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \ | | ------------------ | | | | 393| 5|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 59| 5|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 5|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2088| 5| redundantTagEnd, 2089| 5| tagLen - redundantTagLen + 1); 2090| 5| } else { 2091| 0| tagBuf[preferredTagLen] = '\0'; 2092| 0| } 2093| | // parsedLen should be the length of the input 2094| | // before redundantTag is replaced by preferredTag. 2095| | // Save the delta to add it back later. 2096| 5| parsedLenDelta = redundantTagLen - preferredTagLen; 2097| 5| break; 2098| 5| } 2099| 18| } 2100| 61.7k| } 2101| 2.38k| } 2102| | 2103| | /* 2104| | * langtag = language 2105| | * ["-" script] 2106| | * ["-" region] 2107| | * *("-" variant) 2108| | * *("-" extension) 2109| | * ["-" privateuse] 2110| | */ 2111| | 2112| 2.49k| next = LANG | PRIV; ------------------ | | 1959| 2.49k|#define LANG 0x0001 ------------------ next = LANG | PRIV; ------------------ | | 1966| 2.49k|#define PRIV 0x0080 ------------------ 2113| 2.49k| pNext = pLastGoodPosition = tagBuf; 2114| 2.49k| extlangIdx = 0; 2115| 2.49k| pExtValueSubtag = nullptr; 2116| 2.49k| pExtValueSubtagEnd = nullptr; 2117| | 2118| 5.51M| while (pNext) { ------------------ | Branch (2118:12): [True: 5.50M, False: 1.08k] ------------------ 2119| 5.50M| char *pSep; 2120| | 2121| 5.50M| pSubtag = pNext; 2122| | 2123| | /* locate next separator char */ 2124| 5.50M| pSep = pSubtag; 2125| 46.1M| while (*pSep) { ------------------ | Branch (2125:16): [True: 46.1M, False: 1.68k] ------------------ 2126| 46.1M| if (*pSep == SEP) { ------------------ | | 65| 46.1M|#define SEP '-' ------------------ | Branch (2126:17): [True: 5.50M, False: 40.5M] ------------------ 2127| 5.50M| break; 2128| 5.50M| } 2129| 40.5M| pSep++; 2130| 40.5M| } 2131| 5.50M| if (*pSep == 0) { ------------------ | Branch (2131:13): [True: 1.68k, False: 5.50M] ------------------ 2132| | /* last subtag */ 2133| 1.68k| pNext = nullptr; 2134| 5.50M| } else { 2135| 5.50M| pNext = pSep + 1; 2136| 5.50M| } 2137| 5.50M| subtagLen = static_cast(pSep - pSubtag); 2138| | 2139| 5.50M| if (next & LANG) { ------------------ | | 1959| 5.50M|#define LANG 0x0001 ------------------ | Branch (2139:13): [True: 2.49k, False: 5.50M] ------------------ 2140| 2.49k| if (ultag_isLanguageSubtag(pSubtag, subtagLen)) { ------------------ | | 1225| 2.49k|#define ultag_isLanguageSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isLanguageSubtag) | | ------------------ | | | | 123| 2.49k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.49k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.49k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2140:17): [True: 1.77k, False: 725] ------------------ 2141| 1.77k| *pSep = 0; /* terminate */ 2142| | // TODO: move deprecated language code handling here. 2143| 1.77k| t->language = T_CString_toLowerCase(pSubtag); ------------------ | | 69| 1.77k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 1.77k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.77k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.77k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2144| | 2145| 1.77k| pLastGoodPosition = pSep; 2146| 1.77k| next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1961| 1.77k|#define SCRT 0x0004 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1962| 1.77k|#define REGN 0x0008 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1963| 1.77k|#define VART 0x0010 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1964| 1.77k|#define EXTS 0x0020 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1966| 1.77k|#define PRIV 0x0080 ------------------ 2147| 1.77k| if (subtagLen <= 3) ------------------ | Branch (2147:21): [True: 1.71k, False: 57] ------------------ 2148| 1.71k| next |= EXTL; ------------------ | | 1960| 1.71k|#define EXTL 0x0002 ------------------ 2149| 1.77k| continue; 2150| 1.77k| } 2151| 2.49k| } 2152| 5.50M| if (next & EXTL) { ------------------ | | 1960| 5.50M|#define EXTL 0x0002 ------------------ | Branch (2152:13): [True: 1.77k, False: 5.50M] ------------------ 2153| 1.77k| if (_isExtlangSubtag(pSubtag, subtagLen)) { ------------------ | Branch (2153:17): [True: 86, False: 1.68k] ------------------ 2154| 86| *pSep = 0; 2155| 86| t->extlang[extlangIdx++] = T_CString_toLowerCase(pSubtag); ------------------ | | 69| 86|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 86|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 86|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 86|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2156| | 2157| 86| pLastGoodPosition = pSep; 2158| 86| if (extlangIdx < 3) { ------------------ | Branch (2158:21): [True: 64, False: 22] ------------------ 2159| 64| next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1960| 64|#define EXTL 0x0002 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1961| 64|#define SCRT 0x0004 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1962| 64|#define REGN 0x0008 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1963| 64|#define VART 0x0010 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1964| 64|#define EXTS 0x0020 ------------------ next = EXTL | SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1966| 64|#define PRIV 0x0080 ------------------ 2160| 64| } else { 2161| 22| next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1961| 22|#define SCRT 0x0004 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1962| 22|#define REGN 0x0008 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1963| 22|#define VART 0x0010 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1964| 22|#define EXTS 0x0020 ------------------ next = SCRT | REGN | VART | EXTS | PRIV; ------------------ | | 1966| 22|#define PRIV 0x0080 ------------------ 2162| 22| } 2163| 86| continue; 2164| 86| } 2165| 1.77k| } 2166| 5.50M| if (next & SCRT) { ------------------ | | 1961| 5.50M|#define SCRT 0x0004 ------------------ | Branch (2166:13): [True: 1.76k, False: 5.50M] ------------------ 2167| 1.76k| if (ultag_isScriptSubtag(pSubtag, subtagLen)) { ------------------ | | 1228| 1.76k|#define ultag_isScriptSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isScriptSubtag) | | ------------------ | | | | 123| 1.76k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.76k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.76k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2167:17): [True: 12, False: 1.75k] ------------------ 2168| 12| char *p = pSubtag; 2169| | 2170| 12| *pSep = 0; 2171| | 2172| | /* to title case */ 2173| 12| *p = uprv_toupper(*p); ------------------ | | 1547| 12|#define uprv_toupper U_ICU_ENTRY_POINT_RENAME(uprv_toupper) | | ------------------ | | | | 123| 12|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 12|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 12|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2174| 12| p++; 2175| 48| for (; *p; p++) { ------------------ | Branch (2175:24): [True: 36, False: 12] ------------------ 2176| 36| *p = uprv_tolower(*p); ------------------ | | 68| 36|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 36|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 36|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 36|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 36|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2177| 36| } 2178| | 2179| 12| t->script = pSubtag; 2180| | 2181| 12| pLastGoodPosition = pSep; 2182| 12| next = REGN | VART | EXTS | PRIV; ------------------ | | 1962| 12|#define REGN 0x0008 ------------------ next = REGN | VART | EXTS | PRIV; ------------------ | | 1963| 12|#define VART 0x0010 ------------------ next = REGN | VART | EXTS | PRIV; ------------------ | | 1964| 12|#define EXTS 0x0020 ------------------ next = REGN | VART | EXTS | PRIV; ------------------ | | 1966| 12|#define PRIV 0x0080 ------------------ 2183| 12| continue; 2184| 12| } 2185| 1.76k| } 2186| 5.50M| if (next & REGN) { ------------------ | | 1962| 5.50M|#define REGN 0x0008 ------------------ | Branch (2186:13): [True: 1.76k, False: 5.50M] ------------------ 2187| 1.76k| if (ultag_isRegionSubtag(pSubtag, subtagLen)) { ------------------ | | 1227| 1.76k|#define ultag_isRegionSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isRegionSubtag) | | ------------------ | | | | 123| 1.76k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.76k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.76k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2187:17): [True: 34, False: 1.72k] ------------------ 2188| 34| *pSep = 0; 2189| | // TODO: move deprecated region code handling here. 2190| 34| t->region = T_CString_toUpperCase(pSubtag); ------------------ | | 70| 34|#define T_CString_toUpperCase U_ICU_ENTRY_POINT_RENAME(T_CString_toUpperCase) | | ------------------ | | | | 123| 34|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 34|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 34|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2191| | 2192| 34| pLastGoodPosition = pSep; 2193| 34| next = VART | EXTS | PRIV; ------------------ | | 1963| 34|#define VART 0x0010 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1964| 34|#define EXTS 0x0020 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1966| 34|#define PRIV 0x0080 ------------------ 2194| 34| continue; 2195| 34| } 2196| 1.76k| } 2197| 5.50M| if (next & VART) { ------------------ | | 1963| 5.50M|#define VART 0x0010 ------------------ | Branch (2197:13): [True: 3.98k, False: 5.50M] ------------------ 2198| 3.98k| if (_isVariantSubtag(pSubtag, subtagLen) || ------------------ | Branch (2198:17): [True: 699, False: 3.28k] ------------------ 2199| 3.98k| (privateuseVar && _isPrivateuseVariantSubtag(pSubtag, subtagLen))) { ------------------ | Branch (2199:17): [True: 1.52k, False: 1.75k] | Branch (2199:34): [True: 1.45k, False: 77] ------------------ 2200| 2.14k| icu::LocalPointer var(new VariantListEntry, status); 2201| 2.14k| if (U_FAILURE(status)) { ------------------ | Branch (2201:21): [True: 0, False: 2.14k] ------------------ 2202| 0| return nullptr; 2203| 0| } 2204| 2.14k| *pSep = 0; 2205| 2.14k| var->variant = T_CString_toUpperCase(pSubtag); ------------------ | | 70| 2.14k|#define T_CString_toUpperCase U_ICU_ENTRY_POINT_RENAME(T_CString_toUpperCase) | | ------------------ | | | | 123| 2.14k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.14k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.14k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2206| 2.14k| if (!_addVariantToList(&(t->variants), std::move(var))) { ------------------ | Branch (2206:21): [True: 8, False: 2.14k] ------------------ 2207| | /* duplicated variant entry */ 2208| 8| break; 2209| 8| } 2210| 2.14k| pLastGoodPosition = pSep; 2211| 2.14k| next = VART | EXTS | PRIV; ------------------ | | 1963| 2.14k|#define VART 0x0010 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1964| 2.14k|#define EXTS 0x0020 ------------------ next = VART | EXTS | PRIV; ------------------ | | 1966| 2.14k|#define PRIV 0x0080 ------------------ 2212| 2.14k| continue; 2213| 2.14k| } 2214| 3.98k| } 2215| 5.50M| if (next & EXTS) { ------------------ | | 1964| 5.50M|#define EXTS 0x0020 ------------------ | Branch (2215:13): [True: 5.50M, False: 3.61k] ------------------ 2216| 5.50M| if (_isExtensionSingleton(pSubtag, subtagLen)) { ------------------ | Branch (2216:17): [True: 2.86k, False: 5.49M] ------------------ 2217| 2.86k| if (pExtension.isValid()) { ------------------ | Branch (2217:21): [True: 1.45k, False: 1.41k] ------------------ 2218| 1.45k| if (pExtValueSubtag == nullptr || pExtValueSubtagEnd == nullptr) { ------------------ | Branch (2218:25): [True: 0, False: 1.45k] | Branch (2218:55): [True: 0, False: 1.45k] ------------------ 2219| | /* the previous extension is incomplete */ 2220| 0| delete pExtension.orphan(); 2221| 0| break; 2222| 0| } 2223| | 2224| | /* terminate the previous extension value */ 2225| 1.45k| *pExtValueSubtagEnd = 0; 2226| 1.45k| pExtension->value = T_CString_toLowerCase(pExtValueSubtag); ------------------ | | 69| 1.45k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 1.45k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.45k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.45k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2227| | 2228| | /* insert the extension to the list */ 2229| 1.45k| if (_addExtensionToList(&(t->extensions), pExtension.getAlias(), false)) { ------------------ | Branch (2229:25): [True: 1.44k, False: 3] ------------------ 2230| 1.44k| pExtension.orphan(); 2231| 1.44k| pLastGoodPosition = pExtValueSubtagEnd; 2232| 1.44k| } else { 2233| | /* stop parsing here */ 2234| 3| delete pExtension.orphan(); 2235| 3| break; 2236| 3| } 2237| 1.45k| } 2238| | 2239| | /* create a new extension */ 2240| 2.86k| pExtension.adoptInsteadAndCheckErrorCode(new ExtensionListEntry, status); 2241| 2.86k| if (U_FAILURE(status)) { ------------------ | Branch (2241:21): [True: 0, False: 2.86k] ------------------ 2242| 0| return nullptr; 2243| 0| } 2244| 2.86k| *pSep = 0; 2245| 2.86k| pExtension->key = T_CString_toLowerCase(pSubtag); ------------------ | | 69| 2.86k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 2.86k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.86k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.86k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2246| 2.86k| pExtension->value = nullptr; /* will be set later */ 2247| | 2248| | /* 2249| | * reset the start and the end location of extension value 2250| | * subtags for this extension 2251| | */ 2252| 2.86k| pExtValueSubtag = nullptr; 2253| 2.86k| pExtValueSubtagEnd = nullptr; 2254| | 2255| 2.86k| next = EXTV; ------------------ | | 1965| 2.86k|#define EXTV 0x0040 ------------------ 2256| 2.86k| continue; 2257| 2.86k| } 2258| 5.50M| } 2259| 5.50M| if (next & EXTV) { ------------------ | | 1965| 5.50M|#define EXTV 0x0040 ------------------ | Branch (2259:13): [True: 5.50M, False: 1.14k] ------------------ 2260| 5.50M| if (_isExtensionSubtag(pSubtag, subtagLen)) { ------------------ | Branch (2260:17): [True: 5.50M, False: 411] ------------------ 2261| 5.50M| if (pExtValueSubtag == nullptr) { ------------------ | Branch (2261:21): [True: 2.62k, False: 5.49M] ------------------ 2262| | /* if the start position of this extension's value is not yet, 2263| | this one is the first value subtag */ 2264| 2.62k| pExtValueSubtag = pSubtag; 2265| 2.62k| } 2266| | 2267| | /* Mark the end of this subtag */ 2268| 5.50M| pExtValueSubtagEnd = pSep; 2269| 5.50M| next = EXTS | EXTV | PRIV; ------------------ | | 1964| 5.50M|#define EXTS 0x0020 ------------------ next = EXTS | EXTV | PRIV; ------------------ | | 1965| 5.50M|#define EXTV 0x0040 ------------------ next = EXTS | EXTV | PRIV; ------------------ | | 1966| 5.50M|#define PRIV 0x0080 ------------------ 2270| | 2271| 5.50M| continue; 2272| 5.50M| } 2273| 5.50M| } 2274| 1.55k| if (next & PRIV) { ------------------ | | 1966| 1.55k|#define PRIV 0x0080 ------------------ | Branch (2274:13): [True: 1.28k, False: 262] ------------------ 2275| 1.28k| if (uprv_tolower(*pSubtag) == PRIVATEUSE && subtagLen == 1) { ------------------ | | 68| 1.28k|# define uprv_tolower uprv_asciitolower | | ------------------ | | | | 1397| 1.28k|#define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower) | | | | ------------------ | | | | | | 123| 1.28k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | | | ------------------ | | | | | | | | 122| 1.28k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.28k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (uprv_tolower(*pSubtag) == PRIVATEUSE && subtagLen == 1) { ------------------ | | 66| 2.57k|#define PRIVATEUSE 'x' ------------------ | Branch (2275:17): [True: 653, False: 636] | Branch (2275:57): [True: 560, False: 93] ------------------ 2276| 560| char *pPrivuseVal; 2277| | 2278| 560| if (pExtension.isValid()) { ------------------ | Branch (2278:21): [True: 114, False: 446] ------------------ 2279| | /* Process the last extension */ 2280| 114| if (pExtValueSubtag == nullptr || pExtValueSubtagEnd == nullptr) { ------------------ | Branch (2280:25): [True: 0, False: 114] | Branch (2280:55): [True: 0, False: 114] ------------------ 2281| | /* the previous extension is incomplete */ 2282| 0| delete pExtension.orphan(); 2283| 0| break; 2284| 114| } else { 2285| | /* terminate the previous extension value */ 2286| 114| *pExtValueSubtagEnd = 0; 2287| 114| pExtension->value = T_CString_toLowerCase(pExtValueSubtag); ------------------ | | 69| 114|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 114|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 114|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 114|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2288| | 2289| | /* insert the extension to the list */ 2290| 114| if (_addExtensionToList(&(t->extensions), pExtension.getAlias(), false)) { ------------------ | Branch (2290:29): [True: 113, False: 1] ------------------ 2291| 113| pExtension.orphan(); 2292| 113| pLastGoodPosition = pExtValueSubtagEnd; 2293| 113| } else { 2294| | /* stop parsing here */ 2295| 1| delete pExtension.orphan(); 2296| 1| break; 2297| 1| } 2298| 114| } 2299| 114| } 2300| | 2301| | /* The rest of part will be private use value subtags */ 2302| 559| if (pNext == nullptr) { ------------------ | Branch (2302:21): [True: 2, False: 557] ------------------ 2303| | /* empty private use subtag */ 2304| 2| break; 2305| 2| } 2306| | /* back up the private use value start position */ 2307| 557| pPrivuseVal = pNext; 2308| | 2309| | /* validate private use value subtags */ 2310| 5.23M| while (pNext) { ------------------ | Branch (2310:24): [True: 5.23M, False: 200] ------------------ 2311| 5.23M| pSubtag = pNext; 2312| 5.23M| pSep = pSubtag; 2313| 26.3M| while (*pSep) { ------------------ | Branch (2313:28): [True: 26.3M, False: 342] ------------------ 2314| 26.3M| if (*pSep == SEP) { ------------------ | | 65| 26.3M|#define SEP '-' ------------------ | Branch (2314:29): [True: 5.23M, False: 21.1M] ------------------ 2315| 5.23M| break; 2316| 5.23M| } 2317| 21.1M| pSep++; 2318| 21.1M| } 2319| 5.23M| if (*pSep == 0) { ------------------ | Branch (2319:25): [True: 342, False: 5.23M] ------------------ 2320| | /* last subtag */ 2321| 342| pNext = nullptr; 2322| 5.23M| } else { 2323| 5.23M| pNext = pSep + 1; 2324| 5.23M| } 2325| 5.23M| subtagLen = static_cast(pSep - pSubtag); 2326| | 2327| 5.23M| if (uprv_strncmp(pSubtag, PRIVUSE_VARIANT_PREFIX, uprv_strlen(PRIVUSE_VARIANT_PREFIX)) == 0) { ------------------ | | 44| 5.23M|#define uprv_strncmp(s1, s2, n) U_STANDARD_CPP_NAMESPACE strncmp(s1, s2, n) | | ------------------ | | | | 393| 5.23M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (2327:25): [True: 152, False: 5.23M] ------------------ 2328| 152| *pSep = 0; 2329| 152| next = VART; ------------------ | | 1963| 152|#define VART 0x0010 ------------------ 2330| 152| privateuseVar = true; 2331| 152| break; 2332| 5.23M| } else if (_isPrivateuseValueSubtag(pSubtag, subtagLen)) { ------------------ | Branch (2332:32): [True: 5.23M, False: 205] ------------------ 2333| 5.23M| pLastGoodPosition = pSep; 2334| 5.23M| } else { 2335| 205| break; 2336| 205| } 2337| 5.23M| } 2338| | 2339| 557| if (next == VART) { ------------------ | | 1963| 557|#define VART 0x0010 ------------------ | Branch (2339:21): [True: 152, False: 405] ------------------ 2340| 152| continue; 2341| 152| } 2342| | 2343| 405| if (pLastGoodPosition - pPrivuseVal > 0) { ------------------ | Branch (2343:21): [True: 284, False: 121] ------------------ 2344| 284| *pLastGoodPosition = 0; 2345| 284| t->privateuse = T_CString_toLowerCase(pPrivuseVal); ------------------ | | 69| 284|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 284|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 284|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 284|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2346| 284| } 2347| | /* No more subtags, exiting the parse loop */ 2348| 405| break; 2349| 557| } 2350| 729| break; 2351| 1.28k| } 2352| | 2353| | /* If we fell through here, it means this subtag is illegal - quit parsing */ 2354| 262| break; 2355| 1.55k| } 2356| | 2357| 2.49k| if (pExtension.isValid()) { ------------------ | Branch (2357:9): [True: 1.30k, False: 1.19k] ------------------ 2358| | /* Process the last extension */ 2359| 1.30k| if (pExtValueSubtag == nullptr || pExtValueSubtagEnd == nullptr) { ------------------ | Branch (2359:13): [True: 237, False: 1.06k] | Branch (2359:43): [True: 0, False: 1.06k] ------------------ 2360| | /* the previous extension is incomplete */ 2361| 237| delete pExtension.orphan(); 2362| 1.06k| } else { 2363| | /* terminate the previous extension value */ 2364| 1.06k| *pExtValueSubtagEnd = 0; 2365| 1.06k| pExtension->value = T_CString_toLowerCase(pExtValueSubtag); ------------------ | | 69| 1.06k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 1.06k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.06k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.06k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2366| | /* insert the extension to the list */ 2367| 1.06k| if (_addExtensionToList(&(t->extensions), pExtension.getAlias(), false)) { ------------------ | Branch (2367:17): [True: 1.05k, False: 9] ------------------ 2368| 1.05k| pExtension.orphan(); 2369| 1.05k| pLastGoodPosition = pExtValueSubtagEnd; 2370| 1.05k| } else { 2371| 9| delete pExtension.orphan(); 2372| 9| } 2373| 1.06k| } 2374| 1.30k| } 2375| | 2376| 2.49k| if (parsedLen != nullptr) { ------------------ | Branch (2376:9): [True: 0, False: 2.49k] ------------------ 2377| 0| *parsedLen = static_cast(pLastGoodPosition - t->buf + parsedLenDelta); 2378| 0| } 2379| | 2380| 2.49k| return t.orphan(); 2381| 2.49k|} uloc_tag.cpp:_ZN12_GLOBAL__N_123_initializeULanguageTagEPNS_12ULanguageTagE: 1025| 2.52k|_initializeULanguageTag(ULanguageTag* langtag) { 1026| 2.52k| int32_t i; 1027| | 1028| 2.52k| langtag->buf = nullptr; 1029| | 1030| 2.52k| langtag->language = EMPTY; 1031| 10.1k| for (i = 0; i < MAXEXTLANG; i++) { ------------------ | | 51| 10.1k|#define MAXEXTLANG 3 ------------------ | Branch (1031:17): [True: 7.57k, False: 2.52k] ------------------ 1032| 7.57k| langtag->extlang[i] = nullptr; 1033| 7.57k| } 1034| | 1035| 2.52k| langtag->script = EMPTY; 1036| 2.52k| langtag->region = EMPTY; 1037| | 1038| 2.52k| langtag->variants = nullptr; 1039| 2.52k| langtag->extensions = nullptr; 1040| | 1041| 2.52k| langtag->legacy = EMPTY; 1042| 2.52k| langtag->privateuse = EMPTY; 1043| 2.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116_isExtlangSubtagEPKci: 449| 1.77k|_isExtlangSubtag(const char* s, int32_t len) { 450| | /* 451| | * extlang = 3ALPHA ; selected ISO 639 codes 452| | * *2("-" 3ALPHA) ; permanently reserved 453| | */ 454| 1.77k| if (len < 0) { ------------------ | Branch (454:9): [True: 0, False: 1.77k] ------------------ 455| 0| len = static_cast(uprv_strlen(s)); ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 456| 0| } 457| 1.77k| if (len == 3 && _isAlphaString(s, len)) { ------------------ | Branch (457:9): [True: 115, False: 1.65k] | Branch (457:21): [True: 86, False: 29] ------------------ 458| 86| return true; 459| 86| } 460| 1.68k| return false; 461| 1.77k|} uloc_tag.cpp:_ZN12_GLOBAL__N_126_isPrivateuseVariantSubtagEPKci: 557| 1.52k|_isPrivateuseVariantSubtag(const char* s, int32_t len) { 558| | /* 559| | * variant = 1*8alphanum ; registered variants 560| | * / (DIGIT 3alphanum) 561| | */ 562| 1.52k| return _isAlphaNumericStringLimitedLength(s, len , 1, 8); 563| 1.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_120ultag_getExtlangSizeEPKNS_12ULanguageTagE: 2445| 2.52k|ultag_getExtlangSize(const ULanguageTag* langtag) { 2446| 2.52k| int32_t size = 0; 2447| 2.52k| int32_t i; 2448| 10.1k| for (i = 0; i < MAXEXTLANG; i++) { ------------------ | | 51| 10.1k|#define MAXEXTLANG 3 ------------------ | Branch (2448:17): [True: 7.57k, False: 2.52k] ------------------ 2449| 7.57k| if (langtag->extlang[i]) { ------------------ | Branch (2449:13): [True: 86, False: 7.48k] ------------------ 2450| 86| size++; 2451| 86| } 2452| 7.57k| } 2453| 2.52k| return size; 2454| 2.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116ultag_getExtlangEPKNS_12ULanguageTagEi: 2437| 40|ultag_getExtlang(const ULanguageTag* langtag, int32_t idx) { 2438| 40| if (idx >= 0 && idx < MAXEXTLANG) { ------------------ | | 51| 40|#define MAXEXTLANG 3 ------------------ | Branch (2438:9): [True: 40, False: 0] | Branch (2438:21): [True: 40, False: 0] ------------------ 2439| 40| return langtag->extlang[idx]; 2440| 40| } 2441| 0| return nullptr; 2442| 40|} uloc_tag.cpp:_ZN12_GLOBAL__N_117ultag_getLanguageEPKNS_12ULanguageTagE: 2419| 2.48k|ultag_getLanguage(const ULanguageTag* langtag) { 2420| 2.48k| return langtag->language; 2421| 2.48k|} uloc_tag.cpp:_ZN12_GLOBAL__N_115ultag_getScriptEPKNS_12ULanguageTagE: 2457| 2.52k|ultag_getScript(const ULanguageTag* langtag) { 2458| 2.52k| return langtag->script; 2459| 2.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_115ultag_getRegionEPKNS_12ULanguageTagE: 2462| 2.52k|ultag_getRegion(const ULanguageTag* langtag) { 2463| 2.52k| return langtag->region; 2464| 2.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_113_sortVariantsEPNS_16VariantListEntryE: 1158| 2.52k|void _sortVariants(VariantListEntry* first) { 1159| 4.66k| for (VariantListEntry* var1 = first; var1 != nullptr; var1 = var1->next) { ------------------ | Branch (1159:42): [True: 2.14k, False: 2.52k] ------------------ 1160| 59.8k| for (VariantListEntry* var2 = var1->next; var2 != nullptr; var2 = var2->next) { ------------------ | Branch (1160:51): [True: 57.7k, False: 2.14k] ------------------ 1161| | // Swap var1->variant and var2->variant. 1162| 57.7k| if (uprv_compareInvCharsAsAscii(var1->variant, var2->variant) > 0) { ------------------ | | 153| 57.7k|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 57.7k|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 57.7k|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ | Branch (1162:17): [True: 28.4k, False: 29.2k] ------------------ 1163| 28.4k| const char* temp = var1->variant; 1164| 28.4k| var1->variant = var2->variant; 1165| 28.4k| var2->variant = temp; 1166| 28.4k| } 1167| 57.7k| } 1168| 2.14k| } 1169| 2.52k|} uloc_tag.cpp:_ZN12_GLOBAL__N_121ultag_getVariantsSizeEPKNS_12ULanguageTagE: 2483| 3.67k|ultag_getVariantsSize(const ULanguageTag* langtag) { 2484| 3.67k| int32_t size = 0; 2485| 3.67k| VariantListEntry *cur = langtag->variants; 2486| 5.99k| while (true) { ------------------ | Branch (2486:12): [Folded - Ignored] ------------------ 2487| 5.99k| if (cur == nullptr) { ------------------ | Branch (2487:13): [True: 3.67k, False: 2.32k] ------------------ 2488| 3.67k| break; 2489| 3.67k| } 2490| 2.32k| size++; 2491| 2.32k| cur = cur->next; 2492| 2.32k| } 2493| 3.67k| return size; 2494| 3.67k|} uloc_tag.cpp:_ZN12_GLOBAL__N_116ultag_getVariantEPKNS_12ULanguageTagEi: 2467| 2.14k|ultag_getVariant(const ULanguageTag* langtag, int32_t idx) { 2468| 2.14k| const char *var = nullptr; 2469| 2.14k| VariantListEntry *cur = langtag->variants; 2470| 2.14k| int32_t i = 0; 2471| 59.8k| while (cur) { ------------------ | Branch (2471:12): [True: 59.8k, False: 0] ------------------ 2472| 59.8k| if (i == idx) { ------------------ | Branch (2472:13): [True: 2.14k, False: 57.7k] ------------------ 2473| 2.14k| var = cur->variant; 2474| 2.14k| break; 2475| 2.14k| } 2476| 57.7k| cur = cur->next; 2477| 57.7k| i++; 2478| 57.7k| } 2479| 2.14k| return var; 2480| 2.14k|} uloc_tag.cpp:_ZN12_GLOBAL__N_123ultag_getExtensionsSizeEPKNS_12ULanguageTagE: 2529| 3.92k|ultag_getExtensionsSize(const ULanguageTag* langtag) { 2530| 3.92k| int32_t size = 0; 2531| 3.92k| ExtensionListEntry *cur = langtag->extensions; 2532| 9.15k| while (true) { ------------------ | Branch (2532:12): [Folded - Ignored] ------------------ 2533| 9.15k| if (cur == nullptr) { ------------------ | Branch (2533:13): [True: 3.92k, False: 5.23k] ------------------ 2534| 3.92k| break; 2535| 3.92k| } 2536| 5.23k| size++; 2537| 5.23k| cur = cur->next; 2538| 5.23k| } 2539| 3.92k| return size; 2540| 3.92k|} uloc_tag.cpp:_ZN12_GLOBAL__N_119ultag_getPrivateUseEPKNS_12ULanguageTagE: 2543| 3.92k|ultag_getPrivateUse(const ULanguageTag* langtag) { 2544| 3.92k| return langtag->privateuse; 2545| 3.92k|} uloc_tag.cpp:_ZN12_GLOBAL__N_115_appendKeywordsEPNS_12ULanguageTagERN6icu_788ByteSinkER10UErrorCode: 1781| 1.39k|_appendKeywords(ULanguageTag* langtag, icu::ByteSink& sink, UErrorCode& status) { 1782| 1.39k| if (U_FAILURE(status)) { return; } ------------------ | Branch (1782:9): [True: 0, False: 1.39k] ------------------ 1783| | 1784| 1.39k| int32_t i, n; 1785| 1.39k| int32_t len; 1786| 1.39k| ExtensionListEntry *kwdFirst = nullptr; 1787| 1.39k| ExtensionListEntry *kwd; 1788| 1.39k| const char *key, *type; 1789| 1.39k| icu::MemoryPool extPool; 1790| 1.39k| icu::MemoryPool kwdBuf; 1791| 1.39k| bool posixVariant = false; 1792| | 1793| 1.39k| n = ultag_getExtensionsSize(langtag); 1794| | 1795| | /* resolve locale keywords and reordering keys */ 1796| 4.01k| for (i = 0; i < n; i++) { ------------------ | Branch (1796:17): [True: 2.61k, False: 1.39k] ------------------ 1797| 2.61k| key = ultag_getExtensionKey(langtag, i); 1798| 2.61k| type = ultag_getExtensionValue(langtag, i); 1799| 2.61k| if (*key == LDMLEXT) { ------------------ | | 67| 2.61k|#define LDMLEXT 'u' ------------------ | Branch (1799:13): [True: 1.15k, False: 1.46k] ------------------ 1800| | /* Determine if variants already exists */ 1801| 1.15k| if (ultag_getVariantsSize(langtag)) { ------------------ | Branch (1801:17): [True: 72, False: 1.07k] ------------------ 1802| 72| posixVariant = true; 1803| 72| } 1804| | 1805| 1.15k| _appendLDMLExtensionAsKeywords(type, &kwdFirst, extPool, kwdBuf, posixVariant, status); 1806| 1.15k| if (U_FAILURE(status)) { ------------------ | Branch (1806:17): [True: 0, False: 1.15k] ------------------ 1807| 0| break; 1808| 0| } 1809| 1.46k| } else { 1810| 1.46k| kwd = extPool.create(); 1811| 1.46k| if (kwd == nullptr) { ------------------ | Branch (1811:17): [True: 0, False: 1.46k] ------------------ 1812| 0| status = U_MEMORY_ALLOCATION_ERROR; 1813| 0| break; 1814| 0| } 1815| 1.46k| kwd->key = key; 1816| 1.46k| kwd->value = type; 1817| 1.46k| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1817:17): [True: 0, False: 1.46k] ------------------ 1818| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1819| 0| break; 1820| 0| } 1821| 1.46k| } 1822| 2.61k| } 1823| | 1824| 1.39k| if (U_SUCCESS(status)) { ------------------ | Branch (1824:9): [True: 1.39k, False: 0] ------------------ 1825| 1.39k| type = ultag_getPrivateUse(langtag); 1826| 1.39k| if (static_cast(uprv_strlen(type)) > 0) { ------------------ | | 37| 1.39k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 1.39k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1826:13): [True: 284, False: 1.11k] ------------------ 1827| | /* add private use as a keyword */ 1828| 284| kwd = extPool.create(); 1829| 284| if (kwd == nullptr) { ------------------ | Branch (1829:17): [True: 0, False: 284] ------------------ 1830| 0| status = U_MEMORY_ALLOCATION_ERROR; 1831| 284| } else { 1832| 284| kwd->key = PRIVATEUSE_KEY; 1833| 284| kwd->value = type; 1834| 284| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1834:21): [True: 0, False: 284] ------------------ 1835| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1836| 0| } 1837| 284| } 1838| 284| } 1839| 1.39k| } 1840| | 1841| | /* If a POSIX variant was in the extensions, write it out before writing the keywords. */ 1842| | 1843| 1.39k| if (U_SUCCESS(status) && posixVariant) { ------------------ | Branch (1843:9): [True: 1.39k, False: 0] | Branch (1843:30): [True: 10, False: 1.38k] ------------------ 1844| 10| len = static_cast(uprv_strlen(_POSIX)); ------------------ | | 37| 10|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 10|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1845| 10| sink.Append(_POSIX, len); 1846| 10| } 1847| | 1848| 1.39k| if (U_SUCCESS(status) && kwdFirst != nullptr) { ------------------ | Branch (1848:9): [True: 1.39k, False: 0] | Branch (1848:30): [True: 1.39k, False: 8] ------------------ 1849| | /* write out the sorted keywords */ 1850| 1.39k| bool firstValue = true; 1851| 1.39k| kwd = kwdFirst; 1852| 20.0k| do { 1853| 20.0k| if (firstValue) { ------------------ | Branch (1853:17): [True: 1.39k, False: 18.6k] ------------------ 1854| 1.39k| sink.Append("@", 1); 1855| 1.39k| firstValue = false; 1856| 18.6k| } else { 1857| 18.6k| sink.Append(";", 1); 1858| 18.6k| } 1859| | 1860| | /* key */ 1861| 20.0k| len = static_cast(uprv_strlen(kwd->key)); ------------------ | | 37| 20.0k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 20.0k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1862| 20.0k| sink.Append(kwd->key, len); 1863| 20.0k| sink.Append("=", 1); 1864| | 1865| | /* type */ 1866| 20.0k| len = static_cast(uprv_strlen(kwd->value)); ------------------ | | 37| 20.0k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 20.0k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1867| 20.0k| sink.Append(kwd->value, len); 1868| | 1869| 20.0k| kwd = kwd->next; 1870| 20.0k| } while (kwd); ------------------ | Branch (1870:18): [True: 18.6k, False: 1.39k] ------------------ 1871| 1.39k| } 1872| 1.39k|} uloc_tag.cpp:_ZN12_GLOBAL__N_121ultag_getExtensionKeyEPKNS_12ULanguageTagEi: 2497| 2.61k|ultag_getExtensionKey(const ULanguageTag* langtag, int32_t idx) { 2498| 2.61k| const char *key = nullptr; 2499| 2.61k| ExtensionListEntry *cur = langtag->extensions; 2500| 2.61k| int32_t i = 0; 2501| 13.5k| while (cur) { ------------------ | Branch (2501:12): [True: 13.5k, False: 0] ------------------ 2502| 13.5k| if (i == idx) { ------------------ | Branch (2502:13): [True: 2.61k, False: 10.9k] ------------------ 2503| 2.61k| key = cur->key; 2504| 2.61k| break; 2505| 2.61k| } 2506| 10.9k| cur = cur->next; 2507| 10.9k| i++; 2508| 10.9k| } 2509| 2.61k| return key; 2510| 2.61k|} uloc_tag.cpp:_ZN12_GLOBAL__N_123ultag_getExtensionValueEPKNS_12ULanguageTagEi: 2513| 2.61k|ultag_getExtensionValue(const ULanguageTag* langtag, int32_t idx) { 2514| 2.61k| const char *val = nullptr; 2515| 2.61k| ExtensionListEntry *cur = langtag->extensions; 2516| 2.61k| int32_t i = 0; 2517| 13.5k| while (cur) { ------------------ | Branch (2517:12): [True: 13.5k, False: 0] ------------------ 2518| 13.5k| if (i == idx) { ------------------ | Branch (2518:13): [True: 2.61k, False: 10.9k] ------------------ 2519| 2.61k| val = cur->value; 2520| 2.61k| break; 2521| 2.61k| } 2522| 10.9k| cur = cur->next; 2523| 10.9k| i++; 2524| 10.9k| } 2525| 2.61k| return val; 2526| 2.61k|} uloc_tag.cpp:_ZN12_GLOBAL__N_130_appendLDMLExtensionAsKeywordsEPKcPPNS_18ExtensionListEntryERN6icu_7810MemoryPoolIS2_Li8EEERNS6_INS5_10CharStringELi8EEERbR10UErrorCode: 1523| 1.15k|_appendLDMLExtensionAsKeywords(const char* ldmlext, ExtensionListEntry** appendTo, icu::MemoryPool& extPool, icu::MemoryPool& kwdBuf, bool& posixVariant, UErrorCode& status) { 1524| 1.15k| if (U_FAILURE(status)) { return; } ------------------ | Branch (1524:9): [True: 0, False: 1.15k] ------------------ 1525| | 1526| 1.15k| const char *pTag; /* beginning of current subtag */ 1527| 1.15k| const char *pKwds; /* beginning of key-type pairs */ 1528| 1.15k| bool variantExists = posixVariant; 1529| | 1530| 1.15k| ExtensionListEntry *kwdFirst = nullptr; /* first LDML keyword */ 1531| 1.15k| ExtensionListEntry *kwd, *nextKwd; 1532| | 1533| 1.15k| int32_t len; 1534| | 1535| | /* Reset the posixVariant value */ 1536| 1.15k| posixVariant = false; 1537| | 1538| 1.15k| pTag = ldmlext; 1539| 1.15k| pKwds = nullptr; 1540| | 1541| 1.15k| { 1542| 1.15k| AttributeListEntry *attrFirst = nullptr; /* first attribute */ 1543| 1.15k| AttributeListEntry *attr, *nextAttr; 1544| | 1545| 1.15k| icu::MemoryPool strPool; 1546| 1.15k| icu::MemoryPool attrPool; 1547| | 1548| | /* Iterate through u extension attributes */ 1549| 1.06M| while (*pTag) { ------------------ | Branch (1549:16): [True: 1.06M, False: 226] ------------------ 1550| | /* locate next separator char */ 1551| 3.20M| for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); ------------------ | | 65| 3.20M|#define SEP '-' ------------------ | Branch (1551:27): [True: 3.20M, False: 306] | Branch (1551:44): [True: 2.14M, False: 1.06M] ------------------ 1552| | 1553| 1.06M| if (ultag_isUnicodeLocaleKey(pTag, len)) { ------------------ | | 1233| 1.06M|#define ultag_isUnicodeLocaleKey U_ICU_ENTRY_POINT_RENAME(ultag_isUnicodeLocaleKey) | | ------------------ | | | | 123| 1.06M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.06M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.06M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1553:17): [True: 925, False: 1.06M] ------------------ 1554| 925| pKwds = pTag; 1555| 925| break; 1556| 925| } 1557| | 1558| | /* add this attribute to the list */ 1559| 1.06M| attr = attrPool.create(); 1560| 1.06M| if (attr == nullptr) { ------------------ | Branch (1560:17): [True: 0, False: 1.06M] ------------------ 1561| 0| status = U_MEMORY_ALLOCATION_ERROR; 1562| 0| return; 1563| 0| } 1564| | 1565| 1.06M| if (icu::CharString* str = strPool.create(pTag, len, status)) { ------------------ | Branch (1565:34): [True: 1.06M, False: 0] ------------------ 1566| 1.06M| if (U_FAILURE(status)) { return; } ------------------ | Branch (1566:21): [True: 0, False: 1.06M] ------------------ 1567| 1.06M| attr->attribute = str->data(); 1568| 1.06M| } else { 1569| 0| status = U_MEMORY_ALLOCATION_ERROR; 1570| 0| return; 1571| 0| } 1572| | 1573| | // duplicate attribute is ignored, causes no error. 1574| 1.06M| _addAttributeToList(&attrFirst, attr); 1575| | 1576| | /* next tag */ 1577| 1.06M| pTag += len; 1578| 1.06M| if (*pTag) { ------------------ | Branch (1578:17): [True: 1.06M, False: 226] ------------------ 1579| | /* next to the separator */ 1580| 1.06M| pTag++; 1581| 1.06M| } 1582| 1.06M| } 1583| | 1584| 1.15k| if (attrFirst) { ------------------ | Branch (1584:13): [True: 422, False: 729] ------------------ 1585| | /* emit attributes as an LDML keyword, e.g. attribute=attr1-attr2 */ 1586| | 1587| 422| kwd = extPool.create(); 1588| 422| if (kwd == nullptr) { ------------------ | Branch (1588:17): [True: 0, False: 422] ------------------ 1589| 0| status = U_MEMORY_ALLOCATION_ERROR; 1590| 0| return; 1591| 0| } 1592| | 1593| 422| icu::CharString* value = kwdBuf.create(); 1594| 422| if (value == nullptr) { ------------------ | Branch (1594:17): [True: 0, False: 422] ------------------ 1595| 0| status = U_MEMORY_ALLOCATION_ERROR; 1596| 0| return; 1597| 0| } 1598| | 1599| | /* attribute subtags sorted in alphabetical order as type */ 1600| 422| attr = attrFirst; 1601| 3.02k| while (attr != nullptr) { ------------------ | Branch (1601:20): [True: 2.60k, False: 422] ------------------ 1602| 2.60k| nextAttr = attr->next; 1603| 2.60k| if (attr != attrFirst) { ------------------ | Branch (1603:21): [True: 2.18k, False: 422] ------------------ 1604| 2.18k| value->append('-', status); 1605| 2.18k| } 1606| 2.60k| value->append(attr->attribute, status); 1607| 2.60k| attr = nextAttr; 1608| 2.60k| } 1609| 422| if (U_FAILURE(status)) { ------------------ | Branch (1609:17): [True: 0, False: 422] ------------------ 1610| 0| return; 1611| 0| } 1612| | 1613| 422| kwd->key = LOCALE_ATTRIBUTE_KEY; 1614| 422| kwd->value = value->data(); 1615| | 1616| 422| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1616:17): [True: 0, False: 422] ------------------ 1617| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1618| 0| return; 1619| 0| } 1620| 422| } 1621| 1.15k| } 1622| | 1623| 1.15k| if (pKwds) { ------------------ | Branch (1623:9): [True: 925, False: 226] ------------------ 1624| 925| const char *pBcpKey = nullptr; /* u extension key subtag */ 1625| 925| const char *pBcpType = nullptr; /* beginning of u extension type subtag(s) */ 1626| 925| int32_t bcpKeyLen = 0; 1627| 925| int32_t bcpTypeLen = 0; 1628| 925| bool isDone = false; 1629| | 1630| 925| pTag = pKwds; 1631| | /* BCP47 representation of LDML key/type pairs */ 1632| 2.00M| while (!isDone) { ------------------ | Branch (1632:16): [True: 2.00M, False: 925] ------------------ 1633| 2.00M| const char *pNextBcpKey = nullptr; 1634| 2.00M| int32_t nextBcpKeyLen = 0; 1635| 2.00M| bool emitKeyword = false; 1636| | 1637| 2.00M| if (*pTag) { ------------------ | Branch (1637:17): [True: 2.00M, False: 925] ------------------ 1638| | /* locate next separator char */ 1639| 6.08M| for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); ------------------ | | 65| 6.08M|#define SEP '-' ------------------ | Branch (1639:31): [True: 6.08M, False: 925] | Branch (1639:48): [True: 4.07M, False: 2.00M] ------------------ 1640| | 1641| 2.00M| if (ultag_isUnicodeLocaleKey(pTag, len)) { ------------------ | | 1233| 2.00M|#define ultag_isUnicodeLocaleKey U_ICU_ENTRY_POINT_RENAME(ultag_isUnicodeLocaleKey) | | ------------------ | | | | 123| 2.00M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.00M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.00M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1641:21): [True: 1.70M, False: 297k] ------------------ 1642| 1.70M| if (pBcpKey) { ------------------ | Branch (1642:25): [True: 1.70M, False: 925] ------------------ 1643| 1.70M| emitKeyword = true; 1644| 1.70M| pNextBcpKey = pTag; 1645| 1.70M| nextBcpKeyLen = len; 1646| 1.70M| } else { 1647| 925| pBcpKey = pTag; 1648| 925| bcpKeyLen = len; 1649| 925| } 1650| 1.70M| } else { 1651| 297k| U_ASSERT(pBcpKey != nullptr); ------------------ | | 35| 297k|# define U_ASSERT(exp) (void)0 ------------------ 1652| | /* within LDML type subtags */ 1653| 297k| if (pBcpType) { ------------------ | Branch (1653:25): [True: 281k, False: 16.2k] ------------------ 1654| 281k| bcpTypeLen += (len + 1); 1655| 281k| } else { 1656| 16.2k| pBcpType = pTag; 1657| 16.2k| bcpTypeLen = len; 1658| 16.2k| } 1659| 297k| } 1660| | 1661| | /* next tag */ 1662| 2.00M| pTag += len; 1663| 2.00M| if (*pTag) { ------------------ | Branch (1663:21): [True: 2.00M, False: 925] ------------------ 1664| | /* next to the separator */ 1665| 2.00M| pTag++; 1666| 2.00M| } 1667| 2.00M| } else { 1668| | /* processing last one */ 1669| 925| emitKeyword = true; 1670| 925| isDone = true; 1671| 925| } 1672| | 1673| 2.00M| if (emitKeyword) { ------------------ | Branch (1673:17): [True: 1.70M, False: 298k] ------------------ 1674| 1.70M| const char *pKey = nullptr; /* LDML key */ 1675| 1.70M| const char *pType = nullptr; /* LDML type */ 1676| | 1677| 1.70M| U_ASSERT(pBcpKey != nullptr); ------------------ | | 35| 1.70M|# define U_ASSERT(exp) (void)0 ------------------ 1678| | 1679| | /* BCP key length is always 2 for now */ 1680| 1.70M| if (bcpKeyLen != 2) { ------------------ | Branch (1680:21): [True: 0, False: 1.70M] ------------------ 1681| | /* the BCP key is invalid */ 1682| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1683| 0| return; 1684| 0| } 1685| | 1686| | /* u extension key to LDML key */ 1687| 1.70M| std::optional legacyKey = ulocimp_toLegacyKeyWithFallback( ------------------ | | 1220| 1.70M|#define ulocimp_toLegacyKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyKeyWithFallback) | | ------------------ | | | | 123| 1.70M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.70M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.70M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1688| 1.70M| {pBcpKey, static_cast(bcpKeyLen)}); 1689| 1.70M| if (!legacyKey.has_value()) { ------------------ | Branch (1689:21): [True: 0, False: 1.70M] ------------------ 1690| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1691| 0| return; 1692| 0| } 1693| 1.70M| if (legacyKey->data() == pBcpKey) { ------------------ | Branch (1693:21): [True: 1.68M, False: 25.7k] ------------------ 1694| | /* 1695| | The key returned by toLegacyKey points to the input buffer. 1696| | We normalize the result key to lower case. 1697| | */ 1698| 1.68M| icu::CharString* key = kwdBuf.create(pBcpKey, bcpKeyLen, status); 1699| 1.68M| if (key == nullptr) { ------------------ | Branch (1699:25): [True: 0, False: 1.68M] ------------------ 1700| 0| status = U_MEMORY_ALLOCATION_ERROR; 1701| 0| return; 1702| 0| } 1703| 1.68M| if (U_FAILURE(status)) { ------------------ | Branch (1703:25): [True: 0, False: 1.68M] ------------------ 1704| 0| return; 1705| 0| } 1706| 1.68M| T_CString_toLowerCase(key->data()); ------------------ | | 69| 1.68M|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 1.68M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.68M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.68M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1707| 1.68M| pKey = key->data(); 1708| 1.68M| } else { 1709| 25.7k| pKey = legacyKey->data(); 1710| 25.7k| } 1711| | 1712| 1.70M| if (pBcpType) { ------------------ | Branch (1712:21): [True: 16.2k, False: 1.69M] ------------------ 1713| | /* BCP type to locale type */ 1714| 16.2k| std::optional legacyType = ulocimp_toLegacyTypeWithFallback( ------------------ | | 1222| 16.2k|#define ulocimp_toLegacyTypeWithFallback U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyTypeWithFallback) | | ------------------ | | | | 123| 16.2k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 16.2k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 16.2k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1715| 16.2k| pKey, {pBcpType, static_cast(bcpTypeLen)}); 1716| 16.2k| if (!legacyType.has_value()) { ------------------ | Branch (1716:25): [True: 0, False: 16.2k] ------------------ 1717| 0| status = U_ILLEGAL_ARGUMENT_ERROR; 1718| 0| return; 1719| 0| } 1720| 16.2k| if (legacyType->data() == pBcpType) { ------------------ | Branch (1720:25): [True: 15.7k, False: 452] ------------------ 1721| | /* 1722| | The type returned by toLegacyType points to the input buffer. 1723| | We normalize the result type to lower case. 1724| | */ 1725| 15.7k| icu::CharString* type = kwdBuf.create(pBcpType, bcpTypeLen, status); 1726| 15.7k| if (type == nullptr) { ------------------ | Branch (1726:29): [True: 0, False: 15.7k] ------------------ 1727| 0| status = U_MEMORY_ALLOCATION_ERROR; 1728| 0| return; 1729| 0| } 1730| 15.7k| if (U_FAILURE(status)) { ------------------ | Branch (1730:29): [True: 0, False: 15.7k] ------------------ 1731| 0| return; 1732| 0| } 1733| 15.7k| T_CString_toLowerCase(type->data()); ------------------ | | 69| 15.7k|#define T_CString_toLowerCase U_ICU_ENTRY_POINT_RENAME(T_CString_toLowerCase) | | ------------------ | | | | 123| 15.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 15.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 15.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1734| 15.7k| pType = type->data(); 1735| 15.7k| } else { 1736| 452| pType = legacyType->data(); 1737| 452| } 1738| 1.69M| } else { 1739| | /* typeless - default type value is "yes" */ 1740| 1.69M| pType = LOCALE_TYPE_YES; 1741| 1.69M| } 1742| | 1743| | /* Special handling for u-va-posix, since we want to treat this as a variant, 1744| | not as a keyword */ 1745| 1.70M| if (!variantExists && !uprv_strcmp(pKey, POSIX_KEY) && !uprv_strcmp(pType, POSIX_VALUE) ) { ------------------ | | 38| 1.66M|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 1.66M|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ if (!variantExists && !uprv_strcmp(pKey, POSIX_KEY) && !uprv_strcmp(pType, POSIX_VALUE) ) { ------------------ | | 38| 610|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 610|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1745:21): [True: 1.66M, False: 42.7k] | Branch (1745:39): [True: 610, False: 1.66M] | Branch (1745:72): [True: 198, False: 412] ------------------ 1746| 198| posixVariant = true; 1747| 1.70M| } else { 1748| | /* create an ExtensionListEntry for this keyword */ 1749| 1.70M| kwd = extPool.create(); 1750| 1.70M| if (kwd == nullptr) { ------------------ | Branch (1750:25): [True: 0, False: 1.70M] ------------------ 1751| 0| status = U_MEMORY_ALLOCATION_ERROR; 1752| 0| return; 1753| 0| } 1754| | 1755| 1.70M| kwd->key = pKey; 1756| 1.70M| kwd->value = pType; 1757| | 1758| 1.70M| if (!_addExtensionToList(&kwdFirst, kwd, false)) { ------------------ | Branch (1758:25): [True: 1.68M, False: 17.8k] ------------------ 1759| | // duplicate keyword is allowed, Only the first 1760| | // is honored. 1761| 1.68M| } 1762| 1.70M| } 1763| | 1764| 1.70M| pBcpKey = pNextBcpKey; 1765| 1.70M| bcpKeyLen = pNextBcpKey != nullptr ? nextBcpKeyLen : 0; ------------------ | Branch (1765:29): [True: 1.70M, False: 925] ------------------ 1766| 1.70M| pBcpType = nullptr; 1767| 1.70M| bcpTypeLen = 0; 1768| 1.70M| } 1769| 2.00M| } 1770| 925| } 1771| | 1772| 1.15k| kwd = kwdFirst; 1773| 19.4k| while (kwd != nullptr) { ------------------ | Branch (1773:12): [True: 18.2k, False: 1.15k] ------------------ 1774| 18.2k| nextKwd = kwd->next; 1775| 18.2k| _addExtensionToList(appendTo, kwd, false); 1776| 18.2k| kwd = nextKwd; 1777| 18.2k| } 1778| 1.15k|} uloc_tag.cpp:_ZN12_GLOBAL__N_111ultag_closeEPNS_12ULanguageTagE: 2389| 2.52k|ultag_close(ULanguageTag* langtag) { 2390| | 2391| 2.52k| if (langtag == nullptr) { ------------------ | Branch (2391:9): [True: 0, False: 2.52k] ------------------ 2392| 0| return; 2393| 0| } 2394| | 2395| 2.52k| uprv_free(langtag->buf); ------------------ | | 1503| 2.52k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2396| | 2397| 2.52k| if (langtag->variants) { ------------------ | Branch (2397:9): [True: 302, False: 2.22k] ------------------ 2398| 302| VariantListEntry *curVar = langtag->variants; 2399| 2.44k| while (curVar) { ------------------ | Branch (2399:16): [True: 2.14k, False: 302] ------------------ 2400| 2.14k| VariantListEntry *nextVar = curVar->next; 2401| 2.14k| delete curVar; 2402| 2.14k| curVar = nextVar; 2403| 2.14k| } 2404| 302| } 2405| | 2406| 2.52k| if (langtag->extensions) { ------------------ | Branch (2406:9): [True: 1.22k, False: 1.30k] ------------------ 2407| 1.22k| ExtensionListEntry *curExt = langtag->extensions; 2408| 3.83k| while (curExt) { ------------------ | Branch (2408:16): [True: 2.61k, False: 1.22k] ------------------ 2409| 2.61k| ExtensionListEntry *nextExt = curExt->next; 2410| 2.61k| delete curExt; 2411| 2.61k| curExt = nextExt; 2412| 2.61k| } 2413| 1.22k| } 2414| | 2415| 2.52k| uprv_free(langtag); ------------------ | | 1503| 2.52k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 2.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2416| 2.52k|} uloc_tag.cpp:_ZZ25ulocimp_forLanguageTag_78PKciPiR10UErrorCodeENK3$_0clERN6icu_788ByteSinkES3_: 2677| 2.52k| [&](icu::ByteSink& sink, UErrorCode& status) { 2678| 2.52k| ulocimp_forLanguageTag(langtag, tagLen, sink, parsedLength, status); ------------------ | | 1198| 2.52k|#define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag) | | ------------------ | | | | 123| 2.52k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 2.52k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 2.52k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2679| 2.52k| }, uloc.cpp:_ZN12_GLOBAL__N_114_isIDSeparatorEc: 49| 21.4k|inline bool _isIDSeparator(char a) { return a == '_' || a == '-'; } ------------------ | Branch (49:45): [True: 3.23k, False: 18.2k] | Branch (49:57): [True: 3.32k, False: 14.9k] ------------------ _Z21ulocimp_getSubtags_78NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEDnDnDnDnPPKcR10UErrorCode: 174| 3.55k| UErrorCode& status) { 175| 3.55k| ulocimp_getSubtags( ------------------ | | 1209| 3.55k|#define ulocimp_getSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_getSubtags) | | ------------------ | | | | 123| 3.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 176| 3.55k| localeID, 177| 3.55k| static_cast(nullptr), 178| 3.55k| static_cast(nullptr), 179| 3.55k| static_cast(nullptr), 180| 3.55k| static_cast(nullptr), 181| 3.55k| pEnd, 182| 3.55k| status); 183| 3.55k|} _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| 159k|umtx_lock(UMutex *mutex) { 113| 159k| if (mutex == nullptr) { ------------------ | Branch (113:9): [True: 9, False: 159k] ------------------ 114| 9| mutex = &globalMutex; 115| 9| } 116| 159k| mutex->lock(); 117| 159k|} umtx_unlock_78: 122| 159k|{ 123| 159k| if (mutex == nullptr) { ------------------ | Branch (123:9): [True: 9, False: 159k] ------------------ 124| 9| mutex = &globalMutex; 125| 9| } 126| 159k| mutex->unlock(); 127| 159k|} _ZN6icu_7820umtx_initImplPreInitERNS_9UInitOnceE: 145| 4|umtx_initImplPreInit(UInitOnce &uio) { 146| 4| std::call_once(*pInitFlag, umtx_init); 147| 4| std::unique_lock lock(*initMutex); 148| 4| if (umtx_loadAcquire(uio.fState) == 0) { ------------------ | Branch (148:9): [True: 4, False: 0] ------------------ 149| 4| umtx_storeRelease(uio.fState, 1); 150| 4| return true; // Caller will next call the init function. 151| 4| } 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| 4|} _ZN6icu_7821umtx_initImplPostInitERNS_9UInitOnceE: 170| 4|umtx_initImplPostInit(UInitOnce &uio) { 171| 4| { 172| 4| std::unique_lock lock(*initMutex); 173| 4| umtx_storeRelease(uio.fState, 2); 174| 4| } 175| 4| initCondition->notify_all(); 176| 4|} 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_786UMutex4lockEv: 229| 159k| void lock() { 230| 159k| std::mutex *m = fMutex.load(std::memory_order_acquire); 231| 159k| if (m == nullptr) { m = getMutex(); } ------------------ | Branch (231:13): [True: 2, False: 159k] ------------------ 232| 159k| m->lock(); 233| 159k| } _ZN6icu_786UMutex6unlockEv: 234| 159k| void unlock() { fMutex.load(std::memory_order_relaxed)->unlock(); } _ZN6icu_7816umtx_loadAcquireERNSt3__16atomicIiEE: 75| 1.72M|inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 76| 1.72M| return var.load(std::memory_order_acquire); 77| 1.72M|} _ZN6icu_7817umtx_storeReleaseERNSt3__16atomicIiEEi: 79| 8|inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 80| 8| var.store(val, std::memory_order_release); 81| 8|} _ZN6icu_7813umtx_initOnceERNS_9UInitOnceEPFvvE: 123| 2|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)()) { 124| 2| if (umtx_loadAcquire(uio.fState) == 2) { ------------------ | Branch (124:9): [True: 1, False: 1] ------------------ 125| 1| return; 126| 1| } 127| 1| if (umtx_initImplPreInit(uio)) { ------------------ | Branch (127:9): [True: 1, False: 0] ------------------ 128| 1| (*fp)(); 129| 1| umtx_initImplPostInit(uio); 130| 1| } 131| 1|} _ZN6icu_7813umtx_initOnceERNS_9UInitOnceEPFvR10UErrorCodeES3_: 135| 1.72M|inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(UErrorCode &), UErrorCode &errCode) { 136| 1.72M| if (U_FAILURE(errCode)) { ------------------ | Branch (136:9): [True: 0, False: 1.72M] ------------------ 137| 0| return; 138| 0| } 139| 1.72M| if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { ------------------ | Branch (139:9): [True: 3, False: 1.72M] | Branch (139:46): [True: 3, False: 0] ------------------ 140| | // We run the initialization. 141| 3| (*fp)(errCode); 142| 3| uio.fErrCode = errCode; 143| 3| umtx_initImplPostInit(uio); 144| 1.72M| } else { 145| | // Someone else already ran the initialization. 146| 1.72M| if (U_FAILURE(uio.fErrCode)) { ------------------ | Branch (146:13): [True: 0, False: 1.72M] ------------------ 147| 0| errCode = uio.fErrCode; 148| 0| } 149| 1.72M| } 150| 1.72M|} _ZN6icu_788ByteSinkC2Ev: 59| 4.66k| ByteSink() { } _ZNK6icu_7814ConstChar16PtrcvPKDsEv: 205| 2.17k| inline operator const char16_t *() const { return get(); } _ZNK6icu_7814ConstChar16Ptr3getEv: 241| 2.17k|const char16_t *ConstChar16Ptr::get() const { return p_; } _ZN6icu_7814ConstChar16PtrC2EPKDs: 229| 2.17k|ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) : p_(p) {} _ZN6icu_7814ConstChar16PtrD2Ev: 237| 2.17k|ConstChar16Ptr::~ConstChar16Ptr() { 238| 2.17k| U_ALIASING_BARRIER(p_); ------------------ | | 35| 2.17k|# define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory") ------------------ 239| 2.17k|} _ZN6icu_7816LocalPointerBaseI16UKeywordsContextEC2EPS1_: 82| 1.79k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7816LocalPointerBaseI16UKeywordsContextED2Ev: 88| 1.79k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_7816LocalPointerBaseI12UEnumerationEC2EPS1_: 82| 1.79k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_7816LocalPointerBaseI12UEnumerationED2Ev: 88| 1.79k| ~LocalPointerBase() { /* delete ptr; */ } _ZNK6icu_7816LocalPointerBaseI16UKeywordsContextE6isNullEv: 94| 1.79k| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseI12UEnumerationE6isNullEv: 94| 1.79k| UBool isNull() const { return ptr==nullptr; } _ZNK6icu_7816LocalPointerBaseI12UEnumerationE8getAliasEv: 122| 1.79k| T *getAlias() const { return ptr; } _ZNK6icu_7816LocalPointerBaseI16UKeywordsContextEptEv: 134| 10.7k| T *operator->() const { return ptr; } _ZNK6icu_7816LocalPointerBaseI12UEnumerationEptEv: 134| 1.79k| T *operator->() const { return ptr; } _ZN6icu_7816LocalPointerBaseI16UKeywordsContextE6orphanEv: 141| 1.79k| T *orphan() { 142| 1.79k| T *p=ptr; 143| 1.79k| ptr=nullptr; 144| 1.79k| return p; 145| 1.79k| } _ZN6icu_7816LocalPointerBaseI12UEnumerationE6orphanEv: 141| 1.79k| T *orphan() { 142| 1.79k| T *p=ptr; 143| 1.79k| ptr=nullptr; 144| 1.79k| return p; 145| 1.79k| } _ZN6icu_788internal16LocalOpenPointerI15UResourceBundleXadL_Z13ures_close_78EEEC2EPS2_: 567| 1.07k| explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseI15UResourceBundleEC2EPS1_: 82| 1.07k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZNK6icu_7816LocalPointerBaseI15UResourceBundleE8getAliasEv: 122| 242k| T *getAlias() const { return ptr; } _ZN6icu_788internal16LocalOpenPointerI15UResourceBundleXadL_Z13ures_close_78EEE12adoptInsteadEPS2_: 595| 79.8k| void adoptInstead(Type *p) { 596| 79.8k| if (ptr != nullptr) { closeFunction(ptr); } ------------------ | Branch (596:13): [True: 0, False: 79.8k] ------------------ 597| 79.8k| ptr=p; 598| 79.8k| } _ZN6icu_7816LocalPointerBaseI15UResourceBundleE6orphanEv: 141| 79.8k| T *orphan() { 142| 79.8k| T *p=ptr; 143| 79.8k| ptr=nullptr; 144| 79.8k| return p; 145| 79.8k| } _ZNK6icu_7816LocalPointerBaseI15UResourceBundleE7isValidEv: 100| 2.17k| UBool isValid() const { return ptr!=nullptr; } _ZN6icu_788internal16LocalOpenPointerI15UResourceBundleXadL_Z13ures_close_78EEED2Ev: 575| 1.07k| ~LocalOpenPointer() { if (ptr != nullptr) { closeFunction(ptr); } } ------------------ | Branch (575:31): [True: 1.00k, False: 70] ------------------ _ZN6icu_7816LocalPointerBaseI15UResourceBundleED2Ev: 88| 1.07k| ~LocalPointerBase() { /* delete ptr; */ } _ZN6icu_788internal16LocalOpenPointerI10UHashtableXadL_Z14uhash_close_78EEEC2EPS2_: 567| 37| explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase(p) {} _ZN6icu_7816LocalPointerBaseI10UHashtableEC2EPS1_: 82| 37| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} _ZN6icu_788internal16LocalOpenPointerI10UHashtableXadL_Z14uhash_close_78EEE12adoptInsteadEPS2_: 595| 37| void adoptInstead(Type *p) { 596| 37| if (ptr != nullptr) { closeFunction(ptr); } ------------------ | Branch (596:13): [True: 0, False: 37] ------------------ 597| 37| ptr=p; 598| 37| } _ZNK6icu_7816LocalPointerBaseI10UHashtableE8getAliasEv: 122| 12.8k| T *getAlias() const { return ptr; } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_116VariantListEntryEEC2EPS2_R10UErrorCode: 214| 2.14k| LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase(p) { 215| 2.14k| if(p==nullptr && U_SUCCESS(errorCode)) { ------------------ | Branch (215:12): [True: 0, False: 2.14k] | Branch (215:26): [True: 0, False: 0] ------------------ 216| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 217| 0| } 218| 2.14k| } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEEC2EPS2_: 82| 4.29k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEEptEv: 134| 62.0k| T *operator->() const { return ptr; } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEE6orphanEv: 141| 2.14k| T *orphan() { 142| 2.14k| T *p=ptr; 143| 2.14k| ptr=nullptr; 144| 2.14k| return p; 145| 2.14k| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_116VariantListEntryEEC2EOS3_: 224| 2.14k| LocalPointer(LocalPointer &&src) noexcept : LocalPointerBase(src.ptr) { 225| 2.14k| src.ptr=nullptr; 226| 2.14k| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_116VariantListEntryEED2Ev: 245| 4.29k| ~LocalPointer() { 246| 4.29k| delete LocalPointerBase::ptr; 247| 4.29k| } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_116VariantListEntryEED2Ev: 88| 4.29k| ~LocalPointerBase() { /* delete ptr; */ } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_118ExtensionListEntryEEC2EPS2_: 200| 2.52k| explicit LocalPointer(T *p=nullptr) : LocalPointerBase(p) {} uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEEC2EPS2_: 82| 2.52k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEE6isNullEv: 94| 2.52k| UBool isNull() const { return ptr==nullptr; } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEEptEv: 134| 9.92k| T *operator->() const { return ptr; } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEE6orphanEv: 141| 2.52k| T *orphan() { 142| 2.52k| T *p=ptr; 143| 2.52k| ptr=nullptr; 144| 2.52k| return p; 145| 2.52k| } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEE7isValidEv: 100| 5.92k| UBool isValid() const { return ptr!=nullptr; } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEE6orphanEv: 141| 2.86k| T *orphan() { 142| 2.86k| T *p=ptr; 143| 2.86k| ptr=nullptr; 144| 2.86k| return p; 145| 2.86k| } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEEptEv: 134| 8.36k| T *operator->() const { return ptr; } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEE8getAliasEv: 122| 2.62k| T *getAlias() const { return ptr; } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_118ExtensionListEntryEE29adoptInsteadAndCheckErrorCodeEPS2_R10UErrorCode: 319| 2.86k| void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) { 320| 2.86k| if(U_SUCCESS(errorCode)) { ------------------ | Branch (320:12): [True: 2.86k, False: 0] ------------------ 321| 2.86k| delete LocalPointerBase::ptr; 322| 2.86k| LocalPointerBase::ptr=p; 323| 2.86k| if(p==nullptr) { ------------------ | Branch (323:16): [True: 0, False: 2.86k] ------------------ 324| 0| errorCode=U_MEMORY_ALLOCATION_ERROR; 325| 0| } 326| 2.86k| } else { 327| 0| delete p; 328| 0| } 329| 2.86k| } uloc_tag.cpp:_ZN6icu_7812LocalPointerIN12_GLOBAL__N_118ExtensionListEntryEED2Ev: 245| 2.52k| ~LocalPointer() { 246| 2.52k| delete LocalPointerBase::ptr; 247| 2.52k| } uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_118ExtensionListEntryEED2Ev: 88| 2.52k| ~LocalPointerBase() { /* delete ptr; */ } uloc_tag.cpp:_ZN6icu_788internal16LocalOpenPointerIN12_GLOBAL__N_112ULanguageTagEXadL_ZNS2_11ultag_closeEPS3_EEEC2ES4_: 567| 5.05k| explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase(p) {} uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEEC2EPS2_: 82| 5.05k| explicit LocalPointerBase(T *p=nullptr) : ptr(p) {} uloc_tag.cpp:_ZN6icu_788internal16LocalOpenPointerIN12_GLOBAL__N_112ULanguageTagEXadL_ZNS2_11ultag_closeEPS3_EEED2Ev: 575| 5.05k| ~LocalOpenPointer() { if (ptr != nullptr) { closeFunction(ptr); } } ------------------ | Branch (575:31): [True: 2.52k, False: 2.52k] ------------------ uloc_tag.cpp:_ZN6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEED2Ev: 88| 5.05k| ~LocalPointerBase() { /* delete ptr; */ } uloc_tag.cpp:_ZNK6icu_7816LocalPointerBaseIN12_GLOBAL__N_112ULanguageTagEE8getAliasEv: 122| 26.2k| T *getAlias() const { return ptr; } _ZNK6icu_7816LocalPointerBaseI15UResourceBundleEptEv: 134| 3| T *operator->() const { return ptr; } _ZN6icu_7811ReplaceableC2Ev: 243| 1.08k|inline Replaceable::Replaceable() {} _ZN6icu_7811StringPieceC2EPKci: 151| 109| StringPiece(const char* offset, int32_t len) : ptr_(offset), length_(len) { } _ZNK6icu_7811StringPiececvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEv: 185| 109| inline operator std::string_view() const { 186| 109| return {data(), static_cast(size())}; 187| 109| } _ZNK6icu_7811StringPiece4dataEv: 200| 3.29k| const char* data() const { return ptr_; } _ZNK6icu_7811StringPiece4sizeEv: 206| 109| int32_t size() const { return length_; } _ZNK6icu_7811StringPiece6lengthEv: 212| 3.18k| int32_t length() const { return length_; } _ZNK6icu_7813UnicodeString14hasShortLengthEv: 4202| 501|UnicodeString::hasShortLength() const { 4203| 501| return fUnion.fFields.fLengthAndFlags>=0; 4204| 501|} _ZNK6icu_7813UnicodeString14getShortLengthEv: 4207| 501|UnicodeString::getShortLength() const { 4208| | // fLengthAndFlags must be non-negative -> short length >= 0 4209| | // and arithmetic or logical shift does not matter. 4210| 501| return fUnion.fFields.fLengthAndFlags>>kLengthShift; 4211| 501|} _ZNK6icu_7813UnicodeString6lengthEv: 4214| 501|UnicodeString::length() const { 4215| 501| return hasShortLength() ? getShortLength() : fUnion.fFields.fLength; ------------------ | Branch (4215:10): [True: 501, False: 0] ------------------ 4216| 501|} _ZNK6icu_7813UnicodeString9getBufferEv: 4245| 501|UnicodeString::getBuffer() const { 4246| 501| if(fUnion.fFields.fLengthAndFlags&(kIsBogus|kOpenGetBuffer)) { ------------------ | Branch (4246:6): [True: 0, False: 501] ------------------ 4247| 0| return nullptr; 4248| 501| } else if(fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) { ------------------ | Branch (4248:13): [True: 0, False: 501] ------------------ 4249| 0| return fUnion.fStackFields.fBuffer; 4250| 501| } else { 4251| 501| return fUnion.fFields.fArray; 4252| 501| } 4253| 501|} _ZNK6icu_7813UnicodeString7isEmptyEv: 4863| 1.08k|UnicodeString::isEmpty() const { 4864| | // Arithmetic or logical right shift does not matter: only testing for 0. 4865| 1.08k| return (fUnion.fFields.fLengthAndFlags>>kLengthShift) == 0; 4866| 1.08k|} _ZN6icu_7813UnicodeString14setShortLengthEi: 4877| 1.08k|UnicodeString::setShortLength(int32_t len) { 4878| | // requires 0 <= len <= kMaxShortLength 4879| 1.08k| fUnion.fFields.fLengthAndFlags = 4880| 1.08k| static_cast((fUnion.fFields.fLengthAndFlags & kAllStorageFlags) | (len << kLengthShift)); 4881| 1.08k|} _ZN6icu_7813UnicodeString9setLengthEi: 4884| 1.08k|UnicodeString::setLength(int32_t len) { 4885| 1.08k| if(len <= kMaxShortLength) { ------------------ | Branch (4885:6): [True: 1.08k, False: 0] ------------------ 4886| 1.08k| setShortLength(len); 4887| 1.08k| } else { 4888| 0| fUnion.fFields.fLengthAndFlags |= kLengthIsLarge; 4889| 0| fUnion.fFields.fLength = len; 4890| 0| } 4891| 1.08k|} _ZN6icu_7813UnicodeString8setArrayEPDsii: 4899| 1.08k|UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) { 4900| 1.08k| setLength(len); 4901| 1.08k| fUnion.fFields.fArray = array; 4902| 1.08k| fUnion.fFields.fCapacity = capacity; 4903| 1.08k|} _ZN6icu_7813UnicodeStringC2Ev: 4182| 1.08k|UnicodeString::UnicodeString() { 4183| 1.08k| fUnion.fStackFields.fLengthAndFlags=kShortString; 4184| 1.08k|} _ZN6icu_7821ures_getUnicodeStringEPK15UResourceBundleP10UErrorCode: 813| 1.08k|ures_getUnicodeString(const UResourceBundle *resB, UErrorCode* status) { 814| 1.08k| UnicodeString result; 815| 1.08k| int32_t len = 0; 816| 1.08k| const char16_t *r = ConstChar16Ptr(ures_getString(resB, &len, status)); ------------------ | | 1675| 1.08k|#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString) | | ------------------ | | | | 123| 1.08k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.08k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.08k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 817| 1.08k| if(U_SUCCESS(*status)) { ------------------ | Branch (817:8): [True: 1.08k, False: 0] ------------------ 818| 1.08k| result.setTo(true, r, len); 819| 1.08k| } else { 820| 0| result.setToBogus(); 821| 0| } 822| 1.08k| return result; 823| 1.08k|} uloc.cpp:_ZL9U_FAILURE10UErrorCode: 737| 23.9k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2.52k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uloc_keytype.cpp:_ZL9U_FAILURE10UErrorCode: 737| 5.25M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc_keytype.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 79.7k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uloc_tag.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2.77M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uloc_tag.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 7.06k| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uresbund.cpp:_ZL9U_FAILURE10UErrorCode: 737| 239k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uresbund.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 9| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uresdata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } charstr.cpp:_ZL9U_FAILURE10UErrorCode: 737| 5.73M| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } putil.cpp:_ZL9U_FAILURE10UErrorCode: 737| 2| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } putil.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 1| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } uarrsort.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1.79k| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_FAILURE10UErrorCode: 737| 11| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } udata.cpp:_ZL9U_SUCCESS10UErrorCode: 731| 2| inline UBool U_SUCCESS(UErrorCode code) { return code <= U_ZERO_ERROR; } udatamem.cpp:_ZL9U_FAILURE10UErrorCode: 737| 3| inline UBool U_FAILURE(UErrorCode code) { return code > U_ZERO_ERROR; } uhash.cpp:_ZL9U_FAILURE10UErrorCode: 737| 1.99k| 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; } _ZN6icu_7811ReplaceableD2Ev: 106| 1.08k|Replaceable::~Replaceable() {} _ZN6icu_7813UnicodeString12releaseArrayEv: 161| 2.17k|UnicodeString::releaseArray() { 162| 2.17k| if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) { ------------------ | Branch (162:6): [True: 0, False: 2.17k] | Branch (162:56): [True: 0, False: 0] ------------------ 163| 0| uprv_free(reinterpret_cast(fUnion.fFields.fArray) - 1); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 0| } 165| 2.17k|} _ZN6icu_7813UnicodeStringD2Ev: 462| 1.08k|{ 463| |#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS 464| | // Count lengths of strings at the end of their lifetime. 465| | // Useful for discussion of a desirable stack buffer size. 466| | // Count the contents length, not the optional NUL terminator nor further capacity. 467| | // Ignore open-buffer strings and strings which alias external storage. 468| | if((fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kReadonlyAlias|kWritableAlias)) == 0) { 469| | if(hasShortLength()) { 470| | umtx_atomic_inc(finalLengthCounts + getShortLength()); 471| | } else { 472| | umtx_atomic_inc(&beyondCount); 473| | } 474| | } 475| |#endif 476| | 477| 1.08k| releaseArray(); 478| 1.08k|} _ZN6icu_7813UnicodeString5setToEaNS_14ConstChar16PtrEi: 1342| 1.08k|{ 1343| 1.08k| if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) { ------------------ | Branch (1343:6): [True: 0, False: 1.08k] ------------------ 1344| | // do not modify a string that has an "open" getBuffer(minCapacity) 1345| 0| return *this; 1346| 0| } 1347| | 1348| 1.08k| const char16_t *text = textPtr; 1349| 1.08k| if(text == nullptr) { ------------------ | Branch (1349:6): [True: 0, False: 1.08k] ------------------ 1350| | // treat as an empty string, do not alias 1351| 0| releaseArray(); 1352| 0| setToEmpty(); 1353| 0| return *this; 1354| 0| } 1355| | 1356| 1.08k| if( textLength < -1 || ------------------ | Branch (1356:7): [True: 0, False: 1.08k] ------------------ 1357| 1.08k| (textLength == -1 && !isTerminated) || ------------------ | Branch (1357:8): [True: 0, False: 1.08k] | Branch (1357:28): [True: 0, False: 0] ------------------ 1358| 1.08k| (textLength >= 0 && isTerminated && text[textLength] != 0) ------------------ | Branch (1358:8): [True: 1.08k, False: 0] | Branch (1358:27): [True: 1.08k, False: 0] | Branch (1358:43): [True: 0, False: 1.08k] ------------------ 1359| 1.08k| ) { 1360| 0| setToBogus(); 1361| 0| return *this; 1362| 0| } 1363| | 1364| 1.08k| releaseArray(); 1365| | 1366| 1.08k| if(textLength == -1) { ------------------ | Branch (1366:6): [True: 0, False: 1.08k] ------------------ 1367| | // text is terminated, or else it would have failed the above test 1368| 0| textLength = u_strlen(text); ------------------ | | 393| 0|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1369| 0| } 1370| 1.08k| fUnion.fFields.fLengthAndFlags = kReadonlyAlias; 1371| 1.08k| setArray(const_cast(text), textLength, isTerminated ? textLength + 1 : textLength); ------------------ | Branch (1371:53): [True: 1.08k, False: 0] ------------------ 1372| 1.08k| return *this; 1373| 1.08k|} _ZN6icu_787UMemorynwEm: 61| 5.53M|void * U_EXPORT2 UMemory::operator new(size_t size) noexcept { 62| 5.53M| return uprv_malloc(size); ------------------ | | 1524| 5.53M|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 5.53M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.53M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.53M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 63| 5.53M|} _ZN6icu_787UMemorydlEPv: 65| 5.53M|void U_EXPORT2 UMemory::operator delete(void *p) noexcept { 66| 5.53M| if(p!=nullptr) { ------------------ | Branch (66:8): [True: 5.53M, False: 0] ------------------ 67| 5.53M| uprv_free(p); ------------------ | | 1503| 5.53M|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 5.53M|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 5.53M|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 5.53M|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 68| 5.53M| } 69| 5.53M|} _ZN6icu_787UObjectD2Ev: 94| 1.08k|UObject::~UObject() {} ures_close_78: 1147| 1.00k|{ 1148| 1.00k| ures_closeBundle(resB, true); 1149| 1.00k|} ures_getString_78: 1524| 79.7k|U_CAPI const char16_t* U_EXPORT2 ures_getString(const UResourceBundle* resB, int32_t* len, UErrorCode* status) { 1525| 79.7k| const char16_t *s; 1526| 79.7k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (1526:9): [True: 0, False: 79.7k] | Branch (1526:28): [True: 0, False: 79.7k] ------------------ 1527| 0| return nullptr; 1528| 0| } 1529| 79.7k| if(resB == nullptr) { ------------------ | Branch (1529:8): [True: 0, False: 79.7k] ------------------ 1530| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1531| 0| return nullptr; 1532| 0| } 1533| 79.7k| s = res_getString({resB}, &resB->getResData(), resB->fRes, len); 1534| 79.7k| if (s == nullptr) { ------------------ | Branch (1534:9): [True: 0, False: 79.7k] ------------------ 1535| 0| *status = U_RESOURCE_TYPE_MISMATCH; 1536| 0| } 1537| 79.7k| return s; 1538| 79.7k|} ures_getKey_78: 1685| 1.26k|U_CAPI const char * U_EXPORT2 ures_getKey(const UResourceBundle *resB) { 1686| | // 1687| | // TODO: Trace ures_getKey? I guess not usually. 1688| | // 1689| | // We usually get the key string to decide whether we want the value, or to 1690| | // make a key-value pair. Tracing the value should suffice. 1691| | // 1692| | // However, I believe we have some data (e.g., in res_index) where the key 1693| | // strings are the data. Tracing the enclosing table should suffice. 1694| | // 1695| 1.26k| if(resB == nullptr) { ------------------ | Branch (1695:6): [True: 0, False: 1.26k] ------------------ 1696| 0| return nullptr; 1697| 0| } 1698| 1.26k| return(resB->fKey); 1699| 1.26k|} ures_resetIterator_78: 1721| 917|U_CAPI void U_EXPORT2 ures_resetIterator(UResourceBundle *resB){ 1722| 917| if(resB == nullptr) { ------------------ | Branch (1722:6): [True: 0, False: 917] ------------------ 1723| 0| return; 1724| 0| } 1725| 917| resB->fIndex = -1; 1726| 917|} ures_hasNext_78: 1728| 80.7k|U_CAPI UBool U_EXPORT2 ures_hasNext(const UResourceBundle *resB) { 1729| 80.7k| if(resB == nullptr) { ------------------ | Branch (1729:6): [True: 0, False: 80.7k] ------------------ 1730| 0| return false; 1731| 0| } 1732| 80.7k| return resB->fIndex < resB->fSize-1; 1733| 80.7k|} ures_getNextResource_78: 1784| 79.7k|U_CAPI UResourceBundle* U_EXPORT2 ures_getNextResource(UResourceBundle *resB, UResourceBundle *fillIn, UErrorCode *status) { 1785| 79.7k| const char *key = nullptr; 1786| 79.7k| Resource r = RES_BOGUS; ------------------ | | 65| 79.7k|#define RES_BOGUS 0xffffffff ------------------ 1787| | 1788| 79.7k| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (1788:9): [True: 0, False: 79.7k] | Branch (1788:28): [True: 0, False: 79.7k] ------------------ 1789| | /*return nullptr;*/ 1790| 0| return fillIn; 1791| 0| } 1792| 79.7k| if(resB == nullptr) { ------------------ | Branch (1792:8): [True: 0, False: 79.7k] ------------------ 1793| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1794| | /*return nullptr;*/ 1795| 0| return fillIn; 1796| 0| } 1797| | 1798| 79.7k| if(resB->fIndex == resB->fSize-1) { ------------------ | Branch (1798:8): [True: 0, False: 79.7k] ------------------ 1799| 0| *status = U_INDEX_OUTOFBOUNDS_ERROR; 1800| | /*return nullptr;*/ 1801| 79.7k| } else { 1802| 79.7k| resB->fIndex++; 1803| 79.7k| switch(RES_GET_TYPE(resB->fRes)) { ------------------ | | 68| 79.7k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 1804| 0| case URES_INT: ------------------ | Branch (1804:9): [True: 0, False: 79.7k] ------------------ 1805| 0| case URES_BINARY: ------------------ | Branch (1805:9): [True: 0, False: 79.7k] ------------------ 1806| 0| case URES_STRING: ------------------ | Branch (1806:9): [True: 0, False: 79.7k] ------------------ 1807| 0| case URES_STRING_V2: ------------------ | Branch (1807:9): [True: 0, False: 79.7k] ------------------ 1808| 0| case URES_INT_VECTOR: ------------------ | Branch (1808:9): [True: 0, False: 79.7k] ------------------ 1809| 0| return ures_copyResb(fillIn, resB, status); ------------------ | | 1653| 0|#define ures_copyResb U_ICU_ENTRY_POINT_RENAME(ures_copyResb) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1810| 0| case URES_TABLE: ------------------ | Branch (1810:9): [True: 0, False: 79.7k] ------------------ 1811| 79.7k| case URES_TABLE16: ------------------ | Branch (1811:9): [True: 79.7k, False: 0] ------------------ 1812| 79.7k| case URES_TABLE32: ------------------ | Branch (1812:9): [True: 0, False: 79.7k] ------------------ 1813| 79.7k| r = res_getTableItemByIndex(&resB->getResData(), resB->fRes, resB->fIndex, &key); ------------------ | | 206| 79.7k|#define res_getTableItemByIndex U_ICU_ENTRY_POINT_RENAME(res_getTableItemByIndex) | | ------------------ | | | | 123| 79.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 79.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 79.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1814| 79.7k| if(r == RES_BOGUS && resB->fHasFallback) { ------------------ | | 65| 159k|#define RES_BOGUS 0xffffffff ------------------ | Branch (1814:16): [True: 0, False: 79.7k] | Branch (1814:34): [True: 0, False: 0] ------------------ 1815| | /* TODO: do the fallback */ 1816| 0| } 1817| 79.7k| return init_resb_result(resB->fData, r, key, resB->fIndex, resB, fillIn, status); 1818| 0| case URES_ARRAY: ------------------ | Branch (1818:9): [True: 0, False: 79.7k] ------------------ 1819| 0| case URES_ARRAY16: ------------------ | Branch (1819:9): [True: 0, False: 79.7k] ------------------ 1820| 0| r = res_getArrayItem(&resB->getResData(), resB->fRes, resB->fIndex); ------------------ | | 200| 0|#define res_getArrayItem U_ICU_ENTRY_POINT_RENAME(res_getArrayItem) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1821| 0| if(r == RES_BOGUS && resB->fHasFallback) { ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ | Branch (1821:16): [True: 0, False: 0] | Branch (1821:34): [True: 0, False: 0] ------------------ 1822| | /* TODO: do the fallback */ 1823| 0| } 1824| 0| return init_resb_result(resB->fData, r, key, resB->fIndex, resB, fillIn, status); 1825| 0| default: ------------------ | Branch (1825:9): [True: 0, False: 79.7k] ------------------ 1826| | /*return nullptr;*/ 1827| 0| return fillIn; 1828| 79.7k| } 1829| 79.7k| } 1830| | /*return nullptr;*/ 1831| 0| return fillIn; 1832| 79.7k|} ures_getByKey_78: 2493| 115|U_CAPI UResourceBundle* U_EXPORT2 ures_getByKey(const UResourceBundle *resB, const char* inKey, UResourceBundle *fillIn, UErrorCode *status) { 2494| 115| Resource res = RES_BOGUS; ------------------ | | 65| 115|#define RES_BOGUS 0xffffffff ------------------ 2495| 115| UResourceDataEntry *dataEntry = nullptr; 2496| 115| const char *key = inKey; 2497| | 2498| 115| if (status==nullptr || U_FAILURE(*status)) { ------------------ | Branch (2498:9): [True: 0, False: 115] | Branch (2498:28): [True: 0, False: 115] ------------------ 2499| 0| return fillIn; 2500| 0| } 2501| 115| if(resB == nullptr) { ------------------ | Branch (2501:8): [True: 0, False: 115] ------------------ 2502| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2503| 0| return fillIn; 2504| 0| } 2505| | 2506| 115| int32_t type = RES_GET_TYPE(resB->fRes); ------------------ | | 68| 115|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 2507| 115| if(URES_IS_TABLE(type)) { ------------------ | | 84| 115|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 115, False: 0] | | | Branch (84:61): [True: 0, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 2508| 115| int32_t t; 2509| 115| res = res_getTableItemByKey(&resB->getResData(), resB->fRes, &t, &key); ------------------ | | 207| 115|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 115|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 115|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 115|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2510| 115| if(res == RES_BOGUS) { ------------------ | | 65| 115|#define RES_BOGUS 0xffffffff ------------------ | Branch (2510:12): [True: 70, False: 45] ------------------ 2511| 70| key = inKey; 2512| 70| if(resB->fHasFallback) { ------------------ | Branch (2512:16): [True: 0, False: 70] ------------------ 2513| 0| dataEntry = getFallbackData(resB, &key, &res, status); 2514| 0| if(U_SUCCESS(*status)) { ------------------ | Branch (2514:20): [True: 0, False: 0] ------------------ 2515| | /* check if resB->fResPath gives the right name here */ 2516| 0| return init_resb_result(dataEntry, res, key, -1, resB, fillIn, status); 2517| 0| } else { 2518| 0| *status = U_MISSING_RESOURCE_ERROR; 2519| 0| } 2520| 70| } else { 2521| 70| *status = U_MISSING_RESOURCE_ERROR; 2522| 70| } 2523| 70| } else { 2524| 45| return init_resb_result(resB->fData, res, key, -1, resB, fillIn, status); 2525| 45| } 2526| 115| } 2527| |#if 0 2528| | /* this is a kind of TODO item. If we have an array with an index table, we could do this. */ 2529| | /* not currently */ 2530| | else if(RES_GET_TYPE(resB->fRes) == URES_ARRAY && resB->fHasFallback == true) { 2531| | /* here should go a first attempt to locate the key using index table */ 2532| | dataEntry = getFallbackData(resB, &key, &res, status); 2533| | if(U_SUCCESS(*status)) { 2534| | return init_resb_result(dataEntry, res, key, resB, fillIn, status); 2535| | } else { 2536| | *status = U_MISSING_RESOURCE_ERROR; 2537| | } 2538| | } 2539| |#endif 2540| 0| else { 2541| 0| *status = U_RESOURCE_TYPE_MISMATCH; 2542| 0| } 2543| 70| return fillIn; 2544| 115|} ures_openDirect_78: 2783| 4|ures_openDirect(const char* path, const char* localeID, UErrorCode* status) { 2784| 4| return ures_openWithType(nullptr, path, localeID, URES_OPEN_DIRECT, status); 2785| 4|} uresbund.cpp:_ZL21ures_setIsStackObjectP15UResourceBundlea: 711| 1.00k|static void ures_setIsStackObject( UResourceBundle* resB, UBool state) { 712| 1.00k| if(state) { ------------------ | Branch (712:8): [True: 0, False: 1.00k] ------------------ 713| 0| resB->fMagic1 = 0; 714| 0| resB->fMagic2 = 0; 715| 1.00k| } else { 716| 1.00k| resB->fMagic1 = MAGIC1; ------------------ | | 30| 1.00k|#define MAGIC1 19700503 ------------------ 717| 1.00k| resB->fMagic2 = MAGIC2; ------------------ | | 31| 1.00k|#define MAGIC2 19641227 ------------------ 718| 1.00k| } 719| 1.00k|} uresbund.cpp:_ZL16ures_closeBundleP15UResourceBundlea: 1123| 1.00k|{ 1124| 1.00k| if(resB != nullptr) { ------------------ | Branch (1124:8): [True: 1.00k, False: 0] ------------------ 1125| 1.00k| if(resB->fData != nullptr) { ------------------ | Branch (1125:12): [True: 1.00k, False: 0] ------------------ 1126| 1.00k| entryClose(resB->fData); 1127| 1.00k| } 1128| 1.00k| if(resB->fVersion != nullptr) { ------------------ | Branch (1128:12): [True: 0, False: 1.00k] ------------------ 1129| 0| uprv_free(resB->fVersion); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1130| 0| } 1131| 1.00k| ures_freeResPath(resB); 1132| | 1133| 1.00k| if(ures_isStackObject(resB) == false && freeBundleObj) { ------------------ | Branch (1133:12): [True: 1.00k, False: 0] | Branch (1133:49): [True: 1.00k, False: 0] ------------------ 1134| 1.00k| uprv_free(resB); ------------------ | | 1503| 1.00k|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 1.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1135| 1.00k| } 1136| |#if 0 /*U_DEBUG*/ 1137| | else { 1138| | /* poison the data */ 1139| | uprv_memset(resB, -1, sizeof(UResourceBundle)); 1140| | } 1141| |#endif 1142| 1.00k| } 1143| 1.00k|} uresbund.cpp:_ZL10entryCloseP18UResourceDataEntry: 1061| 79.8k|static void entryClose(UResourceDataEntry *resB) { 1062| 79.8k| Mutex lock(&resbMutex); 1063| 79.8k| entryCloseInt(resB); 1064| 79.8k|} uresbund.cpp:_ZL13entryCloseIntP18UResourceDataEntry: 1028| 79.8k|static void entryCloseInt(UResourceDataEntry *resB) { 1029| 79.8k| UResourceDataEntry *p = resB; 1030| | 1031| 159k| while(resB != nullptr) { ------------------ | Branch (1031:11): [True: 79.8k, False: 79.8k] ------------------ 1032| 79.8k| p = resB->fParent; 1033| 79.8k| resB->fCountExisting--; 1034| | 1035| | /* Entries are left in the cache. TODO: add ures_flushCache() to force a flush 1036| | of the cache. */ 1037| |/* 1038| | if(resB->fCountExisting <= 0) { 1039| | uhash_remove(cache, resB); 1040| | if(resB->fBogus == U_ZERO_ERROR) { 1041| | res_unload(&(resB->fData)); 1042| | } 1043| | if(resB->fName != nullptr) { 1044| | uprv_free(resB->fName); 1045| | } 1046| | if(resB->fPath != nullptr) { 1047| | uprv_free(resB->fPath); 1048| | } 1049| | uprv_free(resB); 1050| | } 1051| |*/ 1052| | 1053| 79.8k| resB = p; 1054| 79.8k| } 1055| 79.8k|} uresbund.cpp:_ZL18ures_isStackObjectPK15UResourceBundle: 721| 1.00k|static UBool ures_isStackObject(const UResourceBundle* resB) { 722| 1.00k| return((resB->fMagic1 == MAGIC1 && resB->fMagic2 == MAGIC2)?false:true); ------------------ | | 30| 2.00k|#define MAGIC1 19700503 ------------------ return((resB->fMagic1 == MAGIC1 && resB->fMagic2 == MAGIC2)?false:true); ------------------ | | 31| 1.00k|#define MAGIC2 19641227 ------------------ | Branch (722:11): [True: 1.00k, False: 0] | Branch (722:38): [True: 1.00k, False: 0] ------------------ 723| 1.00k|} uresbund.cpp:_ZL18ures_appendResPathP15UResourceBundlePKciP10UErrorCode: 1083| 239k|static void ures_appendResPath(UResourceBundle *resB, const char* toAdd, int32_t lenToAdd, UErrorCode *status) { 1084| 239k| int32_t resPathLenOrig = resB->fResPathLen; 1085| 239k| if(resB->fResPath == nullptr) { ------------------ | Branch (1085:8): [True: 79.8k, False: 159k] ------------------ 1086| 79.8k| resB->fResPath = resB->fResBuf; 1087| 79.8k| *(resB->fResPath) = 0; 1088| 79.8k| resB->fResPathLen = 0; 1089| 79.8k| } 1090| 239k| resB->fResPathLen += lenToAdd; 1091| 239k| if(RES_BUFSIZE <= resB->fResPathLen+1) { ------------------ | | 59| 239k|#define RES_BUFSIZE 64 ------------------ | Branch (1091:8): [True: 0, False: 239k] ------------------ 1092| 0| if(resB->fResPath == resB->fResBuf) { ------------------ | Branch (1092:12): [True: 0, False: 0] ------------------ 1093| 0| resB->fResPath = static_cast(uprv_malloc((resB->fResPathLen + 1) * sizeof(char))); ------------------ | | 1524| 0|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1094| | /* Check that memory was allocated correctly. */ 1095| 0| if (resB->fResPath == nullptr) { ------------------ | Branch (1095:17): [True: 0, False: 0] ------------------ 1096| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1097| 0| return; 1098| 0| } 1099| 0| uprv_strcpy(resB->fResPath, resB->fResBuf); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1100| 0| } else { 1101| 0| char* temp = static_cast(uprv_realloc(resB->fResPath, (resB->fResPathLen + 1) * sizeof(char))); ------------------ | | 1536| 0|#define uprv_realloc U_ICU_ENTRY_POINT_RENAME(uprv_realloc) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1102| | /* Check that memory was reallocated correctly. */ 1103| 0| if (temp == nullptr) { ------------------ | Branch (1103:17): [True: 0, False: 0] ------------------ 1104| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1105| 0| return; 1106| 0| } 1107| 0| resB->fResPath = temp; 1108| 0| } 1109| 0| } 1110| 239k| uprv_strcpy(resB->fResPath + resPathLenOrig, toAdd); ------------------ | | 36| 239k|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 239k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1111| 239k|} uresbund.cpp:_ZL13entryIncreaseP18UResourceDataEntry: 304| 79.8k|static void entryIncrease(UResourceDataEntry *entry) { 305| 79.8k| Mutex lock(&resbMutex); 306| 79.8k| entry->fCountExisting++; 307| 79.8k| while(entry->fParent != nullptr) { ------------------ | Branch (307:11): [True: 0, False: 79.8k] ------------------ 308| 0| entry = entry->fParent; 309| 0| entry->fCountExisting++; 310| 0| } 311| 79.8k|} uresbund.cpp:_ZN12_GLOBAL__N_116init_resb_resultEP18UResourceDataEntryjPKciPK15UResourceBundlePS4_P10UErrorCode: 1480| 79.8k| UResourceBundle *resB, UErrorCode *status) { 1481| 79.8k| return init_resb_result( 1482| 79.8k| dataEntry, r, key, idx, 1483| 79.8k| container->fValidLocaleDataEntry, container->fResPath, 0, resB, status); 1484| 79.8k|} uresbund.cpp:_ZN12_GLOBAL__N_116init_resb_resultEP18UResourceDataEntryjPKciS1_S3_iP15UResourceBundleP10UErrorCode: 1389| 79.8k| UResourceBundle *resB, UErrorCode *status) { 1390| | // TODO: When an error occurs: Should we return nullptr vs. resB? 1391| 79.8k| if(status == nullptr || U_FAILURE(*status)) { ------------------ | Branch (1391:8): [True: 0, False: 79.8k] | Branch (1391:29): [True: 0, False: 79.8k] ------------------ 1392| 0| return resB; 1393| 0| } 1394| 79.8k| if (validLocaleDataEntry == nullptr) { ------------------ | Branch (1394:9): [True: 0, False: 79.8k] ------------------ 1395| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1396| 0| return nullptr; 1397| 0| } 1398| 79.8k| if(RES_GET_TYPE(r) == URES_ALIAS) { ------------------ | | 68| 79.8k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (1398:8): [True: 3, False: 79.8k] ------------------ 1399| | // This is an alias, need to exchange with real data. 1400| 3| if(recursionDepth >= URES_MAX_ALIAS_LEVEL) { ------------------ | | 33| 3|#define URES_MAX_ALIAS_LEVEL 256 ------------------ | Branch (1400:12): [True: 0, False: 3] ------------------ 1401| 0| *status = U_TOO_MANY_ALIASES_ERROR; 1402| 0| return resB; 1403| 0| } 1404| 3| return getAliasTargetAsResourceBundle( 1405| 3| dataEntry->fData, r, key, idx, 1406| 3| validLocaleDataEntry, containerResPath, recursionDepth, resB, status); 1407| 3| } 1408| 79.8k| if(resB == nullptr) { ------------------ | Branch (1408:8): [True: 1.00k, False: 78.8k] ------------------ 1409| 1.00k| resB = static_cast(uprv_malloc(sizeof(UResourceBundle))); ------------------ | | 1524| 1.00k|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 1.00k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1.00k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1.00k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1410| 1.00k| if (resB == nullptr) { ------------------ | Branch (1410:13): [True: 0, False: 1.00k] ------------------ 1411| 0| *status = U_MEMORY_ALLOCATION_ERROR; 1412| 0| return nullptr; 1413| 0| } 1414| 1.00k| ures_setIsStackObject(resB, false); 1415| 1.00k| resB->fResPath = nullptr; 1416| 1.00k| resB->fResPathLen = 0; 1417| 78.8k| } else { 1418| 78.8k| if(resB->fData != nullptr) { ------------------ | Branch (1418:12): [True: 78.8k, False: 0] ------------------ 1419| 78.8k| entryClose(resB->fData); 1420| 78.8k| } 1421| 78.8k| if(resB->fVersion != nullptr) { ------------------ | Branch (1421:12): [True: 0, False: 78.8k] ------------------ 1422| 0| uprv_free(resB->fVersion); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1423| 0| } 1424| | /* 1425| | weiv: if stack object was passed in, it doesn't really need to be reinited, 1426| | since the purpose of initing is to remove stack junk. However, at this point 1427| | we would not do anything to an allocated object, so stack object should be 1428| | treated the same 1429| | */ 1430| | /* 1431| | if(ures_isStackObject(resB) != false) { 1432| | ures_initStackObject(resB); 1433| | } 1434| | */ 1435| 78.8k| if(containerResPath != resB->fResPath) { ------------------ | Branch (1435:12): [True: 78.8k, False: 0] ------------------ 1436| 78.8k| ures_freeResPath(resB); 1437| 78.8k| } 1438| 78.8k| } 1439| 79.8k| resB->fData = dataEntry; 1440| 79.8k| entryIncrease(resB->fData); 1441| 79.8k| resB->fHasFallback = false; 1442| 79.8k| resB->fIsTopLevel = false; 1443| 79.8k| resB->fIndex = -1; 1444| 79.8k| resB->fKey = key; 1445| 79.8k| resB->fValidLocaleDataEntry = validLocaleDataEntry; 1446| 79.8k| if(containerResPath != resB->fResPath) { ------------------ | Branch (1446:8): [True: 79.8k, False: 7] ------------------ 1447| 79.8k| ures_appendResPath( 1448| 79.8k| resB, containerResPath, static_cast(uprv_strlen(containerResPath)), status); ------------------ | | 37| 79.8k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 79.8k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1449| 79.8k| } 1450| 79.8k| if(key != nullptr) { ------------------ | Branch (1450:8): [True: 79.8k, False: 0] ------------------ 1451| 79.8k| ures_appendResPath(resB, key, static_cast(uprv_strlen(key)), status); ------------------ | | 37| 79.8k|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 79.8k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1452| 79.8k| if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 79.8k|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1452:12): [True: 79.8k, False: 0] ------------------ 1453| 79.8k| ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 79.8k|#define RES_PATH_SEPARATOR_S "/" ------------------ 1454| 79.8k| } 1455| 79.8k| } else if(idx >= 0) { ------------------ | Branch (1455:15): [True: 0, False: 0] ------------------ 1456| 0| char buf[256]; 1457| 0| int32_t len = T_CString_integerToString(buf, idx, 10); ------------------ | | 67| 0|#define T_CString_integerToString U_ICU_ENTRY_POINT_RENAME(T_CString_integerToString) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1458| 0| ures_appendResPath(resB, buf, len, status); 1459| 0| if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 0|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1459:12): [True: 0, False: 0] ------------------ 1460| 0| ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 0|#define RES_PATH_SEPARATOR_S "/" ------------------ 1461| 0| } 1462| 0| } 1463| | /* Make sure that Purify doesn't complain about uninitialized memory copies. */ 1464| 79.8k| { 1465| 79.8k| int32_t usedLen = ((resB->fResBuf == resB->fResPath) ? resB->fResPathLen : 0); ------------------ | Branch (1465:28): [True: 79.8k, False: 0] ------------------ 1466| 79.8k| uprv_memset(resB->fResBuf + usedLen, 0, sizeof(resB->fResBuf) - usedLen); ------------------ | | 100| 79.8k|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 79.8k|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1467| 79.8k| } 1468| | 1469| 79.8k| resB->fVersion = nullptr; 1470| 79.8k| resB->fRes = r; 1471| 79.8k| resB->fSize = res_countArrayItems(&resB->getResData(), resB->fRes); ------------------ | | 197| 79.8k|#define res_countArrayItems U_ICU_ENTRY_POINT_RENAME(res_countArrayItems) | | ------------------ | | | | 123| 79.8k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 79.8k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 79.8k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1472| 79.8k| ResourceTracer(resB).trace("get"); 1473| 79.8k| return resB; 1474| 79.8k|} uresbund.cpp:_ZN12_GLOBAL__N_130getAliasTargetAsResourceBundleERK12ResourceDatajPKciP18UResourceDataEntryS4_iP15UResourceBundleP10UErrorCode: 1166| 3| UResourceBundle *resB, UErrorCode *status) { 1167| | // TODO: When an error occurs: Should we return nullptr vs. resB? 1168| 3| if (U_FAILURE(*status)) { return resB; } ------------------ | Branch (1168:9): [True: 0, False: 3] ------------------ 1169| 3| U_ASSERT(RES_GET_TYPE(r) == URES_ALIAS); ------------------ | | 35| 3|# define U_ASSERT(exp) (void)0 ------------------ 1170| 3| int32_t len = 0; 1171| 3| const char16_t *alias = res_getAlias(&resData, r, &len); ------------------ | | 199| 3|#define res_getAlias U_ICU_ENTRY_POINT_RENAME(res_getAlias) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1172| 3| if(len <= 0) { ------------------ | Branch (1172:8): [True: 0, False: 3] ------------------ 1173| | // bad alias 1174| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 1175| 0| return resB; 1176| 0| } 1177| | 1178| | // Copy the UTF-16 alias string into an invariant-character string. 1179| | // 1180| | // We do this so that res_findResource() can modify the path, 1181| | // which allows us to remove redundant _res_findResource() variants 1182| | // in uresdata.c. 1183| | // res_findResource() now NUL-terminates each segment so that table keys 1184| | // can always be compared with strcmp() instead of strncmp(). 1185| | // Saves code there and simplifies testing and code coverage. 1186| | // 1187| | // markus 2003oct17 1188| 3| CharString chAlias; 1189| 3| chAlias.appendInvariantChars(alias, len, *status); 1190| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1190:9): [True: 0, False: 3] ------------------ 1191| 0| return nullptr; 1192| 0| } 1193| | 1194| | // We have an alias, now let's cut it up. 1195| 3| const char *path = nullptr, *locale = nullptr, *keyPath = nullptr; 1196| 3| if(chAlias[0] == RES_PATH_SEPARATOR) { ------------------ | | 60| 3|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1196:8): [True: 3, False: 0] ------------------ 1197| | // There is a path included. 1198| 3| char *chAliasData = chAlias.data(); 1199| 3| char *sep = chAliasData + 1; 1200| 3| path = sep; 1201| 3| sep = uprv_strchr(sep, RES_PATH_SEPARATOR); ------------------ | | 40| 3|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1202| 3| if(sep != nullptr) { ------------------ | Branch (1202:12): [True: 3, False: 0] ------------------ 1203| 3| *sep++ = 0; 1204| 3| } 1205| 3| if(uprv_strcmp(path, "LOCALE") == 0) { ------------------ | | 38| 3|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1205:12): [True: 0, False: 3] ------------------ 1206| | // This is an XPath alias, starting with "/LOCALE/". 1207| | // It contains the path to a resource which should be looked up 1208| | // starting in the valid locale. 1209| | // TODO: Can/should we forbid a /LOCALE alias without key path? 1210| | // It seems weird to alias to the same path, just starting from the valid locale. 1211| | // That will often yield an infinite loop. 1212| 0| keyPath = sep; 1213| | // Read from the valid locale which we already have. 1214| 0| path = locale = nullptr; 1215| 3| } else { 1216| 3| if(uprv_strcmp(path, "ICUDATA") == 0) { /* want ICU data */ ------------------ | | 38| 3|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1216:16): [True: 3, False: 0] ------------------ 1217| 3| path = nullptr; 1218| 3| } 1219| 3| if (sep == nullptr) { ------------------ | Branch (1219:17): [True: 0, False: 3] ------------------ 1220| | // TODO: This ends up using the root bundle. Can/should we forbid this? 1221| 0| locale = ""; 1222| 3| } else { 1223| 3| locale = sep; 1224| 3| sep = uprv_strchr(sep, RES_PATH_SEPARATOR); ------------------ | | 40| 3|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1225| 3| if(sep != nullptr) { ------------------ | Branch (1225:20): [True: 3, False: 0] ------------------ 1226| 3| *sep++ = 0; 1227| 3| } 1228| 3| keyPath = sep; 1229| 3| } 1230| 3| } 1231| 3| } else { 1232| | // No path, start with a locale. 1233| 0| char *sep = chAlias.data(); 1234| 0| locale = sep; 1235| 0| sep = uprv_strchr(sep, RES_PATH_SEPARATOR); ------------------ | | 40| 0|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1236| 0| if(sep != nullptr) { ------------------ | Branch (1236:12): [True: 0, False: 0] ------------------ 1237| 0| *sep++ = 0; 1238| 0| } 1239| 0| keyPath = sep; 1240| 0| path = validLocaleDataEntry->fPath; 1241| 0| } 1242| | 1243| | // Got almost everything, let's try to open. 1244| | // First, open the bundle with real data. 1245| 3| LocalUResourceBundlePointer mainRes; 1246| 3| UResourceDataEntry *dataEntry; 1247| 3| if (locale == nullptr) { ------------------ | Branch (1247:9): [True: 0, False: 3] ------------------ 1248| | // alias = /LOCALE/keyPath 1249| | // Read from the valid locale which we already have. 1250| 0| dataEntry = validLocaleDataEntry; 1251| 3| } else { 1252| 3| UErrorCode intStatus = U_ZERO_ERROR; 1253| | // TODO: Shouldn't we use ures_open() for locale data bundles (!noFallback)? 1254| 3| mainRes.adoptInstead(ures_openDirect(path, locale, &intStatus)); ------------------ | | 1693| 3|#define ures_openDirect U_ICU_ENTRY_POINT_RENAME(ures_openDirect) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1255| 3| if(U_FAILURE(intStatus)) { ------------------ | Branch (1255:12): [True: 0, False: 3] ------------------ 1256| | // We failed to open the resource bundle we're aliasing to. 1257| 0| *status = intStatus; 1258| 0| return resB; 1259| 0| } 1260| 3| dataEntry = mainRes->fData; 1261| 3| } 1262| | 1263| 3| const char* temp = nullptr; 1264| 3| if(keyPath == nullptr) { ------------------ | Branch (1264:8): [True: 0, False: 3] ------------------ 1265| | // No key path. This means that we are going to to use the corresponding resource from 1266| | // another bundle. 1267| | // TODO: Why the special code path? 1268| | // Why not put together a key path from containerResPath + key or idx, 1269| | // as a comment below suggests, and go into the regular code branch? 1270| | // First, we are going to get a corresponding container 1271| | // resource to the one we are searching. 1272| 0| r = dataEntry->fData.rootRes; 1273| 0| if(containerResPath) { ------------------ | Branch (1273:12): [True: 0, False: 0] ------------------ 1274| 0| chAlias.clear().append(containerResPath, *status); 1275| 0| if (U_FAILURE(*status)) { ------------------ | Branch (1275:17): [True: 0, False: 0] ------------------ 1276| 0| return nullptr; 1277| 0| } 1278| 0| char *aKey = chAlias.data(); 1279| | // TODO: should res_findResource() return a new dataEntry, too? 1280| 0| r = res_findResource(&dataEntry->fData, r, &aKey, &temp); ------------------ | | 198| 0|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1281| 0| } 1282| 0| if(key) { ------------------ | Branch (1282:12): [True: 0, False: 0] ------------------ 1283| | // We need to make keyPath from the containerResPath and 1284| | // current key, if there is a key associated. 1285| 0| chAlias.clear().append(key, *status); 1286| 0| if (U_FAILURE(*status)) { ------------------ | Branch (1286:17): [True: 0, False: 0] ------------------ 1287| 0| return nullptr; 1288| 0| } 1289| 0| char *aKey = chAlias.data(); 1290| 0| r = res_findResource(&dataEntry->fData, r, &aKey, &temp); ------------------ | | 198| 0|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1291| 0| } else if(idx != -1) { ------------------ | Branch (1291:19): [True: 0, False: 0] ------------------ 1292| | // If there is no key, but there is an index, try to get by the index. 1293| | // Here we have either a table or an array, so get the element. 1294| 0| int32_t type = RES_GET_TYPE(r); ------------------ | | 68| 0|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 1295| 0| if(URES_IS_TABLE(type)) { ------------------ | | 84| 0|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 0, False: 0] | | | Branch (84:61): [True: 0, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 1296| 0| const char *aKey; 1297| 0| r = res_getTableItemByIndex(&dataEntry->fData, r, idx, &aKey); ------------------ | | 206| 0|#define res_getTableItemByIndex U_ICU_ENTRY_POINT_RENAME(res_getTableItemByIndex) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1298| 0| } else { /* array */ 1299| 0| r = res_getArrayItem(&dataEntry->fData, r, idx); ------------------ | | 200| 0|#define res_getArrayItem U_ICU_ENTRY_POINT_RENAME(res_getArrayItem) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1300| 0| } 1301| 0| } 1302| 0| if(r != RES_BOGUS) { ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ | Branch (1302:12): [True: 0, False: 0] ------------------ 1303| 0| resB = init_resb_result( 1304| 0| dataEntry, r, temp, -1, validLocaleDataEntry, nullptr, recursionDepth+1, 1305| 0| resB, status); 1306| 0| } else { 1307| 0| *status = U_MISSING_RESOURCE_ERROR; 1308| 0| } 1309| 3| } else { 1310| | // This one is a bit trickier. 1311| | // We start finding keys, but after we resolve one alias, the path might continue. 1312| | // Consider: 1313| | // aliastest:alias { "testtypes/anotheralias/Sequence" } 1314| | // anotheralias:alias { "/ICUDATA/sh/CollationElements" } 1315| | // aliastest resource should finally have the sequence, not collation elements. 1316| 3| CharString pathBuf(keyPath, *status); 1317| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1317:13): [True: 0, False: 3] ------------------ 1318| 0| return nullptr; 1319| 0| } 1320| 3| char *myPath = pathBuf.data(); 1321| 3| containerResPath = nullptr; 1322| | // Now we have fallback following here. 1323| 3| for(;;) { 1324| 3| r = dataEntry->fData.rootRes; 1325| | // TODO: Move containerResPath = nullptr to here, 1326| | // consistent with restarting from the rootRes of another bundle?! 1327| | 1328| | // This loop handles 'found' resources over several levels. 1329| 6| while(*myPath && U_SUCCESS(*status)) { ------------------ | Branch (1329:19): [True: 3, False: 3] | Branch (1329:30): [True: 3, False: 0] ------------------ 1330| 3| r = res_findResource(&(dataEntry->fData), r, &myPath, &temp); ------------------ | | 198| 3|#define res_findResource U_ICU_ENTRY_POINT_RENAME(res_findResource) | | ------------------ | | | | 123| 3|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1331| 3| if(r == RES_BOGUS) { ------------------ | | 65| 3|#define RES_BOGUS 0xffffffff ------------------ | Branch (1331:20): [True: 0, False: 3] ------------------ 1332| | // No resource found, we don't really want to look anymore on this level. 1333| 0| break; 1334| 0| } 1335| | // Found a resource, but it might be an indirection. 1336| 3| resB = init_resb_result( 1337| 3| dataEntry, r, temp, -1, 1338| 3| validLocaleDataEntry, containerResPath, recursionDepth+1, 1339| 3| resB, status); 1340| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1340:21): [True: 0, False: 3] ------------------ 1341| 0| break; 1342| 0| } 1343| 3| if (temp == nullptr || uprv_strcmp(keyPath, temp) != 0) { ------------------ | | 38| 3|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1343:21): [True: 0, False: 3] | Branch (1343:40): [True: 3, False: 0] ------------------ 1344| | // The call to init_resb_result() above will set resB->fKeyPath to be 1345| | // the same as resB->fKey, 1346| | // throwing away any additional path elements if we had them -- 1347| | // if the key path wasn't just a single resource ID, clear out 1348| | // the bundle's key path and re-set it to be equal to keyPath. 1349| 3| ures_freeResPath(resB); 1350| 3| ures_appendResPath(resB, keyPath, static_cast(uprv_strlen(keyPath)), status); ------------------ | | 37| 3|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1351| 3| if(resB->fResPath[resB->fResPathLen-1] != RES_PATH_SEPARATOR) { ------------------ | | 60| 3|#define RES_PATH_SEPARATOR '/' ------------------ | Branch (1351:24): [True: 3, False: 0] ------------------ 1352| 3| ures_appendResPath(resB, RES_PATH_SEPARATOR_S, 1, status); ------------------ | | 61| 3|#define RES_PATH_SEPARATOR_S "/" ------------------ 1353| 3| } 1354| 3| if (U_FAILURE(*status)) { ------------------ | Branch (1354:25): [True: 0, False: 3] ------------------ 1355| 0| break; 1356| 0| } 1357| 3| } 1358| 3| r = resB->fRes; /* switch to a new resource, possibly a new tree */ 1359| 3| dataEntry = resB->fData; 1360| 3| containerResPath = resB->fResPath; 1361| 3| } 1362| 3| if (U_FAILURE(*status) || r != RES_BOGUS) { ------------------ | | 65| 3|#define RES_BOGUS 0xffffffff ------------------ | Branch (1362:17): [True: 0, False: 3] | Branch (1362:39): [True: 3, False: 0] ------------------ 1363| 3| break; 1364| 3| } 1365| | // Fall back to the parent bundle, if there is one. 1366| 0| dataEntry = dataEntry->fParent; 1367| 0| if (dataEntry == nullptr) { ------------------ | Branch (1367:17): [True: 0, False: 0] ------------------ 1368| 0| *status = U_MISSING_RESOURCE_ERROR; 1369| 0| break; 1370| 0| } 1371| | // Copy the same keyPath again. 1372| 0| myPath = pathBuf.data(); 1373| 0| uprv_strcpy(myPath, keyPath); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1374| 0| } 1375| 3| } 1376| 3| if(mainRes.getAlias() == resB) { ------------------ | Branch (1376:8): [True: 0, False: 3] ------------------ 1377| 0| mainRes.orphan(); 1378| 0| } 1379| 3| ResourceTracer(resB).maybeTrace("getalias"); 1380| 3| return resB; 1381| 3|} uresbund.cpp:_ZL16ures_freeResPathP15UResourceBundle: 1113| 79.8k|static void ures_freeResPath(UResourceBundle *resB) { 1114| 79.8k| if (resB->fResPath && resB->fResPath != resB->fResBuf) { ------------------ | Branch (1114:9): [True: 79.8k, False: 4] | Branch (1114:27): [True: 0, False: 79.8k] ------------------ 1115| 0| uprv_free(resB->fResPath); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1116| 0| } 1117| 79.8k| resB->fResPath = nullptr; 1118| 79.8k| resB->fResPathLen = 0; 1119| 79.8k|} uresbund.cpp:_ZL17ures_openWithTypeP15UResourceBundlePKcS2_12UResOpenTypeP10UErrorCode: 2712| 4| UResOpenType openType, UErrorCode* status) { 2713| 4| if(U_FAILURE(*status)) { ------------------ | Branch (2713:8): [True: 0, False: 4] ------------------ 2714| 0| return nullptr; 2715| 0| } 2716| | 2717| 4| UResourceDataEntry *entry; 2718| 4| if(openType != URES_OPEN_DIRECT) { ------------------ | Branch (2718:8): [True: 0, False: 4] ------------------ 2719| 0| if (localeID == nullptr) { ------------------ | Branch (2719:13): [True: 0, False: 0] ------------------ 2720| 0| localeID = uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2721| 0| } 2722| | /* first "canonicalize" the locale ID */ 2723| 0| CharString canonLocaleID = ulocimp_getBaseName(localeID, *status); ------------------ | | 1199| 0|#define ulocimp_getBaseName U_ICU_ENTRY_POINT_RENAME(ulocimp_getBaseName) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2724| 0| if(U_FAILURE(*status)) { ------------------ | Branch (2724:12): [True: 0, False: 0] ------------------ 2725| 0| *status = U_ILLEGAL_ARGUMENT_ERROR; 2726| 0| return nullptr; 2727| 0| } 2728| 0| entry = entryOpen(path, canonLocaleID.data(), openType, status); 2729| 4| } else { 2730| 4| entry = entryOpenDirect(path, localeID, status); 2731| 4| } 2732| 4| if(U_FAILURE(*status)) { ------------------ | Branch (2732:8): [True: 0, False: 4] ------------------ 2733| 0| return nullptr; 2734| 0| } 2735| 4| if(entry == nullptr) { ------------------ | Branch (2735:8): [True: 0, False: 4] ------------------ 2736| 0| *status = U_MISSING_RESOURCE_ERROR; 2737| 0| return nullptr; 2738| 0| } 2739| | 2740| 4| UBool isStackObject; 2741| 4| if(r == nullptr) { ------------------ | Branch (2741:8): [True: 4, False: 0] ------------------ 2742| 4| r = static_cast(uprv_malloc(sizeof(UResourceBundle))); ------------------ | | 1524| 4|#define uprv_malloc U_ICU_ENTRY_POINT_RENAME(uprv_malloc) | | ------------------ | | | | 123| 4|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2743| 4| if(r == nullptr) { ------------------ | Branch (2743:12): [True: 0, False: 4] ------------------ 2744| 0| entryClose(entry); 2745| 0| *status = U_MEMORY_ALLOCATION_ERROR; 2746| 0| return nullptr; 2747| 0| } 2748| 4| isStackObject = false; 2749| 4| } else { // fill-in 2750| 0| isStackObject = ures_isStackObject(r); 2751| 0| ures_closeBundle(r, false); 2752| 0| } 2753| 4| uprv_memset(r, 0, sizeof(UResourceBundle)); ------------------ | | 100| 4|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 2754| 4| ures_setIsStackObject(r, isStackObject); 2755| | 2756| 4| r->fValidLocaleDataEntry = r->fData = entry; 2757| 4| r->fHasFallback = openType != URES_OPEN_DIRECT && !r->getResData().noFallback; ------------------ | Branch (2757:23): [True: 0, False: 4] | Branch (2757:55): [True: 0, False: 0] ------------------ 2758| 4| r->fIsTopLevel = true; 2759| 4| r->fRes = r->getResData().rootRes; 2760| 4| r->fSize = res_countArrayItems(&r->getResData(), r->fRes); ------------------ | | 197| 4|#define res_countArrayItems U_ICU_ENTRY_POINT_RENAME(res_countArrayItems) | | ------------------ | | | | 123| 4|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2761| 4| r->fIndex = -1; 2762| | 2763| 4| ResourceTracer(r).traceOpen(); 2764| | 2765| 4| return r; 2766| 4|} uresbund.cpp:_ZL9initCacheP10UErrorCode: 483| 4|static void initCache(UErrorCode *status) { 484| 4| umtx_initOnce(gCacheInitOnce, &createCache, *status); 485| 4|} uresbund.cpp:_ZL11createCacheR10UErrorCode: 477| 1|static void U_CALLCONV createCache(UErrorCode &status) { 478| 1| U_ASSERT(cache == nullptr); ------------------ | | 35| 1|# define U_ASSERT(exp) (void)0 ------------------ 479| 1| cache = uhash_open(hashEntry, compareEntries, nullptr, &status); ------------------ | | 1030| 1|#define uhash_open U_ICU_ENTRY_POINT_RENAME(uhash_open) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 480| 1| ucln_common_registerCleanup(UCLN_COMMON_URES, ures_cleanup); ------------------ | | 617| 1|#define ucln_common_registerCleanup U_ICU_ENTRY_POINT_RENAME(ucln_common_registerCleanup) | | ------------------ | | | | 123| 1|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 1|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 1|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 481| 1|} uresbund.cpp:_ZL9hashEntry8UElement: 58| 8|static int32_t U_CALLCONV hashEntry(const UHashTok parm) { 59| 8| UResourceDataEntry* b = static_cast(parm.pointer); 60| 8| UHashTok namekey, pathkey; 61| 8| namekey.pointer = b->fName; 62| 8| pathkey.pointer = b->fPath; 63| 8| return uhash_hashChars(namekey)+37u*uhash_hashChars(pathkey); ------------------ | | 1011| 8|#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars) | | ------------------ | | | | 123| 8|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return uhash_hashChars(namekey)+37u*uhash_hashChars(pathkey); ------------------ | | 1011| 8|#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars) | | ------------------ | | | | 123| 8|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 8|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 8|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 8|} uresbund.cpp:_ZL14compareEntries8UElementS_: 67| 2|static UBool U_CALLCONV compareEntries(const UHashTok p1, const UHashTok p2) { 68| 2| UResourceDataEntry* b1 = static_cast(p1.pointer); 69| 2| UResourceDataEntry* b2 = static_cast(p2.pointer); 70| 2| UHashTok name1, name2, path1, path2; 71| 2| name1.pointer = b1->fName; 72| 2| name2.pointer = b2->fName; 73| 2| path1.pointer = b1->fPath; 74| 2| path2.pointer = b2->fPath; 75| 2| return uhash_compareChars(name1, name2) && uhash_compareChars(path1, path2); ------------------ | | 993| 2|#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ return uhash_compareChars(name1, name2) && uhash_compareChars(path1, path2); ------------------ | | 993| 2|#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (75:12): [True: 2, False: 0] | Branch (75:48): [True: 2, False: 0] ------------------ 76| 2|} uresbund.cpp:_ZL10init_entryPKcS0_P10UErrorCode: 514| 4|static UResourceDataEntry *init_entry(const char *localeID, const char *path, UErrorCode *status) { 515| 4| UResourceDataEntry *r = nullptr; 516| 4| UResourceDataEntry find; 517| | /*int32_t hashValue;*/ 518| 4| const char *name; 519| 4| char aliasName[100] = { 0 }; 520| 4| int32_t aliasLen = 0; 521| | /*UBool isAlias = false;*/ 522| | /*UHashTok hashkey; */ 523| | 524| 4| if(U_FAILURE(*status)) { ------------------ | Branch (524:8): [True: 0, False: 4] ------------------ 525| 0| return nullptr; 526| 0| } 527| | 528| | /* here we try to deduce the right locale name */ 529| 4| if(localeID == nullptr) { /* if localeID is nullptr, we're trying to open default locale */ ------------------ | Branch (529:8): [True: 0, False: 4] ------------------ 530| 0| name = uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 531| 4| } else if(*localeID == 0) { /* if localeID is "" then we try to open root locale */ ------------------ | Branch (531:15): [True: 0, False: 4] ------------------ 532| 0| name = kRootLocaleName; ------------------ | | 18| 0|#define kRootLocaleName "root" ------------------ 533| 4| } else { /* otherwise, we'll open what we're given */ 534| 4| name = localeID; 535| 4| } 536| | 537| 4| find.fName = const_cast(name); 538| 4| find.fPath = const_cast(path); 539| | 540| | /* calculate the hash value of the entry */ 541| | /*hashkey.pointer = (void *)&find;*/ 542| | /*hashValue = hashEntry(hashkey);*/ 543| | 544| | /* check to see if we already have this entry */ 545| 4| r = static_cast(uhash_get(cache, &find)); ------------------ | | 1007| 4|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 123| 4|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 4|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 4|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 546| 4| if(r == nullptr) { ------------------ | Branch (546:8): [True: 2, False: 2] ------------------ 547| | /* if the entry is not yet in the hash table, we'll try to construct a new one */ 548| 2| r = static_cast(uprv_malloc(sizeof(UResourceDataEntry))); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 549| 2| if(r == nullptr) { ------------------ | Branch (549:12): [True: 0, False: 2] ------------------ 550| 0| *status = U_MEMORY_ALLOCATION_ERROR; 551| 0| return nullptr; 552| 0| } 553| | 554| 2| uprv_memset(r, 0, sizeof(UResourceDataEntry)); ------------------ | | 100| 2|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 555| | /*r->fHashKey = hashValue;*/ 556| | 557| 2| setEntryName(r, name, status); 558| 2| if (U_FAILURE(*status)) { ------------------ | Branch (558:13): [True: 0, False: 2] ------------------ 559| 0| uprv_free(r); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 560| 0| return nullptr; 561| 0| } 562| | 563| 2| if(path != nullptr) { ------------------ | Branch (563:12): [True: 0, False: 2] ------------------ 564| 0| r->fPath = uprv_strdup(path); ------------------ | | 1541| 0|#define uprv_strdup U_ICU_ENTRY_POINT_RENAME(uprv_strdup) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 565| 0| if(r->fPath == nullptr) { ------------------ | Branch (565:16): [True: 0, False: 0] ------------------ 566| 0| *status = U_MEMORY_ALLOCATION_ERROR; 567| 0| uprv_free(r); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 568| 0| return nullptr; 569| 0| } 570| 0| } 571| | 572| | /* this is the actual loading */ 573| 2| res_load(&(r->fData), r->fPath, r->fName, status); ------------------ | | 208| 2|#define res_load U_ICU_ENTRY_POINT_RENAME(res_load) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 574| | 575| 2| if (U_FAILURE(*status)) { ------------------ | Branch (575:13): [True: 0, False: 2] ------------------ 576| | /* if we failed to load due to an out-of-memory error, exit early. */ 577| 0| if (*status == U_MEMORY_ALLOCATION_ERROR) { ------------------ | Branch (577:17): [True: 0, False: 0] ------------------ 578| 0| uprv_free(r); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 579| 0| return nullptr; 580| 0| } 581| | /* we have no such entry in dll, so it will always use fallback */ 582| 0| *status = U_USING_FALLBACK_WARNING; 583| 0| r->fBogus = U_USING_FALLBACK_WARNING; 584| 2| } else { /* if we have a regular entry */ 585| 2| Resource aliasres; 586| 2| if (r->fData.usesPoolBundle) { ------------------ | Branch (586:17): [True: 0, False: 2] ------------------ 587| 0| r->fPool = getPoolEntry(r->fPath, status); 588| 0| if (U_SUCCESS(*status)) { ------------------ | Branch (588:21): [True: 0, False: 0] ------------------ 589| 0| const int32_t *poolIndexes = r->fPool->fData.pRoot + 1; 590| 0| if(r->fData.pRoot[1 + URES_INDEX_POOL_CHECKSUM] == poolIndexes[URES_INDEX_POOL_CHECKSUM]) { ------------------ | Branch (590:24): [True: 0, False: 0] ------------------ 591| 0| r->fData.poolBundleKeys = reinterpret_cast(poolIndexes + (poolIndexes[URES_INDEX_LENGTH] & 0xff)); 592| 0| r->fData.poolBundleStrings = r->fPool->fData.p16BitUnits; 593| 0| } else { 594| 0| r->fBogus = *status = U_INVALID_FORMAT_ERROR; 595| 0| } 596| 0| } else { 597| 0| r->fBogus = *status; 598| 0| } 599| 0| } 600| 2| if (U_SUCCESS(*status)) { ------------------ | Branch (600:17): [True: 2, False: 0] ------------------ 601| | /* handle the alias by trying to get out the %%Alias tag.*/ 602| | /* We'll try to get alias string from the bundle */ 603| 2| aliasres = res_getResource(&(r->fData), "%%ALIAS"); ------------------ | | 204| 2|#define res_getResource U_ICU_ENTRY_POINT_RENAME(res_getResource) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 604| 2| if (aliasres != RES_BOGUS) { ------------------ | | 65| 2|#define RES_BOGUS 0xffffffff ------------------ | Branch (604:21): [True: 0, False: 2] ------------------ 605| | // No tracing: called during initial data loading 606| 0| const char16_t *alias = res_getStringNoTrace(&(r->fData), aliasres, &aliasLen); ------------------ | | 205| 0|#define res_getStringNoTrace U_ICU_ENTRY_POINT_RENAME(res_getStringNoTrace) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 0| if(alias != nullptr && aliasLen > 0) { /* if there is actual alias - unload and load new data */ ------------------ | Branch (607:24): [True: 0, False: 0] | Branch (607:44): [True: 0, False: 0] ------------------ 608| 0| u_UCharsToChars(alias, aliasName, aliasLen+1); ------------------ | | 211| 0|#define u_UCharsToChars U_ICU_ENTRY_POINT_RENAME(u_UCharsToChars) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 609| 0| r->fAlias = init_entry(aliasName, path, status); 610| 0| } 611| 0| } 612| 2| } 613| 2| } 614| | 615| 2| { 616| 2| UResourceDataEntry *oldR = nullptr; 617| 2| if ((oldR = static_cast(uhash_get(cache, r))) == nullptr) { /* if the data is not cached */ ------------------ | | 1007| 2|#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (617:17): [True: 2, False: 0] ------------------ 618| | /* just insert it in the cache */ 619| 2| UErrorCode cacheStatus = U_ZERO_ERROR; 620| 2| uhash_put(cache, (void *)r, r, &cacheStatus); ------------------ | | 1032| 2|#define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 621| 2| if (U_FAILURE(cacheStatus)) { ------------------ | Branch (621:21): [True: 0, False: 2] ------------------ 622| 0| *status = cacheStatus; 623| 0| free_entry(r); 624| 0| r = nullptr; 625| 0| } 626| 2| } else { 627| | /* somebody have already inserted it while we were working, discard newly opened data */ 628| | /* Also, we could get here IF we opened an alias */ 629| 0| free_entry(r); 630| 0| r = oldR; 631| 0| } 632| 2| } 633| | 634| 2| } 635| 4| if(r != nullptr) { ------------------ | Branch (635:8): [True: 4, False: 0] ------------------ 636| | /* return the real bundle */ 637| 4| while(r->fAlias != nullptr) { ------------------ | Branch (637:15): [True: 0, False: 4] ------------------ 638| 0| r = r->fAlias; 639| 0| } 640| 4| r->fCountExisting++; /* we increase its reference count */ 641| | /* if the resource has a warning */ 642| | /* we don't want to overwrite a status with no error */ 643| 4| if(r->fBogus != U_ZERO_ERROR && U_SUCCESS(*status)) { ------------------ | Branch (643:12): [True: 0, False: 4] | Branch (643:41): [True: 0, False: 0] ------------------ 644| 0| *status = r->fBogus; /* set the returning status */ 645| 0| } 646| 4| } 647| 4| return r; 648| 4|} uresbund.cpp:_ZL12setEntryNameP18UResourceDataEntryPKcP10UErrorCode: 489| 2|static void setEntryName(UResourceDataEntry *res, const char *name, UErrorCode *status) { 490| 2| int32_t len = static_cast(uprv_strlen(name)); ------------------ | | 37| 2|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 491| 2| if(res->fName != nullptr && res->fName != res->fNameBuffer) { ------------------ | Branch (491:8): [True: 0, False: 2] | Branch (491:33): [True: 0, False: 0] ------------------ 492| 0| uprv_free(res->fName); ------------------ | | 1503| 0|#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 493| 0| } 494| 2| if (len < static_cast(sizeof(res->fNameBuffer))) { ------------------ | Branch (494:9): [True: 0, False: 2] ------------------ 495| 0| res->fName = res->fNameBuffer; 496| 0| } 497| 2| else { 498| 2| res->fName = static_cast(uprv_malloc(len + 1)); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 499| 2| } 500| 2| if(res->fName == nullptr) { ------------------ | Branch (500:8): [True: 0, False: 2] ------------------ 501| 0| *status = U_MEMORY_ALLOCATION_ERROR; 502| 2| } else { 503| 2| uprv_strcpy(res->fName, name); ------------------ | | 36| 2|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 504| 2| } 505| 2|} uresbund.cpp:_ZL15entryOpenDirectPKcS0_P10UErrorCode: 966| 4|entryOpenDirect(const char* path, const char* localeID, UErrorCode* status) { 967| 4| initCache(status); 968| 4| if(U_FAILURE(*status)) { ------------------ | Branch (968:8): [True: 0, False: 4] ------------------ 969| 0| return nullptr; 970| 0| } 971| | 972| | // Note: We need to query the default locale *before* locking resbMutex. 973| | // If the localeID is nullptr, then we want to use the default locale. 974| 4| if (localeID == nullptr) { ------------------ | Branch (974:9): [True: 0, False: 4] ------------------ 975| 0| localeID = uloc_getDefault(); ------------------ | | 1118| 0|#define uloc_getDefault U_ICU_ENTRY_POINT_RENAME(uloc_getDefault) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 976| 4| } else if (*localeID == 0) { ------------------ | Branch (976:16): [True: 0, False: 4] ------------------ 977| | // If the localeID is "", then we want to use the root locale. 978| 0| localeID = kRootLocaleName; ------------------ | | 18| 0|#define kRootLocaleName "root" ------------------ 979| 0| } 980| | 981| 4| Mutex lock(&resbMutex); 982| | 983| | // findFirstExisting() without fallbacks. 984| 4| UResourceDataEntry *r = init_entry(localeID, path, status); 985| 4| if(U_SUCCESS(*status)) { ------------------ | Branch (985:8): [True: 4, False: 0] ------------------ 986| 4| if(r->fBogus != U_ZERO_ERROR) { ------------------ | Branch (986:12): [True: 0, False: 4] ------------------ 987| 0| r->fCountExisting--; 988| 0| r = nullptr; 989| 0| } 990| 4| } else { 991| 0| r = nullptr; 992| 0| } 993| | 994| | // Some code depends on the ures_openDirect() bundle to have a parent bundle chain, 995| | // unless it is marked with "nofallback". 996| 4| UResourceDataEntry *t1 = r; 997| 4| if(r != nullptr && uprv_strcmp(localeID, kRootLocaleName) != 0 && // not root ------------------ | | 38| 4|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 4|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (997:8): [True: 4, False: 0] | Branch (997:24): [True: 4, False: 0] ------------------ 998| 4| r->fParent == nullptr && !r->fData.noFallback && ------------------ | Branch (998:13): [True: 4, False: 0] | Branch (998:38): [True: 0, False: 4] ------------------ 999| 4| uprv_strlen(localeID) < ULOC_FULLNAME_CAPACITY) { ------------------ | | 37| 0|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ uprv_strlen(localeID) < ULOC_FULLNAME_CAPACITY) { ------------------ | | 264| 0|#define ULOC_FULLNAME_CAPACITY 157 ------------------ | Branch (999:13): [True: 0, False: 0] ------------------ 1000| 0| char name[ULOC_FULLNAME_CAPACITY]; 1001| 0| uprv_strcpy(name, localeID); ------------------ | | 36| 0|#define uprv_strcpy(dst, src) U_STANDARD_CPP_NAMESPACE strcpy(dst, src) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 1002| 0| if(!chopLocale(name) || uprv_strcmp(name, kRootLocaleName) == 0 || ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1002:12): [True: 0, False: 0] | Branch (1002:33): [True: 0, False: 0] ------------------ 1003| 0| loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name), false, nullptr, status)) { ------------------ | | 99| 0|#define UPRV_LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) ------------------ | Branch (1003:17): [True: 0, False: 0] ------------------ 1004| 0| if(uprv_strcmp(t1->fName, kRootLocaleName) != 0 && t1->fParent == nullptr) { ------------------ | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (1004:16): [True: 0, False: 0] | Branch (1004:64): [True: 0, False: 0] ------------------ 1005| 0| insertRootBundle(t1, status); 1006| 0| } 1007| 0| } 1008| 0| if(U_FAILURE(*status)) { ------------------ | Branch (1008:12): [True: 0, False: 0] ------------------ 1009| 0| r = nullptr; 1010| 0| } 1011| 0| } 1012| | 1013| 4| if(r != nullptr) { ------------------ | Branch (1013:8): [True: 4, False: 0] ------------------ 1014| | // TODO: Does this ever loop? 1015| 4| while(t1->fParent != nullptr) { ------------------ | Branch (1015:15): [True: 0, False: 4] ------------------ 1016| 0| t1->fParent->fCountExisting++; 1017| 0| t1 = t1->fParent; 1018| 0| } 1019| 4| } 1020| 4| return r; 1021| 4|} res_load_78: 260| 2| const char *path, const char *name, UErrorCode *errorCode) { 261| 2| UVersionInfo formatVersion; 262| | 263| 2| uprv_memset(pResData, 0, sizeof(ResourceData)); ------------------ | | 100| 2|#define uprv_memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE memset(buffer, mark, size) | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 264| | 265| | /* load the ResourceBundle file */ 266| 2| pResData->data=udata_openChoice(path, "res", name, isAcceptable, formatVersion, errorCode); ------------------ | | 894| 2|#define udata_openChoice U_ICU_ENTRY_POINT_RENAME(udata_openChoice) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 267| 2| if(U_FAILURE(*errorCode)) { ------------------ | Branch (267:8): [True: 0, False: 2] ------------------ 268| 0| return; 269| 0| } 270| | 271| | /* get its memory and initialize *pResData */ 272| 2| res_init(pResData, formatVersion, udata_getMemory(pResData->data), -1, errorCode); ------------------ | | 891| 2|#define udata_getMemory U_ICU_ENTRY_POINT_RENAME(udata_getMemory) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 273| 2|} res_getStringNoTrace_78: 311| 79.7k|res_getStringNoTrace(const ResourceData *pResData, Resource res, int32_t *pLength) { 312| 79.7k| const char16_t *p; 313| 79.7k| uint32_t offset=RES_GET_OFFSET(res); ------------------ | | 69| 79.7k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 314| 79.7k| int32_t length; 315| 79.7k| if(RES_GET_TYPE(res)==URES_STRING_V2) { ------------------ | | 68| 79.7k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (315:8): [True: 79.7k, False: 0] ------------------ 316| 79.7k| int32_t first; 317| 79.7k| if((int32_t)offsetpoolStringIndexLimit) { ------------------ | Branch (317:12): [True: 0, False: 79.7k] ------------------ 318| 0| p=(const char16_t *)pResData->poolBundleStrings+offset; 319| 79.7k| } else { 320| 79.7k| p=(const char16_t *)pResData->p16BitUnits+(offset-pResData->poolStringIndexLimit); 321| 79.7k| } 322| 79.7k| first=*p; 323| 79.7k| if(!U16_IS_TRAIL(first)) { ------------------ | | 67| 79.7k|#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00) ------------------ | Branch (323:12): [True: 79.7k, False: 0] ------------------ 324| 79.7k| length=u_strlen(p); ------------------ | | 393| 79.7k|#define u_strlen U_ICU_ENTRY_POINT_RENAME(u_strlen) | | ------------------ | | | | 123| 79.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 79.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 79.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 325| 79.7k| } else if(first<0xdfef) { ------------------ | Branch (325:19): [True: 0, False: 0] ------------------ 326| 0| length=first&0x3ff; 327| 0| ++p; 328| 0| } else if(first<0xdfff) { ------------------ | Branch (328:19): [True: 0, False: 0] ------------------ 329| 0| length=((first-0xdfef)<<16)|p[1]; 330| 0| p+=2; 331| 0| } else { 332| 0| length=((int32_t)p[1]<<16)|p[2]; 333| 0| p+=3; 334| 0| } 335| 79.7k| } else if(res==offset) /* RES_GET_TYPE(res)==URES_STRING */ { ------------------ | Branch (335:15): [True: 0, False: 0] ------------------ 336| 0| const int32_t *p32= res==0 ? &gEmptyString.length : pResData->pRoot+res; ------------------ | Branch (336:29): [True: 0, False: 0] ------------------ 337| 0| length=*p32++; 338| 0| p=(const char16_t *)p32; 339| 0| } else { 340| 0| p=nullptr; 341| 0| length=0; 342| 0| } 343| 79.7k| if(pLength) { ------------------ | Branch (343:8): [True: 79.7k, False: 0] ------------------ 344| 79.7k| *pLength=length; 345| 79.7k| } 346| 79.7k| return p; 347| 79.7k|} res_getAlias_78: 420| 3|res_getAlias(const ResourceData *pResData, Resource res, int32_t *pLength) { 421| 3| const char16_t *p; 422| 3| uint32_t offset=RES_GET_OFFSET(res); ------------------ | | 69| 3|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 423| 3| int32_t length; 424| 3| if(RES_GET_TYPE(res)==URES_ALIAS) { ------------------ | | 68| 3|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ | Branch (424:8): [True: 3, False: 0] ------------------ 425| 3| const int32_t *p32= offset==0 ? &gEmptyString.length : pResData->pRoot+offset; ------------------ | Branch (425:29): [True: 0, False: 3] ------------------ 426| 3| length=*p32++; 427| 3| p=(const char16_t *)p32; 428| 3| } else { 429| 0| p=nullptr; 430| 0| length=0; 431| 0| } 432| 3| if(pLength) { ------------------ | Branch (432:8): [True: 3, False: 0] ------------------ 433| 3| *pLength=length; 434| 3| } 435| 3| return p; 436| 3|} res_countArrayItems_78: 477| 79.8k|res_countArrayItems(const ResourceData *pResData, Resource res) { 478| 79.8k| uint32_t offset=RES_GET_OFFSET(res); ------------------ | | 69| 79.8k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 479| 79.8k| switch(RES_GET_TYPE(res)) { ------------------ | | 68| 79.8k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 480| 0| case URES_STRING: ------------------ | Branch (480:5): [True: 0, False: 79.8k] ------------------ 481| 79.7k| case URES_STRING_V2: ------------------ | Branch (481:5): [True: 79.7k, False: 49] ------------------ 482| 79.7k| case URES_BINARY: ------------------ | Branch (482:5): [True: 0, False: 79.8k] ------------------ 483| 79.7k| case URES_ALIAS: ------------------ | Branch (483:5): [True: 0, False: 79.8k] ------------------ 484| 79.7k| case URES_INT: ------------------ | Branch (484:5): [True: 0, False: 79.8k] ------------------ 485| 79.7k| case URES_INT_VECTOR: ------------------ | Branch (485:5): [True: 0, False: 79.8k] ------------------ 486| 79.7k| return 1; 487| 0| case URES_ARRAY: ------------------ | Branch (487:5): [True: 0, False: 79.8k] ------------------ 488| 0| case URES_TABLE32: ------------------ | Branch (488:5): [True: 0, False: 79.8k] ------------------ 489| 0| return offset==0 ? 0 : *(pResData->pRoot+offset); ------------------ | Branch (489:16): [True: 0, False: 0] ------------------ 490| 7| case URES_TABLE: ------------------ | Branch (490:5): [True: 7, False: 79.8k] ------------------ 491| 7| return offset==0 ? 0 : *((const uint16_t *)(pResData->pRoot+offset)); ------------------ | Branch (491:16): [True: 0, False: 7] ------------------ 492| 0| case URES_ARRAY16: ------------------ | Branch (492:5): [True: 0, False: 79.8k] ------------------ 493| 42| case URES_TABLE16: ------------------ | Branch (493:5): [True: 42, False: 79.7k] ------------------ 494| 42| return pResData->p16BitUnits[offset]; 495| 0| default: ------------------ | Branch (495:5): [True: 0, False: 79.8k] ------------------ 496| 0| return 0; 497| 79.8k| } 498| 79.8k|} res_getTableItemByKey_78: 713| 123| int32_t *indexR, const char **key) { 714| 123| uint32_t offset=RES_GET_OFFSET(table); ------------------ | | 69| 123|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 715| 123| int32_t length; 716| 123| int32_t idx; 717| 123| if(key == nullptr || *key == nullptr) { ------------------ | Branch (717:8): [True: 0, False: 123] | Branch (717:26): [True: 0, False: 123] ------------------ 718| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 719| 0| } 720| 123| switch(RES_GET_TYPE(table)) { ------------------ | | 68| 123|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 721| 123| case URES_TABLE: { ------------------ | Branch (721:5): [True: 123, False: 0] ------------------ 722| 123| if (offset!=0) { /* empty if offset==0 */ ------------------ | Branch (722:13): [True: 123, False: 0] ------------------ 723| 123| const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset); 724| 123| length=*p++; 725| 123| *indexR=idx=_res_findTableItem(pResData, p, length, *key, key); 726| 123| if(idx>=0) { ------------------ | Branch (726:16): [True: 51, False: 72] ------------------ 727| 51| const Resource *p32=(const Resource *)(p+length+(~length&1)); 728| 51| return p32[idx]; 729| 51| } 730| 123| } 731| 72| break; 732| 123| } 733| 72| case URES_TABLE16: { ------------------ | Branch (733:5): [True: 0, False: 123] ------------------ 734| 0| const uint16_t *p=pResData->p16BitUnits+offset; 735| 0| length=*p++; 736| 0| *indexR=idx=_res_findTableItem(pResData, p, length, *key, key); 737| 0| if(idx>=0) { ------------------ | Branch (737:12): [True: 0, False: 0] ------------------ 738| 0| return makeResourceFrom16(pResData, p[length+idx]); 739| 0| } 740| 0| break; 741| 0| } 742| 0| case URES_TABLE32: { ------------------ | Branch (742:5): [True: 0, False: 123] ------------------ 743| 0| if (offset!=0) { /* empty if offset==0 */ ------------------ | Branch (743:13): [True: 0, False: 0] ------------------ 744| 0| const int32_t *p= pResData->pRoot+offset; 745| 0| length=*p++; 746| 0| *indexR=idx=_res_findTable32Item(pResData, p, length, *key, key); 747| 0| if(idx>=0) { ------------------ | Branch (747:16): [True: 0, False: 0] ------------------ 748| 0| return (Resource)p[length+idx]; 749| 0| } 750| 0| } 751| 0| break; 752| 0| } 753| 0| default: ------------------ | Branch (753:5): [True: 0, False: 123] ------------------ 754| 0| break; 755| 123| } 756| 72| return RES_BOGUS; ------------------ | | 65| 72|#define RES_BOGUS 0xffffffff ------------------ 757| 123|} res_getTableItemByIndex_78: 761| 79.7k| int32_t indexR, const char **key) { 762| 79.7k| uint32_t offset=RES_GET_OFFSET(table); ------------------ | | 69| 79.7k|#define RES_GET_OFFSET(res) ((res)&0x0fffffff) ------------------ 763| 79.7k| int32_t length; 764| 79.7k| if (indexR < 0) { ------------------ | Branch (764:9): [True: 0, False: 79.7k] ------------------ 765| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 766| 0| } 767| 79.7k| switch(RES_GET_TYPE(table)) { ------------------ | | 68| 79.7k|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 768| 0| case URES_TABLE: { ------------------ | Branch (768:5): [True: 0, False: 79.7k] ------------------ 769| 0| if (offset != 0) { /* empty if offset==0 */ ------------------ | Branch (769:13): [True: 0, False: 0] ------------------ 770| 0| const uint16_t *p= (const uint16_t *)(pResData->pRoot+offset); 771| 0| length=*p++; 772| 0| if(indexRlocalKeyLimit ? \ | | ------------------ | | | Branch (44:6): [True: 0, False: 0] | | ------------------ | | 45| 0| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 46| 0| (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit) ------------------ 776| 0| } 777| 0| return p32[indexR]; 778| 0| } 779| 0| } 780| 0| break; 781| 0| } 782| 79.7k| case URES_TABLE16: { ------------------ | Branch (782:5): [True: 79.7k, False: 0] ------------------ 783| 79.7k| const uint16_t *p=pResData->p16BitUnits+offset; 784| 79.7k| length=*p++; 785| 79.7k| if(indexRlocalKeyLimit ? \ | | ------------------ | | | Branch (44:6): [True: 79.7k, False: 0] | | ------------------ | | 45| 79.7k| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 46| 79.7k| (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit) ------------------ 788| 79.7k| } 789| 79.7k| return makeResourceFrom16(pResData, p[length+indexR]); 790| 79.7k| } 791| 0| break; 792| 79.7k| } 793| 0| case URES_TABLE32: { ------------------ | Branch (793:5): [True: 0, False: 79.7k] ------------------ 794| 0| if (offset != 0) { /* empty if offset==0 */ ------------------ | Branch (794:13): [True: 0, False: 0] ------------------ 795| 0| const int32_t *p= pResData->pRoot+offset; 796| 0| length=*p++; 797| 0| if(indexR=0 ? \ | | ------------------ | | | Branch (49:6): [True: 0, False: 0] | | ------------------ | | 50| 0| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 51| 0| (pResData)->poolBundleKeys+((keyOffset)&0x7fffffff)) ------------------ 800| 0| } 801| 0| return (Resource)p[length+indexR]; 802| 0| } 803| 0| } 804| 0| break; 805| 0| } 806| 0| default: ------------------ | Branch (806:5): [True: 0, False: 79.7k] ------------------ 807| 0| break; 808| 79.7k| } 809| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 810| 79.7k|} res_getResource_78: 813| 2|res_getResource(const ResourceData *pResData, const char *key) { 814| 2| const char *realKey=key; 815| 2| int32_t idx; 816| 2| return res_getTableItemByKey(pResData, pResData->rootRes, &idx, &realKey); ------------------ | | 207| 2|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 817| 2|} res_findResource_78: 921| 3|res_findResource(const ResourceData *pResData, Resource r, char** path, const char** key) { 922| 3| char *pathP = *path, *nextSepP = *path; 923| 3| char *closeIndex = nullptr; 924| 3| Resource t1 = r; 925| 3| Resource t2; 926| 3| int32_t indexR = 0; 927| 3| UResType type = (UResType)RES_GET_TYPE(t1); ------------------ | | 68| 3|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 928| | 929| | /* if you come in with an empty path, you'll be getting back the same resource */ 930| 3| if(!uprv_strlen(pathP)) { ------------------ | | 37| 3|#define uprv_strlen(str) U_STANDARD_CPP_NAMESPACE strlen(str) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ | Branch (930:6): [True: 0, False: 3] ------------------ 931| 0| return r; 932| 0| } 933| | 934| | /* one needs to have an aggregate resource in order to search in it */ 935| 3| if(!URES_IS_CONTAINER(type)) { ------------------ | | 85| 3|#define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 84| 6|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | | | ------------------ | | | | | Branch (84:30): [True: 3, False: 0] | | | | | Branch (84:61): [True: 0, False: 0] | | | | | Branch (84:94): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | | | ------------------ | | | | | Branch (83:30): [True: 0, False: 0] | | | | | Branch (83:61): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 936| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 937| 0| } 938| | 939| 9| while(nextSepP && *pathP && t1 != RES_BOGUS && URES_IS_CONTAINER(type)) { ------------------ | | 65| 15|#define RES_BOGUS 0xffffffff ------------------ while(nextSepP && *pathP && t1 != RES_BOGUS && URES_IS_CONTAINER(type)) { ------------------ | | 85| 6|#define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 84| 12|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | | | ------------------ | | | | | Branch (84:30): [True: 6, False: 0] | | | | | Branch (84:61): [True: 0, False: 0] | | | | | Branch (84:94): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define URES_IS_CONTAINER(type) (URES_IS_TABLE(type) || URES_IS_ARRAY(type)) | | ------------------ | | | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | | | ------------------ | | | | | Branch (83:30): [True: 0, False: 0] | | | | | Branch (83:61): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (939:9): [True: 6, False: 3] | Branch (939:21): [True: 6, False: 0] | Branch (939:31): [True: 6, False: 0] ------------------ 940| | /* Iteration stops if: the path has been consumed, we found a non-existing 941| | * resource (t1 == RES_BOGUS) or we found a scalar resource (including alias) 942| | */ 943| 6| nextSepP = uprv_strchr(pathP, RES_PATH_SEPARATOR); ------------------ | | 40| 6|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 6|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 944| | /* if there are more separators, terminate string 945| | * and set path to the remaining part of the string 946| | */ 947| 6| if(nextSepP != nullptr) { ------------------ | Branch (947:8): [True: 3, False: 3] ------------------ 948| 3| if(nextSepP == pathP) { ------------------ | Branch (948:10): [True: 0, False: 3] ------------------ 949| | // Empty key string. 950| 0| return RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 951| 0| } 952| 3| *nextSepP = 0; /* overwrite the separator with a NUL to terminate the key */ 953| 3| *path = nextSepP+1; 954| 3| } else { 955| 3| *path = uprv_strchr(pathP, 0); ------------------ | | 40| 3|#define uprv_strchr(s, c) U_STANDARD_CPP_NAMESPACE strchr(s, c) | | ------------------ | | | | 393| 3|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 956| 3| } 957| | 958| | /* if the resource is a table */ 959| | /* try the key based access */ 960| 6| if(URES_IS_TABLE(type)) { ------------------ | | 84| 6|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 6, False: 0] | | | Branch (84:61): [True: 0, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 961| 6| *key = pathP; 962| 6| t2 = res_getTableItemByKey(pResData, t1, &indexR, key); ------------------ | | 207| 6|#define res_getTableItemByKey U_ICU_ENTRY_POINT_RENAME(res_getTableItemByKey) | | ------------------ | | | | 123| 6|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 6|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 6|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 963| 6| } else if(URES_IS_ARRAY(type)) { ------------------ | | 83| 0|#define URES_IS_ARRAY(type) ((int32_t)(type)==URES_ARRAY || (int32_t)(type)==URES_ARRAY16) | | ------------------ | | | Branch (83:30): [True: 0, False: 0] | | | Branch (83:61): [True: 0, False: 0] | | ------------------ ------------------ 964| 0| indexR = uprv_strtol(pathP, &closeIndex, 10); ------------------ | | 77| 0|#define uprv_strtol(str, end, base) U_STANDARD_CPP_NAMESPACE strtol(str, end, base) | | ------------------ | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 965| 0| if(indexR >= 0 && *closeIndex == 0) { ------------------ | Branch (965:10): [True: 0, False: 0] | Branch (965:25): [True: 0, False: 0] ------------------ 966| 0| t2 = res_getArrayItem(pResData, t1, indexR); ------------------ | | 200| 0|#define res_getArrayItem U_ICU_ENTRY_POINT_RENAME(res_getArrayItem) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 967| 0| } else { 968| 0| t2 = RES_BOGUS; /* have an array, but don't have a valid index */ ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 969| 0| } 970| 0| *key = nullptr; 971| 0| } else { /* can't do much here, except setting t2 to bogus */ 972| 0| t2 = RES_BOGUS; ------------------ | | 65| 0|#define RES_BOGUS 0xffffffff ------------------ 973| 0| } 974| 6| t1 = t2; 975| 6| type = (UResType)RES_GET_TYPE(t1); ------------------ | | 68| 6|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 976| | /* position pathP to next resource key/index */ 977| 6| pathP = *path; 978| 6| } 979| | 980| 3| return t1; 981| 3|} uresdata.cpp:_ZL12isAcceptablePvPKcS1_PK9UDataInfo: 141| 2| const UDataInfo *pInfo) { 142| 2| uprv_memcpy(context, pInfo->formatVersion, 4); ------------------ | | 42| 2|#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 2|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 43| 2| /* Suppress warnings about addresses that will never be NULL */ \ | | 44| 2| _Pragma("clang diagnostic push") \ | | 45| 2| _Pragma("clang diagnostic ignored \"-Waddress\"") \ | | 46| 2| U_ASSERT(dst != NULL); \ | | ------------------ | | | | 35| 2|# define U_ASSERT(exp) (void)0 | | ------------------ | | 47| 2| U_ASSERT(src != NULL); \ | | ------------------ | | | | 35| 2|# define U_ASSERT(exp) (void)0 | | ------------------ | | 48| 2| _Pragma("clang diagnostic pop") \ | | 49| 2| U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \ | | ------------------ | | | | 393| 2|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ | | 50| 2|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 2|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 143| 2| return 144| 2| pInfo->size>=20 && ------------------ | Branch (144:9): [True: 2, False: 0] ------------------ 145| 2| pInfo->isBigEndian==U_IS_BIG_ENDIAN && ------------------ | | 353| 4|# define U_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) ------------------ | Branch (145:9): [True: 2, False: 0] ------------------ 146| 2| pInfo->charsetFamily==U_CHARSET_FAMILY && ------------------ | | 588| 2|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 4|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ | Branch (146:9): [True: 2, False: 0] ------------------ 147| 2| pInfo->sizeofUChar==U_SIZEOF_UCHAR && ------------------ | | 352| 4|#define U_SIZEOF_UCHAR 2 ------------------ | Branch (147:9): [True: 2, False: 0] ------------------ 148| 2| pInfo->dataFormat[0]==0x52 && /* dataFormat="ResB" */ ------------------ | Branch (148:9): [True: 2, False: 0] ------------------ 149| 2| pInfo->dataFormat[1]==0x65 && ------------------ | Branch (149:9): [True: 2, False: 0] ------------------ 150| 2| pInfo->dataFormat[2]==0x73 && ------------------ | Branch (150:9): [True: 2, False: 0] ------------------ 151| 2| pInfo->dataFormat[3]==0x42 && ------------------ | Branch (151:9): [True: 2, False: 0] ------------------ 152| 2| (1<=pInfo->formatVersion[0] && pInfo->formatVersion[0]<=3); ------------------ | Branch (152:10): [True: 2, False: 0] | Branch (152:40): [True: 2, False: 0] ------------------ 153| 2|} uresdata.cpp:_ZL8res_initP12ResourceDataPhPKviP10UErrorCode: 160| 2| UErrorCode *errorCode) { 161| 2| UResType rootType; 162| | 163| | /* get the root resource */ 164| 2| pResData->pRoot = static_cast(inBytes); 165| 2| pResData->rootRes = static_cast(*pResData->pRoot); 166| 2| pResData->p16BitUnits=&gEmpty16; 167| | 168| | /* formatVersion 1.1 must have a root item and at least 5 indexes */ 169| 2| if(length>=0 && (length/4)<((formatVersion[0]==1 && formatVersion[1]==0) ? 1 : 1+5)) { ------------------ | Branch (169:8): [True: 0, False: 2] | Branch (169:21): [True: 0, False: 0] | Branch (169:34): [True: 0, False: 0] | Branch (169:57): [True: 0, False: 0] ------------------ 170| 0| *errorCode=U_INVALID_FORMAT_ERROR; 171| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 172| 0| return; 173| 0| } 174| | 175| | /* currently, we accept only resources that have a Table as their roots */ 176| 2| rootType = static_cast(RES_GET_TYPE(pResData->rootRes)); ------------------ | | 68| 2|#define RES_GET_TYPE(res) ((int32_t)((res)>>28UL)) ------------------ 177| 2| if(!URES_IS_TABLE(rootType)) { ------------------ | | 84| 2|#define URES_IS_TABLE(type) ((int32_t)(type)==URES_TABLE || (int32_t)(type)==URES_TABLE16 || (int32_t)(type)==URES_TABLE32) | | ------------------ | | | Branch (84:30): [True: 2, False: 0] | | | Branch (84:61): [True: 0, False: 0] | | | Branch (84:94): [True: 0, False: 0] | | ------------------ ------------------ 178| 0| *errorCode=U_INVALID_FORMAT_ERROR; 179| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 180| 0| return; 181| 0| } 182| | 183| 2| if(formatVersion[0]==1 && formatVersion[1]==0) { ------------------ | Branch (183:8): [True: 0, False: 2] | Branch (183:31): [True: 0, False: 0] ------------------ 184| 0| pResData->localKeyLimit=0x10000; /* greater than any 16-bit key string offset */ 185| 2| } else { 186| | /* bundles with formatVersion 1.1 and later contain an indexes[] array */ 187| 2| const int32_t *indexes=pResData->pRoot+1; 188| 2| int32_t indexLength=indexes[URES_INDEX_LENGTH]&0xff; 189| 2| if(indexLength<=URES_INDEX_MAX_TABLE_LENGTH) { ------------------ | Branch (189:12): [True: 0, False: 2] ------------------ 190| 0| *errorCode=U_INVALID_FORMAT_ERROR; 191| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 192| 0| return; 193| 0| } 194| 2| if( length>=0 && ------------------ | Branch (194:13): [True: 0, False: 2] ------------------ 195| 2| (length<((1+indexLength)<<2) || ------------------ | Branch (195:14): [True: 0, False: 0] ------------------ 196| 0| length<(indexes[URES_INDEX_BUNDLE_TOP]<<2)) ------------------ | Branch (196:14): [True: 0, False: 0] ------------------ 197| 2| ) { 198| 0| *errorCode=U_INVALID_FORMAT_ERROR; 199| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 0| return; 201| 0| } 202| 2| if(indexes[URES_INDEX_KEYS_TOP]>(1+indexLength)) { ------------------ | Branch (202:12): [True: 2, False: 0] ------------------ 203| 2| pResData->localKeyLimit=indexes[URES_INDEX_KEYS_TOP]<<2; 204| 2| } 205| 2| if(formatVersion[0]>=3) { ------------------ | Branch (205:12): [True: 0, False: 2] ------------------ 206| | // In formatVersion 1, the indexLength took up this whole int. 207| | // In version 2, bits 31..8 were reserved and always 0. 208| | // In version 3, they contain bits 23..0 of the poolStringIndexLimit. 209| | // Bits 27..24 are in indexes[URES_INDEX_ATTRIBUTES] bits 15..12. 210| 0| pResData->poolStringIndexLimit = static_cast(static_cast(indexes[URES_INDEX_LENGTH]) >> 8); 211| 0| } 212| 2| if(indexLength>URES_INDEX_ATTRIBUTES) { ------------------ | Branch (212:12): [True: 2, False: 0] ------------------ 213| 2| int32_t att=indexes[URES_INDEX_ATTRIBUTES]; 214| 2| pResData->noFallback = static_cast(att & URES_ATT_NO_FALLBACK); ------------------ | | 148| 2|#define URES_ATT_NO_FALLBACK 1 ------------------ 215| 2| pResData->isPoolBundle = static_cast((att & URES_ATT_IS_POOL_BUNDLE) != 0); ------------------ | | 156| 2|#define URES_ATT_IS_POOL_BUNDLE 2 ------------------ 216| 2| pResData->usesPoolBundle = static_cast((att & URES_ATT_USES_POOL_BUNDLE) != 0); ------------------ | | 157| 2|#define URES_ATT_USES_POOL_BUNDLE 4 ------------------ 217| 2| pResData->poolStringIndexLimit|=(att&0xf000)<<12; // bits 15..12 -> 27..24 218| 2| pResData->poolStringIndex16Limit = static_cast(static_cast(att) >> 16); 219| 2| } 220| 2| if((pResData->isPoolBundle || pResData->usesPoolBundle) && indexLength<=URES_INDEX_POOL_CHECKSUM) { ------------------ | Branch (220:13): [True: 0, False: 2] | Branch (220:39): [True: 0, False: 2] | Branch (220:68): [True: 0, False: 0] ------------------ 221| 0| *errorCode=U_INVALID_FORMAT_ERROR; 222| 0| res_unload(pResData); ------------------ | | 210| 0|#define res_unload U_ICU_ENTRY_POINT_RENAME(res_unload) | | ------------------ | | | | 123| 0|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 0|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 0|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 223| 0| return; 224| 0| } 225| 2| if( indexLength>URES_INDEX_16BIT_TOP && ------------------ | Branch (225:13): [True: 2, False: 0] ------------------ 226| 2| indexes[URES_INDEX_16BIT_TOP]>indexes[URES_INDEX_KEYS_TOP] ------------------ | Branch (226:13): [True: 2, False: 0] ------------------ 227| 2| ) { 228| 2| pResData->p16BitUnits = reinterpret_cast(pResData->pRoot + indexes[URES_INDEX_KEYS_TOP]); 229| 2| } 230| 2| } 231| | 232| 2| if(formatVersion[0]==1 || U_CHARSET_FAMILY==U_ASCII_FAMILY) { ------------------ | | 588| 2|# define U_CHARSET_FAMILY U_ASCII_FAMILY | | ------------------ | | | | 531| 2|#define U_ASCII_FAMILY 0 | | ------------------ ------------------ if(formatVersion[0]==1 || U_CHARSET_FAMILY==U_ASCII_FAMILY) { ------------------ | | 531| 2|#define U_ASCII_FAMILY 0 ------------------ | Branch (232:8): [True: 0, False: 2] | Branch (232:31): [Folded - Ignored] ------------------ 233| | /* 234| | * formatVersion 1: compare key strings in native-charset order 235| | * formatVersion 2 and up: compare key strings in ASCII order 236| | */ 237| 2| pResData->useNativeStrcmp=true; 238| 2| } 239| 2|} uresdata.cpp:_ZL18_res_findTableItemPK12ResourceDataPKtiPKcPS5_: 76| 123| const char *key, const char **realKey) { 77| 123| const char *tableKey; 78| 123| int32_t mid, start, limit; 79| 123| int result; 80| | 81| | /* do a binary search for the key */ 82| 123| start=0; 83| 123| limit=length; 84| 402| while(startlocalKeyLimit ? \ | | ------------------ | | | Branch (44:6): [True: 330, False: 0] | | ------------------ | | 45| 330| (const char *)(pResData)->pRoot+(keyOffset) : \ | | 46| 330| (pResData)->poolBundleKeys+(keyOffset)-(pResData)->localKeyLimit) ------------------ 87| 330| if (pResData->useNativeStrcmp) { ------------------ | Branch (87:13): [True: 330, False: 0] ------------------ 88| 330| result = uprv_strcmp(key, tableKey); ------------------ | | 38| 330|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | ------------------ | | | | 393| 330|#define U_STANDARD_CPP_NAMESPACE :: | | ------------------ ------------------ 89| 330| } else { 90| 0| result = uprv_compareInvCharsAsAscii(key, tableKey); ------------------ | | 153| 0|# define uprv_compareInvCharsAsAscii(s1, s2) uprv_strcmp(s1, s2) | | ------------------ | | | | 38| 0|#define uprv_strcmp(s1, s2) U_STANDARD_CPP_NAMESPACE strcmp(s1, s2) | | | | ------------------ | | | | | | 393| 0|#define U_STANDARD_CPP_NAMESPACE :: | | | | ------------------ | | ------------------ ------------------ 91| 0| } 92| 330| if (result < 0) { ------------------ | Branch (92:13): [True: 160, False: 170] ------------------ 93| 160| limit = mid; 94| 170| } else if (result > 0) { ------------------ | Branch (94:20): [True: 119, False: 51] ------------------ 95| 119| start = mid + 1; 96| 119| } else { 97| | /* We found it! */ 98| 51| *realKey=tableKey; 99| 51| return mid; 100| 51| } 101| 330| } 102| 72| return URESDATA_ITEM_NOT_FOUND; /* not found or table is empty. */ ------------------ | | 53| 72|#define URESDATA_ITEM_NOT_FOUND -1 ------------------ 103| 123|} uresdata.cpp:_ZL18makeResourceFrom16PK12ResourceDatai: 700| 79.7k|makeResourceFrom16(const ResourceData *pResData, int32_t res16) { 701| 79.7k| if(res16poolStringIndex16Limit) { ------------------ | Branch (701:8): [True: 0, False: 79.7k] ------------------ 702| | // Pool string, nothing to do. 703| 79.7k| } else { 704| | // Local string, adjust the 16-bit offset to a regular one, 705| | // with a larger pool string index limit. 706| 79.7k| res16=res16-pResData->poolStringIndex16Limit+pResData->poolStringIndexLimit; 707| 79.7k| } 708| 79.7k| return URES_MAKE_RESOURCE(URES_STRING_V2, res16); ------------------ | | 87| 79.7k|#define URES_MAKE_RESOURCE(type, offset) (((Resource)(type)<<28)|(Resource)(offset)) ------------------ 709| 79.7k|} _ZN6icu_7813res_getStringERKNS_14ResourceTracerEPK12ResourceDatajPi: 486| 79.7k| const ResourceData *pResData, Resource res, int32_t *pLength) { 487| 79.7k| traceInfo.trace("string"); 488| 79.7k| return res_getStringNoTrace(pResData, res, pLength); ------------------ | | 205| 79.7k|#define res_getStringNoTrace U_ICU_ENTRY_POINT_RENAME(res_getStringNoTrace) | | ------------------ | | | | 123| 79.7k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 79.7k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 79.7k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 489| 79.7k|} _ZNK15UResourceBundle10getResDataEv: 94| 239k| inline const ResourceData &getResData() const { return fData->fData; } u_strlen_78: 995| 79.7k|{ 996| |#if U_SIZEOF_WCHAR_T == U_SIZEOF_UCHAR 997| | return (int32_t)uprv_wcslen((const wchar_t *)s); 998| |#else 999| 79.7k| const char16_t *t = s; 1000| 1.10M| while(*t != 0) { ------------------ | Branch (1000:11): [True: 1.03M, False: 79.7k] ------------------ 1001| 1.03M| ++t; 1002| 1.03M| } 1003| 79.7k| return t - s; 1004| 79.7k|#endif 1005| 79.7k|} ustr_hashCharsN_78: 1528| 8|ustr_hashCharsN(const char *str, int32_t length) { 1529| 8| STRING_HASH(uint8_t, str, length, *p); ------------------ | | 1506| 8|#define STRING_HASH(TYPE, STR, STRLEN, DEREF) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 8|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1507| 8| uint32_t hash = 0; \ | | 1508| 8| const TYPE *p = (const TYPE*) STR; \ | | 1509| 8| if (p != nullptr) { \ | | ------------------ | | | Branch (1509:9): [True: 8, False: 0] | | ------------------ | | 1510| 8| int32_t len = (int32_t)(STRLEN); \ | | 1511| 8| int32_t inc = ((len - 32) / 32) + 1; \ | | 1512| 8| const TYPE *limit = p + len; \ | | 1513| 106| while (p(hash); \ | | 1519| 8|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 8|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1530| 8|} ustr_hashICharsN_78: 1533| 1.73M|ustr_hashICharsN(const char *str, int32_t length) { 1534| 1.73M| STRING_HASH(char, str, length, (uint8_t)uprv_tolower(*p)); ------------------ | | 1506| 1.73M|#define STRING_HASH(TYPE, STR, STRLEN, DEREF) UPRV_BLOCK_MACRO_BEGIN { \ | | ------------------ | | | | 169| 1.73M|#define UPRV_BLOCK_MACRO_BEGIN do | | ------------------ | | 1507| 1.73M| uint32_t hash = 0; \ | | 1508| 1.73M| const TYPE *p = (const TYPE*) STR; \ | | 1509| 1.73M| if (p != nullptr) { \ | | ------------------ | | | Branch (1509:9): [True: 1.73M, False: 0] | | ------------------ | | 1510| 1.73M| int32_t len = (int32_t)(STRLEN); \ | | 1511| 1.73M| int32_t inc = ((len - 32) / 32) + 1; \ | | 1512| 1.73M| const TYPE *limit = p + len; \ | | 1513| 5.39M| while (p(hash); \ | | 1519| 1.73M|} UPRV_BLOCK_MACRO_END | | ------------------ | | | | 178| 1.73M|#define UPRV_BLOCK_MACRO_END while (false) | | | | ------------------ | | | | | Branch (178:37): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1535| 1.73M|} _Z23MakeZeroTerminatedInputPKhi: 10| 3.55k|std::string MakeZeroTerminatedInput(const uint8_t *data, int32_t size) { 11| 3.55k| return size == 0 ? "" : std::string(reinterpret_cast(data), size); ------------------ | Branch (11:10): [True: 0, False: 3.55k] ------------------ 12| 3.55k|} LLVMFuzzerTestOneInput: 10| 3.55k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 11| 3.55k| const std::string input = MakeZeroTerminatedInput(data, size); 12| | 13| 3.55k| UErrorCode status = U_ZERO_ERROR; 14| 3.55k| UEnumeration* enumeration = uloc_openKeywords(input.c_str(), &status); ------------------ | | 1144| 3.55k|#define uloc_openKeywords U_ICU_ENTRY_POINT_RENAME(uloc_openKeywords) | | ------------------ | | | | 123| 3.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 15| | 16| | // Have to clean up. Call works even for nullptr enumeration. 17| 3.55k| uenum_close(enumeration); ------------------ | | 948| 3.55k|#define uenum_close U_ICU_ENTRY_POINT_RENAME(uenum_close) | | ------------------ | | | | 123| 3.55k|# define U_ICU_ENTRY_POINT_RENAME(x) U_DEF2_ICU_ENTRY_POINT_RENAME(x,U_ICU_VERSION_SUFFIX) | | | | ------------------ | | | | | | 122| 3.55k|# define U_DEF2_ICU_ENTRY_POINT_RENAME(x,y) U_DEF_ICU_ENTRY_POINT_RENAME(x,y) | | | | | | ------------------ | | | | | | | | 121| 3.55k|# define U_DEF_ICU_ENTRY_POINT_RENAME(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 18| | 19| 3.55k| return 0; 20| 3.55k|}