name string | code string | asm string | file string |
|---|---|---|---|
icu_63::Normalizer2Impl::decompose(char16_t const*, char16_t const*, icu_63::ReorderingBuffer*, UErrorCode&) const | const UChar *
Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
ReorderingBuffer *buffer,
UErrorCode &errorCode) const {
UChar32 minNoCP=minDecompNoCP;
if(limit==NULL) {
src=copyLowPrefixFromNulTerminated(src, minNoCP, buffer, errorCod... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, 0x10(%rsp)
movq %rdi, %r15
movzwl 0x8(%rdi), %r8d
testq %rdx, %rdx
movw %r8w, 0xa(%rsp)
je 0x195522
movq %rdx, %r12
xorl %ebx, %ebx
movq %rsi, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq %rsi, %rax
movq %r14, 0x20(%rsp... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::decomposeShort(char16_t const*, char16_t const*, signed char, signed char, icu_63::ReorderingBuffer&, UErrorCode&) const | const UChar *
Normalizer2Impl::decomposeShort(const UChar *src, const UChar *limit,
UBool stopAtCompBoundary, UBool onlyContiguous,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
if (U_FAILURE(errorCode)) {
return nullptr;
}
w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x195747
xorl %ebp, %ebp
jmp 0x1958fb
movq %rsi, %rbp
cmpq %rdx, %rsi
jae 0x1958fb
movl %ecx, %r14d
movq %rdi, %r12
movzwl (%rbp), %eax
testb %r14b, %r14b
je 0x19576e
cmpw 0xa(%r12), %ax
jb 0x1... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::(anonymous namespace)::codePointFromValidUTF8(unsigned char const*, unsigned char const*) | UChar32 codePointFromValidUTF8(const uint8_t *cpStart, const uint8_t *cpLimit) {
// Similar to U8_NEXT_UNSAFE(s, i, c).
U_ASSERT(cpStart < cpLimit);
uint8_t c = *cpStart;
switch(cpLimit-cpStart) {
case 1:
return c;
case 2:
return ((c&0x1f)<<6) | (cpStart[1]&0x3f);
case 3:
... | movq %rdi, %rcx
notq %rcx
addq %rsi, %rcx
cmpq $0x3, %rcx
ja 0x195d85
movzbl (%rdi), %eax
leaq 0x76ab3(%rip), %rdx # 0x20c7dc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
andl $0x1f, %eax
shll $0x6, %eax
movzbl 0x1(%rdi), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
retq
shll $0xc, %eax
movzbl 0x1(%rdi), %ecx
andl... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::getRawDecomposition(int, char16_t*, int&) const | const UChar *
Normalizer2Impl::getRawDecomposition(UChar32 c, UChar buffer[30], int32_t &length) const {
uint16_t norm16;
if(c<minDecompNoCP || isDecompYes(norm16=getNorm16(c))) {
// c does not decompose
return NULL;
} else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
// Hangul sy... | movzwl 0x8(%rdi), %eax
cmpl %esi, %eax
jle 0x195f23
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
callq 0x19430a
movl %eax, %ecx
movzwl 0xe(%r12), %edx
xorl %eax, %eax
cmpw %cx, %dx
ja 0x196008
cmpw %cx, 0x1e(%r12)
jbe 0x1960... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::hasDecompBoundaryBefore(int) const | UBool Normalizer2Impl::hasDecompBoundaryBefore(UChar32 c) const {
return c < minLcccCP || (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) ||
norm16HasDecompBoundaryBefore(getNorm16(c));
} | pushq %rbx
movzwl 0xc(%rdi), %eax
cmpl %esi, %eax
jle 0x1962eb
movb $0x1, %al
popq %rbx
retq
movq %rdi, %rbx
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x196317
movq 0x38(%rbx), %rax
movl %esi, %ecx
shrl $0x8, %ecx
movzbl (%rax,%rcx), %eax
movl %esi, %ecx
shrb $0x5, %cl
movl $0x1, %edx
shll %cl, %edx
testl %eax, %e... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::hasDecompBoundaryAfter(int) const | UBool Normalizer2Impl::hasDecompBoundaryAfter(UChar32 c) const {
if (c < minDecompNoCP) {
return TRUE;
}
if (c <= 0xffff && !singleLeadMightHaveNonZeroFCD16(c)) {
return TRUE;
}
return norm16HasDecompBoundaryAfter(getNorm16(c));
} | pushq %rbx
movzwl 0x8(%rdi), %eax
cmpl %esi, %eax
jle 0x19637f
movb $0x1, %al
popq %rbx
retq
movq %rdi, %rbx
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x1963ab
movq 0x38(%rbx), %rax
movl %esi, %ecx
shrl $0x8, %ecx
movzbl (%rax,%rcx), %eax
movl %esi, %ecx
shrb $0x5, %cl
movl $0x1, %edx
shll %cl, %edx
testl %eax, %e... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::Normalizer2Impl::combine(unsigned short const*, int) | int32_t Normalizer2Impl::combine(const uint16_t *list, UChar32 trail) {
uint16_t key1, firstUnit;
if(trail<COMP_1_TRAIL_LIMIT) {
// trail character is 0..33FF
// result entry may have 2 or 3 units
key1=(uint16_t)(trail<<1);
while(key1>(firstUnit=*list)) {
list+=2+(fir... | cmpl $0x33ff, %esi # imm = 0x33FF
jg 0x196461
addl %esi, %esi
movzwl %si, %edx
movzwl (%rdi), %ecx
cmpl %ecx, %edx
jbe 0x1964b5
andl $0x1, %ecx
leaq (%rdi,%rcx,2), %rdi
addq $0x4, %rdi
jmp 0x19644d
movl %esi, %ecx
shrl $0x9, %ecx
addl $0x3400, %ecx # imm = 0x3400
shll $0x6, %esi
andl $0xfffe, %ecx ... | /hunter-packages[P]icu/source/common/normalizer2impl.cpp |
icu_63::RBBIRuleScanner::stripRules(icu_63::UnicodeString const&) | UnicodeString RBBIRuleScanner::stripRules(const UnicodeString &rules) {
UnicodeString strippedRules;
int32_t rulesLength = rules.length();
bool skippingSpaces = false;
for (int32_t idx=0; idx<rulesLength; idx = rules.moveIndex32(idx, 1)) {
UChar32 cp = rules.char32At(idx);
bool whiteSpa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x11d893(%rip), %rax # 0x2be248
addq $0x10, %rax
movq %rax, (%rdi)
movq %rdi, (%rsp)
movw $0x2, 0x8(%rdi)
movswl 0x8(%rsi), %r12d
testw %r12w, %r12w
jns 0x1a09d7
movl 0xc(%r14), %r12d
jmp 0x1a09db
sarl $0x5, %r12d
xorl ... | /hunter-packages[P]icu/source/common/rbbiscan.cpp |
icu_63::RBBITableBuilder::sortedAdd(icu_63::UVector**, int) | void RBBITableBuilder::sortedAdd(UVector **vector, int32_t val) {
int32_t i;
if (*vector == NULL) {
*vector = new UVector(*fStatus);
}
if (*vector == NULL || U_FAILURE(*fStatus)) {
return;
}
UVector *vec = *vector;
int32_t vSize = vec->size();
for (i=0; i<vSize; i++) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r15
movq (%rsi), %r14
testq %r14, %r14
jne 0x1a2e9f
movq %rsi, %r12
movl $0x28, %edi
callq 0x1cc4a8
testq %rax, %rax
je 0x1a2ee2
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x1e2dc8
movq %r14, (%r12)... | /hunter-packages[P]icu/source/common/rbbitblb.cpp |
icu_63::RBBITableBuilder::getTableSize() const | int32_t RBBITableBuilder::getTableSize() const {
int32_t size = 0;
int32_t numRows;
int32_t numCols;
int32_t rowSize;
if (fTree == NULL) {
return 0;
}
size = offsetof(RBBIStateTable, fTableData); // The header, with no rows to the table.
numRows = fDStates->... | movq 0x8(%rdi), %rax
cmpq $0x0, (%rax)
je 0x1a354c
pushq %rbx
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movl 0x8(%rcx), %ebx
movq 0xa0(%rax), %rdi
callq 0x1a1520
leal 0x8(,%rax,2), %eax
imull %ebx, %eax
addl $0x10, %eax
popq %rbx
retq
xorl %eax, %eax
retq
nop
| /hunter-packages[P]icu/source/common/rbbitblb.cpp |
icu_63::RBBITableBuilder::buildSafeReverseTable(UErrorCode&) | void RBBITableBuilder::buildSafeReverseTable(UErrorCode &status) {
// The safe table creation has three steps:
// 1. Identifiy pairs of character classes that are "safe." Safe means that boundaries
// following the pair do not depend on context or state before the pair. To test
// whether a pair is saf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
leaq 0x11abb9(%rip), %rax # 0x2be248
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movw $0x2, 0x30(%rsp)
movq (%rdi), %rax
movq 0xa0(%rax), %rdi
callq 0x1a1520
movq %rax, 0x8(%rsp)
testl %eax, %eax
jle 0... | /hunter-packages[P]icu/source/common/rbbitblb.cpp |
icu_63::RBBIStateDescriptor::~RBBIStateDescriptor() | RBBIStateDescriptor::~RBBIStateDescriptor() {
delete fPositions;
delete fDtran;
delete fTagVals;
fPositions = NULL;
fDtran = NULL;
fTagVals = NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x1a3b94
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1a3ba3
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x20(%rbx), %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1a3bb6
movq (%rdi), %rax
callq *0... | /hunter-packages[P]icu/source/common/rbbitblb.cpp |
icu_63::StringCharacterIterator::StringCharacterIterator(icu_63::UnicodeString const&, int) | StringCharacterIterator::StringCharacterIterator(const UnicodeString& textStr,
int32_t textPos)
: UCharCharacterIterator(textStr.getBuffer(), textStr.length(), textPos),
text(textStr)
{
// we had set the input parameter's array, now we need to set our copy's ar... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x8(%rsi), %eax
testb $0x11, %al
je 0x1a3cfb
xorl %edx, %edx
jmp 0x1a3d09
testb $0x2, %al
jne 0x1a3d05
movq 0x18(%r14), %rdx
jmp 0x1a3d09
leaq 0xa(%r14), %rdx
movq %rdx, (%rsp)
testw %ax, %ax
jns 0x1a3d18
movl 0xc(%r14), %edx
... | /hunter-packages[P]icu/source/common/schriter.cpp |
icu_63::StringCharacterIterator::operator==(icu_63::ForwardCharacterIterator const&) const | UBool
StringCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
if (this == &that) {
return TRUE;
}
// do not call UCharCharacterIterator::operator==()
// because that checks for array pointer equality
// while we compare UnicodeString objects
if (typeid(*this) ... | cmpq %rsi, %rdi
je 0x1a3f84
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq (%rsi), %rcx
movq -0x8(%rcx), %rcx
movq 0x8(%rax), %rdi
movq 0x8(%rcx), %rsi
cmpq %rsi, %rdi
je 0x1a3f70
cmpb $0x2a, (%rdi)
je 0x1a3fe6
callq 0xd9420
testl %eax, %eax
jne 0x1a3fe6
mo... | /hunter-packages[P]icu/source/common/schriter.cpp |
icu_63::ICUServiceKey::isFallbackOf(icu_63::UnicodeString const&) const | UBool
ICUServiceKey::isFallbackOf(const UnicodeString& id) const
{
return id == _id;
} | movq %rdi, %rcx
movzwl 0x8(%rsi), %eax
testb $0x1, %al
jne 0x1a41bb
testw %ax, %ax
jns 0x1a41c1
movl 0xc(%rsi), %edx
jmp 0x1a41c7
movb 0x10(%rcx), %al
andb $0x1, %al
retq
movswl %ax, %edx
sarl $0x5, %edx
movswl 0x10(%rcx), %edi
testw %di, %di
jns 0x1a41d6
movl 0x14(%rcx), %r8d
jmp 0x1a41dd
movl %edi, %r8d
sarl $0x5, %r... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUServiceKey::parseSuffix(icu_63::UnicodeString&) | UnicodeString&
ICUServiceKey::parseSuffix(UnicodeString& result)
{
int32_t n = result.indexOf(PREFIX_DELIMITER);
if (n >= 0) {
result.remove(0, n+1);
}
return result;
} | pushq %rbx
movq %rdi, %rbx
movswl 0x8(%rdi), %ecx
testw %cx, %cx
jns 0x1a4278
movl 0xc(%rbx), %ecx
jmp 0x1a427b
sarl $0x5, %ecx
movq %rbx, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x1ca5e4
testl %eax, %eax
js 0x1a42c4
incl %eax
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jne 0x1a42b0
movzwl 0x8(%rbx), %eax
movl ... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::SimpleFactory::updateVisibleIDs(icu_63::Hashtable&, UErrorCode&) const | void
SimpleFactory::updateVisibleIDs(Hashtable& result, UErrorCode& status) const
{
if (_visible) {
result.put(_id, (void*)this, status); // cast away const
} else {
result.remove(_id);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x50(%rdi)
je 0x1a448b
movq %rdx, %r14
movq (%rsi), %r12
movl $0x40, %edi
callq 0x1cc4a8
movq %rax, %r15
testq %rax, %rax
je 0x1a446f
leaq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x1c92c6
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
mov... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::StringPair::create(icu_63::UnicodeString const&, icu_63::UnicodeString const&, UErrorCode&) | UnicodeString&
ICUService::getDisplayName(const UnicodeString& id, UnicodeString& result) const
{
return getDisplayName(id, result, Locale::getDefault());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%rdx)
jg 0x1a45cb
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x88, %edi
callq 0x1cc4a8
movq %rax, %rbx
testq %rax, %rax
je 0x1a45bc
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1a4606
movzwl 0x50(%rbx), %eax
orw 0x10(%rbx), %ax
tes... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUService::getKey(icu_63::ICUServiceKey&, icu_63::UnicodeString*, icu_63::ICUServiceFactory const*, UErrorCode&) const | UnicodeString&
ICUService::getDisplayName(const UnicodeString& id, UnicodeString& result, const Locale& locale) const
{
{
UErrorCode status = U_ZERO_ERROR;
Mutex mutex(&lock);
const Hashtable* map = getVisibleIDMap(status);
if (map != NULL) {
ICUServiceFactory* f = (ICU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0x0, (%r8)
jle 0x1a4817
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rbx
movq %rcx, %rbp
movq %rsi, %r13
movq %rdi, %r12
movq %rdx, 0x10(%rsp)
movq (%rdi), %rax
callq ... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUService::getVisibleIDMap(UErrorCode&) const | UnicodeString&
ICUService::getDisplayName(const UnicodeString& id, UnicodeString& result, const Locale& locale) const
{
{
UErrorCode status = U_ZERO_ERROR;
Mutex mutex(&lock);
const Hashtable* map = getVisibleIDMap(status);
if (map != NULL) {
ICUServiceFactory* f = (ICU... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%rsi)
jle 0x1a4ff4
xorl %r14d, %r14d
jmp 0x1a5000
movq %rdi, %rbx
movq 0x68(%rdi), %r14
testq %r14, %r14
je 0x1a500f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %r15
movl $0x58, %edi
callq 0x1cc4a8
testq %rax,... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUService::getDisplayNames(icu_63::UVector&, icu_63::Locale const&, icu_63::UnicodeString const*, UErrorCode&) const | UVector&
ICUService::getDisplayNames(UVector& result,
const Locale& locale,
const UnicodeString* matchID,
UErrorCode& status) const
{
result.removeAllElements();
result.setDeleter(userv_deleteStringPair);
if (U_SUCCESS(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1e2f96
leaq 0x308(%rip), %rsi # 0x1a5634
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0x1e36fc
cmpl $0x0, (%r14)
jg 0x1a551d
leaq 0x1... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUService::createSimpleFactory(icu_63::UObject*, icu_63::UnicodeString const&, signed char, UErrorCode&) | UnicodeString&
ICUService::getDisplayName(const UnicodeString& id, UnicodeString& result) const
{
return getDisplayName(id, result, Locale::getDefault());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%r8)
jg 0x1a5781
movq %rsi, %r15
testq %rsi, %rsi
je 0x1a577a
movq %rdx, %r14
testb $0x1, 0x8(%rdx)
jne 0x1a577a
movl %ecx, %ebp
movl $0x58, %edi
callq 0x1cc4a8
testq %rax, %rax
je 0x1a5781
movq %rax, %rbx
movsbl %bpl, %ecx
movq %rax, %rdi
movq %r15, %r... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUService::unregister(void const*, UErrorCode&) | UBool
ICUService::unregister(URegistryKey rkey, UErrorCode& status)
{
ICUServiceFactory *factory = (ICUServiceFactory*)rkey;
UBool result = FALSE;
if (factory != NULL && factories != NULL) {
Mutex mutex(&lock);
if (factories->removeElement(factory)) {
clearCaches();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1a5938
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x1a5938
movq %rdx, %r15
movq %rsi, %r14
leaq 0x18f053(%rip), %rdi # 0x334938
callq 0x1c031c
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1e35fc
movl %eax, %ebp
testb %al, %al
je 0x1a590a
mov... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::ICUService::clearCaches() | void
ICUService::clearCaches()
{
// callers synchronize before use
++timestamp;
delete dnCache;
dnCache = NULL;
delete idCache;
idCache = NULL;
delete serviceCache; serviceCache = NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x50(%rdi)
movq 0x70(%rdi), %r14
testq %r14, %r14
je 0x1a5a74
leaq 0x60(%r14), %rdi
callq 0x18c8ec
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a5a74
callq 0x1b4822
movq %r14, %rdi
callq 0x1cc4b8
movq $0x0, 0x70(%rbx)
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0x1a5a9... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::DNCache::DNCache(icu_63::Locale const&) | DNCache(const Locale& _locale)
: cache(), locale(_locale)
{
// cache.setKeyDeleter(uprv_deleteUObject);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq $0x0, 0x8(%rdi)
leaq 0xc(%rsp), %r13
movl $0x0, (%r13)
leaq 0x10(%rdi), %r12
leaq 0x25eb6(%rip), %rsi # 0x1cba83
leaq 0x25eeb(%rip), %rdx # 0x1cbabf
movq %r12, %rdi
xorl %ecx, %ecx
m... | /hunter-packages[P]icu/source/common/serv.cpp |
icu_63::LocaleKeyFactory::~LocaleKeyFactory() | UObject*
LocaleKeyFactory::create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const {
if (handlesKey(key, status)) {
const LocaleKey& lkey = (const LocaleKey&)key;
int32_t kind = lkey.kind();
Locale loc;
lkey.currentLocale(loc);
return handleCrea... | pushq %rbx
movq %rdi, %rbx
leaq 0x11249b(%rip), %rax # 0x2b8180
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x1c95ec
movq %rbx, %rdi
callq 0x1a42da
movq %rbx, %rdi
popq %rbx
jmp 0x1cc4b8
| /hunter-packages[P]icu/source/common/servlkf.cpp |
icu_63::LocaleKeyFactory::handlesKey(icu_63::ICUServiceKey const&, UErrorCode&) const | UBool
LocaleKeyFactory::handlesKey(const ICUServiceKey& key, UErrorCode& status) const {
const Hashtable* supported = getSupportedIDs(status);
if (supported) {
UnicodeString id;
key.currentID(id);
return supported->get(id) != NULL;
}
return FALSE;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x1a5e00
movq %rax, %r14
leaq 0x118482(%rip), %rax # 0x2be248
addq $0x10, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movw $0x2, 0x8(%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)... | /hunter-packages[P]icu/source/common/servlkf.cpp |
icu_63::LocaleKeyFactory::getDisplayName(icu_63::UnicodeString const&, icu_63::Locale const&, icu_63::UnicodeString&) const | UnicodeString&
LocaleKeyFactory::getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const {
if ((_coverage & 0x1) == 0) {
//UErrorCode status = U_ZERO_ERROR;
// assume if this is called on us, we support some fallback of this id
// if (isSupportedID(id, stat... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %rbx
testb $0x1, 0x48(%rdi)
jne 0x1a5f72
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x18c95a
movq %r15, %rdi
movq %r12, %rsi
callq 0x18fbf0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x188e0a
movq %ra... | /hunter-packages[P]icu/source/common/servlkf.cpp |
icu_63::ServiceEnumeration::create(icu_63::ICULocaleService const*) | static ServiceEnumeration* create(const ICULocaleService* service) {
UErrorCode status = U_ZERO_ERROR;
ServiceEnumeration* result = new ServiceEnumeration(service, status);
if (U_SUCCESS(status)) {
return result;
}
delete result;
return NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x0, 0x4(%rsp)
movl $0xb8, %edi
callq 0x1cc4a8
testq %rax, %rax
je 0x1a64c3
movq %rax, %rbx
leaq 0x4(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a6642
cmpl $0x0, 0x4(%rsp)
jle 0x1a64c5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq... | /hunter-packages[P]icu/source/common/servls.cpp |
icu_63::ServiceEnumeration::count(UErrorCode&) const | virtual int32_t count(UErrorCode& status) const {
return upToDate(status) ? _ids.size() : 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, (%rsi)
jg 0x1a657d
movq %rsi, %r14
movq %rdi, %r15
movl 0x80(%rdi), %ebp
movq 0x78(%rdi), %rdi
callq 0x1a5b78
cmpl %eax, %ebp
jne 0x1a6576
movl 0x90(%r15), %ebx
jmp 0x1a657d
movl $0x19, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
pop... | /hunter-packages[P]icu/source/common/servls.cpp |
icu_63::ServiceEnumeration::ServiceEnumeration(icu_63::ICULocaleService const*, UErrorCode&) | ServiceEnumeration(const ICULocaleService* service, UErrorCode &status)
: _service(service)
, _timestamp(service->getTimestamp())
, _ids(uprv_deleteUObject, NULL, status)
, _pos(0)
{
_service->getVisibleIDs(_ids, status);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1d64e4
leaq 0x111c64(%rip), %rax # 0x2b82c0
movq %rax, (%rbx)
movq %r15, 0x78(%rbx)
movq %r15, %rdi
callq 0x1a5b78
movl %eax, 0x80(%rbx)
leaq 0x88(%rbx), %r15
leaq 0x25e8a(%rip), %rsi # 0x1cc509
movq %r15, %rdi
xorl %edx, %e... | /hunter-packages[P]icu/source/common/servls.cpp |
icu_63::ICUNotifier::notifyChanged() | void
ICUNotifier::notifyChanged(void)
{
if (listeners != NULL) {
Mutex lmx(¬ifyLock);
if (listeners != NULL) {
for (int i = 0, e = listeners->size(); i < e; ++i) {
EventListener* el = (EventListener*)listeners->elementAt(i);
notifyListener(*el);
... | pushq %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x1a6a44
movq %rdi, %rbx
leaq 0x18df9f(%rip), %rdi # 0x3349a0
callq 0x1c031c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1a6a38
movl 0x8(%rax), %r14d
testl %r14d, %r14d
jle 0x1a6a38
xorl %ebp, %ebp
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0x1e3376
movq (%rbx)... | /hunter-packages[P]icu/source/common/servnotf.cpp |
icu_63::SharedObject::removeRef() const | void
SharedObject::removeRef() const {
const UnifiedCacheBase *cache = this->cachePtr;
int32_t updatedRefCount = umtx_atomic_dec(&hardRefCount);
U_ASSERT(updatedRefCount >= 0);
if (updatedRefCount == 0) {
if (cache) {
cache->handleUnreferencedObject();
} else {
de... | movq 0x10(%rdi), %rax
lock
decl 0xc(%rdi)
jne 0x1a6eba
testq %rax, %rax
je 0x1a6ebb
movq (%rax), %rcx
movq %rax, %rdi
jmpq *0x18(%rcx)
retq
movq (%rdi), %rax
jmpq *0x8(%rax)
nop
| /hunter-packages[P]icu/source/common/sharedobject.cpp |
icu_63::SimpleFormatter::formatAndAppend(icu_63::UnicodeString const* const*, int, icu_63::UnicodeString&, int*, int, UErrorCode&) const | UnicodeString& SimpleFormatter::formatAndAppend(
const UnicodeString *const *values, int32_t valuesLength,
UnicodeString &appendTo,
int32_t *offsets, int32_t offsetsLength, UErrorCode &errorCode) const {
if (U_FAILURE(errorCode)) {
return appendTo;
}
if (isInvalidArray(values... | pushq %rbx
movq %rcx, %rbx
movq 0x10(%rsp), %r11
cmpl $0x0, (%r11)
jg 0x1a7302
movq %r8, %rax
movq %rsi, %rcx
testq %rsi, %rsi
setne %sil
testl %edx, %edx
sete %r8b
js 0x1a72fb
orb %r8b, %sil
je 0x1a72fb
movl %r9d, %r10d
testq %rax, %rax
setne %sil
testl %r9d, %r9d
sete %r8b
js 0x1a72fb
orb %r8b, %sil
je 0x1a72fb
movzw... | /hunter-packages[P]icu/source/common/simpleformatter.cpp |
icu_63::SimpleFormatter::formatAndReplace(icu_63::UnicodeString const* const*, int, icu_63::UnicodeString&, int*, int, UErrorCode&) const | UnicodeString &SimpleFormatter::formatAndReplace(
const UnicodeString *const *values, int32_t valuesLength,
UnicodeString &result,
int32_t *offsets, int32_t offsetsLength, UErrorCode &errorCode) const {
if (U_FAILURE(errorCode)) {
return result;
}
if (isInvalidArray(values, v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq 0x90(%rsp), %r10
cmpl $0x0, (%r10)
jg 0x1a75bc
movq %rsi, %r12
testq %rsi, %rsi
setne %al
testl %edx, %edx
sete %cl
js 0x1a75b5
orb %cl, %al
je 0x1a75b5
movl %r9d, %r15d
movq %r8, %r14
testq %r8, %r8
setne %al
testl ... | /hunter-packages[P]icu/source/common/simpleformatter.cpp |
(anonymous namespace)::cleanupNumberParseUniSets() | UBool U_CALLCONV cleanupNumberParseUniSets() {
if (gEmptyUnicodeSetInitialized) {
reinterpret_cast<UnicodeSet*>(gEmptyUnicodeSet)->~UnicodeSet();
gEmptyUnicodeSetInitialized = FALSE;
}
for (int32_t i = 0; i < COUNT; i++) {
delete gUnicodeSets[i];
gUnicodeSets[i] = nullptr;
... | pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x18cd33(%rip) # 0x334a30
je 0x1a7d12
leaq 0x18ccca(%rip), %rdi # 0x3349d0
callq 0x1c13fc
movb $0x0, 0x18cd1e(%rip) # 0x334a30
xorl %r14d, %r14d
leaq 0x18cd24(%rip), %r15 # 0x334a40
movq (%r14,%r15), %rbx
testq %rbx, %rbx
je 0x1a7d2d
movq %rbx, %rdi
callq 0x1c13fc... | /hunter-packages[P]icu/source/common/static_unicode_sets.cpp |
(anonymous namespace)::computeUnion(icu_63::unisets::Key, icu_63::unisets::Key) | UnicodeSet* computeUnion(Key k1, Key k2) {
UnicodeSet* result = new UnicodeSet();
if (result == nullptr) {
return nullptr;
}
result->addAll(*getImpl(k1));
result->addAll(*getImpl(k2));
result->freeze();
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x58, %edi
callq 0x1cc4a8
movq %rax, %rbx
testq %rax, %rax
je 0x1a7e5e
movq %rbx, %rdi
callq 0x1c0ea4
leaq 0x18cc1d(%rip), %r14 # 0x334a40
movq 0x18ccae(%rip), %rsi # 0x334ad8
testq %rsi, %rsi
leaq 0x18cb9c(%rip), %r15 # 0x3349d0
cmov... | /hunter-packages[P]icu/source/common/static_unicode_sets.cpp |
(anonymous namespace)::ParseDataSink::put(char const*, icu_63::ResourceValue&, signed char, UErrorCode&) | void put(const char* key, ResourceValue& value, UBool /*noFallback*/, UErrorCode& status) U_OVERRIDE {
ResourceTable contextsTable = value.getTable(status);
if (U_FAILURE(status)) { return; }
for (int i = 0; contextsTable.getKeyAndValue(i, key, value); i++) {
if (uprv_strcmp(key, "da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq (%rdx), %rax
leaq 0x98(%rsp), %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq *0x58(%rax)
cmpl $0x0, (%rbx)
jle 0x1a7ed9
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r1... | /hunter-packages[P]icu/source/common/static_unicode_sets.cpp |
icu_63::StringPiece::StringPiece(icu_63::StringPiece const&, int) | StringPiece::StringPiece(const StringPiece& x, int32_t pos) {
if (pos < 0) {
pos = 0;
} else if (pos > x.length_) {
pos = x.length_;
}
ptr_ = x.ptr_ + pos;
length_ = x.length_ - pos;
} | movl 0x8(%rsi), %eax
cmpl %edx, %eax
movl %edx, %ecx
cmovll %eax, %ecx
xorl %r8d, %r8d
testl %edx, %edx
cmovnsl %ecx, %r8d
movslq %r8d, %rcx
movq (%rsi), %rdx
addq %rcx, %rdx
movq %rdx, (%rdi)
subl %ecx, %eax
movl %eax, 0x8(%rdi)
retq
nop
| /hunter-packages[P]icu/source/common/stringpiece.cpp |
uprv_uint32Comparator_63 | U_CAPI int32_t U_EXPORT2
uprv_uint32Comparator(const void *context, const void *left, const void *right) {
(void)context;
uint32_t l=*(const uint32_t *)left, r=*(const uint32_t *)right;
/* compare directly because (l-r) would overflow the int32_t result */
if(l<r) {
return -1;
} else if(l==... | movl (%rsi), %eax
xorl %ecx, %ecx
cmpl (%rdx), %eax
setne %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovael %ecx, %eax
retq
| /hunter-packages[P]icu/source/common/uarrsort.cpp |
uprv_sortArray_63 | U_CAPI void U_EXPORT2
uprv_sortArray(void *array, int32_t length, int32_t itemSize,
UComparator *cmp, const void *context,
UBool sortStable, UErrorCode *pErrorCode) {
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return;
}
if((length>0 && array==NULL) || length<0 || ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq 0x1d0(%rsp), %r13
testq %r13, %r13
je 0x1a84ce
cmpl $0x0, (%r13)
jg 0x1a84ce
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r12
testl %esi, %esi
setg %al
testq %rdi, %rdi
sete %cl
testq %r14, %r14
je 0x1a84c6
... | /hunter-packages[P]icu/source/common/uarrsort.cpp |
ucase_toFullLower_63 | U_CAPI int32_t U_EXPORT2
ucase_toFullLower(UChar32 c,
UCaseContextIterator *iter, void *context,
const UChar **pString,
int32_t loc) {
// The sign of the result has meaning, input must be non-negative so that it can be returned as is.
U_ASSERT(c >= 0);
U... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rsi, %r8
movl %edi, %ebx
cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1a9624
movl %ebx, %eax
shrl $0x5, %eax
jmp 0x1a9644
cmpl $0xffff, %ebx # imm = 0xFFFF
ja 0x1a971d
movl %ebx, %esi
shrl $0x5, %esi
l... | /hunter-packages[P]icu/source/common/ucase.cpp |
toUpperOrTitle(int, int (*)(void*, signed char), void*, char16_t const**, int, signed char) | static int32_t
toUpperOrTitle(UChar32 c,
UCaseContextIterator *iter, void *context,
const UChar **pString,
int32_t loc,
UBool upperNotTitle) {
// The sign of the result has meaning, input must be non-negative so that it can be returned as is.
U_ASSERT(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebx
cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1a9ca2
movl %ebx, %eax
shrl $0x5, %eax
jmp 0x1a9cc2
cmpl $0xffff, %ebx # imm = 0xFFFF
ja 0x1a9dce
movl %ebx, %edx
shrl $0x5, %edx
... | /hunter-packages[P]icu/source/common/ucase.cpp |
ucase_toFullFolding_63 | U_CAPI int32_t U_EXPORT2
ucase_toFullFolding(UChar32 c,
const UChar **pString,
uint32_t options) {
// The sign of the result has meaning, input must be non-negative so that it can be returned as is.
U_ASSERT(c >= 0);
UChar32 result=c;
uint16_t props=UTRIE2_GET16(&... | cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1aa17d
movl %edi, %eax
shrl $0x5, %eax
jmp 0x1aa19d
cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x1aa24f
movl %edi, %ecx
shrl $0x5, %ecx
leal 0x140(%rcx), %eax
cmpl $0xdc00, %edi # imm = 0xDC00
cmovael %ecx, %eax
movl %eax, %eax
leaq 0x6f2ba(%rip), %rcx ... | /hunter-packages[P]icu/source/common/ucase.cpp |
u_enumCharTypes_63 | U_CAPI void U_EXPORT2
u_enumCharTypes(UCharEnumTypeRange *enumRange, const void *context) {
struct _EnumTypeCallback callback;
if(enumRange==NULL) {
return;
}
callback.enumRange=enumRange;
callback.context=context;
utrie2_enum(&propsTrie, _enumTypeValue, _enumTypeRange, &callback);
} | testq %rdi, %rdi
je 0x1aa58b
subq $0x18, %rsp
leaq 0x8(%rsp), %rcx
movq %rdi, (%rcx)
movq %rsi, 0x8(%rcx)
leaq 0x10e09c(%rip), %rdi # 0x2b8610
leaq 0x11(%rip), %rsi # 0x1aa58c
leaq 0x10(%rip), %rdx # 0x1aa592
callq 0x1e00aa
addq $0x18, %rsp
retq
| /hunter-packages[P]icu/source/common/uchar.cpp |
u_getUnicodeProperties_63 | U_CFUNC uint32_t
u_getUnicodeProperties(UChar32 c, int32_t column) {
U_ASSERT(column>=0);
if(column>=propsVectorsColumns) {
return 0;
} else {
uint16_t vecIndex=UTRIE2_GET16(&propsVectorsTrie, c);
return propsVectors[vecIndex+column];
}
} | xorl %eax, %eax
cmpl $0x2, %esi
jg 0x1aa983
cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1aa90c
movl %edi, %eax
shrl $0x5, %eax
jmp 0x1aa955
cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x1aa92a
movl %edi, %ecx
shrl $0x5, %ecx
leal 0x140(%rcx), %eax
cmpl $0xdc00, %edi # imm = 0xDC00
cmovael %ecx, %eax
j... | /hunter-packages[P]icu/source/common/uchar.cpp |
u_isblank_63 | U_CAPI UBool U_EXPORT2
u_isblank(UChar32 c) {
if((uint32_t)c<=0x9f) {
return c==9 || c==0x20; /* TAB or SPACE */
} else {
/* Zs */
uint32_t props;
GET_PROPS(c, props);
return (UBool)(GET_CATEGORY(props)==U_SPACE_SEPARATOR);
}
} | cmpl $0x9f, %edi
ja 0x1aadb8
cmpl $0x9, %edi
sete %cl
cmpl $0x20, %edi
sete %al
orb %cl, %al
retq
cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1aadc7
movl %edi, %eax
shrl $0x5, %eax
jmp 0x1aae10
cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x1aade5
movl %edi, %ecx
shrl $0x5, %ecx
leal 0x140(%rcx), %eax
cmpl $0xdc... | /hunter-packages[P]icu/source/common/uchar.cpp |
u_isgraph_63 | U_CAPI UBool U_EXPORT2
u_isgraph(UChar32 c) {
uint32_t props;
GET_PROPS(c, props);
/* comparing ==0 returns FALSE for the categories mentioned */
return (UBool)((CAT_MASK(props)&
(U_GC_CC_MASK|U_GC_CF_MASK|U_GC_CS_MASK|U_GC_CN_MASK|U_GC_Z_MASK))
==0);
} | cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1aafe3
movl %edi, %eax
shrl $0x5, %eax
jmp 0x1ab02c
cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x1ab001
movl %edi, %ecx
shrl $0x5, %ecx
leal 0x140(%rcx), %eax
cmpl $0xdc00, %edi # imm = 0xDC00
cmovael %ecx, %eax
jmp 0x1ab02c
movl $0x11f4, %eax # i... | /hunter-packages[P]icu/source/common/uchar.cpp |
u_isIDIgnorable_63 | U_CAPI UBool U_EXPORT2
u_isIDIgnorable(UChar32 c) {
if(c<=0x9f) {
return u_isISOControl(c) && !IS_THAT_ASCII_CONTROL_SPACE(c);
} else {
uint32_t props;
GET_PROPS(c, props);
return (UBool)(GET_CATEGORY(props)==U_FORMAT_CHAR);
}
} | cmpl $0x9f, %edi
jg 0x1ab1fe
seta %cl
leal -0x20(%rdi), %eax
cmpl $0x5f, %eax
setb %dl
orb %cl, %dl
je 0x1ab20d
xorl %eax, %eax
retq
cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1ab21f
movl %edi, %eax
shrl $0x5, %eax
jmp 0x1ab268
cmpl $-0x17, %eax
setb %cl
addl $-0xe, %edi
cmpl $0xe, %edi
setb %al
orb %cl, %al
retq... | /hunter-packages[P]icu/source/common/uchar.cpp |
u_charDigitValue_63 | U_CAPI int32_t U_EXPORT2
u_charDigitValue(UChar32 c) {
uint32_t props;
int32_t value;
GET_PROPS(c, props);
value=(int32_t)GET_NUMERIC_TYPE_VALUE(props)-UPROPS_NTV_DECIMAL_START;
if(value<=9) {
return value;
} else {
return -1;
}
} | cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x1ab3ab
movl %edi, %eax
shrl $0x5, %eax
jmp 0x1ab3f4
cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x1ab3c9
movl %edi, %ecx
shrl $0x5, %ecx
leal 0x140(%rcx), %eax
cmpl $0xdc00, %edi # imm = 0xDC00
cmovael %ecx, %eax
jmp 0x1ab3f4
movl $0x11f4, %eax # i... | /hunter-packages[P]icu/source/common/uchar.cpp |
u_digit_63 | U_CAPI int32_t U_EXPORT2
u_digit(UChar32 ch, int8_t radix) {
int8_t value;
if((uint8_t)(radix-2)<=(36-2)) {
value=(int8_t)u_charDigitValue(ch);
if(value<0) {
/* ch is not a decimal digit, try latin letters */
if(ch>=0x61 && ch<=0x7A) {
value=(int8_t)(ch-0x... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
leal -0x2(%rbx), %ecx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $0x22, %cl
ja 0x1ab615
movl %edi, %r14d
callq 0x1ab39c
testb %al, %al
jns 0x1ab615
leal -0x61(%r14), %ecx
cmpl $0x19, %ecx
ja 0x1ab5f9
addl $-0x57, ... | /hunter-packages[P]icu/source/common/uchar.cpp |
uchar_addPropertyStarts_63 | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x1ab8ae
retq
pushq %rbx
movq %rdi, %rbx
leaq 0x10cd57(%rip), %rdi # 0x2b8610
leaq 0x1bb(%rip), %rdx # 0x1aba7b
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1e00aa
movq (%rbx), %rdi
movl $0x9, %esi
callq *0x8(%rbx)
movq (%rbx), %rdi
movl $0xa, %esi
callq *0x8(%rbx)
movq (%rbx), %rdi
movl $0xe,... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::UCharsTrie::current() const | UStringTrieResult
UCharsTrie::current() const {
const UChar *pos=pos_;
if(pos==NULL) {
return USTRINGTRIE_NO_MATCH;
} else {
int32_t node;
return (remainingMatchLength_<0 && (node=*pos)>=kMinValueLead) ?
valueResult(node) : USTRINGTRIE_NO_VALUE;
}
} | movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x1abad1
movl $0x1, %eax
cmpl $0x0, 0x18(%rdi)
js 0x1abad4
retq
xorl %eax, %eax
retq
movzwl (%rcx), %ecx
cmpl $0x40, %ecx
jb 0x1abad0
shrl $0xf, %ecx
xorl $0x3, %ecx
movl %ecx, %eax
retq
nop
| /hunter-packages[P]icu/source/common/ucharstrie.cpp |
icu_63::UCharsTrie::next(int) | UStringTrieResult
UCharsTrie::next(int32_t uchar) {
const UChar *pos=pos_;
if(pos==NULL) {
return USTRINGTRIE_NO_MATCH;
}
int32_t length=remainingMatchLength_; // Actual remaining match length minus 1.
if(length>=0) {
// Remaining part of a linear-match node.
if(uchar==*pos+... | movl %esi, %edx
movq 0x10(%rdi), %rsi
xorl %eax, %eax
testq %rsi, %rsi
je 0x1abbaf
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
js 0x1abd86
movzwl (%rsi), %r8d
cmpl %edx, %r8d
jne 0x1abba7
addq $0x2, %rsi
movl $0x1, %eax
subl $0x1, %ecx
movl %ecx, 0x18(%rdi)
movq %rsi, 0x10(%rdi)
jae 0x1abbaf
movzwl (%rsi), %ecx
cmpl $0x40, ... | /hunter-packages[P]icu/source/common/ucharstrie.cpp |
icu_63::UCharsTrie::findUniqueValueFromBranch(char16_t const*, int, signed char, int&) | const UChar *
UCharsTrie::findUniqueValueFromBranch(const UChar *pos, int32_t length,
UBool haveUniqueValue, int32_t &uniqueValue) {
while(length>kMaxBranchLinearSubNodeLength) {
++pos; // ignore the comparison unit
if(NULL==findUniqueValueFromBranch(jumpByDelt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %r13
cmpl $0x6, %esi
jl 0x1ac07f
movsbl %r15b, %eax
movl %eax, 0x4(%rsp)
leaq 0x4(%r13), %r12
movzwl 0x2(%r13), %eax
cmpl $0xfc00, %eax # imm = 0xFC00
jb 0x1ac014
cmpl $0xf... | /hunter-packages[P]icu/source/common/ucharstrie.cpp |
icu_63::UCharsTrie::getNextUChars(icu_63::Appendable&) const | int32_t
UCharsTrie::getNextUChars(Appendable &out) const {
const UChar *pos=pos_;
if(pos==NULL) {
return 0;
}
if(remainingMatchLength_>=0) {
out.appendCodeUnit(*pos); // Next unit of a pending linear-match node.
return 1;
}
int32_t node=*pos++;
if(node>=kMinValueLead... | movq 0x10(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x1ac27b
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0x18(%rdi)
js 0x1ac27c
movzwl (%rcx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2(%rcx), %r14
movzwl (%rcx), %ebp
cmpl $... | /hunter-packages[P]icu/source/common/ucharstrie.cpp |
icu_63::UCharsTrieElement::setTo(icu_63::UnicodeString const&, int, icu_63::UnicodeString&, UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%r8)
jle 0x1ac3ef
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movswl 0x8(%rsi), %eax
testw %ax, %ax
jns 0x1ac410
movl 0xc(%r14), %eax
jmp 0x1ac413
sarl $0x5, %eax
cmpl $0x10000, %eax # imm = 0x10000
jl 0x1ac423
movl $0x... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::UCharsTrieBuilder::UCharsTrieBuilder(UErrorCode&) | UCharsTrieBuilder::UCharsTrieBuilder(UErrorCode & /*errorCode*/)
: elements(NULL), elementsCapacity(0), elementsLength(0),
uchars(NULL), ucharsCapacity(0), ucharsLength(0) {} | pushq %rbx
movq %rdi, %rbx
callq 0x1ee040
leaq 0x10c148(%rip), %rax # 0x2b86c0
movq %rax, (%rbx)
leaq 0x111cc6(%rip), %rax # 0x2be248
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movw $0x2, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
popq %rbx
retq
nop
| /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharsTrieBuilder::countElementUnits(int, int, int) const | int32_t
UCharsTrieBuilder::countElementUnits(int32_t start, int32_t limit, int32_t unitIndex) const {
int32_t length=0; // Number of different units at unitIndex.
int32_t i=start;
do {
UChar unit=elements[i++].charAt(unitIndex, strings);
while(i<limit && unit==elements[i].charAt(unitIndex, ... | movswl 0x18(%rdi), %eax
testw %ax, %ax
jns 0x1acb6d
movl 0x1c(%rdi), %r8d
jmp 0x1acb74
movl %eax, %r8d
sarl $0x5, %r8d
testb $0x2, %al
jne 0x1acb7e
movq 0x28(%rdi), %r9
jmp 0x1acb82
leaq 0x1a(%rdi), %r9
pushq %rbp
pushq %rbx
movq 0x50(%rdi), %rdi
incl %ecx
movslq %edx, %rdx
xorl %eax, %eax
movslq %esi, %r10
movl (%rdi,... | /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharsTrieBuilder::indexOfElementWithNextUnit(int, int, char16_t) const | int32_t
UCharsTrieBuilder::indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, UChar unit) const {
while(unit==elements[i].charAt(unitIndex, strings)) {
++i;
}
return i;
} | movswl 0x18(%rdi), %eax
testw %ax, %ax
jns 0x1acc6f
movl 0x1c(%rdi), %r8d
jmp 0x1acc76
movl %eax, %r8d
sarl $0x5, %r8d
testb $0x2, %al
jne 0x1acc80
movq 0x28(%rdi), %r9
jmp 0x1acc84
leaq 0x1a(%rdi), %r9
incl %edx
movslq %esi, %rsi
leal -0x1(%rsi), %eax
shlq $0x3, %rsi
addq 0x50(%rdi), %rsi
movl (%rsi), %r10d
addl %edx,... | /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharsTrieBuilder::UCTLinearMatchNode::operator==(icu_63::StringTrieBuilder::Node const&) const | UBool
UCharsTrieBuilder::UCTLinearMatchNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
}
if(!LinearMatchNode::operator==(other)) {
return FALSE;
}
const UCTLinearMatchNode &o=(const UCTLinearMatchNode &)other;
return 0==u_memcmp(s, o.s, length);
} | cmpq %rsi, %rdi
je 0x1acd65
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1eeefe
testb %al, %al
je 0x1acd68
movq 0x28(%rbx), %rdi
movq 0x28(%r14), %rsi
movl 0x18(%rbx), %edx
callq 0x1d832f
testl %eax, %eax
sete %al
jmp 0x1acd6a
movb $0x1, %al
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
pop... | /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharsTrieBuilder::ensureCapacity(int) | UBool
UCharsTrieBuilder::ensureCapacity(int32_t length) {
if(uchars==NULL) {
return FALSE; // previous memory allocation had failed
}
if(length>ucharsCapacity) {
int32_t newCapacity=ucharsCapacity;
do {
newCapacity*=2;
} while(newCapacity<=length);
UChar ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x60(%rdi)
je 0x1acf3d
movq %rdi, %rbx
movl 0x68(%rdi), %r15d
movb $0x1, %bpl
cmpl %esi, %r15d
jge 0x1acf5a
movl %r15d, %eax
leal (%rax,%rax), %r15d
cmpl %esi, %r15d
jle 0x1acef7
shll $0x2, %eax
movslq %eax, %rdi
callq 0x186790
testq %rax, %rax
je 0x1acf... | /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharsTrieBuilder::writeValueAndFinal(int, signed char) | int32_t
UCharsTrieBuilder::writeValueAndFinal(int32_t i, UBool isFinal) {
if(0<=i && i<=UCharsTrie::kMaxOneUnitValue) {
return write(i|(isFinal<<15));
}
UChar intUnits[3];
int32_t length;
if(i<0 || i>UCharsTrie::kMaxTwoUnitValue) {
intUnits[0]=(UChar)(UCharsTrie::kThreeUnitValueLead)... | cmpl $0x3fff, %esi # imm = 0x3FFF
ja 0x1ad049
movsbl %dl, %eax
shll $0xf, %eax
orl %esi, %eax
movq (%rdi), %rcx
movq 0x78(%rcx), %rcx
movl %eax, %esi
jmpq *%rcx
pushq %rax
movl %esi, %ecx
shrl $0x10, %ecx
cmpl $0x3fff0000, %esi # imm = 0x3FFF0000
jb 0x1ad068
movw %si, 0x6(%rsp)
movl $0x3, %eax
movw $0x7... | /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharsTrieBuilder::writeDeltaTo(int) | int32_t
UCharsTrieBuilder::writeDeltaTo(int32_t jumpTarget) {
int32_t i=ucharsLength-jumpTarget;
U_ASSERT(i>=0);
if(i<=UCharsTrie::kMaxOneUnitDelta) {
return write(i);
}
UChar intUnits[3];
int32_t length;
if(i<=UCharsTrie::kMaxTwoUnitDelta) {
intUnits[0]=(UChar)(UCharsTrie::k... | movl %esi, %eax
movl 0x6c(%rdi), %esi
subl %eax, %esi
cmpl $0xfbff, %esi # imm = 0xFBFF
jg 0x1ad11c
movq (%rdi), %rax
movq 0x78(%rax), %rax
jmpq *%rax
pushq %rax
movl %esi, %ecx
shrl $0x10, %ecx
cmpl $0x3feffff, %esi # imm = 0x3FEFFFF
ja 0x1ad137
orl $0xfc00, %ecx # imm = 0xFC00
movl $0x1, %e... | /hunter-packages[P]icu/source/common/ucharstriebuilder.cpp |
icu_63::UCharCharacterIterator::setIndex(int) | UChar
UCharCharacterIterator::setIndex(int32_t position) {
if(position < begin) {
pos = begin;
} else if(position > end) {
pos = end;
} else {
pos = position;
}
if(pos < end) {
return text[pos];
} else {
return DONE;
}
} | movl 0x10(%rdi), %ecx
cmpl %esi, %ecx
jle 0x1add1d
movl %ecx, 0xc(%rdi)
movl 0x14(%rdi), %edx
jmp 0x1add31
movl 0x14(%rdi), %edx
cmpl %esi, %edx
jge 0x1add2c
movl %edx, 0xc(%rdi)
movw $0xffff, %ax # imm = 0xFFFF
retq
movl %esi, 0xc(%rdi)
movl %esi, %ecx
movw $0xffff, %ax # imm = 0xFFFF
cmpl %edx, ... | /hunter-packages[P]icu/source/common/uchriter.cpp |
icu_63::UCharCharacterIterator::first32() | UChar32
UCharCharacterIterator::first32() {
pos = begin;
if(pos < end) {
int32_t i = pos;
UChar32 c;
U16_NEXT(text, i, end, c);
return c;
} else {
return DONE;
}
} | movslq 0x10(%rdi), %rcx
movl %ecx, 0xc(%rdi)
movl 0x14(%rdi), %edx
movl $0xffff, %eax # imm = 0xFFFF
cmpl %edx, %ecx
jge 0x1ade26
movq 0x18(%rdi), %rsi
movzwl (%rsi,%rcx,2), %eax
movl %eax, %edi
andl $0xfc00, %edi # imm = 0xFC00
cmpl $0xd800, %edi # imm = 0xD800
jne 0x1ade26
incl %ecx
cmpl... | /hunter-packages[P]icu/source/common/uchriter.cpp |
icu_63::UCharCharacterIterator::last32() | UChar32
UCharCharacterIterator::last32() {
pos = end;
if(pos > begin) {
UChar32 c;
U16_PREV(text, begin, pos, c);
return c;
} else {
return DONE;
}
} | movslq 0x14(%rdi), %rcx
movl %ecx, 0xc(%rdi)
movl 0x10(%rdi), %edx
movl $0xffff, %eax # imm = 0xFFFF
cmpl %edx, %ecx
jle 0x1adee8
movq 0x18(%rdi), %rsi
leaq -0x1(%rcx), %r8
movl %r8d, 0xc(%rdi)
movzwl -0x2(%rsi,%rcx,2), %eax
cmpl %edx, %r8d
jle 0x1adee8
movl %eax, %edx
andl $0xfc00, %edx # imm = 0xF... | /hunter-packages[P]icu/source/common/uchriter.cpp |
icu_63::UCharCharacterIterator::current32() const | UChar32
UCharCharacterIterator::current32() const {
if (pos >= begin && pos < end) {
UChar32 c;
U16_GET(text, begin, pos, end, c);
return c;
} else {
return DONE;
}
} | movslq 0xc(%rdi), %rcx
movl 0x10(%rdi), %edx
movl $0xffff, %eax # imm = 0xFFFF
cmpl %edx, %ecx
jl 0x1ae015
movl 0x14(%rdi), %r8d
cmpl %r8d, %ecx
jge 0x1ae015
movq 0x18(%rdi), %rsi
movzwl (%rsi,%rcx,2), %eax
movl %eax, %edi
andl $0xf800, %edi # imm = 0xF800
cmpl $0xd800, %edi # imm = 0xD800... | /hunter-packages[P]icu/source/common/uchriter.cpp |
icu_63::UCharCharacterIterator::next32PostInc() | UChar32
UCharCharacterIterator::next32PostInc() {
if (pos < end) {
UChar32 c;
U16_NEXT(text, pos, end, c);
return c;
} else {
return DONE;
}
} | movslq 0xc(%rdi), %rcx
movl 0x14(%rdi), %edx
movl $0xffff, %eax # imm = 0xFFFF
cmpl %edx, %ecx
jge 0x1ae10d
movq 0x18(%rdi), %rsi
leal 0x1(%rcx), %r8d
movl %r8d, 0xc(%rdi)
movzwl (%rsi,%rcx,2), %eax
movl %eax, %r9d
andl $0xfc00, %r9d # imm = 0xFC00
cmpl $0xd800, %r9d # imm = 0xD800
jne 0x1... | /hunter-packages[P]icu/source/common/uchriter.cpp |
icu_63::UCharCharacterIterator::move(int, icu_63::CharacterIterator::EOrigin) | int32_t
UCharCharacterIterator::move(int32_t delta, CharacterIterator::EOrigin origin) {
switch(origin) {
case kStart:
pos = begin + delta;
break;
case kCurrent:
pos += delta;
break;
case kEnd:
pos = end + delta;
break;
default:
break;
}
... | movl %esi, %eax
testl %edx, %edx
je 0x1ae184
cmpl $0x1, %edx
je 0x1ae17f
cmpl $0x2, %edx
jne 0x1ae18c
addl 0x14(%rdi), %eax
jmp 0x1ae187
addl 0xc(%rdi), %eax
jmp 0x1ae187
addl 0x10(%rdi), %eax
movl %eax, 0xc(%rdi)
jmp 0x1ae18f
movl 0xc(%rdi), %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
jl 0x1ae19d
movl 0x14(%rdi), %ecx
... | /hunter-packages[P]icu/source/common/uchriter.cpp |
icu_63::UCharCharacterIterator::setText(icu_63::ConstChar16Ptr, int) | void UCharCharacterIterator::setText(ConstChar16Ptr newText,
int32_t newTextLength) {
text = newText;
if(newText == 0 || newTextLength < 0) {
newTextLength = 0;
}
end = textLength = newTextLength;
pos = begin = 0;
} | xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
movq (%rsi), %rcx
testq %rcx, %rcx
cmovel %eax, %edx
movq %rcx, 0x18(%rdi)
movl %edx, 0x8(%rdi)
movl %edx, 0x14(%rdi)
movq $0x0, 0xc(%rdi)
retq
nop
| /hunter-packages[P]icu/source/common/uchriter.cpp |
ucln_lib_cleanup_63 | U_CFUNC UBool ucln_lib_cleanup(void) {
int32_t libType = UCLN_START;
int32_t commonFunc = UCLN_COMMON_START;
for (libType++; libType<UCLN_COMMON; libType++) {
ucln_cleanupOne(static_cast<ECleanupLibraryType>(libType));
}
for (commonFunc++; commonFunc<UCLN_COMMON_COUNT; commonFunc++) {
... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x1866b4(%rip), %r14 # 0x334b00
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x1ae45f
callq *%rax
movq $0x0, (%rbx,%r14)
addq $0x8, %rbx
cmpq $0x40, %rbx
jne 0x1ae44c
xorl %ebx, %ebx
leaq 0x1866ce(%rip), %r14 # 0x334b40
movq (%rbx,%r14), %rax
testq %rax, %rax
je... | /hunter-packages[P]icu/source/common/ucln_cmn.cpp |
ucptrie_internalU8PrevIndex_63 | U_CAPI int32_t U_EXPORT2
ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c,
const uint8_t *start, const uint8_t *src) {
int32_t i, length;
// Support 64-bit pointers by avoiding cast of arbitrary difference.
if ((src - start) <= 7) {
i = length = (int32_t)(src - ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
movq %rdi, %rbx
leaq -0x7(%rcx), %rdi
subq %rdx, %rcx
cmpq $0x8, %rcx
movl $0x7, %ebp
cmovll %ecx, %ebp
cmovlq %rdx, %rdi
leaq 0xc(%rsp), %r14
movl %ebp, (%r14)
xorl %esi, %esi
movq %r14, %rdx
movl %eax, %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFF... | /hunter-packages[P]icu/source/common/ucptrie.cpp |
ucptrie_internalGetRange_63 | U_CFUNC UChar32
ucptrie_internalGetRange(UCPTrieGetRange *getRange,
const void *trie, UChar32 start,
UCPMapRangeOption option, uint32_t surrogateValue,
UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
if (option == UCPMAP_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %r8d, %eax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r9
movq 0x58(%rsp), %r8
movq 0x50(%rsp), %r15
testl %ecx, %ecx
je 0x1ae950
movl %eax, 0x4(%rsp)
testq %r8, %r8
leaq 0x14(%rsp), %r13
cmovneq %r8, %r13
xorl %ebx, ... | /hunter-packages[P]icu/source/common/ucptrie.cpp |
ucptrie_toBinary_63 | U_CAPI int32_t U_EXPORT2
ucptrie_toBinary(const UCPTrie *trie,
void *data, int32_t capacity,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
return 0;
}
UCPTrieType type = (UCPTrieType)trie->type;
UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, (%rcx)
jg 0x1af007
movl %edx, %eax
testl %edx, %edx
js 0x1aef2c
movq %rsi, %r15
movq %rdi, %r14
movb 0x1e(%rdi), %sil
cmpb $0x1, %sil
ja 0x1aef2c
movb 0x1f(%r14), %dil
cmpb $0x2, %dil
ja 0x1aef2c
testl %eax, %eax
je 0x1aef07
testq %r15, %... | /hunter-packages[P]icu/source/common/ucptrie.cpp |
idForLocale(char const*, char*, int, UErrorCode*) | static uint32_t
idForLocale(const char* locale, char* countryAndVariant, int capacity, UErrorCode* ec)
{
uint32_t variantType = 0;
// !!! this is internal only, assumes buffer is not null and capacity is sufficient
// Extract the country name and variant name. We only
// recognize two variant names, EU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %ebp, %ebp
xorl %esi, %esi
movq %rbx, %rdx
movl $0x9d, %ecx
movq %r14, %r8
callq 0x18ed11
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x9d, %edx
movq %r14, %rcx
callq 0x1b858c
cmpb $0x0... | /hunter-packages[P]icu/source/common/ucurr.cpp |
getCacheEntry(char const*, UErrorCode&) | static CurrencyNameCacheEntry*
getCacheEntry(const char* locale, UErrorCode& ec) {
int32_t total_currency_name_count = 0;
CurrencyNameStruct* currencyNames = NULL;
int32_t total_currency_symbol_count = 0;
CurrencyNameStruct* currencySymbols = NULL;
CurrencyNameCacheEntry* cacheEntry = NULL;
um... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, 0x40(%rsp)
movq %rdi, %r15
leaq 0x1851dc(%rip), %rdi # 0x334ca0
callq 0x1c031c
xorl %ebx, %ebx
leaq 0x18516e(%rip), %r14 # 0x334c40
movq (%rbx,%r14), %rsi
testq %rsi, %rsi
je 0x1afaeb
movq %r15,... | /hunter-packages[P]icu/source/common/ucurr.cpp |
findMetaData(char16_t const*, UErrorCode&) | static const int32_t*
_findMetaData(const UChar* currency, UErrorCode& ec) {
if (currency == 0 || *currency == 0) {
if (U_SUCCESS(ec)) {
ec = U_ILLEGAL_ARGUMENT_ERROR;
}
return LAST_RESORT_DATA;
}
// Get CurrencyMeta resource out of root locale file. [This may
// m... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1b0942
movq %rdi, %r15
cmpw $0x0, (%rdi)
je 0x1b0942
leaq 0x4f68a(%rip), %rdi # 0x1fff8c
leaq 0x8e6f7(%rip), %rsi # 0x23f000
movq %rbx, %rdx
callq 0x1cf5e5
leaq 0x8e728(%rip), %rsi # 0x23f040
movq %... | /hunter-packages[P]icu/source/common/ucurr.cpp |
ucurr_isAvailable_63 | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x1b0abd
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x1841f5(%rip), %eax # 0x334ccc
cmpl $0x2, %eax
je 0x1b0bb9
leaq 0x1841e5(%rip), %rdi # 0x334ccc
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rs... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
ucurr_countCurrencies_63 | U_CAPI int32_t U_EXPORT2
ucurr_countCurrencies(const char* locale,
UDate date,
UErrorCode* ec)
{
int32_t currCount = 0;
if (ec != NULL && U_SUCCESS(*ec))
{
// local variables
UErrorCode localStatus = U_ZERO_ERROR;
char id[ULOC_FULLNAME_CAPACITY];... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
testq %rsi, %rsi
je 0x1b114e
movq %rsi, %rbx
cmpl $0x0, (%rsi)
jg 0x1b114e
movq %rdi, %r14
movsd %xmm0, 0x10(%rsp)
leaq 0x4(%rsp), %r8
movl $0x0, (%r8)
leaq 0x4c201(%rip), %rsi # 0x1fd152
leaq 0x30(%rsp), %r15
movq %r15, %rdx
movl $0... | /hunter-packages[P]icu/source/common/ucurr.cpp |
currency_cleanup() | static void cleanup(void) {
while (gCRegHead) {
CReg* n = gCRegHead;
gCRegHead = gCRegHead->next;
delete n;
}
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0x183252(%rip), %rdi # 0x334c30
testq %rdi, %rdi
je 0x1b19f4
movq (%rdi), %rax
movq %rax, 0x183243(%rip) # 0x334c30
callq 0x1cc4b8
jmp 0x1b19d7
xorl %ebx, %ebx
leaq 0x183243(%rip), %r14 # 0x334c40
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x1b1a13
callq 0x1b1a84
movq $0x0... | /hunter-packages[P]icu/source/common/ucurr.cpp |
toUpperCase(char16_t const*, int, char const*) | static UChar*
toUpperCase(const UChar* source, int32_t len, const char* locale) {
UChar* dest = NULL;
UErrorCode ec = U_ZERO_ERROR;
int32_t destLen = u_strToUpper(dest, 0, source, len, locale, &ec);
ec = U_ZERO_ERROR;
dest = (UChar*)uprv_malloc(sizeof(UChar) * MAX(destLen, len));
u_strToUpper(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x4(%rsp), %r12
movl %eax, (%r12)
xorl %r13d, %r13d
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x1d63df
movl %eax, %e... | /hunter-packages[P]icu/source/common/ucurr.cpp |
ucurr_nextCurrencyList(UEnumeration*, int*, UErrorCode*) | static const char* U_CALLCONV
ucurr_nextCurrencyList(UEnumeration *enumerator,
int32_t* resultLength,
UErrorCode * /*pErrorCode*/)
{
UCurrencyContext *myContext = (UCurrencyContext *)(enumerator->context);
/* Find the next in the list that matches the type we are... | movq 0x8(%rdi), %rax
movl 0x4(%rax), %ecx
cmpl $0x130, %ecx # imm = 0x130
movl $0x12f, %edx # imm = 0x12F
cmovael %ecx, %edx
movq %rcx, %rdi
shlq $0x4, %rdi
leaq 0x10668f(%rip), %r8 # 0x2b8940
addq %rdi, %r8
addq $0x8, %r8
cmpq %rcx, %rdx
je 0x1b22f6
movq %r8, %rdi
leal 0x1(%rcx), %r8d
movl %r... | /hunter-packages[P]icu/source/common/ucurr.cpp |
CReg::unreg(void const*) | static UBool unreg(UCurrRegistryKey key) {
UBool found = FALSE;
umtx_lock(&gCRegLock);
CReg** p = &gCRegHead;
while (*p) {
if (*p == key) {
*p = ((CReg*)key)->next;
delete (CReg*)key;
found = TRUE;
break;
... | pushq %rbx
movq %rdi, %rbx
leaq 0x182829(%rip), %rdi # 0x334c08
callq 0x1c031c
leaq 0x182845(%rip), %rcx # 0x334c30
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1b240d
cmpq %rbx, %rcx
jne 0x1b23eb
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x1cc4b8
movb $0x1, %bl
jmp 0x1b240f
xorl %ebx, ... | /hunter-packages[P]icu/source/common/ucurr.cpp |
CReg::CReg(char16_t const*, char const*) | CReg(const UChar* _iso, const char* _id)
: next(0)
{
int32_t len = (int32_t)uprv_strlen(_id);
if (len > (int32_t)(sizeof(id)-1)) {
len = (sizeof(id)-1);
}
uprv_strncpy(id, _id, len);
id[len] = 0;
u_memcpy(iso, _iso, ISO_CURRENCY_CODE_LENGTH);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rdi)
movq %rdx, %rdi
callq 0xd9160
movl $0x9c, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
leaq 0x10(%r15), %rdi
movslq %ecx, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0xd91a0
movb $0x0, 0x10(%r15,%r12)
leaq ... | /hunter-packages[P]icu/source/common/ucurr.cpp |
icu_63::UDataPathIterator::next(UErrorCode*) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x1b26b0
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x70(%rdi), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %r13
testq %r13, %r13
je 0x1b2809
cmpq 0x30(%r15), %r13
je 0x1b2701
movq %r13, %rdi
movl $0x3a, %esi
ca... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
setCommonICUData(UDataMemory*, signed char, UErrorCode*) | static UBool
setCommonICUData(UDataMemory *pData, /* The new common data. Belongs to caller, we copy it. */
UBool warn, /* If true, set USING_DEFAULT warning if ICUData was */
/* changed by another thread before we got to it. */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1b3bb7
cmpl $0x0, (%rbx)
jle 0x1b295a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
call... | /hunter-packages[P]icu/source/common/udata.cpp |
udata_cacheDataItem(char const*, UDataMemory*, UErrorCode*) | static UDataMemory *udata_cacheDataItem(const char *path, UDataMemory *item, UErrorCode *pErr) {
DataCacheElement *newElement;
const char *baseName;
int32_t nameLen;
UHashtable *htable;
DataCacheElement *oldValue = NULL;
UErrorCode subErr = U_ZERO_ERROR;
htable ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movl $0x0, 0xc(%rsp)
movq %rdx, %rdi
callq 0x1b3477
cmpl $0x0, (%r14)
jg 0x1b2ac6
movq %rax, %r15
movl $0x10, %edi
callq 0x186790
testq %rax, %rax
je 0x1b2abf
movq %rax, %rbx
movq %r14, %rdi
callq 0x1... | /hunter-packages[P]icu/source/common/udata.cpp |
doOpenChoice(char const*, char const*, char const*, signed char (*)(void*, char const*, char const*, UDataInfo const*), void*, UErrorCode*) | static UDataMemory *
doOpenChoice(const char *path, const char *type, const char *name,
UDataMemoryIsAcceptable *isAcceptable, void *context,
UErrorCode *pErrorCode)
{
UDataMemory *retVal = NULL;
const char *dataPath;
int32_t tocEntrySuffixIndex;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %rbp
movl $0x0, 0xc(%rsp)
testq %rdi, %rdi
je 0x1b2c6a
leaq 0x8c464(%rip), %rsi # 0x23f085
movq %rbp... | /hunter-packages[P]icu/source/common/udata.cpp |
udata_getHashTable(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rdi)
jg 0x1b3507
pushq %rbx
movq %rdi, %rbx
movl 0x1818be(%rip), %eax # 0x334d48
cmpl $0x2, %eax
je 0x1b34fa
leaq 0x1818b2(%rip), %rdi # 0x334d48
callq 0x1c035f
testb %al, %al
je 0x1b34fa
leaq 0x198a(%rip), %rdi # 0x1b4e30
leaq 0x1ad3(%rip), %rsi # 0x1b4f80
xorl %edx, %edx
movq %rbx, %rcx
c... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
udata_findCachedData(char const*, UErrorCode&) | static UDataMemory *udata_findCachedData(const char *path, UErrorCode &err)
{
UHashtable *htable;
UDataMemory *retVal = NULL;
DataCacheElement *el;
const char *baseName;
htable = udata_getHashTable(err);
if (U_FAILURE(err)) {
return NULL;
}
baseName = findB... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1b3477
cmpl $0x0, (%r15)
jle 0x1b3b27
xorl %ebx, %ebx
jmp 0x1b3b69
movq %rax, %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0xd9340
leaq 0x1(%rax), %r15
testq %rax, %rax
cmoveq %rbx, %r15
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1c031... | /hunter-packages[P]icu/source/common/udata.cpp |
UDataMemory_normalizeDataPointer_63 | U_CFUNC const DataHeader *
UDataMemory_normalizeDataPointer(const void *p) {
/* allow the data to be optionally prepended with an alignment-forcing double value */
const DataHeader *pdh = (const DataHeader *)p;
if(pdh==NULL || (pdh->dataHeader.magic1==0xda && pdh->dataHeader.magic2==0x27)) {
return ... | testq %rdi, %rdi
je 0x1b3c18
movq %rdi, %rax
cmpb $-0x26, 0x2(%rdi)
jne 0x1b3c13
cmpb $0x27, 0x3(%rax)
je 0x1b3c17
addq $0x8, %rax
retq
xorl %eax, %eax
retq
| /hunter-packages[P]icu/source/common/udatamem.cpp |
udata_close_63 | U_CAPI void U_EXPORT2
udata_close(UDataMemory *pData) {
if(pData!=NULL) {
uprv_unmapFile(pData);
if(pData->heapAllocated ) {
uprv_free(pData);
} else {
UDataMemory_init(pData);
}
}
} | pushq %rbx
testq %rdi, %rdi
je 0x1b3c73
movq %rdi, %rbx
callq 0x1bde4c
cmpb $0x0, 0x18(%rbx)
je 0x1b3c56
movq %rbx, %rdi
popq %rbx
jmp 0x186846
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
popq %rbx
retq
| /hunter-packages[P]icu/source/common/udatamem.cpp |
udata_swapInvStringBlock_63 | U_CAPI int32_t U_EXPORT2
udata_swapInvStringBlock(const UDataSwapper *ds,
const void *inData, int32_t length, void *outData,
UErrorCode *pErrorCode) {
const char *inChars;
int32_t stringsLength;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
retur... | xorl %eax, %eax
testq %r8, %r8
je 0x1b3dba
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
cmpl $0x0, (%r8)
jg 0x1b3db2
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
testl %ebp, %ebp
sets %cl
orb %dl, %cl
jne 0x1b3d46
testl %ebp, %... | /hunter-packages[P]icu/source/common/udataswp.cpp |
uprv_copyArray32(UDataSwapper const*, void const*, int, void*, UErrorCode*) | static int32_t U_CALLCONV
uprv_copyArray32(const UDataSwapper *ds,
const void *inData, int32_t length, void *outData,
UErrorCode *pErrorCode) {
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return 0;
}
if(ds==NULL || inData==NULL || length<0 || (length&3)!=0 || o... | xorl %eax, %eax
testq %r8, %r8
je 0x1b421e
cmpl $0x0, (%r8)
jle 0x1b421f
retq
pushq %rbx
movl %edx, %ebx
testq %rdi, %rdi
sete %dl
testq %rsi, %rsi
sete %dil
orb %dl, %dil
testl %ebx, %ebx
sets %dl
orb %dil, %dl
jne 0x1b424e
testb $0x3, %bl
sete %dl
testq %rcx, %rcx
setne %dil
testb %dil, %dl
jne 0x1b4257
movl $0x1, (%... | /hunter-packages[P]icu/source/common/udataswp.cpp |
uprv_swapArray16(UDataSwapper const*, void const*, int, void*, UErrorCode*) | static int32_t U_CALLCONV
uprv_swapArray16(const UDataSwapper *ds,
const void *inData, int32_t length, void *outData,
UErrorCode *pErrorCode) {
const uint16_t *p;
uint16_t *q;
int32_t count;
uint16_t x;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
retur... | xorl %eax, %eax
testq %r8, %r8
je 0x1b42e4
cmpl $0x0, (%r8)
jle 0x1b42e5
retq
testq %rdi, %rdi
sete %dil
testq %rsi, %rsi
sete %r9b
orb %dil, %r9b
testl %edx, %edx
sets %dil
orb %r9b, %dil
jne 0x1b4314
testb $0x1, %dl
sete %dil
testq %rcx, %rcx
setne %r9b
testb %r9b, %dil
jne 0x1b431c
movl $0x1, (%r8)
retq
testl %edx, ... | /hunter-packages[P]icu/source/common/udataswp.cpp |
uprv_swapArray64(UDataSwapper const*, void const*, int, void*, UErrorCode*) | static int32_t U_CALLCONV
uprv_swapArray64(const UDataSwapper *ds,
const void *inData, int32_t length, void *outData,
UErrorCode *pErrorCode) {
const uint64_t *p;
uint64_t *q;
int32_t count;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return 0;
}
i... | xorl %eax, %eax
testq %r8, %r8
je 0x1b43bd
cmpl $0x0, (%r8)
jle 0x1b43be
retq
testq %rdi, %rdi
sete %dil
testq %rsi, %rsi
sete %r9b
orb %dil, %r9b
testl %edx, %edx
sets %dil
orb %r9b, %dil
jne 0x1b43ed
testb $0x7, %dl
sete %dil
testq %rcx, %rcx
setne %r9b
testb %r9b, %dil
jne 0x1b43f5
movl $0x1, (%r8)
retq
testl %edx, ... | /hunter-packages[P]icu/source/common/udataswp.cpp |
uenum_close_63 | U_CAPI void U_EXPORT2
uenum_close(UEnumeration* en)
{
if (en) {
if (en->close != NULL) {
if (en->baseContext) {
uprv_free(en->baseContext);
}
en->close(en);
} else { /* this seems dangerous, but we better kill the object */
uprv_free(en... | pushq %rbx
testq %rdi, %rdi
je 0x1b4505
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1b4507
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b44ff
callq 0x186846
movq 0x10(%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *%rax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x186846
| /hunter-packages[P]icu/source/common/uenum.cpp |
uenum_unextDefault_63 | U_CAPI const UChar* U_EXPORT2
uenum_unextDefault(UEnumeration* en,
int32_t* resultLength,
UErrorCode* status)
{
UChar *ustr = NULL;
int32_t len = 0;
if (en->next != NULL) {
const char *cstr = en->next(en, &len, status);
if (cstr != NULL) {
ustr = (UChar*) ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movl $0x0, 0x4(%rsp)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1b4595
movq %rdi, %r14
leaq 0x4(%rsp), %rsi
movq %r15, %rdx
callq *%rax
testq %rax, %rax
je 0x1b45a5
movq %rax, %r12
movl 0x4(%rsp), %eax
leal 0x2(,%rax,2), %esi
movq %... | /hunter-packages[P]icu/source/common/uenum.cpp |
uhash_create(int (*)(UElement), signed char (*)(UElement, UElement), signed char (*)(UElement, UElement), int, UErrorCode*) | U_CAPI void* U_EXPORT2
uhash_put(UHashtable *hash,
void* key,
void* value,
UErrorCode *status) {
UHashTok keyholder, valueholder;
keyholder.pointer = key;
valueholder.pointer = value;
return _uhash_put(hash, keyholder, valueholder,
HINT_KEY_POINTER | H... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%r8)
jle 0x1b4723
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x50, %edi
call... | /hunter-packages[P]icu/source/common/uhash.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.