name string | code string | asm string | file string |
|---|---|---|---|
JSONHandler::JSONHandler() | JSONHandler::JSONHandler() :
m(new Members())
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x180, %edi # imm = 0x180
callq 0x191a0
movq %rax, %r14
leaq 0x128(%rax), %r15
movl $0x138, %edx # imm = 0x138
movq %rax, %rdi
xorl %esi, %esi
callq 0x19350
movq %r15, 0x138(%r14)
movq %r15, 0x140(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%... | /qpdf[P]qpdf/libqpdf/JSONHandler.cc |
MD5::unparse[abi:cxx11]() | std::string
MD5::unparse()
{
this->crypto->MD5_finalize();
Digest digest_val;
digest(digest_val);
return QUtil::hex_encode(std::string(reinterpret_cast<char*>(digest_val), 16));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x24d3e
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
c... | /qpdf[P]qpdf/libqpdf/MD5.cc |
NNTreeIterator::NNTreeIterator(NNTreeImpl&) | NNTreeIterator::NNTreeIterator(NNTreeImpl& impl) :
impl(impl),
item_number(-1)
{
} | leaq 0x1870dd(%rip), %rax # 0x1ac098
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
orl $-0x1, 0x38(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
retq
nop
| /qpdf[P]qpdf/libqpdf/NNTree.cc |
error(QPDF&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void
error(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
{
throw QPDFExc(qpdf_e_damaged_pdf, qpdf.getFilename(), get_description(node), 0, msg);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x19400
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x31b38
movq %rsp, %rdi
movq %r15, %rsi
callq 0x28d7d
movb $0x1, %bpl
pushq $0x5
popq %rsi
leaq 0x20(%rsp), %... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::deepen(QPDFObjectHandle, bool, bool) | bool
NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
{
// Starting at this node, descend through the first or last kid until we reach a node with
// items. If we succeed, return true; otherwise return false and leave path alone.
auto opath = this->path;
bool failed = false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %ecx, 0x3c(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
leaq 0x10(%rdi), %r12
leaq 0xd0(%rsp), %rdi
movq %r12, %rsi
callq 0x28ee8
leaq 0xf0(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::split(QPDFObjectHandle, std::_List_iterator<NNTreeIterator::PathElement>) | void
NNTreeIterator::split(QPDFObjectHandle to_split, std::list<PathElement>::iterator parent)
{
// Split some node along the path to the item pointed to by this iterator, and adjust the
// iterator so it points to the same item.
// In examples, for simplicity, /Nums is shown to just contain numbers instea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, 0x10(%rsp)
cmpl $0x0, 0x38(%rdi)
js 0x26b93
movq %rdx, %r15
movq %rdi, %r14
leaq 0xe7017(%rip), %rsi # 0x10d634
leaq 0xb8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x1b660
leaq 0xa8(%rsp), %rdi
leaq... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::insertAfter(QPDFObjectHandle, QPDFObjectHandle) | void
NNTreeIterator::insertAfter(QPDFObjectHandle key, QPDFObjectHandle value)
{
if (!valid()) {
QTC::TC("qpdf", "NNTree insertAfter inserts first");
impl.insertFirst(key, value);
deepen(impl.oh, true, false);
return;
}
auto items = this->node.getKey(impl.details.itemsKey())... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
js 0x26e60
leaq 0x28(%rbx), %r14
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
call... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::remove() | bool
NNTreeIterator::valid() const
{
return this->item_number >= 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpl $0x0, 0x38(%rdi)
js 0x274d8
movq %rdi, %r12
leaq 0x28(%rdi), %r14
movq 0x8(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc2a84
movq %rbx, ... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::NNTreeImpl(NNTreeDetails const&, QPDF&, QPDFObjectHandle&, bool) | NNTreeImpl::NNTreeImpl(
NNTreeDetails const& details, QPDF& qpdf, QPDFObjectHandle& oh, bool auto_repair) :
details(details),
qpdf(qpdf),
split_threshold(32),
oh(oh),
auto_repair(auto_repair)
{
} | pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rdi, %r14
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movl $0x20, 0x10(%rdi)
addq $0x18, %rdi
movq %rcx, %rsi
callq 0x2905c
movb %bl, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::withinLimits(QPDFObjectHandle, QPDFObjectHandle) | int
NNTreeImpl::withinLimits(QPDFObjectHandle key, QPDFObjectHandle node)
{
int result = 0;
auto limits = node.getKey("/Limits");
if (limits.isArray() && (limits.getArrayNItems() >= 2) &&
details.keyValid(limits.getArrayItem(0)) && details.keyValid(limits.getArrayItem(1))) {
if (details.comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe5de9(%rip), %rsi # 0x10d64a
leaq 0x80(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1b660
leaq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rdx
movq %r15, %rsi
callq 0xc2a84
leaq 0x80(%rsp), %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::repair() | void
NNTreeImpl::repair()
{
auto new_node = QPDFObjectHandle::newDictionary();
new_node.replaceKey(details.itemsKey(), QPDFObjectHandle::newArray());
NNTreeImpl repl(details, qpdf, new_node, false);
for (auto const& i: *this) {
repl.insert(i.first, i.second);
}
this->oh.replaceKey("/Kids... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9c81e
movq %rbx, 0x20(%rsp)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9b194
leaq 0x10(%rsp), %rdi
leaq 0x58(%rs... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
QPDF::writeHGeneric(BitWriter&, QPDF::HGeneric&) | void
QPDF::writeHGeneric(BitWriter& w, HGeneric& t)
{
w.writeBitsInt(t.first_object, 32); // 1
w.writeBits(toULL(t.first_object_offset), 32); // 2
w.writeBitsInt(t.nobjects, 32); // 3
w.writeBitsInt(t.group_length, 32); // 4
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl (%rdx), %esi
pushq $0x20
popq %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x1bfa6
leaq 0x8(%rbx), %rdi
callq 0xbf9c2
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1be94
movl 0x10(%rbx), %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1bfa6
movl... | /qpdf[P]qpdf/libqpdf/QPDF_linearization.cc |
ObjTable<QPDFWriter::NewObject>::element(unsigned long) const | inline T const&
element(size_t idx) const
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < std::vector<T>::size()) {
return std::vector<T>::operator[](idx);
}
if (idx < max_size) {
return sparse_elements.at(idx);
}
thr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movb 0xd4d65(%rip), %al # 0x1b3428
testb %al, %al
je 0xde707
movq (%rsp), %rcx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rcx
jae 0xde6e7
shlq $0x5, %rcx
addq %rcx, %rax
jmp 0xde6ff
cmpq 0xd4d32(%rip), %rcx ... | /qpdf[P]qpdf/libqpdf/qpdf/ObjTable.hh |
QPDF::parse(char const*) | void
QPDF::parse(char const* password)
{
if (password) {
m->encp->provided_password = password;
}
// Find the header anywhere in the first 1024 bytes of the file.
PatternFinder hf(*this, &QPDF::findHeader);
if (!m->file->findFirst("%PDF-", 0, 1024, hf)) {
QTC::TC("qpdf", "QPDF not a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
testq %rsi, %rsi
je 0xdeae4
movq (%rbx), %rax
movq 0x108(%rax), %rdi
addq $0x50, %rdi
callq 0x19df0
leaq 0xd203d(%rip), %r14 # 0x1b0b28
leaq 0xe8(%rsp), %r8
movq %r14, (%r8)
movq %rbx, 0x8(%r... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::reconstruct_xref(QPDFExc&, bool) | void
QPDF::reconstruct_xref(QPDFExc& e, bool found_startxref)
{
if (m->reconstructed_xref) {
// Avoid xref reconstruction infinite loops. This is getting very hard to reproduce because
// qpdf is throwing many fewer exceptions while parsing. Most situations are warnings now.
throw e;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movl %edx, 0x3c(%rsp)
movq %rsi, %r14
movq (%rdi), %rax
cmpb $0x1, 0x2d0(%rax)
je 0xdfe86
movq %rdi, %rbx
movq 0x278(%rax), %rcx
subq 0x270(%rax), %rcx
sarq $0x7, %rcx
addq $0x3e8, %rcx # imm = 0x3E8
... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::removeObject(QPDFObjGen) | void
QPDF::removeObject(QPDFObjGen og)
{
m->xref_table.erase(og);
if (auto cached = m->obj_cache.find(og); cached != m->obj_cache.end()) {
// Take care of any object handles that may be floating around.
cached->second.object->assign_null();
cached->second.object->setObjGen(nullptr, QPDFO... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movl $0x138, %edi # imm = 0x138
addq (%rbx), %rdi
movq %r15, %rsi
callq 0xea3e0
movl $0x1a8, %r14d # imm = 0x1A8
movq (%rbx), %rdi
addq %r14, %rdi
movq %r15, %rsi
callq 0xeaee6
movq %rax, %r15
m... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::resolveXRefTable() | bool
QPDF::resolveXRefTable()
{
bool may_change = !m->reconstructed_xref;
for (auto& iter: m->xref_table) {
if (isUnresolved(iter.first)) {
resolve(iter.first);
if (may_change && m->reconstructed_xref) {
return false;
}
}
}
return true;... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movb 0x2d0(%r15), %bpl
movq 0x150(%r15), %r14
addq $0x140, %r15 # imm = 0x140
cmpq %r15, %r14
je 0xe44b7
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xe44c8
testb %al, %al
je 0xe44aa
movq 0x20(%r14), %rsi
movq %rbx, %rdi... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getAllObjects() | std::vector<QPDFObjectHandle>
QPDF::getAllObjects()
{
// After fixDanglingReferences is called, all objects are in the object cache.
fixDanglingReferences();
std::vector<QPDFObjectHandle> result;
for (auto const& iter: m->obj_cache) {
result.push_back(newIndirect(iter.first, iter.second.object))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xe4b24
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq (%r14), %rbp
movq 0x1c0(%rbp), %r12
addq $0x1b0, %rbp # imm = 0x1B0
leaq 0x10(%rs... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::readObjectInStream(qpdf::is::OffsetBuffer&, int, int) | QPDFObjectHandle
QPDF::readObjectInStream(is::OffsetBuffer& input, int stream_id, int obj_id)
{
auto [object, empty] = QPDFParser::parse(input, stream_id, obj_id, m->tokenizer, *this);
if (empty) {
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
// ac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r8
addq $0x18, %r8
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movl %ebp, %ecx
movq %r14, ... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::resolveObjectsInStream(int) | void
QPDF::resolveObjectsInStream(int obj_stream_number)
{
auto damaged =
[this, obj_stream_number](int id, qpdf_offset_t offset, std::string const& msg) -> QPDFExc {
return {
qpdf_e_damaged_pdf,
m->file->getName() + " object stream " + std::to_string(obj_stream_number),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rdi, 0xa0(%rsp)
movl %esi, 0xa8(%rsp)
movl $0x2d8, %r14d # imm = 0x2D8
movq (%rdi), %rdi
addq %r14, %rdi
movq %rax, %rsi
callq 0x6ff20
testq... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::replaceObject(QPDFObjGen, QPDFObjectHandle) | QPDFObjectHandle
QPDF::readObjectInStream(is::OffsetBuffer& input, int stream_id, int obj_id)
{
auto [object, empty] = QPDFParser::parse(input, stream_id, obj_id, m->tokenizer, *this);
if (empty) {
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
// ac... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, (%rdx)
je 0xe7666
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x99458
testb %al, %al
je 0xe7629
movq %r15, %rdi
callq 0x9874a
testb %al, %al
je 0xe7666
movq %r15, %rdi
callq 0x99ecc
cmpq %rbx, %rax
jne 0xe7666
leaq 0x8(%rs... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::tableSize() | size_t
QPDF::tableSize()
{
// If obj_cache is dense, accommodate all object in tables,else accommodate only original
// objects.
auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
auto m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
xorl %ebp, %ebp
cmpq $0x0, 0x160(%r14)
movl $0x0, %r15d
je 0xe7840
leaq 0x140(%r14), %rdi
callq 0x19c70
movl 0x20(%rax), %r15d
movq 0x1d0(%r14), %r12
testq %r12, %r12
je 0xe785e
addq $0x1b0, %r14 # imm =... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
std::vector<bool, std::allocator<bool>> QPDF::getCompressibleObjGens<bool>() | std::vector<T>
QPDF::getCompressibleObjGens()
{
// Return a list of objects that are allowed to be in object streams. Walk through the objects
// by traversing the document from the root, including a traversal of the pages tree. This
// makes that objects that are on the same page are more likely to be in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movq (%rsi), %rbx
leaq 0x410df(%rip), %rsi # 0x1296d2
leaq 0xe0(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1b660
addq $0x208, %rbx # imm = 0x208
leaq 0xd0(%rsp... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::pushInheritedAttributesToPageInternal(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocato... | void
QPDF::pushInheritedAttributesToPageInternal(
QPDFObjectHandle cur_pages,
std::map<std::string, std::vector<QPDFObjectHandle>>& key_ancestors,
bool allow_changes,
bool warn_skipped_keys)
{
// Make a list of inheritable keys. Only the keys /MediaBox, /CropBox, /Resources, and /Rotate
// are i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %r8d, %ebx
movl %ecx, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
leaq 0xe0(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0,... | /qpdf[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::updateAllPagesCache() | void
QPDF::updateAllPagesCache()
{
// Force regeneration of the pages cache. We force immediate recalculation of all_pages since
// users may have references to it that they got from calls to getAllPages(). We can defer
// recalculation of pageobj_to_pages_pos until needed.
QTC::TC("qpdf", "QPDF updat... | pushq %rbx
movq %rdi, %rbx
movl $0x218, %edi # imm = 0x218
addq (%rbx), %rdi
callq 0x34894
movl $0x238, %edi # imm = 0x238
addq (%rbx), %rdi
callq 0xf154e
movq (%rbx), %rax
movb $0x0, 0x268(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0xef790
nop
| /qpdf[P]qpdf/libqpdf/QPDF_pages.cc |
QPDF::addPageAt(QPDFObjectHandle, bool, QPDFObjectHandle) | void
QPDF::addPageAt(QPDFObjectHandle newpage, bool before, QPDFObjectHandle refpage)
{
int refpos = findPage(refpage);
if (!before) {
++refpos;
}
insertPage(newpage, refpos);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rsi
callq 0xf118e
xorb $0x1, %bl
movzbl %bl, %ebx
addl %eax, %ebx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2905c
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xf0ae0
leaq... | /qpdf[P]qpdf/libqpdf/QPDF_pages.cc |
QPDF::findPage(QPDFObjGen) | int
QPDF::findPage(QPDFObjGen og)
{
flattenPagesTree();
auto it = m->pageobj_to_pages_pos.find(og);
if (it == m->pageobj_to_pages_pos.end()) {
QTC::TC("qpdf", "QPDF_pages findPage not found");
setLastObjectDescription("page object", og);
throw QPDFExc(
qpdf_e_pages,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rsi, (%rbx)
callq 0xf05fa
movl $0x238, %edi # imm = 0x238
addq (%r14), %rdi
movq %rbx, %rsi
callq 0xf17b2
movl $0x240, %ecx # imm = 0x240
addq (%r14), %rcx
cmpq %rcx, %rax
je 0xf13cf
movl 0x28(... | /qpdf[P]qpdf/libqpdf/QPDF_pages.cc |
QTC::TC_real(char const*, char const*, int) | void
QTC::TC_real(char const* const scope, char const* const ccase, int n)
{
static std::map<std::string, bool> active;
auto is_active = active.find(scope);
if (is_active == active.end()) {
active[scope] = tc_active(scope);
is_active = active.find(scope);
}
if (!is_active->second) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movb 0xc1c5e(%rip), %al # 0x1b3468
testb %al, %al
je 0xf1a29
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r15, %rsi
callq 0x1b660
leaq 0xc1c0d(%rip), %rdi # 0x1b3438
leaq 0x8(%rsp), %rsi
... | /qpdf[P]qpdf/libqpdf/QTC.cc |
call_init_write_memory(_qpdf_data*) | static void
call_init_write_memory(qpdf_data qpdf)
{
qpdf->qpdf_writer = std::make_shared<QPDFWriter>(*(qpdf->qpdf));
qpdf->qpdf_writer->setOutputMemory();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1080bf
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x107ef6
leaq 0x10(%rsp), %rdi
callq 0x1cf2a
movq 0x10(%rbx), %rdi
callq 0xb1c78
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r6_encryption_parameters2 | void
qpdf_set_r6_encryption_parameters2(
qpdf_data qpdf,
char const* user_password,
char const* owner_password,
QPDF_BOOL allow_accessibility,
QPDF_BOOL allow_extract,
QPDF_BOOL allow_assemble,
QPDF_BOOL allow_annotate_and_form,
QPDF_BOOL allow_form_filling,
QPDF_BOOL allow_modify_ot... | pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %eax
movl %r8d, %r9d
movl %ecx, %r8d
movl 0x38(%rsp), %r10d
movq 0x10(%rdi), %rdi
xorl %ecx, %ecx
testl %r8d, %r8d
setne %cl
xorl %r8d, %r8d
testl %r9d, %r9d
setne %r8b
xorl %r9d, %r9d
testl %eax, %eax
setne %r9b
xorl %eax, %eax
cmpl $0x0, 0x20(%rsp)
setne %al
xorl %r11d, %r1... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_register_progress_reporter | void
qpdf_register_progress_reporter(
qpdf_data qpdf, void (*report_progress)(int percent, void* data), void* data)
{
QTC::TC("qpdf", "qpdf-c registered progress reporter");
qpdf->qpdf_writer->registerProgressReporter(
std::shared_ptr<QPDFWriter::ProgressReporter>(new QPDFWriter::FunctionProgressRep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq 0x10(%rdi), %r14
pushq $0x28
popq %rdi
callq 0x191a0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x10(%rsp), %rdi
callq 0x107a92
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_key | qpdf_oh
qpdf_oh_get_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf, key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_key");
return new_object(qpdf, o.getKey(key));
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rax
andq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x2086(%rip), %rcx # 0x103b4c
movq %rcx, 0x18(%rax)
leaq 0x2083(%rip), %rcx # 0x103b54
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x4ac2(%rip), %rdx # 0x1065a8
movq %rdx, 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_unicode_string | qpdf_oh
qpdf_oh_new_unicode_string(qpdf_data qpdf, char const* utf8_str)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_unicode_string");
return new_object(qpdf, QPDFObjectHandle::newUnicodeString(utf8_str));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1b660
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x9c3bc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xfe0f3
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1cf2a
leaq 0x18(%rsp), %rdi
callq 0x19e78
mo... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
tnt_object | struct tnt_stream *
tnt_object(struct tnt_stream *s)
{
if ((s = tnt_buf(s)) == NULL)
goto error;
struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
sb->resize = tnt_sbuf_object_resize;
struct tnt_sbuf_object *sbo = tnt_mem_alloc(sizeof(struct tnt_sbuf_object));
if (sbo == NULL)
goto error;
sb->free = tnt_sbuf_ob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e30
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xb7c4
jmp 0xb85f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0xa5(%rip), %rcx # 0xb880
movq %rcx, 0x20(%rax)
movl... | /tarantool[P]tarantool-c/tnt/tnt_object.c |
tnt_sbuf_object_resize | static char *
tnt_sbuf_object_resize(struct tnt_stream *s, size_t size) {
struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
if (sb->size + size > sb->alloc) {
size_t newsize = 2 * (sb->alloc);
if (newsize < sb->size + size)
newsize = sb->size + size;
char *nd = tnt_mem_realloc(sb->data, newsize);
if (nd == NUL... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xb92e
movq -0x20(%rbp), %rax
movq 0x10(%rax),... | /tarantool[P]tarantool-c/tnt/tnt_object.c |
tnt_object_add_int | ssize_t
tnt_object_add_int (struct tnt_stream *s, int64_t value)
{
struct tnt_sbuf_object *sbo = TNT_SOBJ_CAST(s);
if (sbo->stack_size > 0)
sbo->stack[sbo->stack_size - 1].size += 1;
char data[10], *end;
if (value < 0)
end = mp_encode_int(data, value);
else
end = mp_encode_uint(data, value);
return s->write... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0xbb02
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzb... | /tarantool[P]tarantool-c/tnt/tnt_object.c |
tnt_object_add_str | ssize_t
tnt_object_add_str (struct tnt_stream *s, const char *str, uint32_t len)
{
struct tnt_sbuf_object *sbo = TNT_SOBJ_CAST(s);
if (sbo->stack_size > 0)
sbo->stack[sbo->stack_size - 1].size += 1;
struct iovec v[2]; int v_sz = 2;
char data[6], *end;
end = mp_encode_strl(data, len);
v[0].iov_base = data;
v[0]... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0xbba5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq ... | /tarantool[P]tarantool-c/tnt/tnt_object.c |
icetStrategySupportsOrdering | IceTBoolean icetStrategySupportsOrdering(IceTEnum strategy)
{
switch (strategy) {
case ICET_STRATEGY_DIRECT: return ICET_TRUE;
case ICET_STRATEGY_SEQUENTIAL: return ICET_TRUE;
case ICET_STRATEGY_SPLIT: return ICET_FALSE;
case ICET_STRATEGY_REDUCE: return ICET_TRUE;
... | pushq %rax
leal -0x6001(%rdi), %ecx
cmpl $0x4, %ecx
ja 0x134a7
movb $0x1, %al
leaq 0x89a6(%rip), %rdx # 0x1be44
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $-0x1, %edi
jne 0x134c4
leaq 0x8a05(%rip), %rdi # 0x1beb8
leaq 0x8a3a(%rip), %rcx # 0x1bef4
pushq $-0x2
popq %rsi
pushq $0x1
popq %rdx... | /kmorel[P]IceT/src/strategies/select.c |
icetDirectCompose | IceTImage icetDirectCompose(void)
{
IceTImage image;
IceTVoid *inSparseImageBuffer;
IceTSparseImage outSparseImage;
IceTSizeType sparseImageSize;
const IceTInt *contrib_counts;
const IceTInt *display_nodes;
IceTInt max_width, max_height;
IceTInt num_tiles;
IceTInt num_contributors;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x13
popq %rdi
leaq 0x14(%rsp), %r15
movq %r15, %rsi
callq 0x9efa
pushq $0x14
popq %rdi
leaq 0x10(%rsp), %r13
movq %r13, %rsi
callq 0x9efa
pushq $0x10
popq %rdi
leaq 0xc(%rsp), %r12
movq %r12, %rsi
callq 0x9efa
movl (%r15), %edi
m... | /kmorel[P]IceT/src/strategies/direct.c |
icetSequentialCompose | IceTImage icetSequentialCompose(void)
{
IceTInt num_tiles;
IceTInt rank;
IceTInt num_proc;
const IceTInt *display_nodes;
const IceTInt *tile_viewports;
IceTBoolean ordered_composite;
IceTBoolean image_collect;
IceTImage my_image;
IceTInt *compose_group;
int i;
icetGetInteger... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
pushq $0x10
popq %rdi
leaq 0x1c(%rsp), %rsi
callq 0x9efa
pushq $0x2
popq %rdi
leaq 0x18(%rsp), %rsi
callq 0x9efa
pushq $0x3
popq %rdi
leaq 0x14(%rsp), %rsi
callq 0x9efa
pushq $0x1a
popq %rdi
callq 0xa3e6
movq %rax, 0x38(%rsp)
pushq $0x11... | /kmorel[P]IceT/src/strategies/sequential.c |
icetSplitCompose | IceTImage icetSplitCompose(void)
{
IceTInt *tile_groups;
IceTInt my_tile;
IceTInt group_size;
IceTSizeType my_fragment_size;
IceTInt rank;
IceTInt num_proc;
IceTInt num_tiles;
IceTInt max_width, max_height;
const IceTInt *tile_contribs;
IceTInt total_image_count;
IceTInt til... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
pushq $0x2
popq %rdi
leaq 0x3c(%rsp), %rsi
callq 0x9efa
pushq $0x3
popq %rdi
leaq 0x14(%rsp), %rsi
callq 0x9efa
pushq $0x10
popq %rdi
leaq 0x10(%rsp), %rsi
callq 0x9efa
pushq $0x13
popq %rdi
leaq 0x24(%rsp), %rsi
callq 0x9efa
pushq $0x14... | /kmorel[P]IceT/src/strategies/split.c |
std::function<void (std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&)> TasDREAM::posterior<(TasDREAM::TypeSamplingForm)1>(std::function<void (std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&)>, std::function<void (TasDREAM::... | DreamPDF posterior(DreamMergedLikelyModel likelihood_model,
DreamPrior prior){
return [=](const std::vector<double> &candidates, std::vector<double> &values)->void{
likelihood_model(candidates, values);
std::vector<double> prior_vals(values.size());
prior(form, candidates, prior_v... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x9e56
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xd15e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd524
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xc801
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
... | /mkstoyanov[P]TASMANIAN/DREAM/tsgDreamSample.hpp |
czh::error::location_to_str[abi:cxx11](std::source_location const&) | std::string location_to_str(const std::source_location &l)
{
return std::string(l.file_name()) + ":" + std::to_string(l.line()) +
":" + l.function_name() + "()";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0xe78f
movq (%rax), %rsi
jmp 0xe796
leaq 0x55efe(%rip), %rsi # 0x64694
leaq 0xb0(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x10b0c
leaq 0x551c5(%rip), %rdx # 0x63977
leaq 0x30(%rs... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/error.hpp |
czh::utils::grisu_round(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, unsigned long, unsigned long, unsigned long) | void grisu_round(std::string &buffer, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
{
while (rest < wp_w &&
delta - rest >= ten_kappa &&
(rest + ten_kappa < wp_w || /// closer
wp_w - rest > rest + ten_kappa - wp_w))
{
--buffer.back();
rest += t... | subq %rdx, %rsi
movq %rcx, %rax
subq %r8, %rax
movq %r8, %r9
subq %rdx, %r9
cmpq %r8, %rdx
jae 0xea18
subq %rcx, %rsi
jb 0xea18
leaq (%rdx,%rcx), %r10
cmpq %r8, %r10
jb 0xea04
addq %rax, %rdx
cmpq %rdx, %r9
jbe 0xea18
movq (%rdi), %rdx
movq 0x8(%rdi), %r11
decb -0x1(%rdx,%r11)
subq %rcx, %r9
movq %r10, %rdx
jmp 0xe9e9
... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/dtoa.hpp |
czh::utils::grisu2(double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&) | void grisu2(double v, std::string &buffer, int &K)
{
int q = 64, alpha = -59;
auto[w_m, w_p] = DiyFp(v).normalized_boundaries();
DiyFp w = DiyFp(v).normalize();
int mk = k_comp(w_p.e + q, alpha);
DiyFp c_mk = cached_power(mk);
DiyFp W = w * c_mk;
DiyFp Wp = w_p * c_mk;
DiyFp Wm = w_m *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movq %xmm0, %rax
movq %rax, %rcx
shrq $0x34, %rcx
andl $0x7ff, %ecx # imm = 0x7FF
movabsq $0xfffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFF
andq %rdx, %rax
testl %ecx, %ecx
leaq 0x1(%rax,%rdx), %rbx
cmoveq ... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/dtoa.hpp |
czh::utils::fill_exponent(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void fill_exponent(int K, std::string &buffer)
{
if (K < 0)
{
buffer += '-';
K = -K;
}
if (K >= 100)
{
buffer += static_cast<char>(static_cast<int>('0') + K / 100);
K %= 100;
buffer += static_cast<char>(static_cast<int>('0') + K / 10);
K %= 10;
buffer +... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
testl %edi, %edi
jns 0xecf7
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x34dc0
negl %ebp
cmpl $0x64, %ebp
jb 0xed16
pushq $0x64
popq %rcx
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
addb $0x30, %al
movsbl %al, %esi
movl %edx, %ebp
movq %rbx, %rdi
callq 0x3... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/dtoa.hpp |
czh::utils::fill_double[abi:cxx11](double) | std::string fill_double(double v)
{
int K;
std::string buffer;
grisu2(v, buffer, K);
return std::move(prettify_string(buffer, K));
} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0xeb99
movl 0xc(%rsp), %edx
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xed49
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x40(%rsp), ... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/dtoa.hpp |
czh::utils::dtoa[abi:cxx11](double const&) | std::string dtoa(const double &value)
{
if (value == 0 && ((double_to_uint64(value) & SIGN_MASK) != 0))
{
return "-0.0";
}
std::string buffer;
if (value == 0)
{
buffer = "0.0";
}
else
{
buffer = fill_double(std::abs(value));
}
if (value < 0)
{
re... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf067
jp 0xf067
movq %xmm0, %rax
testq %rax, %rax
js 0xf0e8
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
andq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x4de63(%rip... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/dtoa.hpp |
czh::value::details::get_typename[abi:cxx11](unsigned long) | std::string get_typename(size_t sz)
{
static std::vector<std::string>
names{"Null", "int", "long long", "double", "bool", "std::string", "czh::value::Reference",
"czh::value::Array"};
return names[sz];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r12
movq %rdi, %r15
movb 0x889ed(%rip), %al # 0x97b58
testb %al, %al
je 0xf197
shlq $0x5, %r12
addq 0x889c6(%rip), %r12 # 0x97b40
movq %r15, %rdi
movq %r12, %rsi
callq 0x11642
movq %r15, %rax
addq $0x118, %rsp ... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/value.hpp |
czh::utils::colorify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, czh::utils::Color, czh::utils::ColorType) | std::string colorify(const std::string &str, Color with_color, ColorType type)
{
if (with_color == Color::no_color) return str;
switch (get_color(type))
{
case CzhColor::PURPLE:
return "\033[35m" + str + "\033[0m";
case CzhColor::LIGHT_BLUE:
return "\033[36m" + str + "\033[0m";... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0xf367
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11642
jmp 0xf4e4
movl %ecx, 0x58(%rsp)
movb 0x8881f(%rip), %al # 0x97b90
testb %al, %al
je 0xf4f1
leaq 0x887e0(%rip), %rdi # 0x97b60
leaq 0x58(%rsp), %rsi
callq 0... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/utils.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> czh::utils::to_czhstr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, czh::utils::Color) | std::string to_czhstr(const std::string &val, Color color)
{
std::string ret;
for (auto &r: val)
{
switch (r)
{
case '\"':
ret += '\\';
ret += '\"';
break;
case '\\':
ret += '\\';
ret += '\\';
break;
case '\b':... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, 0xc(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, 0x10(%rsp)
movb $0x0, (%rax)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
leaq 0x4a914(%rip), %rbx # 0... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/utils.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> czh::utils::to_czhstr<std::vector<std::variant<czh::value::Null, int, long long, double, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::variant<czh::value::Null, int, long long, dou... | std::string to_czhstr(const value::Array &v, Color color)
{
auto visitor = [&color](auto &&v) -> std::string { return to_czhstr(v, color); };
std::string result = "{";
for (auto it = v.cbegin(); it != std::prev(v.cend()); ++it)
{
result += std::visit(visitor, *it);
result += ",";
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14(%rsp), %rax
movl %edx, (%rax)
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x4d6fe(%rip), %rsi # 0x5d016
leaq 0x18(%rsp), %r12
movq %r12, %rdx
callq 0x10b0c
movq (%r14), %r13
leaq 0x85999(%rip... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/utils.hpp |
czh::utils::get_string_edit_distance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | int get_string_edit_distance(const std::string &s1, const std::string &s2)
{
std::size_t n = s1.size();
std::size_t m = s2.size();
if (n * m == 0) return static_cast<int>(n + m);
std::vector<std::vector<int>> D(n + 1, std::vector<int>(m + 1));
for (int i = 0; i < n + 1; i++)
{
D[i][0] = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %rcx
movq %rsi, 0x20(%rsp)
movq 0x8(%rsi), %rbx
movq %rbx, %rax
imulq %rcx, %rax
testq %rax, %rax
je 0xfb36
movq %rcx, 0x8(%rsp)
leaq 0x1(%rcx), %r12
movq %rbx, 0x10(%rsp)
leaq 0x1(%rbx), %r13
leaq 0... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/utils.hpp |
ws::details::xml_parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string xml_parse(const std::string &xml, const std::string &tag)
{
auto a = xml.find("<" + tag + ">");
auto b = xml.find("</" + tag + ">");
std::string ret;
auto i = a + tag.size() + 2;
ret = xml.substr(i, b - i);
if (ret.substr(0, 9) == "<![CDATA[")
{
a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4d445(%rip), %rsi # 0x5d0dc
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x11592
leaq 0x531ab(%rip), %rdx # 0x62e56
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x10a85
leaq 0x8... | /caozhanhao[P]wxserver/include/wxserver/server.hpp |
czh::node::Node::Node() | Node() : name(""), last_node(nullptr) { data.emplace<NodeData>(); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x52b80(%rip), %rsi # 0x64694
leaq 0x7(%rsp), %rdx
callq 0x10b0c
andq $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x16334
leaq 0x78(%rbx), %r15
movl $0xc, 0x78(%rbx)
movb $0x0, 0xa0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/node.hpp |
czh::node::Node::operator=(czh::node::Node const&) | Node &operator=(const Node &v)
{
name = v.name;
last_node = v.last_node;
czh_token = token::Token(v.czh_token);
if (v.is_node())
{
data.emplace<NodeData>(NodeData(std::get<NodeData>(v.data)));
auto &nd = std::get<NodeData>(data);
for (auto &r: nd.nodes)
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x55098
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
leaq 0x78(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x19d3e
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0x1672e
movq %r15, %rdi
callq 0x1630a
cmpb $0x0, 0x70(%r14)
je 0x11c... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/node.hpp |
czh::error::CzhError::get_content[abi:cxx11]() const | [[nodiscard]] std::string get_content() const
{
return {"\033[1;37m" + location + ": "
+ "\033[0;32;31mError: \033[m" + detail};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsi), %rdx
leaq 0x4b6c4(%rip), %rsi # 0x5d3ce
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x11592
leaq 0x51c40(%rip), %rdx # 0x6395e
movq %rsp, %rdi
movq %r15, %rsi
callq 0x10a85
leaq 0x4be79(%rip), %rdx # 0x5dba9
l... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/error.hpp |
czh::node::Node::Node(czh::node::Node&&) | Node(Node &&node)
: name(std::move(node.name)), last_node(std::move(node.last_node)), czh_token(std::move(node.czh_token)),
data(std::move(node.data))
{
if (is_node())
{
auto &nd = std::get<NodeData>(data);
for (auto &r: nd.nodes)
{
r.last_node = this;... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
callq 0x11558
movq 0x20(%r12), %rax
movq %rax, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x28(%r12), %rsi
movq %r14, %rdi
callq 0x1c2ae
leaq 0x78(%rbx), %r15
addq $0x78, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x16e4a
cmpb $0x0, 0x70(... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/node.hpp |
ws::Server::Server() | Server() : inited(false), port(-1),
new_task_queue([] { return new httplib::ThreadPool(4); }) {} | pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb %al, 0x18(%rdi)
orl $-0x1, 0x28(%rdi)
addq $0x30, %rdi
callq 0x1c316
leaq 0x90(%rbx), %rdi
callq 0x1c348
leaq 0xf8(%rbx), %rdi
callq 0x1c37a
xorps %xmm0, %xmm0
movups %xmm0, 0x408(%rbx)
movu... | /caozhanhao[P]wxserver/include/wxserver/server.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> czh::node::Node::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::source_location const&) const | T get(const std::source_location &l =
std::source_location::current()) const
{
assert_value(l);
auto &value = std::get<Value>(data);
if (value.is<value::Reference>() && typeid(T) != typeid(value::Reference))
{
auto ptr = get_end_of_list_of_ref(value.get<value::Reference>(), l);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1d206
leaq 0x28(%r15), %rdi
callq 0x1c23c
movq %rax, %r12
movb 0x20(%rax), %al
cmpb $0x6, %al
jne 0x128d1
leaq 0x842e8(%rip), %rdi # 0x96ba0
leaq 0x83b01(%r... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/node.hpp |
int czh::node::Node::get<int>(std::source_location const&) const | T get(const std::source_location &l =
std::source_location::current()) const
{
assert_value(l);
auto &value = std::get<Value>(data);
if (value.is<value::Reference>() && typeid(T) != typeid(value::Reference))
{
auto ptr = get_end_of_list_of_ref(value.get<value::Reference>(), l);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d206
leaq 0x28(%r14), %rdi
callq 0x1c23c
movq %rax, %r15
movb 0x20(%rax), %al
cmpb $0x6, %al
jne 0x12bbb
movq 0x843c5(%rip), %rdi # 0x96f68
leaq 0x83816(%rip), %rsi # 0x963c0
callq 0x15a14
testb %al, %al
je 0x1... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/node.hpp |
ws::Server::run() | Server &run()
{
std::unique_ptr<httplib::TaskQueue> task_queue(new_task_queue());
if (!inited)
{
critical(no_fmt, "Not inited.");
}
svr.Get("/",
[this](const httplib::Request &req, httplib::Response &res)
{
auto msg_sig = req.get_para... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
addq $0x408, %rdi # imm = 0x408
callq 0x1de26
movq %rax, 0x8(%rsp)
cmpb $0x0, (%rbx)
jne 0x12e4b
leaq 0x84cfd(%rip), %rsi # 0x97b18
leaq 0x10(%rsp), %rdi
callq 0x11642
leaq 0x82934(%rip), %rax # 0x95760
leaq 0x10(%rsp), %rdi... | /caozhanhao[P]wxserver/include/wxserver/server.hpp |
httplib::detail::SocketStream::read(char*, unsigned long) | inline ssize_t SocketStream::read(char *ptr, size_t size) {
#ifdef _WIN32
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#else
size = (std::min)(size,
static_cast<size_t>((std::numeric_limits<ssize_t>::max)()));
#endif
if (read_buff_off_ < read_buff_con... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %r15, %rdx
cmovbq %rdx, %r15
movq %rdi, %rbx
movq 0x48(%rdi), %rsi
movq 0x50(%rdi), %r13
subq %rsi, %r13
jbe 0x130bd
addq 0x30(%rbx), %rsi
cmpq %r13, %r15
cmovbq %r15, %r13
movq %r14,... | /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
httplib::detail::SocketStream::write(char const*, unsigned long) | inline ssize_t SocketStream::write(const char *ptr, size_t size) {
if (!is_writable()) { return -1; }
#if defined(_WIN32) && !defined(_WIN64)
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#endif
return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1317c
movl 0x8(%r15), %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x4b6bc
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
httplib::detail::BufferStream::read(char*, unsigned long) | inline ssize_t BufferStream::read(char *ptr, size_t size) {
#if defined(_MSC_VER) && _MSC_VER < 1910
auto len_read = buffer._Copy_s(ptr, size, size, position);
#else
auto len_read = buffer.copy(ptr, size, position);
#endif
position += static_cast<size_t>(len_read);
return static_cast<ssize_t>(len_read);
} | pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x28(%rbx), %rcx
callq 0x4b8ae
addq %rax, 0x28(%rbx)
popq %rbx
retq
nop
| /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
httplib::detail::ssl_delete(std::mutex&, ssl_st*, bool) | inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl,
bool shutdown_gracefully) {
// sometimes we may want to skip this to try to avoid SIGPIPE if we know
// the remote has closed the network connection
// Note that it is not always possible to avoid SIGPIPE, this is merely a
// best-ef... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x14173
movq %r14, %rdi
callq 0xd290
movq %rbx, %rdi
callq 0x1cae8
movq %r14, %rdi
callq 0xd110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd310
movq %rax, %r14
movq %rbx, %rdi
callq 0xd310
movq %r14, %rdi
callq 0xd750
| /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
czh::file::NonStreamFile::get_spec_line[abi:cxx11](unsigned long, unsigned long, unsigned long) const | [[nodiscard]] std::string get_spec_line(std::size_t beg, std::size_t end, std::size_t linenosize) const override
{
std::size_t lineno = 1;
bool first_line_flag = true;
bool first_line_no = true;
std::string ret;
for (std::size_t i = 0; i < code.size() && lineno < end; ++i)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r13
movb $0x0, 0x10(%rdi)
movb $0x1, %al
pushq $0x1
popq %rbp
xorl %r14d, %r14d
movb $0x1,... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/file.hpp |
czh::file::NonStreamFile::get_arrowpos(unsigned long) const | [[nodiscard]] std::size_t get_arrowpos(std::size_t pos) const override
{
int i = static_cast<int>(pos);
if (pos != 1)
--i;
while (code[i] != '\n' && i >= 0)
--i;
return pos - i;
} | leal -0x1(%rsi), %eax
cmpq $0x1, %rsi
movslq %eax, %rdx
movq 0x28(%rdi), %rcx
cmoveq %rsi, %rdx
leaq -0x1(%rdx), %rax
testq %rdx, %rdx
js 0x15836
cmpb $0xa, (%rcx,%rdx)
movq %rax, %rdx
jne 0x15824
notq %rax
addq %rsi, %rax
retq
nop
| /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/file.hpp |
czh::file::StreamFile::get_arrowpos(unsigned long) const | [[nodiscard]] std::size_t get_arrowpos(std::size_t pos) const override
{
std::size_t postmp = 0;
std::string tmp;
file->clear();
file->seekg(std::ios::beg);
while (std::getline(*file, tmp))
{
if (postmp + tmp.size() >= pos) return pos - postmp + 1;
postmp += tmp.s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0xdca0
movq 0x28(%r14), %rdi
xorl %esi, %esi
x... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/file.hpp |
czh::lexer::Lexer::reset() | void reset()
{
is_eof = false;
buffer = token::Token{token::TokenType::UNEXPECTED, 0, codepos};
match.reset();
nmatch.reset();
codepos.reset();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movb $0x0, 0x90(%rdi)
leaq 0x20(%rdi), %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x150c0
leaq 0x20(%rsp), %rdi
pushq $0xc
popq %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x150d4
leaq 0x40(%r14), %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::lexer::Lexer::check_token(czh::token::Token const&) | void check_token(const token::Token &token)
{
if (token.type == token::TokenType::FEND)
{
if (match.get_state() == State::END || match.get_state() == State::INIT)
return;
else
token.report_error("Unexpected end of file.");
}
if (match.end() && token.type !... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %eax
cmpl $0x8, %eax
jne 0x17d5d
movl 0x10(%r15), %eax
testl %eax, %eax
je 0x17e56
cmpl $0xc, %eax
je 0x17e56
leaq 0x45aa3(%rip), %rsi # 0x5d7de
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x10b0c
movq %rsp, %rsi
movq %rb... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::lexer::Lexer::skip() | void skip()
{
while (check_char() && get_character_size() == 1 && isspace(ch))
{
ch = get_char();
}
while (check_char() && ch == '<')
{
int notes = 0;
auto bak = get_pos().set_size(1);
ch = get_char();
while (check_char() && !(ch == '>' && notes ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x1805b
movq %r14, %rdi
callq 0x17fc8
cmpq $0x1, %rax
jne 0x1805b
movsbl 0x91(%r14), %edi
callq 0xd880
testl %eax, %eax
je 0x1805b
movq %r14, %rdi
ca... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::token::Token::Token<double>(czh::token::TokenType, double, czh::token::Pos) | Token(TokenType type_, T what_, Pos pos_)
:type(type_), what(std::move(what_)), pos(std::move(pos_)) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %rax
movsd %xmm0, (%rax)
movl %esi, (%rdi)
addq $0x8, %rdi
movq %rax, %rsi
callq 0x189ca
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x48(%r14)
movups 0x10(%rbx), %xmm0
andq $0x0, 0x18(%rbx)
movups %xmm0, 0x40(%r14)
andq $0x0, 0x10... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/token.hpp |
czh::token::Token::Token<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(czh::token::TokenType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, czh::token::Pos) | Token(TokenType type_, T what_, Pos pos_)
:type(type_), what(std::move(what_)), pos(std::move(pos_)) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x18ee4
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x48(%r14)
movups 0x10(%rbx), %xmm0
andq $0x0, 0x18(%rbx)
movups %xmm0, 0x40(%r14)
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
pop... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/token.hpp |
czh::lexer::NumberMatch::get_token(int) | Token get_token(int ch = -1)
{
if (std::isdigit(ch))
return Token::INT;
else if (ch == '.')
{
_is_double = true;
return Token::DOT;
}
else if (ch == 'e' || ch == 'E')
return Token::EXP;
else if (ch == '+' || ch == '-')
return Token::SIGN;
... | leal -0x30(%rsi), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
jae 0x188b1
retq
cmpl $0x2e, %esi
jne 0x188be
movb $0x1, 0x4(%rdi)
pushq $0x1
jmp 0x188ca
movl %esi, %eax
andl $-0x21, %eax
cmpl $0x45, %eax
jne 0x188cc
pushq $0x3
popq %rax
retq
pushq $0x2
popq %rax
cmpl $0x2d, %esi
je 0x188b0
cmpl $0x2b, %esi
je 0x188b0
cmpl $-0x... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::lexer::NumberMatch::next(czh::lexer::NumberMatch::Token const&) | void next(const Token &token)
{
switch (state)
{
case State::INIT:
switch (token)
{
case Token::INT:
state = State::INT;
break;
case Token::DOT:
state = State::DOT_NO_INT;
break;
case ... | movl (%rdi), %ecx
pushq $0xa
popq %rax
cmpq $0x8, %rcx
ja 0x189c6
leaq 0x439a4(%rip), %rdx # 0x5c2a0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl (%rsi), %ecx
cmpq $0x3, %rcx
jae 0x189c6
leaq 0x43850(%rip), %rax # 0x5c168
jmp 0x1892d
movl (%rsi), %ecx
cmpq $0x6, %rcx
jae 0x189c6
leaq 0x43847(%rip)... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::token::Pos::get_code[abi:cxx11]() const | [[nodiscard]] std::string get_code() const
{
std::size_t lineno = code->get_lineno(pos);
std::size_t linenosize = utils::to_str(lineno + next).size();
std::size_t actual_last = last;
std::size_t actual_next = next;
std::size_t total_line = code->get_lineno(code->size() - 1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movq (%rsi), %rsi
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r12
leaq 0x3(%rax), %r13
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1589e
movq 0x8(%rbp), %r1... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/token.hpp |
czh::lexer::Match::match(czh::token::TokenType const&) | void match(const token::TokenType &token)
{
if (token == token::TokenType::NOTE) return;
switch (state)
{
case State::INIT:
switch (token)
{
case token::TokenType::ID:
state = State::ID;
break;
case token::TokenType::S... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl (%rsi), %r14d
cmpl $0xb, %r14d
je 0x193b9
movq %rdi, %rbx
movl (%rdi), %edx
leaq 0x430a6(%rip), %rax # 0x5c2dc
leal -0x8(%r14), %ecx
movabsq $0xb00000000, %r15 # imm = 0xB00000000
cmpl $0xc, %edx
ja 0x193f2
movl %edx, %edx
movslq (%rax,%rdx,4), %rdx
addq %... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::lexer::Match::error_correct[abi:cxx11]() | std::string error_correct()
{
switch (last_state)
{
case State::REF:
case State::INIT:
return "identifier";
case State::ID:
return "'=' or ':'";
case State::EQUAL:
return "value or '['";
case State::ARR_LP:
return "value or ... | pushq %rbx
subq $0x30, %rsp
movl 0x4(%rsi), %eax
cmpq $0xa, %rax
ja 0x19516
movq %rdi, %rbx
leaq 0x42e76(%rip), %rcx # 0x5c330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x44377(%rip), %rsi # 0x5d841
jmp 0x19500
leaq 0x44384(%rip), %rsi # 0x5d857
jmp 0x19500
leaq 0x44388(%rip), %rsi # 0x... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/lexer.hpp |
czh::parser::Parser::parse_ref() | value::Reference parse_ref()
{
std::vector<std::string> path;
if (curr_tok.type == token::TokenType::REF)
{
path = {""};
}
bool id = false;
while (curr_tok.type == token::TokenType::ID || curr_tok.type == token::TokenType::REF)
{
if (curr_tok.type == token::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cmpl $0x7, 0xd8(%rsi)
jne 0x1a010
leaq 0x4a6b1(%rip), %rsi # 0x64694
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x10b0c
leaq 0x50... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/parser.hpp |
czh::parser::Parser::parse_array[abi:cxx11]() | value::Array parse_array()
{
value::Array ret;
curr_tok = get();//eat [
for (; curr_tok.type != token::TokenType::ARR_RP; curr_tok = get())
{
if (curr_tok.type == token::TokenType::COMMA) continue;
std::visit(utils::overloaded{
[&ret](auto &&a) { ret.insert(ret.en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x1671c
leaq 0xd8(%r14), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1672e
movq %r12, %rdi
cal... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/parser.hpp |
czh::node::Node& czh::node::Node::add<czh::value::Value&, void>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, czh::value::Value&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, czh::token::Token, std::source_location const&) | Node &add(std::string add_name, T &&_value, const std::string &before = "", token::Token token = token::Token(),
const std::source_location &l =
std::source_location::current())
{
assert_node(l);
auto &nd = std::get<NodeData>(data);
int err = 0;
auto ret = nd.add(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movq %r9, 0x10(%rsp)
movq %r9, %rsi
callq 0x1a68a
leaq 0x28(%r15), %rdi
callq 0x1640b
movq %rax, %r12
andl $0x0, 0xc(%rsp)
leaq 0x18... | /caozhanhao[P]wxserver/thirdparty/libczh/include/libczh/node.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [52], char const*>(char const (&) [52], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2d145
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2c40c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d167
mo... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::type_name() const | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x2d0f0
leaq 0x2f0a4(%rip), %rcx # 0x5c18c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x32c2f(%rip), %rax # 0x5fd26
retq
| /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
ws::Cli::get_access_token() | void get_access_token()
// see https://open.work.weixin.qq.com/api/doc/90000/90135/91039
{
httplib::SSLClient cli("qyapi.weixin.qq.com");
httplib::Params params
{
{"corpid", corp_id},
{"corpsecret", corp_secret}
};
auto res = cli.Get("/cgi-bi... | pushq %r14
pushq %rbx
subq $0x578, %rsp # imm = 0x578
movq %rdi, %rbx
leaq 0x32326(%rip), %rsi # 0x6020e
leaq 0x60(%rsp), %rdi
leaq 0xe0(%rsp), %rdx
callq 0x10b0c
leaq 0x158(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2e2b0
leaq 0x60(%rsp), %rdi
callq 0x10b86
leaq 0x20(%rbx), %rdx
leaq 0x323b0(%rip), %rsi ... | /caozhanhao[P]wxserver/include/wxserver/wxcli.hpp |
bool httplib::detail::parse_header<httplib::detail::read_headers(httplib::Stream&, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, httplib::detail::ci, std::allocator<std::pair<std::__cxx11::bas... | inline bool parse_header(const char *beg, const char *end, T fn) {
// Skip trailing spaces and tabs.
while (beg < end && is_space_or_tab(end[-1])) {
end--;
}
auto p = beg;
while (p < end && *p != ':') {
p++;
}
if (p == end) { return false; }
auto key_end = p;
if (*p++ != ':') { return fals... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rdi, %rax
movq %rsi, %r14
cmpq %rax, %rsi
jbe 0x380f3
leaq -0x1(%r14), %rsi
movzbl -0x1(%r14), %ecx
cmpl $0x9, %ecx
je 0x380d8
cmpl $0x20, %ecx
je 0x380d8
movq %rax, %rdx
cmpq %r14, %rdx
jae 0x38105
cmpb $0x3a, (%rdx)
je 0x38105
incq %rdx
jmp 0x380... | /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
bool httplib::detail::read_content_chunked<httplib::Response>(httplib::Stream&, httplib::Response&, std::function<bool (char const*, unsigned long, unsigned long, unsigned long)>) | inline bool read_content_chunked(Stream &strm, T &x,
ContentReceiverWithProgress out) {
const auto bufsiz = 16;
char buf[bufsiz];
stream_line_reader line_reader(strm, buf, bufsiz);
if (!line_reader.getline()) { return false; }
unsigned long chunk_len;
while (true) {
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
leaq 0x20(%rsp), %rcx
movq %rdi, -0x20(%rcx)
leaq 0x70(%rsp), %rax
movq %rax, -0x18(%rcx)
movq $0x10, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movq %rdx, %r12
movq %rsi, %r14
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x... | /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
httplib::detail::trim(char const*, char const*, unsigned long, unsigned long) | inline std::pair<size_t, size_t> trim(const char *b, const char *e, size_t left,
size_t right) {
while (b + left < e && is_space_or_tab(b[left])) {
left++;
}
while (right > 0 && is_space_or_tab(b[right - 1])) {
right--;
}
return std::make_pair(left, right);
} | movq %rdx, %rax
leaq (%rdi,%rax), %rdx
cmpq %rsi, %rdx
jae 0x3c009
movzbl (%rdx), %edx
cmpl $0x20, %edx
je 0x3bff5
cmpl $0x9, %edx
jne 0x3c009
incq %rax
jmp 0x3bfdf
movzbl -0x1(%rdi,%rdx), %esi
cmpl $0x20, %esi
je 0x3c009
cmpl $0x9, %esi
jne 0x3c012
movq %rcx, %rdx
subq $0x1, %rcx
jae 0x3bffa
retq
nop
| /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
httplib::ClientImpl::redirect(httplib::Request&, httplib::Response&, httplib::Error&) | inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) {
if (req.redirect_count_ == 0) {
error = Error::ExceedRedirectCount;
return false;
}
auto location = res.get_header_value("location");
if (location.empty()) { return false; }
const static std::regex re(
R"((?:(https?)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x558, %rsp # imm = 0x558
movq %rcx, %rbx
cmpq $0x0, 0x220(%rsi)
je 0x3cd91
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x23a93(%rip), %rsi # 0x6075d
leaq 0x138(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x10b0c
leaq 0x98(%rsp)... | /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsign... | bool start_array(std::size_t len)
{
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
keep_stack.push_back(keep);
auto val = handle_value(BasicJsonType::value_t::array, true);
ref_stack.push_back(val.second);
// check arr... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x80, %rdi
leaq 0x8(%r14), %rbx
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
shrq $0x3, %rsi
leaq 0xa8(%r14), %rcx
pushq $0x2
popq %rdx
callq 0x44720
leaq 0x20(%r14), %rdi
movzbl %al, %esi
callq 0x439c4
leaq 0x8(%rsp), %rsi... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsign... | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq -0x8(%rsi), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x4444a
leaq 0x80(%rbx), %rdi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
decl %esi
pushq $0x3
popq %rdx
callq 0x44720
testb %al, %al
jne 0x4444a
leaq 0xa8(%rbx), %rsi
movq %rsp, %r... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_2::detail::iter_impl<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::alloc... | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x44ed3
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, %rsi
callq 0x44cb8
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x44e66
cmpq $0x0, 0x18(%r15)
jne 0x44f27
cmpl $0x8, %eax
je 0x44e87
cmpl $0x3, %eax
jne ... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_2::detail::iter_impl<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::alloc... | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
... | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x45039
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x45029
cmpl $0x1, %eax
jne 0x45030
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x4548c
jmp 0x45034
addq $0x10, 0x10(%rbx)
jmp 0x45034
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x1d4dc(%rip), %r... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [23], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [2... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x44c57
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2c40c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x45827
mo... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> ... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x45906
cmpl $0x0, 0x38(%rbx)
je 0x45a5e
leaq 0x20(%rbx), %rdi
callq 0x446f2
testq %rdx, (%rax)
je 0x459a1
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x45af2
testb... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> ... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x45ffa
cmpl $0x0, 0x38(%rbx)
je 0x46152
leaq 0x20(%rbx), %rdi
callq 0x446f2
testq %rdx, (%rax)
je 0x46095
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x461e6
testb... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_2::detail::serializer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allo... | static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
... | movl %edx, %ecx
leaq 0x1da30(%rip), %rax # 0x6762d
movzbl (%rcx,%rax), %ecx
cmpb $0x0, (%rdi)
je 0x49c17
andb $0x3f, %dl
movzbl %dl, %r8d
movl (%rsi), %edx
shll $0x6, %edx
orl %r8d, %edx
jmp 0x49c26
movl $0xff, %r8d
shrl %cl, %r8d
movzbl %dl, %edx
andl %r8d, %edx
movl %edx, (%rsi)
movzbl (%rdi), %edx
shll $0x4, %ed... | /caozhanhao[P]wxserver/thirdparty/json/single_include/nlohmann/json.hpp |
httplib::Server::bind_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int) | inline int Server::bind_internal(const std::string &host, int port,
int socket_flags) {
if (!is_valid()) { return -1; }
svr_sock_ = create_server_socket(host, port, socket_flags, socket_options_);
if (svr_sock_ == INVALID_SOCKET) { return -1; }
if (port == 0) {
struct sock... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
pushq $-0x1
popq %rbx
testb %al, %al
je 0x4b245
leaq 0x2a0(%r14), %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x3ef84
movq %r14, %rd... | /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
bool httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | inline bool write_multipart_ranges_data(Stream &strm, const Request &req,
Response &res,
const std::string &boundary,
const std::string &content_type,
const T &... | subq $0x38, %rsp
movq %rdi, %rax
movq %rdi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %r9, 0x30(%rsp)
movq %r9, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
movq %rax, %r9
callq 0x4f075
addq $0x38, %rsp
retq
| /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
httplib::ClientImpl::create_client_socket(httplib::Error&) const | inline socket_t ClientImpl::create_client_socket(Error &error) const {
if (!proxy_host_.empty() && proxy_port_ != -1) {
return detail::create_client_socket(
proxy_host_, std::string(), proxy_port_, address_family_, tcp_nodelay_,
socket_options_, connection_timeout_sec_, connection_timeout_usec_,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x298(%rdi)
je 0x543d0
movl 0x2b0(%rbx), %ebp
cmpl $-0x1, %ebp
je 0x543d0
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x23c(%rbx), %r15d
movb 0x240(... | /caozhanhao[P]wxserver/thirdparty/cpp-httplib/httplib.h |
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.