name string | code string | asm string | file string |
|---|---|---|---|
icu_63::FCDUTF8CollationIterator::getOffset() const | int32_t
FCDUTF8CollationIterator::getOffset() const {
if(state != IN_NORMALIZED) {
return pos;
} else if(pos == 0) {
return start;
} else {
return limit;
}
} | leaq 0x190(%rdi), %rax
cmpl $0x3, 0x198(%rdi)
jne 0x128396
cmpl $0x0, (%rax)
je 0x12838c
addq $0x1a0, %rdi # imm = 0x1A0
jmp 0x128393
addq $0x19c, %rdi # imm = 0x19C
movq %rdi, %rax
movl (%rax), %eax
retq
nop
| /hunter-packages[P]icu/source/i18n/utf8collationiterator.cpp |
icu_63::FCDUTF8CollationIterator::switchToForward() | void
FCDUTF8CollationIterator::switchToForward() {
U_ASSERT(state == CHECK_BWD ||
(state == IN_FCD_SEGMENT && pos == limit) ||
(state == IN_NORMALIZED && pos == normalized.length()));
if(state == CHECK_BWD) {
// Turn around from backward checking.
start = pos;
i... | movl 0x198(%rdi), %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
je 0x128d03
cmpl $0x1, %ecx
jne 0x128cf1
movl 0x190(%rdi), %ecx
xorl %eax, %eax
cmpl 0x1a0(%rdi), %ecx
setne %al
movl %ecx, 0x19c(%rdi)
addl %eax, %eax
jmp 0x128d03
movl 0x1a0(%rdi), %ecx
movl %ecx, 0x190(%rdi)
movl %ecx, 0x19c(%rdi)
movl %eax, 0x198(%rdi)
retq
| /hunter-packages[P]icu/source/i18n/utf8collationiterator.cpp |
icu_63::FCDUTF8CollationIterator::nextCodePoint(UErrorCode&) | UChar32
FCDUTF8CollationIterator::nextCodePoint(UErrorCode &errorCode) {
UChar32 c;
for(;;) {
if(state == CHECK_FWD) {
if(pos == length || ((c = u8[pos]) == 0 && length < 0)) {
return U_SENTINEL;
}
if(U8_IS_SINGLE(c)) {
++pos;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xd40be(%rip), %rbp # 0x1fcef8
leaq 0xd5b5f(%rip), %r12 # 0x1fe9a0
movl 0x198(%rbx), %eax
cmpq $0x3, %rax
ja 0x128f17
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movslq 0x190(%rbx), %rsi
m... | /hunter-packages[P]icu/source/i18n/utf8collationiterator.cpp |
u_writeIdenticalLevelRun_63 | U_CFUNC UChar32
u_writeIdenticalLevelRun(UChar32 prev, const UChar *s, int32_t length, icu::ByteSink &sink) {
char scratch[64];
int32_t capacity;
int32_t i=0;
while(i<length) {
char *buffer=sink.GetAppendBuffer(1, length*2, scratch, (int32_t)sizeof(scratch), &capacity);
uint8_t *p;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edi, %r12d
testl %edx, %edx
jle 0x129c62
movq %rcx, %r8
movl %edx, %r14d
movq %rsi, %r15
leal (%r14,%r14), %eax
movl %eax, 0x4(%rsp)
xorl %ebx, %ebx
leaq 0x10(%rsp), %rcx
movl $0x7654, %r13d # imm = 0x7654
movq %r8, 0x8(%r... | /hunter-packages[P]icu/source/i18n/bocsu.cpp |
icu_63::CollationElementIterator::getOffset() const | int32_t CollationElementIterator::getOffset() const
{
if (dir_ < 0 && offsets_ != NULL && !offsets_->isEmpty()) {
// CollationIterator::previousCE() decrements the CEs length
// while it pops CEs from its internal buffer.
int32_t i = iter_->getCEsLength();
if (otherHalf_ != 0) {
... | cmpb $0x0, 0x1c(%rdi)
js 0x129ee2
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
jmpq *0x28(%rax)
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x129ed8
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x129ed8
movq 0x8(%rdi), %rsi
xorl %edx, %edx
cmpl $0x0, 0x18(%rdi)
setne %dl
addl 0x18(%rsi), %edx
sets %sil
cmpl %edx, %eax
setle %dil
x... | /hunter-packages[P]icu/source/i18n/coleitr.cpp |
icu_63::CollationElementIterator::setOffset(int, UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rdx)
jle 0x12a2aa
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jle 0x12a39e
movq %rdx, %r14
movswl 0x30(%rbx), %eax
testw %ax, %ax
jns 0x12a2d3
movl 0x34(%rbx), %eax
jmp 0x12a2d6
sarl $0x5, %eax
cmpl %ebp, %eax
jle 0x12a3... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::CollationElementIterator::CollationElementIterator(icu_63::CharacterIterator const&, icu_63::RuleBasedCollator const*, UErrorCode&) | CollationElementIterator::CollationElementIterator(
const CharacterIterator &source,
const RuleBasedCollator *coll,
UErrorCode &status)
: iter_(NULL), rbc_(coll), otherHalf_(0), dir_(... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x187a26(%rip), %rax # 0x2b20e0
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
movb $0x0, 0x1c(%rdi)
movq %rax, 0x20(%rdi)
leaq 0x193b6b(%rip), %rax # 0x2be248
addq $0x10, %rax
movq %rax, 0x28(%rdi)
movw $0x2, 0x30(%rdi)
cmp... | /hunter-packages[P]icu/source/i18n/coleitr.cpp |
icu_63::ICUCollatorFactory::~ICUCollatorFactory() | UObject*
ICUCollatorFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const {
if (handlesKey(key, status)) {
const LocaleKey& lkey = (const LocaleKey&)key;
Locale loc;
// make sure the requested locale is correct
// default LocaleFactory u... | pushq %rbx
movq %rdi, %rbx
callq 0x1a6ada
movq %rbx, %rdi
popq %rbx
jmp 0x1cc4b8
| /hunter-packages[P]icu/source/i18n/coll.cpp |
icu_63::Collator::getAvailableLocales(int&) | const Locale* U_EXPORT2 Collator::getAvailableLocales(int32_t& count)
{
UErrorCode status = U_ZERO_ERROR;
Locale *result = NULL;
count = 0;
if (isAvailableLocaleListInitialized(status))
{
result = availableLocaleList;
count = availableLocaleListCount;
}
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x4(%rsp), %rdi
movl %ebx, (%rdi)
movl %ebx, (%r14)
callq 0x12af13
testb %al, %al
je 0x12af08
movq 0x208521(%rip), %rbx # 0x333420
movl 0x208523(%rip), %eax # 0x333428
movl %eax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /hunter-packages[P]icu/source/i18n/coll.cpp |
icu_63::CFactory::getDisplayName(icu_63::UnicodeString const&, icu_63::Locale const&, icu_63::UnicodeString&) const | UnicodeString&
CFactory::getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const
{
if ((_coverage & 0x1) == 0) {
UErrorCode status = U_ZERO_ERROR;
const Hashtable* ids = getSupportedIDs(status);
if (ids && (ids->get(id) != NULL)) {
Locale loc;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rcx, %rbx
testb $0x1, 0x48(%rdi)
jne 0x12b4fa
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x12b4fa
movq (%rax), %rdi
movq %r12, %rsi
callq 0x1b... | /hunter-packages[P]icu/source/i18n/coll.cpp |
icu_63::(anonymous namespace)::getReorderCode(char const*) | int32_t getReorderCode(const char *s) {
for (int32_t i = 0; i < UPRV_LENGTHOF(collReorderCodes); ++i) {
if (uprv_stricmp(s, collReorderCodes[i]) == 0) {
return UCOL_REORDER_CODE_FIRST + i;
}
}
// Not supporting "others" = UCOL_REORDER_CODE_OTHERS
// as a synonym for Zzzz = US... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1000, %ebx # imm = 0x1000
xorl %r15d, %r15d
leaq 0xd1764(%rip), %r12 # 0x1fd050
movslq (%r15,%r12), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x186adc
testl %eax, %eax
je 0x12b910
addq $0x4, %r15
incl %ebx
cmpq $0x14, %r15
jne... | /hunter-packages[P]icu/source/i18n/coll.cpp |
icu_63::CollationLocaleListEnumeration::next(int*, UErrorCode&) | virtual const char* next(int32_t* resultLength, UErrorCode& /*status*/) {
const char* result;
if(index < availableLocaleListCount) {
result = availableLocaleList[index++].getName();
if(resultLength != NULL) {
*resultLength = (int32_t)uprv_strlen(result);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq 0x74(%rdi), %rax
cmpl 0x207747(%rip), %eax # 0x333428
jge 0x12bd0b
movq 0x207736(%rip), %rcx # 0x333420
leal 0x1(%rax), %edx
movl %edx, 0x74(%rdi)
imulq $0xe0, %rax, %rax
movq 0x28(%rcx,%rax), %r14
testq %rbx, %rbx
je 0x12bd1a
movq %r14, %rdi
callq 0xd9160
j... | /hunter-packages[P]icu/source/i18n/coll.cpp |
icu_63::RuleBasedCollator::RuleBasedCollator(icu_63::UnicodeString const&, UErrorCode&) | RuleBasedCollator::RuleBasedCollator(const UnicodeString &rules, UErrorCode &errorCode)
: data(NULL),
settings(NULL),
tailoring(NULL),
cacheEntry(NULL),
validLocale(""),
explicitlySetAttributes(0),
actualLocaleIsSameAsValid(FALSE) {
internalBuildTa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x12b20c
leaq 0x18582f(%rip), %rax # 0x2b1760
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x28(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
leaq 0x11a830(%rip), %rsi # 0x2467... | /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::RuleBasedCollator::RuleBasedCollator(icu_63::UnicodeString const&, UColAttributeValue, UErrorCode&) | RuleBasedCollator::RuleBasedCollator(const UnicodeString &rules,
UColAttributeValue decompositionMode,
UErrorCode &errorCode)
: data(NULL),
settings(NULL),
tailoring(NULL),
cacheEntry(NULL),
validLo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x12b20c
leaq 0x185501(%rip), %rax # 0x2b1760
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x28(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
leaq... | /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::CollationBuilder::getSpecialResetPosition(icu_63::UnicodeString const&, char const*&, UErrorCode&) | int64_t
CollationBuilder::getSpecialResetPosition(const UnicodeString &str,
const char *&parserErrorReason, UErrorCode &errorCode) {
U_ASSERT(str.length() == 2);
int64_t ce;
int32_t strength = UCOL_PRIMARY;
UBool isBoundary = FALSE;
UChar32 pos = str.charAt(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdi, %rbx
movswl 0x8(%rsi), %eax
testw %ax, %ax
jns 0x12d537
movl 0xc(%rsi), %ecx
jmp 0x12d53c
movl %eax, %ecx
sarl $0x5, %ecx
cmpl $0x2, %ecx
jb 0x12d7d5
testb $0x2, %al
jne 0x12d54f
movq 0x18(%rsi), %rsi
jmp 0x12d553
ad... | /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::CollationBuilder::findCommonNode(int, int) const | int32_t
CollationBuilder::findCommonNode(int32_t index, int32_t strength) const {
U_ASSERT(UCOL_SECONDARY <= strength && strength <= UCOL_TERTIARY);
int64_t node = nodes.elementAti(index);
if(strengthFromNode(node) >= strength) {
// The current node is no stronger.
return index;
}
if... | movl %esi, %eax
testl %esi, %esi
setns %sil
movl 0x1e0(%rdi), %ecx
cmpl %eax, %ecx
setg %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x12dce9
movq 0x1f0(%rdi), %rsi
movl %eax, %r8d
movq (%rsi,%r8,8), %r8
jmp 0x12dcec
xorl %r8d, %r8d
movl %r8d, %esi
andl $0x3, %esi
cmpl %edx, %esi
jge 0x12dd6c
cmpl $0x1, %edx
jne 0x12dd03
t... | /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::CollationBuilder::ignoreString(icu_63::UnicodeString const&, UErrorCode&) const | UBool
CollationBuilder::ignoreString(const UnicodeString &s, UErrorCode &errorCode) const {
// Do not map non-FCD strings.
// Do not map strings that start with Hangul syllables: We decompose those on the fly.
return !isFCD(s, errorCode) || Hangul::isHangul(s.charAt(0));
} | pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
cmpl $0x0, (%rdx)
jle 0x12ea50
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb %al, %al
je 0x12ea47
movswl 0x8(%rbx), %eax
testw %ax, %ax
jns 0x12ea6f
movl 0xc(%rbx), %ecx
jmp 0x12ea... | /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::CollationBuilder::suppressContractions(icu_63::UnicodeSet const&, char const*&, UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rcx)
jle 0x12ebce
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq 0x48(%rdi), %rdi
movq %rcx, %rdx
callq 0x132d96
cmpl $0x0, (%r14)
jle 0x12ebf4
leaq 0xceb11(%rip), %rax # 0x1fd702
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::CollationBuilder::addTailComposites(icu_63::UnicodeString const&, icu_63::UnicodeString const&, UErrorCode&) | void
CollationBuilder::addTailComposites(const UnicodeString &nfdPrefix, const UnicodeString &nfdString,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
// Look for the last starter in the NFD string.
UChar32 lastStarter;
int32_t indexAfterLastStarter =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rcx)
jle 0x12f069
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
mo... | /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::CollationBuilder::countTailoredNodes(long const*, int, int) | int32_t
CollationBuilder::countTailoredNodes(const int64_t *nodesArray, int32_t i, int32_t strength) {
int32_t count = 0;
for(;;) {
if(i == 0) { break; }
int64_t node = nodesArray[i];
if(strengthFromNode(node) < strength) { break; }
if(strengthFromNode(node) == strength) {
... | xorl %eax, %eax
testl %esi, %esi
je 0x12f5eb
movslq %esi, %rcx
movq (%rdi,%rcx,8), %rsi
movl %esi, %ecx
andl $0x3, %ecx
cmpl %edx, %ecx
jl 0x12f5eb
jne 0x12f5e0
testb $0x8, %sil
je 0x12f5eb
incl %eax
shrl $0x8, %esi
andl $0xfffff, %esi # imm = 0xFFFFF
jne 0x12f5c6
retq
| /hunter-packages[P]icu/source/i18n/collationbuilder.cpp |
icu_63::CollationData::getFinalCE32(unsigned int) const | uint32_t
CollationData::getFinalCE32(uint32_t ce32) const {
if(Collation::isSpecialCE32(ce32)) {
ce32 = getIndirectCE32(ce32);
}
return ce32;
} | movl %esi, %eax
movl %esi, %ecx
notl %ecx
testb $-0x40, %cl
jne 0x130067
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0xd, %ecx
je 0x13006f
cmpl $0xb, %ecx
je 0x130068
cmpl $0xa, %ecx
jne 0x130067
movq 0x8(%rdi), %rcx
shrl $0xd, %eax
movl (%rcx,%rax,4), %eax
retq
movq 0x8(%rdi), %rax
movl (%rax), %eax
retq
movl $0xffffffff, %... | /hunter-packages[P]icu/source/i18n/collationdata.cpp |
icu_63::CollationData::getLastPrimaryForGroup(int) const | uint32_t
CollationData::getLastPrimaryForGroup(int32_t script) const {
int32_t index = getScriptIndex(script);
if(index == 0) {
return 0;
}
uint32_t limit = scriptStarts[index + 1];
return (limit << 16) - 1;
} | xorl %eax, %eax
testl %esi, %esi
js 0x130241
movl 0x64(%rdi), %ecx
cmpl %esi, %ecx
jle 0x130209
movl %esi, %ecx
jmp 0x130224
movl %esi, %edx
andl $0x7ffffff8, %edx # imm = 0x7FFFFFF8
cmpl $0x1000, %edx # imm = 0x1000
jne 0x130241
addl %esi, %ecx
addl $0xfffff000, %ecx # imm = 0xFFFFF000
movslq %ec... | /hunter-packages[P]icu/source/i18n/collationdata.cpp |
icu_63::CollationData::getEquivalentScripts(int, int*, int, UErrorCode&) const | int32_t
CollationData::getEquivalentScripts(int32_t script,
int32_t dest[], int32_t capacity,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return 0; }
int32_t index = getScriptIndex(script);
if(index == 0) { return 0; }
... | xorl %eax, %eax
testl %esi, %esi
js 0x13036d
cmpl $0x0, (%r8)
jg 0x13036d
movl 0x64(%rdi), %r9d
cmpl %esi, %r9d
jle 0x1302e0
movq 0x68(%rdi), %r10
movl %esi, %r11d
jmp 0x130305
movl %esi, %r10d
andl $0x7ffffff8, %r10d # imm = 0x7FFFFFF8
cmpl $0x1000, %r10d # imm = 0x1000
jne 0x13036d
movq 0x68(%rdi), %r10... | /hunter-packages[P]icu/source/i18n/collationdata.cpp |
icu_63::CollationData::addHighScriptRange(unsigned char*, int, int) const | int32_t
CollationData::addHighScriptRange(uint8_t table[], int32_t index, int32_t highLimit) const {
int32_t limit = scriptStarts[index + 1];
if((limit & 0xff) > (highLimit & 0xff)) {
highLimit -= 0x100;
}
int32_t start = scriptStarts[index];
highLimit = ((highLimit & 0xff00) - ((limit & 0xf... | pushq %rbx
movq 0x70(%rdi), %rax
movslq %edx, %rdx
movzwl 0x2(%rax,%rdx,2), %edi
movl $0xff, %r8d
movl %edi, %r9d
andl %r8d, %r9d
movl %ecx, %r10d
andl %r8d, %r10d
movl $0xff00, %ebx # imm = 0xFF00
leal (%rcx,%rbx), %r11d
cmpl %r10d, %r9d
cmovbel %ecx, %r11d
movzwl (%rax,%rdx,2), %eax
andl %ebx, %r11d
andl %e... | /hunter-packages[P]icu/source/i18n/collationdata.cpp |
icu_63::DataBuilderCollationIterator::nextCodePoint(UErrorCode&) | UChar32
DataBuilderCollationIterator::nextCodePoint(UErrorCode & /*errorCode*/) {
if(pos == s->length()) {
return U_SENTINEL;
}
UChar32 c = s->char32At(pos);
pos += U16_LENGTH(c);
return c;
} | pushq %rbx
movq %rdi, %rbx
movl 0x338(%rdi), %esi
movq 0x330(%rdi), %rdi
movswl 0x8(%rdi), %ecx
testw %cx, %cx
jns 0x130c99
movl 0xc(%rdi), %ecx
jmp 0x130c9c
sarl $0x5, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %ecx, %esi
je 0x130cc1
callq 0x1c9d18
cmpl $0x10000, %eax # imm = 0x10000
movl 0x338... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::clearContexts() | void
CollationDataBuilder::clearContexts() {
contexts.remove();
UnicodeSetIterator iter(contextChars);
while(iter.next()) {
U_ASSERT(!iter.isString());
uint32_t ce32 = utrie2_get32(trie, iter.getCodepoint());
U_ASSERT(isBuilderContextCE32(ce32));
getConditionalCE32ForCE32(ce3... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movzwl 0xf0(%rdi), %eax
movl %eax, %ecx
andl $0x1e, %ecx
testb $0x1, %al
movl $0x2, %eax
cmovel %ecx, %eax
movw %ax, 0xf0(%rdi)
leaq 0x90(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1d386c
leaq 0x68(%rbx), %r15
movq %r14, %rdi
callq 0x1d39b4
test... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::addCE(long, UErrorCode&) | int32_t
CollationDataBuilder::addCE(int64_t ce, UErrorCode &errorCode) {
int32_t length = ce64s.size();
for(int32_t i = 0; i < length; ++i) {
if(ce == ce64s.elementAti(i)) { return i; }
}
ce64s.addElement(ce, errorCode);
return length;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x50(%rdi), %rbx
testq %rbx, %rbx
jle 0x1317be
movq 0x60(%r14), %rcx
xorl %eax, %eax
cmpq %r15, (%rcx,%rax,8)
je 0x1317f1
incq %rax
cmpq %rax, %rbx
jne 0x1317b0
cmpl $-0x1, %ebx
jl 0x1317cb
movl %ebx, %eax
cmpl %ebx, 0x54(%r14)
jg 0x1317df
leaq 0x4... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::addCE32(unsigned int, UErrorCode&) | int32_t
CollationDataBuilder::addCE32(uint32_t ce32, UErrorCode &errorCode) {
int32_t length = ce32s.size();
for(int32_t i = 0; i < length; ++i) {
if(ce32 == (uint32_t)ce32s.elementAti(i)) { return i; }
}
ce32s.addElement((int32_t)ce32, errorCode);
return length;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x30(%rdi), %rbx
testq %rbx, %rbx
jle 0x131b3d
movq 0x40(%r14), %rcx
xorl %eax, %eax
cmpl %ebp, (%rcx,%rax,4)
je 0x131b6d
incq %rax
cmpq %rax, %rbx
jne 0x131b30
cmpl $-0x1, %ebx
jl 0x131b4a
movl %ebx, %eax
cmpl %ebx, 0x34(%r14)
jg 0x131b5e
leaq 0x2... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::encodeOneCEAsCE32(long) | uint32_t
CollationDataBuilder::encodeOneCEAsCE32(int64_t ce) {
uint32_t p = (uint32_t)(ce >> 32);
uint32_t lower32 = (uint32_t)ce;
uint32_t t = (uint32_t)(ce & 0xffff);
U_ASSERT((t & 0xc000) != 0xc000); // Impossible case bits 11 mark special CE32s.
if((ce & INT64_C(0xffff00ff00ff)) == 0) {
... | movq %rdi, %rdx
movq %rdi, %rcx
shrq $0x20, %rcx
movabsq $0xffff00ff00ff, %rax # imm = 0xFFFF00FF00FF
testq %rax, %rdi
je 0x13257f
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
movq %rdx, %rsi
andq %rax, %rsi
cmpq $0x5000500, %rsi # imm = 0x5000500
jne 0x13258e
orl $0xc1, %ecx
movl %ecx, %eax
retq
pushq... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::encodeCEs(long const*, int, UErrorCode&) | uint32_t
CollationDataBuilder::encodeCEs(const int64_t ces[], int32_t cesLength,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return 0; }
if(cesLength < 0 || cesLength > Collation::MAX_EXPANSION_LENGTH) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %r12d, %r12d
cmpl $0x0, (%rcx)
jg 0x132643
movq %rcx, %rbx
movl %edx, %ebp
cmpl $0x20, %edx
jb 0x132625
movl $0x1, (%rbx)
jmp 0x132643
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x13263d
movq %rsi, %r15
callq 0x1e003a... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::encodeExpansion(long const*, int, UErrorCode&) | uint32_t
CollationDataBuilder::encodeExpansion(const int64_t ces[], int32_t length, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return 0; }
// See if this sequence of CEs has already been stored.
int64_t first = ces[0];
int32_t ce64sMax = ce64s.size() - length;
for(int32_t i = 0; i <= ce64sM... | xorl %eax, %eax
cmpl $0x0, (%rcx)
jle 0x13289a
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
movslq 0x50(%rdi), %rbp
cmpl %edx, %ebp
jge 0x1328cd
cmpl $0x7ffff, %ebp # imm = 0x7FFFF
jle 0x132955
movl $0xf, (%rcx)
jmp 0x1329cf
movq (%r15)... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationDataBuilder::copyFrom(icu_63::CollationDataBuilder const&, icu_63::CollationDataBuilder::CEModifier const&, UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rcx)
jle 0x132c16
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rcx, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x132c44
movq %rdx, %r12
movq %rsi, %r15
callq 0x1e003a
testb %al, %al
je 0x132c4c
movl $0x1b, (%rbx)
jmp 0x132c... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::CollationDataBuilder::setDigitTags(UErrorCode&) | void
CollationDataBuilder::setDigitTags(UErrorCode &errorCode) {
UnicodeSet digits(UNICODE_STRING_SIMPLE("[:Nd:]"), errorCode);
if(U_FAILURE(errorCode)) { return; }
UnicodeSetIterator iter(digits);
while(iter.next()) {
U_ASSERT(!iter.isString());
UChar32 c = iter.getCodepoint();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xca886(%rip), %rax # 0x1fd970
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x1c8d3a
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %r... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CopyHelper::copyRangeCE32(int, int, unsigned int) | UBool copyRangeCE32(UChar32 start, UChar32 end, uint32_t ce32) {
ce32 = copyCE32(ce32);
utrie2_setRange32(dest.trie, start, end, ce32, TRUE, &errorCode);
if(CollationDataBuilder::isBuilderContextCE32(ce32)) {
dest.contextChars.add(start, end);
}
return U_SUCCESS(error... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %ecx, %esi
callq 0x133b6e
movl %eax, %r12d
movq 0x8(%r14), %rax
movq 0x20(%rax), %rdi
leaq 0x110(%r14), %r15
movl %ebp, %esi
movl %ebx, %edx
movl %r12d, %ecx
movl $0x1, %r8d
movq %r15, %r9
callq 0x1e1c94
andl $0x... | /hunter-packages[P]icu/source/i18n/collationdatabuilder.cpp |
icu_63::CollationFastLatinBuilder::encodeUniqueCEs(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x136d9c
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c58(%rdi), %rdi
callq 0x186846
movslq 0x1c40(%r14), %rdi
addq %rdi, %rdi
callq 0x186790
movq %rax, 0x1c58(%r14)
testq %rax, %rax
je 0x137084
movq... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::CollationFastLatinBuilder::encodeCharCEs(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x13713a
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, 0x20(%rsp)
leaq 0x1c88(%rdi), %r15
movswl 0x1c90(%rdi), %ebx
movl %ebx, %ebp
shrl $0x5, %ebp
movl 0x1c94(%rdi), %eax
movl %eax, 0xc(%rsp)
movl $0x1c0, %r13d ... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::CollationFastLatinBuilder::addUniqueCE(long, UErrorCode&) | void
CollationFastLatinBuilder::addUniqueCE(int64_t ce, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
if(ce == 0 || (uint32_t)(ce >> 32) == Collation::NO_CE_PRIMARY) { return; }
ce &= ~(int64_t)Collation::CASE_MASK; // blank out case bits
int32_t i = binarySearch(uniqueCEs.getBuffer(), ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
shrq $0x20, %rax
cmpl $0x1, %eax
je 0x1378af
movq %rsi, %r14
testq %rsi, %rsi
je 0x1378af
movq %rdx, %rbx
cmpl $0x0, (%rdx)
jg 0x1378af
movq %rdi, %r15
andq $-0xc001, %r14 # imm = 0xFFFF3FFF
movq 0x1c50(%rdi), %rdi
movl 0x1c40(%r15), %esi
movq %r14, %rdx
callq 0... | /hunter-packages[P]icu/source/i18n/collationfastlatinbuilder.cpp |
icu_63::(anonymous namespace)::binarySearch(long const*, int, long) | int32_t
binarySearch(const int64_t list[], int32_t limit, int64_t ce) {
if (limit == 0) { return ~0; }
int32_t start = 0;
for (;;) {
int32_t i = (start + limit) / 2;
int32_t cmp = compareInt64AsUnsigned(ce, list[i]);
if (cmp == 0) {
return i;
} else if (cmp < 0) {... | testl %esi, %esi
je 0x137cb1
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
movslq %eax, %rcx
movq (%rdi,%rcx,8), %r8
cmpq %rdx, %r8
je 0x137cb0
xorl %ecx, %ecx
cmpq %rdx, %r8
jbe 0x137c8f
cmpl %ecx, %eax
je 0x137cc1
movl %eax, %esi
jmp 0x137c95
cmpl %ecx, %eax
je 0x137cb7
movl %eax, %ecx
leal (%rsi,%rcx), ... | /hunter-packages[P]icu/source/i18n/collationfastlatinbuilder.cpp |
icu_63::Collation::ceFromCE32(unsigned int) | static inline int64_t ceFromCE32(uint32_t ce32) {
uint32_t tertiary = ce32 & 0xff;
if(tertiary < SPECIAL_CE32_LOW_BYTE) {
// normal form ppppsstt -> pppp0000ss00tt00
return ((int64_t)(ce32 & 0xffff0000) << 32) | ((ce32 & 0xff00) << 16) | (tertiary << 8);
} else {
... | movzbl %dil, %eax
cmpl $0xbf, %eax
ja 0x137e64
movl %edi, %ecx
andl $0xffff0000, %ecx # imm = 0xFFFF0000
shlq $0x20, %rcx
shll $0x10, %edi
andl $0xff000000, %edi # imm = 0xFF000000
orq %rcx, %rdi
shll $0x8, %eax
orq %rdi, %rax
retq
movl %edi, %eax
andl $0xffffff00, %eax # imm = 0xFFFFFF00
andl $0xf, %... | /hunter-packages[P]icu/source/i18n/collation.h |
icu_63::CollationIterator::CEBuffer::ensureAppendCapacity(int, UErrorCode&) | UBool
CollationIterator::CEBuffer::ensureAppendCapacity(int32_t appCap, UErrorCode &errorCode) {
int32_t capacity = buffer.getCapacity();
if((length + appCap) <= capacity) { return TRUE; }
if(U_FAILURE(errorCode)) { return FALSE; }
do {
if(capacity < 1000) {
capacity *= 4;
} ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %r13d
movl 0x10(%rdi), %ebp
addl %r13d, %esi
movb $0x1, %bl
cmpl %ebp, %esi
jle 0x137f2f
movq %rdx, %r15
cmpl $0x0, (%rdx)
jg 0x137f2d
movq %rdi, %r14
movl %ebp, %eax
cmpl $0x3e8, %ebp # imm = 0x3E8
setl %cl
incb %cl
sh... | /hunter-packages[P]icu/source/i18n/collationiterator.cpp |
icu_63::CollationIterator::nextCEFromCE32(icu_63::CollationData const*, int, unsigned int, UErrorCode&) | int64_t
CollationIterator::nextCEFromCE32(const CollationData *d, UChar32 c, uint32_t ce32,
UErrorCode &errorCode) {
--ceBuffer.length; // Undo ceBuffer.incLength().
appendCEsFromCE32(d, c, ce32, TRUE, errorCode);
if(U_SUCCESS(errorCode)) {
return ceBuffer.get(cesI... | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdi, %rbx
decl 0x18(%rdi)
movl $0x1, %r8d
movq %r14, %r9
callq 0x138248
movl $0x1, %eax
cmpl $0x0, (%r14)
jg 0x138240
movslq 0x170(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x170(%rbx)
movq 0x20(%rbx), %rcx
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %... | /hunter-packages[P]icu/source/i18n/collationiterator.cpp |
icu_63::number::impl::CompactHandler::CompactHandler(UNumberCompactStyle, icu_63::Locale const&, char const*, icu_63::number::impl::CompactType, icu_63::PluralRules const*, icu_63::number::impl::MutablePatternModifier*, icu_63::number::impl::MicroPropsGenerator const*, UErrorCode&) | CompactHandler::CompactHandler(CompactStyle compactStyle, const Locale &locale, const char *nsName,
CompactType compactType, const PluralRules *rules,
MutablePatternModifier *buildReference, const MicroPropsGenerator *parent,
U... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0xc(%rsp)
movq %rcx, %r12
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbx
movq 0x58(%rsp), %rax
leaq 0x1367d1(%rip), %rcx # 0x2b6198
movq %rcx, (%rdi)
movq %r9, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rax
movq %r... | /hunter-packages[P]icu/source/i18n/number_compact.cpp |
icu_63::LocaleDisplayNamesImpl::CapitalizationContextSink::~CapitalizationContextSink() | void
LocaleDisplayNamesImpl::initialize(void) {
LocaleDisplayNamesImpl *nonConstThis = (LocaleDisplayNamesImpl *)this;
nonConstThis->locale = langData.getLocale() == Locale::getRoot()
? regionData.getLocale()
: langData.getLocale();
UnicodeString sep;
langData.getNoFallback("localeDispl... | pushq %rbx
movq %rdi, %rbx
callq 0x1a3bf0
movq %rbx, %rdi
popq %rbx
jmp 0x1cc4b8
| /hunter-packages[P]icu/source/common/locdspnm.cpp |
icu_63::LocaleDisplayNamesImpl::adjustForUsageAndContext(icu_63::LocaleDisplayNamesImpl::CapContextUsage, icu_63::UnicodeString&) const | UnicodeString&
LocaleDisplayNamesImpl::adjustForUsageAndContext(CapContextUsage usage,
UnicodeString& result) const {
#if !UCONFIG_NO_BREAK_ITERATION
// check to see whether we need to titlecase result
if ( result.length() > 0 && u_islower(result.char32At(0)) && c... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movswl 0x8(%rdx), %eax
testw %ax, %ax
jns 0x18a8fe
movl 0xc(%rbx), %eax
jmp 0x18a901
sarl $0x5, %eax
testl %eax, %eax
jle 0x18a971
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c9d18
movl %eax, %edi
callq 0x1aa59d
testb %al, %al
je 0x18a971
cmp... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
ncat(char*, unsigned int, ...) | static int32_t ncat(char *buffer, uint32_t buflen, ...) {
va_list args;
char *str;
char *p = buffer;
const char* e = buffer + buflen - 1;
if (buffer == NULL || buflen < 1) {
return -1;
}
va_start(args, buflen);
while ((str = va_arg(args, char *)) != 0) {
char c;
while (p != e && (c = *str+... | subq $0x58, %rsp
movq %rdx, -0x50(%rsp)
movq %rcx, -0x48(%rsp)
movq %r8, -0x40(%rsp)
movq %r9, -0x38(%rsp)
testb %al, %al
je 0x18b3df
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
icu_63::LocaleDisplayNamesImpl::scriptDisplayName(char const*, icu_63::UnicodeString&, signed char) const | UnicodeString&
LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
UnicodeString& result,
UBool skipAdjust) const {
if (nameLength == UDISPCTX_LENGTH_SHORT) {
langData.get("Scripts%short", script, result);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x201, 0x4a8(%rdi) # imm = 0x201
jne 0x18b529
leaq 0xf0(%r14), %rdi
leaq 0x787d1(%rip), %rsi # 0x203ce7
xorl %edx, %edx
movq %r15, %rcx
movq %rbx, %r8
callq 0x189c6e
testb $0x1, 0x8(%rbx)... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
icu_63::LocaleDisplayNamesImpl::regionDisplayName(char const*, icu_63::UnicodeString&, signed char) const | UnicodeString&
LocaleDisplayNamesImpl::regionDisplayName(const char* region,
UnicodeString& result,
UBool skipAdjust) const {
if (nameLength == UDISPCTX_LENGTH_SHORT) {
regionData.get("Countries%short", region, result);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x201, 0x4a8(%rdi) # imm = 0x201
jne 0x18b603
leaq 0x1d8(%r14), %rdi
leaq 0x7870d(%rip), %rsi # 0x203cfd
xorl %edx, %edx
movq %r15, %rcx
movq %rbx, %r8
callq 0x189c6e
testb $0x1, 0x8(%rbx... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
icu_63::LocaleDisplayNamesImpl::languageDisplayName(char const*, icu_63::UnicodeString&) const | UnicodeString&
LocaleDisplayNamesImpl::languageDisplayName(const char* lang,
UnicodeString& result) const {
if (uprv_strcmp("root", lang) == 0 || uprv_strchr(lang, '_') != NULL) {
return result = UnicodeString(lang, -1, US_INV);
}
if (nameLength == UDISPCT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x71457(%rip), %rdi # 0x1fcd18
callq 0xd9420
testl %eax, %eax
je 0x18b8dc
movq %r15, %rdi
movl $0x5f, %esi
callq 0xd9130
testq %rax, %rax
je 0x18b909
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0xfffffff... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
uldn_languageDisplayName_63 | U_CAPI int32_t U_EXPORT2
uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
const char *lang,
UChar *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
return 0;
}
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r15d, %r15d
cmpl $0x0, (%r8)
jg 0x18bd78
movq %r8, %rbx
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x18bd15
movl $0x1, (%rbx)
jmp 0x18bd78
movq %rdx, %r14
tes... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
uldn_scriptDisplayName_63 | U_CAPI int32_t U_EXPORT2
uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
const char *script,
UChar *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
return 0;
}
if (ldn == N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r15d, %r15d
cmpl $0x0, (%r8)
jg 0x18be4e
movq %r8, %rbx
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x18bdeb
movl $0x1, (%rbx)
jmp 0x18be4e
movq %rdx, %r14
tes... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
uldn_variantDisplayName_63 | U_CAPI int32_t U_EXPORT2
uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
const char *variant,
UChar *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
return 0;
}
if (ld... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r15d, %r15d
cmpl $0x0, (%r8)
jg 0x18c030
movq %r8, %rbx
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x18bfcd
movl $0x1, (%rbx)
jmp 0x18c030
movq %rdx, %r14
tes... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
uldn_keyValueDisplayName_63 | U_CAPI int32_t U_EXPORT2
uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
const char *key,
const char *value,
UChar *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r15d, %r15d
cmpl $0x0, (%r9)
jg 0x18c1ed
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
je 0x18... | /hunter-packages[P]icu/source/common/locdspnm.cpp |
locale_cleanup() | static UBool U_CALLCONV locale_cleanup(void)
{
U_NAMESPACE_USE
delete [] gLocaleCache;
gLocaleCache = NULL;
gLocaleCacheInitOnce.reset();
if (gDefaultLocalesHashT) {
uhash_close(gDefaultLocalesHashT); // Automatically deletes all elements, using deleter func.
gDefaultLocalesHashT... | pushq %r15
pushq %r14
pushq %rbx
movq 0x1a733a(%rip), %r14 # 0x333860
testq %r14, %r14
je 0x18c560
leaq -0x8(%r14), %rbx
movq -0x8(%r14), %rax
testq %rax, %rax
je 0x18c558
addq $-0xe0, %r14
imulq $0xe0, %rax, %r15
leaq (%r14,%r15), %rdi
callq 0x18c8ec
addq $-0xe0, %r15
jne 0x18c546
movq %rbx, %rdi
callq 0x1cc4de
mov... | /hunter-packages[P]icu/source/common/locid.cpp |
icu_63::Locale::~Locale() | Locale::~Locale()
{
if (baseName != fullName) {
uprv_free(baseName);
}
baseName = NULL;
/*if fullName is on the heap, we free it*/
if (fullName != fullNameBuffer)
{
uprv_free(fullName);
fullName = NULL;
}
} | pushq %rbx
movq %rdi, %rbx
leaq 0x12a3e9(%rip), %rax # 0x2b6ce0
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
movq 0xd0(%rbx), %rax
cmpq %rdi, %rax
je 0x18c916
movq %rax, %rdi
callq 0x186846
movq 0x28(%rbx), %rdi
movq $0x0, 0xd0(%rbx)
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x18c937
callq 0x186846
movq $0x0, 0x28(%rbx)
m... | /hunter-packages[P]icu/source/common/locid.cpp |
icu_63::Locale::setToBogus() | void
Locale::setToBogus() {
/* Free our current storage */
if(baseName != fullName) {
uprv_free(baseName);
}
baseName = NULL;
if(fullName != fullNameBuffer) {
uprv_free(fullName);
fullName = fullNameBuffer;
}
*fullNameBuffer = 0;
*language = 0;
*script = 0;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq 0xd0(%rbx), %rax
cmpq %rdi, %rax
je 0x18ca09
movq %rax, %rdi
callq 0x186846
movq 0x28(%rbx), %rdi
movq $0x0, 0xd0(%rbx)
leaq 0x30(%rbx), %r14
cmpq %r14, %rdi
je 0x18ca26
callq 0x186846
movq %r14, 0x28(%rbx)
xorl %eax, %eax
movb %al, 0x30(%rbx)
... | /hunter-packages[P]icu/source/common/locid.cpp |
icu_63::Locale::operator=(icu_63::Locale const&) | Locale& Locale::operator=(const Locale& other) {
if (this == &other) {
return *this;
}
setToBogus();
if (other.fullName == other.fullNameBuffer) {
uprv_strcpy(fullNameBuffer, other.fullNameBuffer);
} else if (other.fullName == nullptr) {
fullName = nullptr;
} else {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x18cddf
movq %rsi, %r14
movq %rbx, %rdi
callq 0x18c9e6
movq 0x28(%r14), %rdi
leaq 0x30(%r14), %rsi
cmpq %rsi, %rdi
je 0x18cd61
testq %rdi, %rdi
je 0x18cd6c
callq 0x186bd2
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x18cd74
jmp 0x18cddf
leaq 0x30(%rbx)... | /hunter-packages[P]icu/source/common/locid.cpp |
icu_63::Locale::initBaseName(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x18cf32
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rdi), %r12
movq %r12, %rdi
movl $0x40, %esi
callq 0xd9130
movq %rax, %r14
movq %r12, %rdi
movl $0x3d, %esi
callq 0xd9130
testq %r14, %r14
je 0x18cfc0
cmpq %rax, %r14
jae 0x18cfc0
subq %r... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::Locale::createFromName(char const*) | Locale U_EXPORT2
Locale::createFromName (const char *name)
{
if (name) {
Locale l("");
l.init(name, FALSE);
return l;
}
else {
return getDefault();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x18d4a6
movq %rsi, %r14
leaq 0xb92f6(%rip), %rsi # 0x24677e
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x18ca4a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x18c5a2
jmp 0x18d4b6
callq 0x18c88c
movq %rbx, %rdi
... | /hunter-packages[P]icu/source/common/locid.cpp |
icu_63::Locale::getEnglish() | const Locale &
Locale::getLocale(int locid)
{
Locale *localeCache = getLocaleCache();
U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0));
if (localeCache == NULL) {
// Failure allocating the locale cache.
// The best we can do is return a NULL reference.
locid = 0;
}
return local... | jmp 0x18d772
nop
| /hunter-packages[P]icu/source/common/locid.cpp |
icu_63::Locale::setKeywordValue(icu_63::StringPiece, icu_63::StringPiece, UErrorCode&) | void
Locale::setKeywordValue(StringPiece keywordName,
StringPiece keywordValue,
UErrorCode& status) {
// TODO: Remove the need for a const char* to a NUL terminated buffer.
const CharString keywordName_nul(keywordName, status);
const CharString keywordValue_nu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, (%rsp)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xdefee
movl $0x0, 0x38(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %r14, %rdi
movq %r13, %r... | /hunter-packages[P]icu/source/common/locid.cpp |
uloc_isRightToLeft_63 | U_CAPI UBool U_EXPORT2
uloc_isRightToLeft(const char *locale) {
UErrorCode errorCode = U_ZERO_ERROR;
char script[8];
int32_t scriptLength = uloc_getScript(locale, script, UPRV_LENGTHOF(script), &errorCode);
if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING ||
scriptLen... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
movq %r14, %rcx
callq 0x1b8436
movl (%r14), %ecx
testl %ecx, %ecx
jg 0x18ec25
cmpl $-0x7c, %ecx
je 0x18ec25
testl %eax, %eax
je 0x18ec25
leaq 0x10(%rsp), %rsi
movl $0x100a, %edi... | /hunter-packages[P]icu/source/common/loclikely.cpp |
findLikelySubtags(char const*, char*, int, UErrorCode*) | static const char* U_CALLCONV
findLikelySubtags(const char* localeID,
char* buffer,
int32_t bufferLength,
UErrorCode* err) {
const char* result = NULL;
if (!U_FAILURE(*err)) {
int32_t resLen = 0;
const UChar* s = NULL;
UErrorCode tm... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
cmpl $0x0, (%rdx)
jg 0x18f362
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movl %eax, 0x8(%rsp)
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
leaq 0x74b39(%rip), %rsi # 0x203e83
xorl %edi, %edi
movq %r13, %rdx
callq 0x1cf5e5
movq %r... | /hunter-packages[P]icu/source/common/loclikely.cpp |
icu_63::MessagePattern::MessagePattern(UErrorCode&) | MessagePattern::MessagePattern(UErrorCode &errorCode)
: aposMode(UCONFIG_MSGPAT_DEFAULT_APOSTROPHE_MODE),
partsList(NULL), parts(NULL), partsLength(0),
numericValuesList(NULL), numericValues(NULL), numericValuesLength(0),
hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting(F... | leaq 0x126bfd(%rip), %rax # 0x2b6e20
movq %rax, (%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
leaq 0x12e016(%rip), %rcx # 0x2be248
addq $0x10, %rcx
movq %rcx, 0x10(%rdi)
movw $0x2, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movl %eax, 0x60(%rdi)
movups %xmm0, 0x68(%rdi)
movq $0x0, 0x77(%rdi)
jmp 0x19025... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::MessagePattern(UMessagePatternApostropheMode, UErrorCode&) | MessagePattern::MessagePattern(UMessagePatternApostropheMode mode, UErrorCode &errorCode)
: aposMode(mode),
partsList(NULL), parts(NULL), partsLength(0),
numericValuesList(NULL), numericValues(NULL), numericValuesLength(0),
hasArgNames(FALSE), hasArgNumbers(FALSE), needsAutoQuoting... | leaq 0x126b53(%rip), %rax # 0x2b6e20
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
leaq 0x12df6e(%rip), %rax # 0x2be248
addq $0x10, %rax
movq %rax, 0x10(%rdi)
movw $0x2, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movl $0x0, 0x60(%rdi)
movups %xmm0, 0x68(%rdi)
movq $0x0, 0x77(%rdi)
movq %rdx, %rsi
jmp 0x19025... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::parse(icu_63::UnicodeString const&, UParseError*, UErrorCode&) | MessagePattern &
MessagePattern::parse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) {
preParse(pattern, parseError, errorCode);
parseMessage(0, 0, 0, UMSGPAT_ARG_TYPE_NONE, parseError, errorCode);
postParse();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x0, (%rcx)
jg 0x1903e3
testq %r14, %r14
je 0x1903cf
movq $0x0, (%r14)
xorl %eax, %eax
movw %ax, 0x8(%r14)
movw %ax, 0x28(%r14)
leaq 0x10(%rbx), %rdi
callq 0x1c9826
xorl %eax, %eax
movl %eax, 0x60(%rbx)
movl %eax, 0x... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::copyStorage(icu_63::MessagePattern const&, UErrorCode&) | UBool
MessagePattern::copyStorage(const MessagePattern &other, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return FALSE;
}
parts=NULL;
partsLength=0;
numericValues=NULL;
numericValuesLength=0;
if(partsList==NULL) {
partsList=new MessagePatternPartsList();
if(p... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
cmpl $0x0, (%rdx)
jg 0x190632
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %r12, 0x58(%rdi)
movl %r12d, 0x60(%rdi)
movq %r12, 0x70(%rdi)
movl %r12d, 0x78(%rdi)
movq 0x50(%rdi), %r12
testq %r12, %r12
jne 0x19055e
movl $0x210, %edi ... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::~MessagePattern() | MessagePattern::~MessagePattern() {
delete partsList;
delete numericValuesList;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x12672e(%rip), %rax # 0x2b6e20
movq %rax, (%rdi)
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x190706
movq %r14, %rdi
callq 0x192abe
movq %r14, %rdi
callq 0x1cc4b8
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0x19071f
movq %r14, %rdi
callq 0x192ad8
movq %r14, %rdi
ca... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::parseChoiceStyle(int, int, UParseError*, UErrorCode&) | int32_t
MessagePattern::parseChoiceStyle(int32_t index, int32_t nestingLevel,
UParseError *parseError, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return 0;
}
int32_t start=index;
index=skipWhiteSpace(index);
if(index==msg.length() || msg.charAt(index... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%r8)
jg 0x190cba
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %r13d
movq %rdi, %r15
movq %rdx, 0x18(%rsp)
callq 0x191d42
movl %eax, %ebp
movswl 0x18(%r15), %eax
testw %ax, %ax
jns 0x190c68
movl 0x1c(%r15), %ecx
jmp 0x190c6d
movl... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::parsePluralOrSelectStyle(UMessagePatternArgType, int, int, UParseError*, UErrorCode&) | int32_t
MessagePattern::parsePluralOrSelectStyle(UMessagePatternArgType argType,
int32_t index, int32_t nestingLevel,
UParseError *parseError, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return 0;
}
int32_t sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r14d, %r14d
cmpl $0x0, (%r9)
jg 0x19127e
movq %r9, %rbx
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %r15
movq %r8, 0x10(%rsp)
movl %edx, 0x1c(%rsp)
movl %edx, %esi
callq 0x191d42
movl %eax, %r13d
movswl 0x18(%r15), %eax
testw %ax, ... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::operator==(icu_63::MessagePattern const&) const | UBool
MessagePattern::operator==(const MessagePattern &other) const {
if(this==&other) {
return TRUE;
}
return
aposMode==other.aposMode &&
msg==other.msg &&
// parts.equals(o.parts)
partsLength==other.partsLength &&
(partsLength==0 || partsList->equals(*other.... | movb $0x1, %al
cmpq %rsi, %rdi
je 0x1913ca
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x1913c1
movzwl 0x18(%r14), %eax
testb $0x1, %al
jne 0x19135d
testw %ax, %ax
jns 0x191364
movl 0x1c(%r14), %edx
jmp 0x19136a
movb 0x18(%rbx), %al
andb $0x1, %al
jmp 0... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::validateArgumentName(icu_63::UnicodeString const&) | int32_t
MessagePattern::validateArgumentName(const UnicodeString &name) {
if(!PatternProps::isIdentifier(name.getBuffer(), name.length())) {
return UMSGPAT_ARG_NAME_NOT_VALID;
}
return parseArgNumber(name, 0, name.length());
} | pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0x11, %al
je 0x191454
xorl %edi, %edi
jmp 0x191462
testb $0x2, %al
jne 0x19145e
movq 0x18(%rbx), %rdi
jmp 0x191462
leaq 0xa(%rbx), %rdi
testw %ax, %ax
jns 0x19146c
movl 0xc(%rbx), %esi
jmp 0x191472
movswl %ax, %esi
sarl $0x5, %esi
callq 0x19a3fc
testb %al, %al
je... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::autoQuoteApostropheDeep() const | UnicodeString
MessagePattern::autoQuoteApostropheDeep() const {
if(!needsAutoQuoting) {
return msg;
}
UnicodeString modified(msg);
// Iterate backward so that the insertion indexes do not change.
int32_t count=countParts();
for(int32_t i=count; i>0;) {
const Part &part=getPart(--... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x7e(%rsi), %bpl
addq $0x10, %rsi
callq 0x1c92c6
testb %bpl, %bpl
je 0x1915ce
movslq 0x60(%r14), %r12
testq %r12, %r12
jle 0x1915ce
leaq 0x1(%r12), %r13
shlq $0x4, %r12
addq $-0x6, %r12
leaq 0x6(%rsp), %r15... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::Part::operator==(icu_63::MessagePattern::Part const&) const | UBool
MessagePattern::Part::operator==(const Part &other) const {
if(this==&other) {
return TRUE;
}
return
type==other.type &&
index==other.index &&
length==other.length &&
value==other.value &&
limitPartIndex==other.limitPartIndex;
} | cmpq %rsi, %rdi
je 0x191694
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x191691
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x191691
movzwl 0x8(%rdi), %eax
cmpw 0x8(%rsi), %ax
jne 0x191691
movzwl 0xa(%rdi), %eax
cmpw 0xa(%rsi), %ax
jne 0x191691
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
sete %al
retq
xorl %eax, %eax
retq... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::parseArg(int, int, int, UParseError*, UErrorCode&) | int32_t
MessagePattern::parseArg(int32_t index, int32_t argStartLength, int32_t nestingLevel,
UParseError *parseError, UErrorCode &errorCode) {
int32_t argStart=partsLength;
UMessagePatternArgType argType=UMSGPAT_ARG_TYPE_NONE;
addPart(UMSGPAT_PART_TYPE_ARG_START, index, argStartLen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, 0x8(%rsp)
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbp
movslq 0x60(%rdi), %r15
movl $0x5, %esi
movl %r13d, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x191698
cmpl $0x0, (%r14)
jle 0x191742
... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePattern::isChoice(int) | inline UBool
UnicodeString::hasShortLength() const {
return fUnion.fFields.fLengthAndFlags>=0;
} | movswl 0x18(%rdi), %ecx
testw %cx, %cx
jns 0x191de2
movl 0x1c(%rdi), %eax
jmp 0x191de7
movl %ecx, %eax
sarl $0x5, %eax
cmpl %esi, %eax
jbe 0x191e83
testb $0x2, %cl
jne 0x191dfa
movq 0x28(%rdi), %rdi
jmp 0x191dfe
addq $0x1a, %rdi
movslq %esi, %rcx
movzwl (%rdi,%rcx,2), %ecx
andl $-0x21, %ecx
cmpw $0x43, %cx
jne 0x191e83... | /hunter-packages[P]icu/source/common/unicode/unistr.h |
icu_63::MessagePattern::isSelect(int) | inline UBool
UnicodeString::hasShortLength() const {
return fUnion.fFields.fLengthAndFlags>=0;
} | movswl 0x18(%rdi), %ecx
testw %cx, %cx
jns 0x191f46
movl 0x1c(%rdi), %eax
jmp 0x191f4b
movl %ecx, %eax
sarl $0x5, %eax
cmpl %esi, %eax
jbe 0x191fe7
testb $0x2, %cl
jne 0x191f5e
movq 0x28(%rdi), %rdi
jmp 0x191f62
addq $0x1a, %rdi
movslq %esi, %rcx
movzwl (%rdi,%rcx,2), %ecx
andl $-0x21, %ecx
cmpw $0x53, %cx
jne 0x191fe7... | /hunter-packages[P]icu/source/common/unicode/unistr.h |
icu_63::MessagePattern::parseSimpleStyle(int, UParseError*, UErrorCode&) | int32_t
MessagePattern::parseSimpleStyle(int32_t index, UParseError *parseError, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return 0;
}
int32_t start=index;
int32_t nestedBraces=0;
while(index<msg.length()) {
UChar c=msg.charAt(index++);
if(c==u_apos) {
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r13d, %r13d
cmpl $0x0, (%rcx)
jg 0x1921d3
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, 0x8(%rsp)
movswl 0x18(%rdi), %esi
movl %esi, %ecx
sarl $0x5, %ecx
testw %si, %si
movl 0x1c(%rdi), %edx
movl %ecx, %r8d
cmovsl %edx... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessageImpl::appendReducedApostrophes(icu_63::UnicodeString const&, int, int, icu_63::UnicodeString&) | void
MessageImpl::appendReducedApostrophes(const UnicodeString &s, int32_t start, int32_t limit,
UnicodeString &sb) {
int32_t doubleApos=-1;
for(;;) {
int32_t i=s.indexOf(u_apos, start);
if(i<0 || i>=limit) {
sb.append(s, start, limit-start);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movswl 0x8(%r15), %eax
movl %eax, %ecx
sarl $0x5, %ecx
testl %ebp, %ebp
js 0x19264e
testw %ax, %ax
movl 0xc(%r15), %esi
movl %ecx, ... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePatternList<icu_63::MessagePattern::Part, 32>::copyFrom(icu_63::MessagePatternList<icu_63::MessagePattern::Part, 32> const&, int, UErrorCode&) | void
MessagePatternList<T, stackCapacity>::copyFrom(
const MessagePatternList<T, stackCapacity> &other,
int32_t length,
UErrorCode &errorCode) {
if(U_SUCCESS(errorCode) && length>0) {
if(length>a.getCapacity() && NULL==a.resize(length)) {
errorCode=U_MEMORY_ALLOCATION_ERR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x19286a
movq %rcx, %r13
cmpl $0x0, (%rcx)
jg 0x19286a
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
cmpl %edx, 0x8(%rdi)
jge 0x19283c
movl %ebp, %r14d
shlq $0x4, %r14
movq %r14, %rdi
callq 0x186790
testq %rax, %rax
je 0... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::MessagePatternList<icu_63::MessagePattern::Part, 32>::equals(icu_63::MessagePatternList<icu_63::MessagePattern::Part, 32> const&, int) const | UBool equals(const MessagePatternList<T, stackCapacity> &other, int32_t length) const {
for(int32_t i=0; i<length; ++i) {
if(a[i]!=other.a[i]) { return FALSE; }
}
return TRUE;
} | testl %edx, %edx
jle 0x19296f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq (%rdi), %rbx
movq (%rsi), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x191660
testb %al, %al
je 0x192972
movl %ebp, %r15d
addq $0x10, %r14
addq $0x10, %rbx
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %r15
je 0x19296... | /hunter-packages[P]icu/source/common/messagepattern.cpp |
icu_63::Normalizer2::~Normalizer2() | void
Normalizer2::normalizeUTF8(uint32_t /*options*/, StringPiece src, ByteSink &sink,
Edits *edits, UErrorCode &errorCode) const {
if (U_FAILURE(errorCode)) {
return;
}
if (edits != nullptr) {
errorCode = U_UNSUPPORTED_ERROR;
return;
}
UnicodeStrin... | ud2
| /hunter-packages[P]icu/source/common/normalizer2.cpp |
icu_63::Normalizer2Factory::getNoopInstance(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rdi)
jle 0x192c76
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
movl 0x1a0c10(%rip), %eax # 0x333890
cmpl $0x2, %eax
je 0x192cd0
leaq 0x1a0c04(%rip), %rdi # 0x333890
callq 0x1c035f
testb %al, %al
je 0x192cd0
movl (%rbx), %eax
testl %eax, %eax
jg 0x192cf4
movl $0x8, %edi
callq 0x1cc4a8
testq %rax, %... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::Norm2AllModes::getNFCInstance(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rdi)
jle 0x192e5c
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
movl 0x1a0a32(%rip), %eax # 0x333898
cmpl $0x2, %eax
je 0x192eb1
leaq 0x1a0a26(%rip), %rdi # 0x333898
callq 0x1c035f
testb %al, %al
je 0x192eb1
movq %rbx, %rdi
callq 0x192dd2
movq %rax, 0x1a09fe(%rip) # 0x333888
leaq 0xa18(%rip), %r... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
normalizeSecondAndAppend(UNormalizer2 const*, char16_t*, int, int, char16_t const*, int, signed char, UErrorCode*) | static int32_t
normalizeSecondAndAppend(const UNormalizer2 *norm2,
UChar *first, int32_t firstLength, int32_t firstCapacity,
const UChar *second, int32_t secondLength,
UBool doNormalize,
UErrorCode *pErrorCode) {
if(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r15
movq 0x148(%rsp), %rsi
xorl %r14d, %r14d
cmpl $0x0, (%rsi)
jg 0x193382
movl %r9d, %r13d
movq %r8, %r12
movl %ecx, %ebx
movq %rdi, %rbp
testq %r8, %r8
je 0x193195
cmpl $-0x1, %r13d
jge 0x19319a
jm... | /hunter-packages[P]icu/source/common/normalizer2.cpp |
unorm2_getRawDecomposition_63 | U_CAPI int32_t U_EXPORT2
unorm2_getRawDecomposition(const UNormalizer2 *norm2,
UChar32 c, UChar *decomposition, int32_t capacity,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return 0;
}
if(decomposition==NULL ? capacity!=0 : capacity<0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r14d, %r14d
cmpl $0x0, (%r8)
jg 0x1935dc
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
testq %rdx, %rdx
je 0x1935c0
testl %ebp, %ebp
js 0x1935c4
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rs... | /hunter-packages[P]icu/source/common/normalizer2.cpp |
unorm2_quickCheck_63 | U_CAPI UNormalizationCheckResult U_EXPORT2
unorm2_quickCheck(const UNormalizer2 *norm2,
const UChar *s, int32_t length,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return UNORM_NO;
}
if((s==NULL && length!=0) || length<-1) {
*pErrorCode=U_ILLEGA... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
xorl %ebp, %ebp
cmpl $0x0, (%rcx)
jg 0x193732
movl %edx, %ecx
testq %rsi, %rsi
sete %al
testl %edx, %edx
setne %dl
cmpl $-0x1, %ecx
jl 0x19372c
andb %dl, %al
jne 0x19372c
movq %rdi, %r14
movl %ecx, %eax
shrl $0x1f, %eax
leaq 0x8(%rsp), %rdx
movq %rsi, (%... | /hunter-packages[P]icu/source/common/normalizer2.cpp |
u_getCombiningClass_63 | U_CAPI uint8_t U_EXPORT2
u_getCombiningClass(UChar32 c) {
UErrorCode errorCode=U_ZERO_ERROR;
const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode);
if(U_SUCCESS(errorCode)) {
return nfd->getCombiningClass(c);
} else {
return 0;
}
} | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq %r14, %rdi
callq 0x192e54
cmpl $0x0, (%r14)
jle 0x19384e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x20(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
movl %ebx, %esi
... | /hunter-packages[P]icu/source/common/normalizer2.cpp |
icu_63::Normalizer2WithImpl::normalize(icu_63::UnicodeString const&, icu_63::UnicodeString&, UErrorCode&) const | virtual UnicodeString &
normalize(const UnicodeString &src,
UnicodeString &dest,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
dest.setToBogus();
return dest;
}
const UChar *sArray=src.getBuffer();
if(&dest==&src || sArr... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
cmpl $0x0, (%rcx)
jg 0x193934
movq %rcx, %r14
movq %rsi, %r12
movzwl 0x8(%rsi), %eax
testb $0x11, %al
je 0x19394d
movl $0x1, (%r14)
movq %rbx, %rdi
callq 0x1c8dfe
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %... | /hunter-packages[P]icu/source/common/norm2allmodes.h |
icu_63::Normalizer2WithImpl::getRawDecomposition(int, icu_63::UnicodeString&) const | virtual UBool
getRawDecomposition(UChar32 c, UnicodeString &decomposition) const {
UChar buffer[30];
int32_t length;
const UChar *d=impl.getRawDecomposition(c, buffer, length);
if(d==NULL) {
return FALSE;
}
if(d==buffer) {
decomposition.setTo(b... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
leaq 0x20(%rsp), %r14
leaq 0x4(%rsp), %rcx
movq %r14, %rdx
callq 0x195f18
testq %rax, %rax
je 0x193b1b
cmpq %r14, %rax
je 0x193b1f
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl 0x4(%rsp), %ecx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c... | /hunter-packages[P]icu/source/common/norm2allmodes.h |
icu_63::Normalizer2WithImpl::spanQuickCheckYes(icu_63::UnicodeString const&, UErrorCode&) const | virtual int32_t
spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return 0;
}
const UChar *sArray=s.getBuffer();
if(sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
re... | xorl %eax, %eax
cmpl $0x0, (%rdx)
jle 0x193c3a
retq
pushq %rbx
movq %rdx, %rcx
movzwl 0x8(%rsi), %edx
testb $0x11, %dl
je 0x193c4f
movl $0x1, (%rcx)
jmp 0x193c8b
testb $0x2, %dl
jne 0x193c5f
movq 0x18(%rsi), %rbx
testq %rbx, %rbx
jne 0x193c63
jmp 0x193c47
leaq 0xa(%rsi), %rbx
testw %dx, %dx
jns 0x193c6d
movl 0xc(%rsi),... | /hunter-packages[P]icu/source/common/norm2allmodes.h |
icu_63::ComposeNormalizer2::quickCheck(icu_63::UnicodeString const&, UErrorCode&) const | virtual UNormalizationCheckResult
quickCheck(const UnicodeString &s, UErrorCode &errorCode) const U_OVERRIDE {
if(U_FAILURE(errorCode)) {
return UNORM_MAYBE;
}
const UChar *sArray=s.getBuffer();
if(sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
... | movl $0x2, %eax
cmpl $0x0, (%rdx)
jle 0x193ed9
retq
movzwl 0x8(%rsi), %ecx
testb $0x11, %cl
je 0x193ee9
movl $0x1, (%rdx)
retq
testb $0x2, %cl
jne 0x193ef9
movq 0x18(%rsi), %r8
testq %r8, %r8
jne 0x193efd
jmp 0x193ee2
leaq 0xa(%rsi), %r8
pushq %rbx
subq $0x10, %rsp
movl $0x1, 0xc(%rsp)
movq 0x8(%rdi), %rax
testw %cx, %... | /hunter-packages[P]icu/source/common/norm2allmodes.h |
icu_63::NoopNormalizer2::normalizeUTF8(unsigned int, icu_63::StringPiece, icu_63::ByteSink&, icu_63::Edits*, UErrorCode&) const | virtual void
normalizeUTF8(uint32_t options, StringPiece src, ByteSink &sink,
Edits *edits, UErrorCode &errorCode) const U_OVERRIDE {
if(U_SUCCESS(errorCode)) {
if (edits != nullptr) {
if ((options & U_EDITS_NO_RESET) == 0) {
edits->reset();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x194083
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %r12
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
testq %r9, %r9
je 0x1940af
btl $0xd, %r15d
jb 0x1940a5
movq %r12, %rdi
callq 0... | /hunter-packages[P]icu/source/common/normalizer2.cpp |
icu_63::NoopNormalizer2::append(icu_63::UnicodeString&, icu_63::UnicodeString const&, UErrorCode&) const | virtual UnicodeString &
append(UnicodeString &first,
const UnicodeString &second,
UErrorCode &errorCode) const U_OVERRIDE {
if(U_SUCCESS(errorCode)) {
if(&first!=&second) {
first.append(second);
} else {
errorCode=U_ILLEGAL_ARGUME... | pushq %rbx
movq %rsi, %rbx
cmpl $0x0, (%rcx)
jg 0x194144
cmpq %rdx, %rbx
je 0x19412c
movswl 0x8(%rdx), %ecx
testw %cx, %cx
jns 0x194134
movl 0xc(%rdx), %ecx
jmp 0x194137
movl $0x1, (%rcx)
jmp 0x194144
sarl $0x5, %ecx
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x1cb1d6
movq %rbx, %rax
popq %rbx
retq
nop
| /hunter-packages[P]icu/source/common/normalizer2.cpp |
icu_63::Normalizer2Impl::hasCompBoundaryAfter(int, signed char) const | UBool hasCompBoundaryAfter(UChar32 c, UBool onlyContiguous) const {
return norm16HasCompBoundaryAfter(getNorm16(c), onlyContiguous);
} | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x19430a
testb $0x1, %al
jne 0x1943ef
xorl %ecx, %ecx
jmp 0x19441d
movb $0x1, %cl
testb %bpl, %bpl
je 0x19441d
cmpw $0x1, %ax
je 0x19441d
cmpw %ax, 0x1a(%rbx)
jbe 0x194413
movq 0x30(%rbx), %rcx
andl $0xfffe, %eax # imm = 0xFFFE
cmpw $0x200... | /hunter-packages[P]icu/source/common/normalizer2impl.h |
icu_63::ReorderingBuffer::ReorderingBuffer(icu_63::Normalizer2Impl const&, icu_63::UnicodeString&, UErrorCode&) | ReorderingBuffer::ReorderingBuffer(const Normalizer2Impl &ni, UnicodeString &dest,
UErrorCode &errorCode) :
impl(ni), str(dest),
start(str.getBuffer(8)), reorderStart(start), limit(start),
remainingCapacity(str.getCapacity()), lastCC(0) {
if (start == nullp... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rdx, %rdi
movl $0x8, %esi
callq 0x1c9746
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
movq 0x8(%r14), %rcx
movzwl 0x8(%rcx), %esi
movl $0x1b, %edx
testb $0x2, %sil
jne 0x1944b8
movl 0x10(%r... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::ReorderingBuffer::previousCC() | uint8_t ReorderingBuffer::previousCC() {
codePointLimit=codePointStart;
if(reorderStart>=codePointStart) {
return 0;
}
UChar32 c=*--codePointStart;
UChar c2;
if(U16_IS_TRAIL(c) && start<codePointStart && U16_IS_LEAD(c2=*(codePointStart-1))) {
--codePointStart;
c=U16_GET_S... | pushq %rbx
movq 0x18(%rdi), %rcx
movq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
cmpq %rax, %rcx
jae 0x194602
leaq -0x2(%rax), %rcx
movq %rcx, 0x30(%rdi)
movzwl -0x2(%rax), %esi
movl %esi, %edx
andl $0xfc00, %edx # imm = 0xFC00
cmpl $0xdc00, %edx # imm = 0xDC00
jne 0x1945df
cmpq %rcx, 0x10(%rdi)
jae 0x1... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::ReorderingBuffer::appendZeroCC(int, UErrorCode&) | UBool ReorderingBuffer::appendZeroCC(UChar32 c, UErrorCode &errorCode) {
int32_t cpLength=U16_LENGTH(c);
if(remainingCapacity<cpLength && !resize(cpLength, errorCode)) {
return FALSE;
}
remainingCapacity-=cpLength;
if(cpLength==1) {
*limit++=(UChar)c;
} else {
limit[0]=U1... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x10000, %esi # imm = 0x10000
movl $0x2, %r14d
sbbl $0x0, %r14d
movl 0x28(%rdi), %eax
cmpl %r14d, %eax
jge 0x194bef
movq %rbx, %rdi
movl %r14d, %esi
callq 0x194810
testb %al, %al
je 0x194c47
movl 0x28(%rbx), %eax
subl %r14d, %eax
movl %eax,... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::ReorderingBuffer::removeSuffix(int) | void ReorderingBuffer::removeSuffix(int32_t suffixLength) {
if(suffixLength<(limit-start)) {
limit-=suffixLength;
remainingCapacity+=suffixLength;
} else {
limit=start;
remainingCapacity=str.getCapacity();
}
lastCC=0;
reorderStart=limit;
} | movslq %esi, %rcx
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq %rsi
cmpq %rcx, %rsi
jle 0x194d13
subq %rcx, %rdx
subq %rcx, %rdx
movq %rdx, 0x20(%rdi)
addl %ecx, 0x28(%rdi)
movq %rdx, %rax
jmp 0x194d30
movq %rax, 0x20(%rdi)
movq 0x8(%rdi), %rcx
movzwl 0x8(%rcx), %esi
movl $0x1b, %edx... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::addPropertyStarts(USetAdder const*, UErrorCode&) const | void
Normalizer2Impl::addPropertyStarts(const USetAdder *sa, UErrorCode & /*errorCode*/) const {
// Add the start code point of each same-value range of the trie.
UChar32 start = 0, end;
uint32_t value;
while ((end = ucptrie_getRange(normTrie, start, UCPMAP_RANGE_FIXED_LEAD_SURROGATES, INERT,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq 0x20(%rdi), %rdi
leaq 0x14(%rsp), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
xorl %esi, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1ae9cd
testl %eax, %eax
js 0x195... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::ensureCanonIterData(UErrorCode&) const | UBool Normalizer2Impl::ensureCanonIterData(UErrorCode &errorCode) const {
// Logically const: Synchronized instantiation.
Normalizer2Impl *me=const_cast<Normalizer2Impl *>(this);
umtx_initOnce(me->fCanonIterDataInitOnce, &initCanonIterData, me, errorCode);
return U_SUCCESS(errorCode);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, (%rsi)
jg 0x195149
movq %rdi, %r14
leaq 0x40(%rdi), %r15
movl (%r15), %eax
cmpl $0x2, %eax
je 0x19513f
movq %r15, %rdi
callq 0x1c035f
testb %al, %al
je 0x19513f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19987c
movl (%rbx), %eax
movl %eax, 0x44(%r14)
movq %r15, %... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.