name string | code string | asm string | file string |
|---|---|---|---|
Pl_DCT::decompress(void*, Buffer*) | void
Pl_DCT::decompress(void* cinfo_p, Buffer* b)
{
auto* cinfo = reinterpret_cast<jpeg_decompress_struct*>(cinfo_p);
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
jpeg_create_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x290, %edx # imm = 0x290
movq %rsi, %rdi
movl $0x50, %esi
callq 0x195f0
movq 0x1bdc22(%rip), %rcx # 0x1f20e0
movq 0x8(%r14), %rax
testq %rcx, %rcx
jle 0x344cb
movq %rcx, 0x58(%rax... | /qpdf[P]qpdf/libqpdf/Pl_DCT.cc |
empty_pipeline_output_buffer(jpeg_compress_struct*) | static boolean
empty_pipeline_output_buffer(j_compress_ptr cinfo)
{
QTC::TC("libtests", "Pl_DCT empty_pipeline_output_buffer");
auto* dest = reinterpret_cast<dct_pipeline_dest*>(cinfo->dest);
dest->next->write(dest->buffer, dest->size);
dest->pub.next_output_byte = dest->buffer;
dest->pub.free_in_bu... | pushq %rbx
movq 0x28(%rdi), %rbx
movq 0x38(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movups 0x28(%rbx), %xmm0
movups %xmm0, (%rbx)
movl $0x1, %eax
popq %rbx
retq
| /qpdf[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_Discard::~Pl_Discard() | Pl_Discard::~Pl_Discard() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b6565(%rip), %rax # 0x1eb070
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x34b26
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x190e0
| /qpdf[P]qpdf/libqpdf/Pl_Discard.cc |
Pl_Flate::zopfli_enabled() | bool
Pl_Flate::zopfli_enabled()
{
if (zopfli_supported()) {
std::string value;
static bool enabled = QUtil::get_env("QPDF_ZOPFLI", &value) && value != "disabled";
return enabled;
} else {
return false;
}
} | xorl %eax, %eax
retq
nop
| /qpdf[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::write(unsigned char const*, unsigned long) | void
Pl_Flate::write(unsigned char const* data, size_t len)
{
if (m->outbuf == nullptr) {
throw std::logic_error(
this->identifier + ": Pl_Flate: write() called after finish() called");
}
if (m->zopfli_buf) {
m->zopfli_buf->append(reinterpret_cast<char const*>(data), len);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rax
cmpq $0x0, (%rax)
je 0x34f1d
movq %rdx, %rbx
movq %rsi, %r15
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x34ed1
movq %r15, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14... | /qpdf[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Function::Pl_Function(char const*, Pipeline*, int (*)(unsigned char const*, unsigned long, void*), void*) | Pl_Function::Pl_Function(char const* identifier, Pipeline* next, writer_c_t fn, void* udata) :
Pipeline(identifier, next),
m(std::make_unique<Members>(nullptr))
{
m->fn = [identifier, fn, udata](unsigned char const* data, size_t len) {
int code = fn(data, len, udata);
if (code != 0) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x316ec
leaq 0x1b5876(%rip), %rax # 0x1eb598
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x19180
movq %rax, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%... | /qpdf[P]qpdf/libqpdf/Pl_Function.cc |
Pl_Function::~Pl_Function() | Pl_Function::~Pl_Function() // NOLINT (modernize-use-equals-default)
{
// Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1b55af(%rip), %rax # 0x1eb598
movq %rax, (%rdi)
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x35ffe
leaq 0x30(%rbx), %rdi
callq 0x3651c
movq $0x0, 0x30(%rbx)
leaq 0x1b5063(%rip), %rax # 0x1eb070
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x36029
movq... | /qpdf[P]qpdf/libqpdf/Pl_Function.cc |
Pl_LZWDecoder::write(unsigned char const*, unsigned long) | void
Pl_LZWDecoder::write(unsigned char const* bytes, size_t len)
{
for (size_t i = 0; i < len; ++i) {
buf[next_char_++] = bytes[i];
if (next_char_ == 3) {
next_char_ = 0;
}
this->bits_available += 8;
if (this->bits_available >= this->code_size) {
send... | testq %rdx, %rdx
je 0x36692
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movl 0x38(%r15), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x38(%r15)
movb %al, 0x30(%r15,%rcx)
cmpl $0x3, 0x38(%r15)
jne 0x36666
movl $0x0, 0x38(%r15)
mo... | /qpdf[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::getFirstChar(unsigned int) | unsigned char
Pl_LZWDecoder::getFirstChar(unsigned int code)
{
unsigned char result = '\0';
if (code < 256) {
result = static_cast<unsigned char>(code);
} else if (code > 257) {
unsigned int idx = code - 258;
if (idx >= table.size()) {
throw std::runtime_error("Pl_LZWDeco... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
cmpl $0xff, %esi
jbe 0x369b7
cmpl $0x102, %r14d # imm = 0x102
jb 0x369c5
addl $0xfffffefe, %r14d # imm = 0xFFFFFEFE
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x36a27
leaq (%... | /qpdf[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::addToTable(unsigned char) | void
Pl_LZWDecoder::addToTable(unsigned char c)
{
unsigned int last_size = 0;
unsigned char const* last_data = nullptr;
unsigned char tmp[1];
if (this->last_code < 256) {
tmp[0] = static_cast<unsigned char>(this->last_code);
last_data = tmp;
last_size = 1;
} else if (this->l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl 0x68(%rdi), %eax
cmpl $0xff, %eax
ja 0x36b67
leaq 0x7(%rsp), %r15
movb %al, (%r15)
movl $0x1, %r12d
jmp 0x36bb7
cmpl $0x102, %eax # imm = 0x102
jb 0x36c14
addl $0xfffffefe, %eax # imm... | /qpdf[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_MD5::write(unsigned char const*, unsigned long) | void
Pl_MD5::write(unsigned char const* buf, size_t len)
{
if (this->enabled) {
if (!this->in_progress) {
this->md5.reset();
this->in_progress = true;
}
// Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
static size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
cmpb $0x1, 0x48(%rdi)
jne 0x37180
cmpb $0x0, 0x30(%r15)
jne 0x37142
leaq 0x38(%r15), %rdi
callq 0x2a75c
movb $0x1, 0x30(%r15)
cmpq $0x0, 0x8(%rsp)
je 0x37180
leaq 0x38(%r15), %r1... | /qpdf[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_PNGFilter::encodeRow() | void
Pl_PNGFilter::encodeRow()
{
// For now, hard-code to using UP filter.
unsigned char ch = 2;
next()->write(&ch, 1);
if (this->prev_row) {
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
ch = static_cast<unsigned char>(this->cur_row[i] - this->prev_row[i]);
ne... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rsi
movb $0x2, (%rsi)
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x3775b
cmpl $0x0, 0x34(%rbx)
je 0x3776c
xorl %r15d, %r15d
leaq 0xf(%rsp), %r14
movq 0x40(%rbx), %rax
movq 0x48(%rbx... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeAverage() | void
Pl_PNGFilter::decodeAverage()
{
QTC::TC("libtests", "Pl_PNGFilter decodeAverage");
unsigned char* buffer = this->cur_row + 1;
unsigned char* above_buffer = this->prev_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
int left = ... | cmpl $0x0, 0x34(%rdi)
je 0x378cb
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movl 0x38(%rdi), %edx
movl %edx, %esi
negl %esi
xorl %r8d, %r8d
cmpq %rdx, %r8
jae 0x378a0
xorl %r9d, %r9d
jmp 0x378aa
leal (%rsi,%r8), %r9d
movzbl 0x1(%rax,%r9), %r9d
movzbl 0x1(%rcx,%r8), %r10d
movzwl %r9w, %r9d
addl %r10d, %r9d
shrl %r9d
ad... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::PaethPredictor(int, int, int) | int
Pl_PNGFilter::PaethPredictor(int a, int b, int c)
{
int p = a + b - c;
int pa = abs_diff(p, a);
int pb = abs_diff(p, b);
int pc = abs_diff(p, c);
if (pa <= pb && pa <= pc) {
return a;
}
if (pb <= pc) {
return b;
}
return c;
} | movl %esi, %eax
leal (%rdx,%rax), %esi
subl %ecx, %esi
movl %esi, %edi
subl %eax, %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl %esi, %edi
subl %edx, %edi
movl %edi, %r9d
negl %r9d
cmovsl %edi, %r9d
subl %ecx, %esi
movl %esi, %edi
negl %edi
cmovsl %esi, %edi
cmpl %edi, %r9d
cmoval %ecx, %edx
cmpl %edi, %r8d
cmo... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::finish() | void
Pl_PNGFilter::finish()
{
if (this->pos) {
// write partial row
processRow();
}
this->prev_row = nullptr;
this->cur_row = buf1.get();
this->pos = 0;
memset(this->cur_row, 0, this->bytes_per_row + 1);
next()->finish();
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x379c5
movq %rbx, %rdi
callq 0x376e0
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rdi
movq %rdi, 0x40(%rbx)
movq %rax, 0x70(%rbx)
movl 0x34(%rbx), %edx
incl %edx
xorl %esi, %esi
callq 0x19330
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%ra... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::~Pl_PNGFilter() | ~Pl_PNGFilter() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x37a00
callq 0x1dba8
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x37a0e
callq 0x1dba8
leaq 0x1b365b(%rip), %rax # 0x1eb070
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x37a31
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp ... | /qpdf[P]qpdf/libqpdf/qpdf/Pl_PNGFilter.hh |
Pl_QPDFTokenizer::~Pl_QPDFTokenizer() | Pl_QPDFTokenizer::~Pl_QPDFTokenizer() = default; | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b3be0(%rip), %rax # 0x1eb720
movq %rax, (%rdi)
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x37b6b
leaq 0x10(%r14), %rdi
callq 0x335a6
leaq 0x8(%r14), %rdi
callq 0xe1f26
movl $0x48, %esi
movq %r14, %rdi
callq 0x190e0
movq $0x0, 0x30(%rbx)
leaq 0x1b34f6(%rip), %r... | /qpdf[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_QPDFTokenizer::finish() | void
Pl_QPDFTokenizer::finish()
{
m->buf.finish();
auto input = BufferInputSource("tokenizer data", m->buf.getBuffer(), true);
std::string empty;
while (true) {
auto token = m->tokenizer.readToken(input, empty, true);
m->filter->handleToken(token);
if (token.getType() == QPDFToke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $0x10, %rdi
callq 0x33656
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x128b3b(%rip), %rsi # 0x160736
leaq 0x128b42(%rip), %rdx # 0x160744
leaq 0x50(%rsp), ... | /qpdf[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_RunLength::Pl_RunLength(char const*, Pipeline*, Pl_RunLength::action_e) | Pl_RunLength::Pl_RunLength(char const* identifier, Pipeline* next, action_e action) :
Pipeline(identifier, next),
m(std::make_unique<Members>(action))
{
if (!next) {
throw std::logic_error("Attempt to create Pl_RunLength with nullptr as next");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %rbx
callq 0x316ec
leaq 0x1b3454(%rip), %rax # 0x1eb7b0
movq %rax, (%rbx)
movl $0xb0, %edi
callq 0x19180
leaq 0x30(%rbx), %r14
movl %ebp, (%rax)
xorl %ecx, %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x88(%rax)
movq %rax, %rcx... | /qpdf[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::decode(unsigned char const*, unsigned long) | void
Pl_RunLength::decode(unsigned char const* data, size_t len)
{
if (memory_limit && (len + m->out.size()) > memory_limit) {
throw std::runtime_error("Pl_RunLength memory limit exceeded");
}
m->out.reserve(len);
for (size_t i = 0; i < len; ++i) {
unsigned char const& ch = data[i];
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1b9b04(%rip), %rax # 0x1f2118
movq 0x30(%rdi), %rdi
testq %rax, %rax
je 0x38630
movq 0x98(%rdi), %rcx
addq %rbx, %rcx
cmpq %rax, %rcx
ja 0x3870c
addq $0x90, %rdi
movq %rbx, %rsi
callq 0x19940
testq %rbx, %rb... | /qpdf[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_SHA2::getHexDigest[abi:cxx11]() | std::string
Pl_SHA2::getHexDigest()
{
if (this->in_progress) {
throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
}
return QUtil::hex_encode(getRawDigest());
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x30(%rsi)
je 0x38b94
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x38ade
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13f5b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38b89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rax
... | /qpdf[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_TIFFPredictor::finish() | void
Pl_TIFFPredictor::finish()
{
if (!cur_row.empty()) {
// write partial row
cur_row.insert(cur_row.end(), bytes_per_row - cur_row.size(), 0);
processRow();
}
cur_row.clear();
next()->finish();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
subq %rsi, %rax
je 0x39412
leaq 0x48(%rbx), %rdi
movl 0x38(%rbx), %edx
addq %rax, %rdx
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
callq 0x39b9e
movq %rbx, %rdi
callq 0x39252
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x39412
movq %r... | /qpdf[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
QPDFAcroFormDocumentHelper::adjustDefaultAppearances(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void
QPDFAcroFormDocumentHelper::adjustDefaultAppearances(
QPDFObjectHandle obj, std::map<std::string, std::map<std::string, std::string>> const& dr_map)
{
// This method is called on a field that has been copied from another file but whose /DA still
// refers to resources in the original file's /DR.
/... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x100(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x10ef76(%rip), %rsi # 0x1624b1
leaq 0x10ef72(%rip), %rdx # 0x1624b4
leaq 0xf0(%rsp), %rdi
callq 0x1fa24
leaq 0x30(%r... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
(anonymous namespace)::ResourceReplacer::ResourceReplacer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std:... | ResourceReplacer::ResourceReplacer(
std::map<std::string, std::map<std::string, std::string>> const& dr_map,
std::map<std::string, std::map<std::string, std::set<size_t>>> const& rnames)
{
// We have:
// * dr_map[resource_type][key] == new_key
// * rnames[resource_type][key] == set of offsets
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
leaq 0x198715(%rip), %rax # 0x1ec148
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movl $0x0, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rax, 0x... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::adjustAppearanceStream(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<c... | void
QPDFAcroFormDocumentHelper::adjustAppearanceStream(
QPDFObjectHandle stream, std::map<std::string, std::map<std::string, std::string>> dr_map)
{
// We don't have to modify appearance streams or their resource dictionaries for them to display
// properly, but we need to do so to make them save to regene... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdx, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0xd0(%rsp), %rdi
movq %rsi, 0x18(%rsp)
callq 0x10004e
leaq 0xf0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10e934(%rip), %rsi # 0x162504
leaq 0x10e937(%rip), %r... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::transformAnnotations(QPDFObjectHandle, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::set<QPDFObjGen, std::less<QPDFObjGen>, std::allocator<QPDFObjGen>>&, QPDFMatrix const&, QPDF*, QPDFAcroFormDocumentH... | void
QPDFAcroFormDocumentHelper::transformAnnotations(
QPDFObjectHandle old_annots,
std::vector<QPDFObjectHandle>& new_annots,
std::vector<QPDFObjectHandle>& new_fields,
std::set<QPDFObjGen>& old_fields,
QPDFMatrix const& cm,
QPDF* from_qpdf,
QPDFAcroFormDocumentHelper* from_afdh)
{
std:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
movq %r9, %r12
movq %r8, 0x3f8(%rsp)
movq %rcx, 0x400(%rsp)
movq %rdx, 0x410(%rsp)
movq %rsi, %rbx
movq %rdi, %r13
movq 0x570(%rsp), %rcx
movq 0x8(%rdi), %rsi
testq %rcx, %rcx
je 0x545eb
movq 0x578(%rsp), %rdx
c... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::fixCopiedAnnotations(QPDFObjectHandle, QPDFObjectHandle, QPDFAcroFormDocumentHelper&, std::set<QPDFObjGen, std::less<QPDFObjGen>, std::allocator<QPDFObjGen>>*) | void
QPDFAcroFormDocumentHelper::fixCopiedAnnotations(
QPDFObjectHandle to_page,
QPDFObjectHandle from_page,
QPDFAcroFormDocumentHelper& from_afdh,
std::set<QPDFObjGen>* added_fields)
{
auto old_annots = from_page.getKey("/Annots");
if ((!old_annots.isArray()) || (old_annots.getArrayNItems() == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
leaq 0xb0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x10b210(%rip), %rsi # 0x162615
leaq 0x10b210(%rip), %rdx # 0x16261c
leaq 0xa0(%rsp), %rdi
callq 0x1fa... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
(anonymous namespace)::ResourceReplacer::handleToken(QPDFTokenizer::Token const&) | void
ResourceReplacer::handleToken(QPDFTokenizer::Token const& token)
{
bool wrote = false;
if (token.getType() == QPDFTokenizer::tt_name) {
std::string name = QPDFObjectHandle::newName(token.getValue()).getName();
if (to_replace.count(name) && to_replace[name].count(offset)) {
QTC::... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, (%rsi)
jne 0x577fe
leaq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xc89c2
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xc31de
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x57761
callq 0x1dba8
leaq 0x18... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
ResourceFinder::~ResourceFinder() | ~ResourceFinder() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x197e97(%rip), %rax # 0x1efdc8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
callq 0x58d94
leaq 0x30(%rbx), %rdi
callq 0x58eec
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x57f63
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /qpdf[P]qpdf/libqpdf/qpdf/ResourceFinder.hh |
QPDFAnnotationObjectHelper::QPDFAnnotationObjectHelper(QPDFObjectHandle) | QPDFAnnotationObjectHelper::QPDFAnnotationObjectHelper(QPDFObjectHandle oh) :
QPDFObjectHelper(oh)
{
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x5be09
movq 0x195181(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x5be1e
incl 0x8(%rdi)
jmp 0x5be27
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x5be4c
lock
incl 0x8(%rdi)
cmpb $0x0, ... | /qpdf[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFAnnotationObjectHelper::getSubtype[abi:cxx11]() | std::string
QPDFAnnotationObjectHelper::getSubtype()
{
return oh().getKey("/Subtype").getName();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5be9c
movq 0x1950f2(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x5be98
incl 0x8(%rax)
jmp 0x5be9c
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %r14
movq %r14, -0... | /qpdf[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFAnnotationObjectHelper::getRect() | QPDFObjectHandle::Rectangle
QPDFAnnotationObjectHelper::getRect()
{
return oh().getKey("/Rect").getArrayAsRectangle();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5bf9e
movq 0x194ff0(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x5bf9a
incl 0x8(%rax)
jmp 0x5bf9e
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %r14
movq %r14, -0... | /qpdf[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFAnnotationObjectHelper::getAppearanceDictionary() | QPDFObjectHandle
QPDFAnnotationObjectHelper::getAppearanceDictionary()
{
return oh().getKey("/AP");
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5c0a0
movq 0x194eee(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x5c09c
incl 0x8(%rax)
jmp 0x5c0a0
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %r14
movq %r14, -0... | /qpdf[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFAnnotationObjectHelper::getAppearanceStream(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&) | QPDFObjectHandle
QPDFAnnotationObjectHelper::getAppearanceStream(std::string const& which, std::string const& state)
{
QPDFObjectHandle ap = getAppearanceDictionary();
std::string desired_state = state.empty() ? getAppearanceState() : state;
if (ap.isDictionary()) {
QPDFObjectHandle ap_sub = ap.getK... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5c06a
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x5c453
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1... | /qpdf[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFArgParser::Members::Members(int, char const* const*, char const*) | QPDFArgParser::Members::Members(int argc, char const* const argv[], char const* progname_env) :
argc(argc),
argv(argv),
progname_env(progname_env),
cur_arg(0),
bash_completion(false),
zsh_completion(false),
option_table(nullptr),
final_check_handler(nullptr)
{
auto tmp = QUtil::make... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rdi, %r14
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
addq $0x30, ... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::addChoices(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>, bool, char const**) | void
QPDFArgParser::addChoices(
std::string const& arg, param_arg_handler_t handler, bool required, char const** choices)
{
OptionEntry& oe = registerArg(arg);
oe.parameter_needed = required;
oe.param_arg_handler = handler;
for (char const** i = choices; *i; ++i) {
oe.choices.insert(*i);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
callq 0x5e0dc
movq %rax, %r14
movb %bpl, (%rax)
leaq 0x78(%rax), %rdi
movq %r15, %rsi
callq 0x29dc2
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x5db55
addq $0x28, %r14
leaq 0x18(%rsp), %r13
addq ... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::invalidHelpArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFArgParser::invalidHelpArg(std::string const& p)
{
usage(std::string("unknown help option") + (p.empty() ? "" : (" " + p)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x104d7a(%rip), %rsi # 0x162a39
leaq 0x104d86(%rip), %rdx # 0x162a4c
leaq 0x48(%rsp), %rdi
callq 0x1fa24
cmpq $0x0, 0x8(%r14)
leaq 0x38(%rsp), %r12
jne 0x5dcf5
leaq 0x28(%... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::registerOptionTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void ()>) | void
QPDFArgParser::registerOptionTable(std::string const& name, bare_arg_handler_t end_handler)
{
if (0 != m->option_tables.count(name)) {
QTC::TC("libtests", "QPDFArgParser register registered table");
throw std::logic_error(
"QPDFArgParser: registering already registered option table ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0xe8(%r12), %rdi
callq 0x6246e
addq $0xf0, %r12
cmpq %r12, %rax
jne 0x5e017
movl $0xe8, %edi
addq (%rbx), %rdi
movq %r15, %rsi
callq 0x61a48
movq %rbx, %rdi
movq %r15, %rsi
call... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::completionCommon(bool) | void
QPDFArgParser::completionCommon(bool zsh)
{
std::string progname = m->argv[0];
std::string executable;
std::string appdir;
std::string appimage;
if (QUtil::get_env(m->progname_env.c_str(), &executable)) {
progname = executable;
} else if (QUtil::get_env("APPDIR", &appdir) && QUtil::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x1f9e6
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %a... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::handleBashArguments() | void
QPDFArgParser::handleBashArguments()
{
// Do a minimal job of parsing bash_line into arguments. This doesn't do everything the shell
// does (e.g. $(...), variable expansion, arithmetic, globs, etc.), but it should be good enough
// for purposes of handling completion. As we build up the new argv, we c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq (%rdi), %r14
movq 0xa0(%r14), %r15
testq %r15, %r15
je 0x5f097
movq 0x98(%r14), %r12
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %r13d, ... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
(anonymous namespace)::ArgParser::argZopfli() | void
ArgParser::argZopfli()
{
auto logger = QPDFLogger::defaultLogger();
if (Pl_Flate::zopfli_supported()) {
if (Pl_Flate::zopfli_enabled()) {
logger->info("zopfli support is enabled, and zopfli is active\n");
} else {
logger->info("zopfli support is enabled but not activ... | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rdi
callq 0xb9fb6
callq 0x357fe
testb %al, %al
je 0x96bb5
callq 0x34c88
movq (%rsp), %rdi
testb %al, %al
je 0x96b44
leaq 0xd526a(%rip), %rsi # 0x16bdac
jmp 0x96b9b
leaq 0xd5292(%rip), %rsi # 0x16bddd
callq 0xba054
movq (%rsp), %rdi
leaq 0xd52ac(%rip), %rsi # 0x16be07
... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
QPDFJob::Config::splitPages(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::splitPages(std::string const& parameter)
{
int n = (parameter.empty() ? 1 : QUtil::string_to_int(parameter.c_str()));
o.m->split_pages = n;
return this;
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xa5515
movq (%rsi), %rdi
callq 0x13e85e
jmp 0xa551a
movl $0x1, %eax
movq (%rbx), %rcx
movq (%rcx), %rcx
movl %eax, 0x5c(%rcx)
movq %rbx, %rax
popq %rbx
retq
| /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::passwordFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::passwordFile(std::string const& parameter)
{
std::list<std::string> lines;
if (parameter == "-") {
QTC::TC("qpdf", "QPDFJob_config password stdin");
lines = QUtil::read_lines_from_file(std::cin);
} else {
QTC::TC("qpdf", "QPDFJob_config password file... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
leaq 0xbd5b8(%rip), %rsi # 0x162b82
movq %r14, %rdi
callq 0x19a70
testl %eax, %eax
je 0xa55e5
movq (%r14), %rsi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x142cc8
jmp... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::streamData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::streamData(std::string const& parameter)
{
o.m->stream_data_set = true;
if (parameter == "compress") {
o.m->stream_data_mode = qpdf_s_compress;
} else if (parameter == "preserve") {
o.m->stream_data_mode = qpdf_s_preserve;
} else if (parameter == "uncomp... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x128(%rax)
leaq 0xc8810(%rip), %rsi # 0x16e06b
movq %r14, %rdi
callq 0x19a70
testl %eax, %eax
je 0xa58cf
leaq 0xc607a(%rip), %rsi # 0x16b8e8
movq %r14, %rdi
callq 0x19a70
testl %eax,... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::copyAttachmentsFrom() | std::shared_ptr<QPDFJob::CopyAttConfig>
QPDFJob::Config::copyAttachmentsFrom()
{
return std::shared_ptr<CopyAttConfig>(new CopyAttConfig(this));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x68, %edi
callq 0x19180
movq %r14, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), ... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFNameTreeObjectHelper::last() const | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::last() const
{
return {std::make_shared<NNTreeIterator>(m->impl->last())};
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x2e63a
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %r14, %rcx
callq 0xbcf80
leaq 0x13012a(%rip), %rax # 0x1ec600
movq %rax, (%rbx)... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_String, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f156
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
JSON::Writer::writeNext() | Writer&
writeNext()
{
auto n = indent;
if (first) {
first = false;
write(&spaces[1], n % n_spaces + 1);
} else {
write(&spaces[0], n % n_spaces + 2);
}
while (n >= n_spaces) {
write(&spaces[2], n_spaces);
n -= n_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
cmpb $0x1, 0x8(%rdi)
jne 0xcb688
movb $0x0, 0x8(%rbx)
leaq 0xaed56(%rip), %rsi # 0x17a3d7
movl $0x1, %ecx
jmp 0xcb694
leaq 0xaed47(%rip), %rsi # 0x17a3d6
movl $0x2, %ecx
movq %r15, %rax
shrq %rax
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0x... | /qpdf[P]qpdf/libqpdf/qpdf/JSON_writer.hh |
QPDFObjectHandle::as_array(qpdf::typed) const | inline qpdf::Array
QPDFObjectHandle::as_array(qpdf::typed options) const
{
if (options & qpdf::error) {
assertType("array", false);
}
if (options & qpdf::any_flag || type_code() == ::ot_array ||
(options & qpdf::optional && type_code() == ::ot_null)) {
return qpdf::Array(obj);
}
... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x4, %bpl
je 0xcbb61
leaq 0xb24f1(%rip), %rsi # 0x17e048
movq %r14, %rdi
xorl %edx, %edx
callq 0xc9ba8
testb $0x1, %bpl
jne 0xcbbdb
movq (%r14), %rdi
testq %rdi, %rdi
je 0xcbb9e
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xcbb8f... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Real, 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&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f156
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Name, 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&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f156
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_String, 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&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f156
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_InlineImage, 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&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f156
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Array, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&>(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xce4da
movq $0x0, (%rbx)
movl $0x70, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x11f74a(%rip), %rcx # 0x1ebb40
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x8(%rsp), %rdi
movq -0x8(%r... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFObject::getDescription(QPDF*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool
getDescription(QPDF*& a_qpdf, std::string& description)
{
a_qpdf = qpdf;
description = getDescription();
return qpdf != nullptr;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, (%rsi)
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbeb78
movq %r14, %rdi
movq %r15, %rsi
callq 0x195c0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xcc5f7
movq 0x10(%rsp), %rsi
i... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
QPDF_Array::QPDF_Array(QPDF_Array const&) | QPDF_Array(QPDF_Array const& other) :
sp(other.sp ? std::make_unique<Sparse>(*other.sp) : nullptr)
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0xcd37d
movl $0x38, %edi
callq 0x19180
movq %rax, %r14
movl (%r15), %eax
movl %eax, (%r14)
leaq 0x8(%r14), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0xcd3b0
jmp 0xcd380
xorl %r14d, %r14d
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
QPDFOutlineDocumentHelper::QPDFOutlineDocumentHelper(QPDF&) | QPDFOutlineDocumentHelper::QPDFOutlineDocumentHelper(QPDF& qpdf) :
QPDFDocumentHelper(qpdf),
m(new Members())
{
QPDFObjectHandle root = qpdf.getRoot();
if (!root.hasKey("/Outlines")) {
return;
}
QPDFObjectHandle outlines = root.getKey("/Outlines");
if (!(outlines.isDictionary() && ou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
leaq 0x11e2e6(%rip), %rax # 0x1ecc10
movq %rax, (%rdi)
movl $0x98, %edi
callq 0x19180
leaq 0x20(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x60(%rax)
movu... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFOutlineDocumentHelper::getOutlinesForPage(QPDFObjGen) | std::vector<QPDFOutlineObjectHelper>
QPDFOutlineDocumentHelper::getOutlinesForPage(QPDFObjGen og)
{
if (m->by_page.empty()) {
initializeByPage();
}
std::vector<QPDFOutlineObjectHelper> result;
if (m->by_page.count(og)) {
result = m->by_page[og];
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movq 0x10(%rsi), %r15
cmpq $0x0, 0x90(%r15)
jne 0xcefe6
movq %r14, %rdi
callq 0xcedc4
movq 0x10(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x68(%r15), %rdi
leaq 0x8(%rsp), %rsi
call... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFOutlineDocumentHelper::resolveNamedDest(QPDFObjectHandle) | QPDFObjectHandle
QPDFOutlineDocumentHelper::resolveNamedDest(QPDFObjectHandle name)
{
QPDFObjectHandle result;
if (name.isName()) {
if (!m->dest_dict) {
m->dest_dict = qpdf.getRoot().getKey("/Dests");
}
QTC::TC("qpdf", "QPDFOutlineDocumentHelper name named dest");
res... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rdx, %rdi
callq 0xc2ebc
testb %al, %al
je 0xcf180
movq 0x10(%r15), %r12
cmpq $0x0, 0x48(%r12)
jne 0xcf124
movq 0x8(%r15), %rsi
leaq 0x30(%rsp), %rdi
c... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFOutlineObjectHelper::~QPDFOutlineObjectHelper() | ~QPDFOutlineObjectHelper() override
{
// This must be cleared explicitly to avoid circular references that prevent cleanup of
// shared pointers.
m->parent = nullptr;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x11f837(%rip), %rax # 0x1eed40
movq %rax, (%rdi)
movq 0x28(%rdi), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
movq %rcx, 0x10(%rax)
testq %rdi, %rdi
je 0xcf528
callq 0x1dba8
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xcf536
callq 0x1dba8
movq %rbx, %rdi
popq %rbx
... | /qpdf[P]qpdf/include/qpdf/QPDFOutlineObjectHelper.hh |
QPDFOutlineObjectHelper::QPDFOutlineObjectHelper(QPDFObjectHandle, QPDFOutlineDocumentHelper&, int) | QPDFOutlineObjectHelper::QPDFOutlineObjectHelper(
QPDFObjectHandle a_oh, QPDFOutlineDocumentHelper& dh, int depth) :
QPDFObjectHelper(a_oh),
m(new Members(dh))
{
if (depth > 50) {
// Not exercised in test suite, but was tested manually by temporarily changing max depth
// to 1.
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xd06ad
movq 0x1208dd(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xd06d0
incl 0x8(%rdi)
jmp 0xd06dd... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFOutlineObjectHelper::getDest() | QPDFObjectHandle
QPDFOutlineObjectHelper::getDest()
{
QPDFObjectHandle dest;
QPDFObjectHandle A;
if (oh().hasKey("/Dest")) {
QTC::TC("qpdf", "QPDFOutlineObjectHelper direct dest");
dest = oh().getKey("/Dest");
} else if (
(A = oh().getKey("/A")).isDictionary() && A.getKey("/S").i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x50(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0xd0b09... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFOutlineObjectHelper::getDestPage() | QPDFObjectHandle
QPDFOutlineObjectHelper::getDestPage()
{
QPDFObjectHandle dest = getDest();
if ((dest.isArray()) && (dest.getArrayNItems() > 0)) {
return dest.getArrayItem(0);
}
return QPDFObjectHandle::newNull();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd0aba
movq %r14, %rdi
callq 0xc2fe4
testb %al, %al
je 0xd1224
leaq 0x8(%rsp), %rdi
callq 0xf9eac
testl %eax, %eax
jle 0xd1224
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xfa01c
jmp 0xd122c
movq %rbx, %rdi... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFOutlineObjectHelper::getTitle[abi:cxx11]() | std::string
QPDFOutlineObjectHelper::getTitle()
{
std::string result;
if (oh().hasKey("/Title")) {
result = oh().getKey("/Title").getUTF8Value();
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xd1469
movq 0x1... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFPageDocumentHelper::getAllPages() | std::vector<QPDFPageObjectHelper>
QPDFPageDocumentHelper::getAllPages()
{
std::vector<QPDFPageObjectHelper> pages;
for (auto const& iter: this->qpdf.getAllPages()) {
pages.emplace_back(iter);
}
return pages;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
callq 0x13a448
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0xd184a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2e26
addq $0x10, %r14
jmp 0xd1834
movq %rbx, %rax
popq %rbx
popq %... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::addPage(QPDFPageObjectHelper, bool) | void
QPDFPageDocumentHelper::addPage(QPDFPageObjectHelper newpage, bool first)
{
this->qpdf.addPage(newpage.getObjectHandle(), first);
} | pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd18f8
movq 0x11f696(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xd18f4
incl 0x8(%rax)
jmp 0xd18f8
lock
incl 0x8(%rax)
movzbl %dl, %edx
movq %rsp, %rsi
callq 0x13cc... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::removePage(QPDFPageObjectHelper) | void
QPDFPageDocumentHelper::removePage(QPDFPageObjectHelper page)
{
this->qpdf.removePage(page.getObjectHandle());
} | pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd1a24
movq 0x11f56a(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xd1a20
incl 0x8(%rax)
jmp 0xd1a24
lock
incl 0x8(%rax)
movq %rsp, %rsi
callq 0x13c914
movq 0x8(%rsp)... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::flattenAnnotations(int, int) | void
QPDFPageDocumentHelper::flattenAnnotations(int required_flags, int forbidden_flags)
{
QPDFAcroFormDocumentHelper afdh(this->qpdf);
if (afdh.getNeedAppearances()) {
this->qpdf.getRoot()
.getKey("/AcroForm")
.warnIfPossible(
"document does not have updated appe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, 0x74(%rsp)
movl %esi, 0x70(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x8(%rdi), %rsi
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x4f54e
movq %r14, %rdi
callq 0x526f2
testb %al, %al
je 0xd1b62
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageLabelDocumentHelper::pageLabelDict(qpdf_page_label_e, int, std::basic_string_view<char, std::char_traits<char>>) | QPDFObjectHandle
QPDFPageLabelDocumentHelper::pageLabelDict(
qpdf_page_label_e label_type, int start_num, std::string_view prefix)
{
auto num = QPDFObjectHandle::newDictionary();
switch (label_type) {
case pl_none:
break;
case pl_digits:
num.replaceKey("/S", "/D"_qpdf);
break... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
callq 0xc8e76
decl %r12d
cmpl $0x4, %r12d
ja 0xd4415
leaq 0xa6549(%rip), %rax # 0x17a7ac
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x18(... | /qpdf[P]qpdf/libqpdf/QPDFPageLabelDocumentHelper.cc |
QPDFPageObjectHelper::QPDFPageObjectHelper(QPDFObjectHandle) | QPDFPageObjectHelper::QPDFPageObjectHelper(QPDFObjectHandle oh) :
QPDFObjectHelper(oh)
{
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xd4815
movq 0x11c775(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xd482a
incl 0x8(%rdi)
jmp 0xd4833
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0xd4858
lock
incl 0x8(%rdi)
cmpb $0x0, ... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::function<QPDFObjectHandle ()>, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getAttribute(
std::string const& name,
bool copy_if_shared,
std::function<QPDFObjectHandle()> get_fallback,
bool copy_if_fallback)
{
const bool is_form_xobject = oh().isFormXObject();
bool inherited = false;
auto dict = is_form_xobject ? oh().getDict() ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %r12d
movq %r8, %r13
movl %ecx, 0x6c(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0xd492e
movq 0x11c660(%rip),... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getMediaBox(bool) | QPDFObjectHandle
QPDFPageObjectHelper::getMediaBox(bool copy_if_shared)
{
return getAttribute("/MediaBox", copy_if_shared);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xa5a97(%rip), %rsi # 0x17a8c0
leaq 0xa5a99(%rip), %rdx # 0x17a8c9
movq %rsp, %r15
movq %r15, %rdi
callq 0x1fa24
movq %rbx, %rdi
movq %r14, %r... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getArtBox(bool, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getArtBox(bool copy_if_shared, bool copy_if_fallback)
{
return getAttribute(
"/ArtBox",
copy_if_shared,
[this, copy_if_shared, copy_if_fallback]() {
return this->getCropBox(copy_if_shared, copy_if_fallback);
},
copy_if_fallba... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xa582d(%rip), %rsi # 0x17a8dc
leaq 0xa582d(%rip), %rdx # 0x17a8e3
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x1... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::forEachXObject(bool, std::function<void (QPDFObjectHandle&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>, std::function<bool (QPDFObjectHandle)>) | void
QPDFPageObjectHelper::forEachXObject(
bool recursive,
std::function<void(QPDFObjectHandle& obj, QPDFObjectHandle& xobj_dict, std::string const& key)>
action,
std::function<bool(QPDFObjectHandle)> selector)
{
QTC::TC(
"qpdf",
"QPDFPageObjectHelper::forEachXObject",
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
movl %esi, 0xc(%rsp)
testl %esi, %esi
je 0xd52d0
movq 0x8(%r12), %rax
movq %rax, 0x88(%rsp)
movq 0x10(%r12), %rax
movq %rax, 0x90(%rsp)
testq %rax, %rax
je 0xd5304
movq 0x11bcba(%rip), %rcx... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::forEachFormXObject(bool, std::function<void (QPDFObjectHandle&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>) | void
QPDFPageObjectHelper::forEachFormXObject(
bool recursive,
std::function<void(QPDFObjectHandle& obj, QPDFObjectHandle& xobj_dict, std::string const& key)>
action)
{
forEachXObject(recursive, action, [](QPDFObjectHandle obj) { return obj.isFormXObject(); });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xdc394
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x6850(%rip), %rax # 0xdc0dc
movq %rax, 0x18(%rcx)
leaq 0x6895(%rip), %rax # 0xdc12c
movq %rax, 0x1... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getFormXObjects[abi:cxx11]() | std::map<std::string, QPDFObjectHandle>
QPDFPageObjectHelper::getFormXObjects()
{
std::map<std::string, QPDFObjectHandle> result;
forEachFormXObject(
false, [&result](QPDFObjectHandle& obj, QPDFObjectHandle&, std::string const& key) {
result[key] = obj;
});
return result;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x8(%rsp), %rdx
movq %rcx, 0x8(%rdx)
movq %rdi, (%rdx)
leaq 0x676e(%rip), %rax # 0xdc190
movq %rax, 0x18(%rdx... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::filterContents(QPDFObjectHandle::TokenFilter*, Pipeline*) | void
QPDFPageObjectHelper::filterContents(QPDFObjectHandle::TokenFilter* filter, Pipeline* next)
{
if (oh().isFormXObject()) {
oh().filterAsContents(filter, next);
} else {
oh().filterPageContents(filter, next);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xd63ab
movq 0x11abe3(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xd63a7
incl 0x8(%rax)
jmp 0xd63ab
l... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getAnnotations(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<QPDFAnnotationObjectHelper>
QPDFPageObjectHelper::getAnnotations(std::string const& only_subtype)
{
std::vector<QPDFAnnotationObjectHelper> result;
QPDFObjectHandle annots = oh().getKey("/Annots");
if (annots.isArray()) {
int nannots = annots.getArrayNItems();
for (int i = 0; i <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x50(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x28(%rsp)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0xd6520
movq 0x11aa6e(%r... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::parseContents(QPDFObjectHandle::ParserCallbacks*) | void
QPDFPageObjectHelper::parseContents(QPDFObjectHandle::ParserCallbacks* callbacks)
{
if (oh().isFormXObject()) {
oh().parseAsContents(callbacks);
} else {
oh().parsePageContents(callbacks);
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd6921
movq 0x11a66d(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xd691d
incl 0x8(%rax)
jmp 0xd6921
lock
incl 0x8(%rax)
movq %rsp, %... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getMatrixForFormXObjectPlacement(QPDFObjectHandle, QPDFObjectHandle::Rectangle, bool, bool, bool) | QPDFMatrix
QPDFPageObjectHelper::getMatrixForFormXObjectPlacement(
QPDFObjectHandle fo,
QPDFObjectHandle::Rectangle rect,
bool invert_transformations,
bool allow_shrink,
bool allow_expand)
{
// Calculate the transformation matrix that will place the given form XObject fully inside the
// giv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movl %r9d, %r14d
movl %r8d, %ebp
movl %ecx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
movq %rdx, %rsi
callq 0x10004e
leaq 0xa0(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8a146(%rip), %rsi # ... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::copyAnnotations(QPDFPageObjectHelper, QPDFMatrix const&, QPDFAcroFormDocumentHelper*, QPDFAcroFormDocumentHelper*) | void
QPDFPageObjectHelper::copyAnnotations(
QPDFPageObjectHelper from_page,
QPDFMatrix const& cm,
QPDFAcroFormDocumentHelper* afdh,
QPDFAcroFormDocumentHelper* from_afdh)
{
auto old_annots = from_page.getObjectHandle().getKey("/Annots");
if (!old_annots.isArray()) {
return;
}
QP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r8, 0x28(%rsp)
movq %rcx, %r12
movq %rdx, 0xe8(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xda3c9
movq 0... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
(anonymous namespace)::ContentProvider::provideStreamData(QPDFObjGen const&, Pipeline*) | void
ContentProvider::provideStreamData(QPDFObjGen const&, Pipeline* p)
{
Pl_Concatenate concat("concatenate", p);
std::string description = "contents from page object " + from_page.getObjGen().unparse(' ');
std::string all_description;
from_page.getKey("/Contents").pipeContentStreams(&concat, descripti... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x82f1b(%rip), %rsi # 0x15ec75
leaq 0x70(%rsp), %rdi
callq 0x3396c
addq $0x10, %rbx
movq %rbx, %rdi
callq 0xc51f0
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
movl $0x20, %edx
callq 0x3f3fa
leaq 0x9ef47(%rip), %rcx # 0x... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFParser::parse(bool&, bool) | QPDFObjectHandle
QPDFParser::parse(bool& empty, bool content_stream)
{
// This method must take care not to resolve any objects. Don't check the type of any object
// without first ensuring that it is a direct object. Otherwise, doing so may have the side
// effect of reading the object and changing the fil... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0xdd423
movl $0x1, %esi
callq 0x126a32
movb $0x0, (%r15)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax... | /qpdf[P]qpdf/libqpdf/QPDFParser.cc |
QIntC::IntConverter<int, unsigned long long, true, false>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19af0
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19130
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x195d0
movq %rsp, %rdi
callq 0x19b40
leaq ... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QPDF_Array::QPDF_Array(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&&, bool) | QPDF_Array::QPDF_Array(std::vector<QPDFObjectHandle>&& v, bool sparse)
{
if (sparse) {
sp = std::make_unique<Sparse>();
for (auto& item: v) {
if (item.raw_type_code() != ::ot_null || item.indirect()) {
sp->elements[sp->size] = std::move(item);
}
++... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
testl %edx, %edx
je 0xf9006
movl $0x38, %edi
callq 0x19180
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x20(... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::getAsVector() const | std::vector<QPDFObjectHandle>
Array::getAsVector() const
{
auto a = array();
if (a->sp) {
std::vector<QPDFObjectHandle> v;
v.reserve(size_t(size()));
for (auto const& item: a->sp->elements) {
v.resize(size_t(item.first), null_oh);
v.emplace_back(item.second);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf9058
movq %rax, %r15
cmpq $0x0, (%rax)
je 0xf91a4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0xf9058
movq (%rax), %rcx
testq %rcx, %rcx
je 0xf91b8
movl (%rcx), %ecx
jm... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::cend() | Array::const_iterator
Array::cend()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.cend();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->cend();
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0xfb3de
testq %rax, %rax
je 0xf944f
cmpq $0x0, (%rax)
je 0xf9453
movq 0x10(%rbx), %rax
testq %rax, %rax
jne 0xf9449
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xf9162
movl $0x18, %edi
callq 0x19180
addq $0x10, %rbx
movq %rsp, %r14
movaps (%r14), %xmm0
m... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::crend() | Array::const_reverse_iterator
Array::crend()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.crend();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->crend();... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfb3de
testq %rax, %rax
je 0xf95c8
cmpq $0x0, (%rax)
je 0xf95cc
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0xf95d0
movq %rsp, %rdi
movq %r14, %rsi
callq 0xf9162
movl $0x18, %edi
callq 0x19180
addq $0x10, ... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::size() const | int
Array::size() const
{
auto a = array();
return a->sp ? a->sp->size : int(a->elements.size());
} | pushq %rax
callq 0xf9058
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0xf963f
movl (%rax), %eax
jmp 0xf964b
movq 0x10(%rcx), %rax
subq 0x8(%rcx), %rax
shrq $0x4, %rax
popq %rcx
retq
nop
| /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::setAt(int, QPDFObjectHandle const&) | bool
Array::setAt(int at, QPDFObjectHandle const& oh)
{
if (at < 0 || at >= size()) {
return false;
}
auto a = array();
checkOwnership(oh);
if (a->sp) {
a->sp->elements[at] = oh;
} else {
a->elements[size_t(at)] = oh;
}
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
testl %esi, %esi
js 0xf9800
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xf9058
movq (%rax), %rcx
testq %rcx, %rcx
je 0xf9797
movl (%rcx), %ecx
jmp 0xf97a3
movq 0x10(%rax), %rcx
subq 0x8(%rax), %rcx
shrq $0x4, %rcx
cmpl %ebp, %ecx
jle 0xf9... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::insert(int, QPDFObjectHandle const&) | bool
Array::insert(int at, QPDFObjectHandle const& item)
{
auto a = array();
int sz = size();
if (at < 0 || at > sz) {
// As special case, also allow insert beyond the end
return false;
} else if (at == sz) {
push_back(item);
} else {
checkOwnership(item);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r15
movl %esi, 0xc(%rsp)
callq 0xf9058
movq %rax, %r14
movq %r15, %rdi
callq 0xf9058
movq (%rax), %rcx
testq %rcx, %rcx
je 0xf99c2
movl (%rcx), %ecx
jmp 0xf99ce
movq 0x10(%rax), %rcx
subq 0x8(%... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::erase(int) | bool
Array::erase(int at)
{
auto a = array();
if (at < 0 || at >= size()) {
return false;
}
if (a->sp) {
auto end = a->sp->elements.end();
if (auto iter = a->sp->elements.lower_bound(at); iter != end) {
if (iter->first == at) {
iter++;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0x4(%rsp)
callq 0xf9058
testl %ebp, %ebp
js 0xf9e64
movq %rax, %rbx
movq %r14, %rdi
callq 0xf9058
movq (%rax), %rcx
testq %rcx, %rcx
je 0xf9d49
movl (%rcx), %ecx
jmp 0xf9d55
movq 0x10(%rax), %rc... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayItem(int) const | QPDFObjectHandle
QPDFObjectHandle::getArrayItem(int n) const
{
if (auto array = as_array(strict)) {
if (auto const [success, oh] = array.at(n); success) {
return oh;
} else {
objectWarning("returning null for out of bounds array access");
QTC::TC("qpdf", "QPDFObje... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xfa09a
movl %edx, %ebp
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfa059
cmpl $0xd, %eax
jne 0xfa064
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfa05e... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::isMatrix() const | bool
QPDFObjectHandle::isMatrix() const
{
if (auto array = as_array(strict)) {
for (int i = 0; i < 6; ++i) {
if (auto item = array.at(i).second; !item.isNumber()) {
return false;
}
}
return array.size() == 6;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfa4e6
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfa4b1
cmpl $0xd, %eax
jne 0xfa4bc
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfa4b6
callq 0x3fe7f
movq (... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayAsMatrix() const | QPDFObjectHandle::Matrix
QPDFObjectHandle::getArrayAsMatrix() const
{
if (auto array = as_array(strict)) {
if (array.size() != 6) {
return {};
}
double items[6];
for (int i = 0; i < 6; ++i) {
if (auto item = array.at(i).second; !item.getValueAsNumber(items[i])... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xfa831
movq %rsi, %r14
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfa7fc
cmpl $0xd, %eax
jne 0xfa807
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::setArrayItem(int, QPDFObjectHandle const&) | void
QPDFObjectHandle::setArrayItem(int n, QPDFObjectHandle const& item)
{
if (auto array = as_array(strict)) {
if (!array.setAt(n, item)) {
objectWarning("ignoring attempt to set out of bounds array item");
QTC::TC("qpdf", "QPDFObjectHandle set array bounds");
}
} else {... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfab7d
movq %rdx, %r14
movl %esi, %ebp
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfab3c
cmpl $0xd, %eax
jne 0xfab47
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfab41
callq 0x3f... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::appendItem(QPDFObjectHandle const&) | void
QPDFObjectHandle::appendItem(QPDFObjectHandle const& item)
{
if (auto array = as_array(strict)) {
array.push_back(item);
} else {
typeWarning("array", "ignoring attempt to append item");
QTC::TC("qpdf", "QPDFObjectHandle array ignoring append item");
}
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfb006
movq %rsi, %r14
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfafd1
cmpl $0xd, %eax
jne 0xfafdc
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfafd6
callq 0x3fe7f
movq (%rax), %rax
movb ... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::appendItemAndGetNew(QPDFObjectHandle const&) | QPDFObjectHandle
QPDFObjectHandle::appendItemAndGetNew(QPDFObjectHandle const& item)
{
appendItem(item);
return item;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xfaf9c
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xfb117
movq 0xf5e77(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xfb113
incl 0x8(%rax)
jmp 0xfb117
lock
in... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::eraseItem(int) | void
QPDFObjectHandle::eraseItem(int at)
{
if (auto array = as_array(strict)) {
if (!array.erase(at)) {
objectWarning("ignoring attempt to erase out of bounds array item");
QTC::TC("qpdf", "QPDFObjectHandle erase array bounds");
}
} else {
typeWarning("array", "ig... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfb198
movl %esi, %ebp
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfb157
cmpl $0xd, %eax
jne 0xfb162
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfb15c
callq 0x3fe7f
movq (%rax),... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::eraseItemAndGetOld(int) | QPDFObjectHandle
QPDFObjectHandle::eraseItemAndGetOld(int at)
{
auto array = as_array(strict);
auto result = (array && at < array.size() && at >= 0) ? array.at(at).second : newNull();
eraseItem(at);
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xfb311
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfb2dc
cmpl $0xd, %eax
jne 0xfb2e7
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfb2e1
callq 0x3f... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
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.