name string | code string | asm string | file string |
|---|---|---|---|
QPDFObjectHandle::getInlineImageValue[abi:cxx11]() const | std::string
QPDFObjectHandle::getInlineImageValue() const
{
if (isInlineImage()) {
return obj->getStringValue();
} else {
typeWarning("inlineimage", "returning empty data");
QTC::TC("qpdf", "QPDFObjectHandle inlineimage returning empty data");
return "";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c00d0
testb $0x1, %al
jne 0x1c167e
jmp 0x1c1698
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq -0x60(%rbp), %rdi
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isOrHasName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool
QPDFObjectHandle::isOrHasName(std::string const& value) const
{
if (isNameAndEquals(value)) {
return true;
} else if (isArray()) {
for (auto& item: getArrayAsVector()) {
if (item.isNameAndEquals(value)) {
return true;
}
}
}
return fals... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c0250
testb $0x1, %al
jne 0x1c187a
jmp 0x1c1883
movb $0x1, -0x1(%rbp)
jmp 0x1c1952
movq -0x70(%rbp), %rdi
callq 0x1c0100
testb $0x1, %al
jne 0x1c1895
jm... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::mergeResources(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<char>>, std::less<s... | void
QPDFObjectHandle::mergeResources(
QPDFObjectHandle other, std::map<std::string, std::map<std::string, std::string>>* conflicts)
{
if (!(isDictionary() && other.isDictionary())) {
QTC::TC("qpdf", "QPDFObjectHandle merge top type mismatch");
return;
}
auto make_og_to_name = [](QPDFOb... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rsi, -0x3a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1c0130
testb $0x1, %al
jne 0x1c1c54
jmp 0x1c1c64
movq -0x3a8(%rbp), %rdi
callq 0x1c0130
testb $0x1, %al
... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getResourceNames[abi:cxx11]() const | std::set<std::string>
QPDFObjectHandle::getResourceNames() const
{
// Return second-level dictionary keys
std::set<std::string> result;
for (auto const& item: as_dictionary(strict)) {
for (auto const& [key2, val2]: item.second.as_dictionary(strict)) {
if (!val2.null()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xc55d0
movq -0xb8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %ed... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::arrayOrStreamToStreamArray(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>>&) | std::vector<QPDFObjectHandle>
QPDFObjectHandle::arrayOrStreamToStreamArray(
std::string const& description, std::string& all_description)
{
all_description = description;
std::vector<QPDFObjectHandle> result;
if (auto array = as_array(strict)) {
int n_items = array.size();
for (int i = 0... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x318(%rbp)
movq %rdi, %rax
movq %rax, -0x320(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x310(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
ca... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getPageContents() | std::vector<QPDFObjectHandle>
QPDFObjectHandle::getPageContents()
{
std::string description = "page object " + getObjGen().unparse(' ');
std::string all_description;
return this->getKey("/Contents").arrayOrStreamToStreamArray(description, all_description);
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1c2e70
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
leaq -0x58(%rbp), %rsi
movl $0x20, %edx... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::addPageContents(QPDFObjectHandle, bool) | void
QPDFObjectHandle::addPageContents(QPDFObjectHandle new_contents, bool first)
{
new_contents.assertStream();
std::vector<QPDFObjectHandle> content_streams;
if (first) {
QTC::TC("qpdf", "QPDFObjectHandle prepend page contents");
content_streams.push_back(new_contents);
}
for (aut... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rcx
movq -0xc0(%rbp), %rdi
movb %dl, %al
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x1c3f00
leaq -0x30(%rbp), %rdi
callq 0x63310
testb $0x1, -0x11(%rb... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newStream(QPDF*) | QPDFObjectHandle
QPDFObjectHandle::newStream(QPDF* qpdf)
{
if (qpdf == nullptr) {
throw std::runtime_error("attempt to create stream in null qpdf object");
}
QTC::TC("qpdf", "QPDFObjectHandle newStream");
return qpdf->newStream();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c4b52
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x167d72(%rip), %rsi # 0x32c88f
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parse(QPDF*, 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
QPDFObjectHandle::parse(
QPDF* context, std::string const& object_str, std::string const& object_description)
{
// BufferInputSource does not modify the input, but Buffer either requires a string& or copies
// the string.
Buffer buf(const_cast<std::string&>(object_str));
auto input ... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1f850
leaq -0x131(%rbp), %rdi
movq %rdi, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::pipeContentStreams(Pipeline*, 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>>&) | void
QPDFObjectHandle::pipeContentStreams(
Pipeline* p, std::string const& description, std::string& all_description)
{
std::vector<QPDFObjectHandle> streams =
arrayOrStreamToStreamArray(description, all_description);
bool need_newline = false;
Pl_Buffer buf("concatenated content stream buffer")... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x1c32a0
movb $0x0, -0x39(%rbp)
leaq 0x166fd3(%rip), %rsi #... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parseContentStream_data(std::shared_ptr<Buffer>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::ParserCallbacks*, QPDF*) | void
QPDFObjectHandle::parseContentStream_data(
std::shared_ptr<Buffer> stream_data,
std::string const& description,
ParserCallbacks* callbacks,
QPDF* context)
{
size_t stream_length = stream_data->getSize();
auto input = BufferInputSource(description, stream_data.get());
Tokenizer tokenizer... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x390(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x1cc430
movq %rax, %rdi
callq 0x1fa60
movq -0x390(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x388(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newArray(QPDFObjectHandle::Matrix const&) | QPDFObjectHandle
QPDFObjectHandle::newArray(Matrix const& matrix)
{
return newArray(
{newReal(matrix.a),
newReal(matrix.b),
newReal(matrix.c),
newReal(matrix.d),
newReal(matrix.e),
newReal(matrix.f)});
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorl %esi, %esi
movl $0x1, %edx
callq 0x1c7000
jmp 0x1... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newArray(QPDFMatrix const&) | QPDFObjectHandle
QPDFObjectHandle::newArray(QPDFMatrix const& matrix)
{
return newArray(
{newReal(matrix.a),
newReal(matrix.b),
newReal(matrix.c),
newReal(matrix.d),
newReal(matrix.e),
newReal(matrix.f)});
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorl %esi, %esi
movl $0x1, %edx
callq 0x1c7000
jmp 0x1... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newStream(QPDF*, std::shared_ptr<Buffer>) | QPDFObjectHandle
QPDFObjectHandle::newStream(QPDF* qpdf, std::shared_ptr<Buffer> data)
{
if (qpdf == nullptr) {
throw std::runtime_error("attempt to create stream in null qpdf object");
}
QTC::TC("qpdf", "QPDFObjectHandle newStream with data");
return qpdf->newStream(data);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c7bea
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newReserved(QPDF*) | QPDFObjectHandle
QPDFObjectHandle::newReserved(QPDF* qpdf)
{
if (qpdf == nullptr) {
throw std::runtime_error("attempt to create reserved object in null qpdf object");
}
return qpdf->newReserved();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c7d82
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x164bd6(%rip), %rsi # 0x32c923
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isPageObject() const | bool
QPDFObjectHandle::isPageObject() const
{
// See comments in QPDFObjectHandle.hh.
if (getOwningQPDF() == nullptr) {
return false;
}
// getAllPages repairs /Type when traversing the page tree.
getOwningQPDF()->getAllPages();
return isDictionaryOfType("/Page");
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1c3ab0
cmpq $0x0, %rax
jne 0x1c928b
movb $0x0, -0x1(%rbp)
jmp 0x1c9380
movq -0x78(%rbp), %rdi
callq 0x1c3ab0
movq %rax, %rdi
callq 0x2a7070
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be40... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isImage(bool) const | bool
QPDFObjectHandle::isImage(bool exclude_imagemask) const
{
return (
isStreamOfType("", "/Image") &&
((!exclude_imagemask) ||
(!(getDict().getKey("/ImageMask").isBool() &&
getDict().getKey("/ImageMask").getBoolValue()))));
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x1be40
movq -0x120(%rbp), %rdx
movb $0x0, -0x99(%rbp)
movb $0x0, -0xc2(%rb... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
(anonymous namespace)::CoalesceProvider::provideStreamData(QPDFObjGen const&, Pipeline*) | void
CoalesceProvider::provideStreamData(QPDFObjGen const&, Pipeline* p)
{
QTC::TC("qpdf", "QPDFObjectHandle coalesce provide stream data");
std::string description = "page object " + containing_page.getObjGen().unparse(' ');
std::string all_description;
old_contents.pipeContentStreams(p, description, a... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq 0x167a3f(%rip), %rdi # 0x331f38
leaq 0x1626cf(%rip), %rsi # 0x32cbcf
xorl %edx, %edx
callq 0x25230
movq -0xa0(%rbp), %rdi
addq $0x10, %rdi
callq 0x1c2e7... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDF_Bool* qpdf::BaseHandle::as<QPDF_Bool>() const | T*
BaseHandle::as() const
{
if (!obj) {
return nullptr;
}
if (std::holds_alternative<T>(obj->value)) {
return &std::get<T>(obj->value);
}
if (std::holds_alternative<QPDF_Unresolved>(obj->value)) {
return BaseHandle(QPDF::Resolver::resol... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x43890
testb $0x1, %al
jne 0x1cbd7d
movq $0x0, -0x8(%rbp)
jmp 0x1cbebc
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x1d6fc0
testb $0x1, %al
jne 0x1cbd94
jmp 0x1cbdae
movq -0x50(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF_String* qpdf::BaseHandle::as<QPDF_String>() const | T*
BaseHandle::as() const
{
if (!obj) {
return nullptr;
}
if (std::holds_alternative<T>(obj->value)) {
return &std::get<T>(obj->value);
}
if (std::holds_alternative<QPDF_Unresolved>(obj->value)) {
return BaseHandle(QPDF::Resolver::resol... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x43890
testb $0x1, %al
jne 0x1cc09d
movq $0x0, -0x8(%rbp)
jmp 0x1cc1dc
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x1d7020
testb $0x1, %al
jne 0x1cc0b4
jmp 0x1cc0ce
movq -0x50(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
qpdf::Tokenizer::getValue[abi:cxx11]() const | inline std::string const&
getValue() const
{
return (this->type == QPDFTokenizer::tt_name || this->type == QPDFTokenizer::tt_string)
? this->val
: this->raw_val;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x8, 0x8(%rax)
je 0x1cc5d0
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0x1cc5de
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x1cc5ea
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rb... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFTokenizer_private.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
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rsi, -0x160(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x42b80
movq -0x158(%rbp), %rdi
movq... | /jberkenbilt[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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1df340
movq -0x40(%rbp), %rdi
callq 0x1c0100
movb %al, -0x31(%rbp)
jmp 0x1dfd2a
movb -0x31(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFPageDocumentHelper::removeUnreferencedResources() | void
QPDFPageDocumentHelper::removeUnreferencedResources()
{
for (auto& ph: getAllPages()) {
ph.removeUnreferencedResources();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e0e60
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaae10
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaae40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::flattenAnnotationsForPage(QPDFPageObjectHelper&, QPDFObjectHandle&, QPDFAcroFormDocumentHelper&, int, int) | void
QPDFPageDocumentHelper::flattenAnnotationsForPage(
QPDFPageObjectHelper& page,
QPDFObjectHandle& resources,
QPDFAcroFormDocumentHelper& afdh,
int required_flags,
int forbidden_flags)
{
bool need_appearances = afdh.getNeedAppearances();
std::vector<QPDFAnnotationObjectHelper> annots = pa... | pushq %rbp
movq %rsp, %rbp
subq $0x630, %rsp # imm = 0x630
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x520(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa32a0
movb %al, -0x29(%rbp)
movq -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageLabelDocumentHelper::QPDFPageLabelDocumentHelper(QPDF&) | QPDFPageLabelDocumentHelper::QPDFPageLabelDocumentHelper(QPDF& qpdf) :
QPDFDocumentHelper(qpdf),
m(new Members())
{
QPDFObjectHandle root = qpdf.getRoot();
if (root.hasKey("/PageLabels")) {
m->labels =
std::make_shared<QPDFNumberTreeObjectHelper>(root.getKey("/PageLabels"), this->qpd... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0xa9ad0
movq -0xb8(%rbp), %rax
leaq 0x2a94f3(%rip), %rcx # 0x48ca88
movq %rcx, (%rax)
addq $0x10, %rax
movq %rax, -0xb0(%rbp)
movl $0x10, %edi
callq 0x1b2... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageLabelDocumentHelper.cc |
QPDFPageLabelDocumentHelper::getLabelsForPageRange(long long, long long, long long, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&) | void
QPDFPageLabelDocumentHelper::getLabelsForPageRange(
long long start_idx,
long long end_idx,
long long new_start_idx,
std::vector<QPDFObjectHandle>& new_labels)
{
// Start off with a suitable label for the first page. For every remaining page, if that page
// has an explicit entry, copy it. ... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x370(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x368(%rbp)
callq 0x1e3800
movq -... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageLabelDocumentHelper.cc |
QPDFPageObjectHelper::getTrimBox(bool, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getTrimBox(bool copy_if_shared, bool copy_if_fallback)
{
return getAttribute(
"/TrimBox",
copy_if_shared,
[this, copy_if_shared, copy_if_fallback]() {
return this->getCropBox(copy_if_shared, copy_if_fallback);
},
copy_if_fall... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, %rdx
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getBleedBox(bool, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getBleedBox(bool copy_if_shared, bool copy_if_fallback)
{
return getAttribute(
"/BleedBox",
copy_if_shared,
[this, copy_if_shared, copy_if_fallback]() {
return this->getCropBox(copy_if_shared, copy_if_fallback);
},
copy_if_fa... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, %rdx
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getImages[abi:cxx11]() | std::map<std::string, QPDFObjectHandle>
QPDFPageObjectHelper::getImages()
{
std::map<std::string, QPDFObjectHandle> result;
forEachImage(
false, [&result](QPDFObjectHandle& obj, QPDFObjectHandle&, std::string const& key) {
result[key] = obj;
});
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b5910
movq -0x68(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::externalizeInlineImages(unsigned long, bool) | void
QPDFPageObjectHelper::externalizeInlineImages(size_t min_size, bool shallow)
{
if (shallow) {
QPDFObjectHandle resources = getAttribute("/Resources", true);
// Calling mergeResources also ensures that /XObject becomes direct and is not shared with
// other pages.
resources.merge... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2e0(%rbp)
testb $0x1, -0x11(%rbp)
je 0x1e8a57
leaq -0x49(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0x1be40
movq -0x2e8... | /jberkenbilt[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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xaa740
movq -0xc0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xbf790
jmp... | /jberkenbilt[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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xbf790
movq -0x60(%rbp), %rdi
callq 0x1c94e0
movb %al, -0x51(%rbp)
jmp 0x1e9286
leaq -0x20(%rbp), %rdi
callq 0x23380
movb -0x51(%rbp)... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::addContentTokenFilter(std::shared_ptr<QPDFObjectHandle::TokenFilter>) | void
QPDFPageObjectHelper::addContentTokenFilter(
std::shared_ptr<QPDFObjectHandle::TokenFilter> token_filter)
{
if (oh().isFormXObject()) {
oh().addTokenFilter(token_filter);
} else {
oh().addContentTokenFilter(token_filter);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xbf790
movq -0x80(%rbp), %rdi
callq 0x1c94e0
movb %al, -0x71(%rbp)
jmp 0x1e9500
leaq -0x20(%rbp), %rdi
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::shallowCopyPage() | QPDFPageObjectHelper
QPDFPageObjectHelper::shallowCopyPage()
{
QPDF& qpdf = oh().getQPDF("QPDFPageObjectHelper::shallowCopyPage called with a direct object");
QPDFObjectHandle new_page = oh().shallowCopy();
return {qpdf.makeIndirectObject(new_page)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xbf790
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be40
movq -0xa8(%rbp), %rdx
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getMatrixForTransformations(bool) | QPDFObjectHandle::Matrix
QPDFPageObjectHelper::getMatrixForTransformations(bool invert)
{
QPDFObjectHandle::Matrix matrix(1, 0, 0, 1, 0, 0);
QPDFObjectHandle bbox = getTrimBox(false);
if (!bbox.isRectangle()) {
return matrix;
}
QPDFObjectHandle rotate_obj = getAttribute("/Rotate", false);
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x1c8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1c0(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movsd 0x1290a6(%rip), %xmm3 # 0x313a10
xorps %xmm5, %xmm5
movaps %... | /jberkenbilt[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
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movl %r8d, -0x3b0(%rbp)
movl %ecx, %eax
movl -0x3b0(%rbp), %ecx
movl %eax, -0x3ac(%rbp)
movq %rdx, %rax
movl -0x3ac(%rbp), %edx
movq %rax, -0x3a8(%rbp)
movq %rsi, %rax
movq -0x3a8(%rbp), %rsi
movq %rax, -0x3a0(%rbp)
movq %rdi, %r8
movq -0x3a0(%rbp), ... | /jberkenbilt[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
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rsi, -0x2a0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x298(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa9bb0
leaq -0x69(%rbp), %rdi
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
(anonymous namespace)::InlineImageTracker::convertIIDict(QPDFObjectHandle) | QPDFObjectHandle
InlineImageTracker::convertIIDict(QPDFObjectHandle odict)
{
QPDFObjectHandle dict = QPDFObjectHandle::newDictionary();
dict.replaceKey("/Type", QPDFObjectHandle::newName("/XObject"));
dict.replaceKey("/Subtype", QPDFObjectHandle::newName("/Image"));
for (auto const& [k, v]: odict.as_dic... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdx, -0x2d0(%rbp)
movq %rdi, -0x2c8(%rbp)
movq %rdi, %rax
movq %rax, -0x2c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1c7a80
leaq -0x4... | /jberkenbilt[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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x11d8d5(%rip), %rsi # 0x30da92
leaq -0x50(%rbp), %rdi
callq 0x4a320
movq -0x110(%rbp), %rdi
addq $0x10, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFParser::parse(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF*) | QPDFObjectHandle
QPDFParser::parse(InputSource& input, std::string const& object_description, QPDF* context)
{
qpdf::Tokenizer tokenizer;
bool empty = false;
return QPDFParser(
input,
make_description(input.getName(), object_description),
object_description,
... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x1a8(%rbp)
movq %rdi, %rax
movq %rax, -0x1a0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1ff680
movb $0x0, -0xb9(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.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
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x200(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq 0x20(%rax), %rs... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::parse(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, qpdf::Tokenizer&, QPDFObjectHandle::StringDecrypter*, QPDF&) | std::pair<QPDFObjectHandle, bool>
QPDFParser::parse(
InputSource& input,
std::string const& object_description,
qpdf::Tokenizer& tokenizer,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF& context)
{
bool empty{false};
auto result = QPDFParser(
input,
... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x10(%rbp), %rdi
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::parse(qpdf::is::OffsetBuffer&, int, int, qpdf::Tokenizer&, QPDF&) | std::pair<QPDFObjectHandle, bool>
QPDFParser::parse(
is::OffsetBuffer& input, int stream_id, int obj_id, qpdf::Tokenizer& tokenizer, QPDF& context)
{
bool empty{false};
auto result = QPDFParser(
input,
std::make_shared<QPDFObject::Description>(
... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::add(std::shared_ptr<QPDFObject>&&) | void
QPDFParser::add(std::shared_ptr<QPDFObject>&& obj)
{
if (frame->state != st_dictionary_value) {
// If state is st_dictionary_key then there is a missing key. Push onto olist for
// processing once the tt_dict_close token has been found.
frame->olist.emplace_back(std::move(obj));
} e... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x60(%rax), %rax
cmpl $0x1, 0x48(%rax)
je 0x1fa355
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fc1f0
jmp 0x1fa3a4
movq -0x38(%rbp), %rax
movq 0x60(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::warn(long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
QPDFParser::warn(qpdf_offset_t offset, std::string const& msg) const
{
if (stream_id) {
std::string descr = "object "s + std::to_string(obj_id) + " 0";
std::string name = context->getFilename() + " object stream " + std::to_string(stream_id);
warn(QPDFExc(qpdf_e_damaged_pdf, name, descr... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
cmpl $0x0, 0x3c(%rax)
je 0x1fa9e1
leaq 0x1312c7(%rip), %rsi # 0x32ba2a
leaq -0x78(%rbp), %rdi
movl $0x7, %edx
callq 0x48980
movq -0x2... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::warn(QPDFExc const&) const | void
QPDFParser::warn(QPDFExc const& e) const
{
// If parsing on behalf of a QPDF object and want to give a warning, we can warn through the
// object. If parsing for some other reason, such as an explicit creation of an object from a
// string, then just throw the exception.
if (context) {
cont... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x1fafe2
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d9a0
jmp 0x1fb02f
movl $0x80, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi,... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::QPDFParser(InputSource&, std::shared_ptr<std::variant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, QPDFObject::JSON_Descr, QPDFObject::ChildDescr, QPDFObject::ObjStreamDescr>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, qpdf::Tok... | QPDFParser(
InputSource& input,
std::shared_ptr<QPDFObject::Description> sp_description,
std::string const& object_description,
qpdf::Tokenizer& tokenizer,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF* context,
bool parse_pdf,
int stream_id = 0,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rdx
movq -0x48(%rbp), %rsi
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x3... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFParser.hh |
void QPDFParser::addScalar<QPDF_Bool, bool>(bool&&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
je 0x1fbbb9
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x761c0
cmpq $0x1388, %rax # imm = 0x1388
ja 0x1fbbac
movq -0x38(%rbp), %rax
movq 0x60(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<QPDF_Operator, 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&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
je 0x1fbf79
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x761c0
cmpq $0x1388, %rax # imm = 0x1388
ja 0x1fbf6c
movq -0x38(%rbp), %rax
movq 0x60(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<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&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
je 0x1fc069
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x761c0
cmpq $0x1388, %rax # imm = 0x1388
ja 0x1fc05c
movq -0x38(%rbp), %rax
movq 0x60(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<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>>&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
je 0x1fc159
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x761c0
cmpq $0x1388, %rax # imm = 0x1388
ja 0x1fc14c
movq -0x38(%rbp), %rax
movq 0x60(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
qpdf::Tokenizer::inTop(char) | void
Tokenizer::inTop(char ch)
{
switch (ch) {
case '(':
string_depth = 1;
state = st_in_string;
return;
case '<':
state = st_lt;
return;
case '>':
state = st_gt;
return;
case (')'):
type = tt::tt_bad;
QTC::TC("qpdf", "QPDFTo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x28, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x55, %eax
ja 0x1ffd2c
movq -0x18(%rbp), %rax
leaq 0x12e815(%rip), %rcx # 0x32e430
... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inComment(char) | void
Tokenizer::inComment(char ch)
{
if ((ch == '\r') || (ch == '\n')) {
if (include_ignorable) {
type = tt::tt_comment;
in_token = false;
char_to_unread = ch;
state = st_token_ready;
} else {
state = st_before_token;
}
}
} | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0x1ffdb8
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x1ffdeb
movq -0x18(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x1ffddf
movq -0x18(%rbp), %rax
movl ... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inLt(char) | void
Tokenizer::inLt(char ch)
{
if (ch == '<') {
type = tt::tt_dict_open;
state = st_token_ready;
return;
}
state = st_in_hexstring;
inHexstring(ch);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x3c, %eax
jne 0x1ffe26
movq -0x18(%rbp), %rax
movl $0x6, 0x8(%rax)
movl $0x15, (%rax)
jmp 0x1ffe39
movq -0x18(%rbp), %rdi
movl $0x1, (%rdi)
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inString(char) | void
Tokenizer::inString(char ch)
{
switch (ch) {
case '\\':
state = st_string_escape;
return;
case '(':
val += ch;
++string_depth;
return;
case ')':
if (--string_depth == 0) {
type = tt::tt_string;
state = st_token_ready;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xa, %eax
je 0x1fffc4
jmp 0x1ffefc
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x1fffa6
jmp 0x1fff0a
movl -0x10(%rbp), %ea... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inNumber(char) | void
Tokenizer::inNumber(char ch)
{
if (util::is_digit(ch)) {
} else if (ch == '.') {
state = st_real;
} else if (isDelimiter(ch)) {
type = tt::tt_integer;
state = st_token_ready;
in_token = false;
char_to_unread = ch;
} else {
state = st_literal;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x63ce0
testb $0x1, %al
jne 0x2000c9
jmp 0x2000cb
jmp 0x20011e
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %eax
jne 0x2000e0
movq -0x18(%rbp), %rax
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inReal(char) | void
Tokenizer::inReal(char ch)
{
if (util::is_digit(ch)) {
} else if (isDelimiter(ch)) {
type = tt::tt_real;
state = st_token_ready;
in_token = false;
char_to_unread = ch;
} else {
state = st_literal;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x63ce0
testb $0x1, %al
jne 0x200159
jmp 0x20015b
jmp 0x200197
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x1ff7f0
testb $0x1, %al
jn... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inCharCode(char) | void
Tokenizer::inCharCode(char ch)
{
bool handled = false;
if (('0' <= ch) && (ch <= '7')) {
char_code = 8 * char_code + (int(ch) - int('0'));
if (++(digit_count) < 3) {
return;
}
handled = true;
}
// We've accumulated \ddd or we have \d or \dd followed by ot... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0xa(%rbp)
movsbl -0x9(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x20035a
movsbl -0x9(%rbp), %eax
cmpl $0x37, %eax
jg 0x20035a
movq -0x18(%rbp), %rcx
movl 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inLiteral(char) | void
Tokenizer::inLiteral(char ch)
{
if (isDelimiter(ch)) {
// A C-locale whitespace character or delimiter terminates token. It is important to unread
// the whitespace character even though it is ignored since it may be the newline after a
// stream keyword. Removing it here could make t... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x1ff7f0
testb $0x1, %al
jne 0x2003c9
jmp 0x200448
movq -0x18(%rbp), %rdi
movb $0x0, 0x71(%rdi)
movb -0x9(%rbp), %al
movb %al, 0x72(%rdi)
movl ... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inHexstring2nd(char) | void
Tokenizer::inHexstring2nd(char ch)
{
if (char hval = util::hex_decode_char(ch); hval < '\20') {
val += char(char_code) | hval;
state = st_in_hexstring;
} else if (ch == '>') {
// PDF spec says odd hexstrings have implicit trailing 0.
val += char(char_code);
type = t... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x31490
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x10, %eax
jge 0x2006e9
movq -0x90(%rbp), %rdi
movl 0x88(%rdi), %eax
movsbl %al, %ea... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inSign(char) | void
Tokenizer::inSign(char ch)
{
if (util::is_digit(ch)) {
state = st_number;
} else if (ch == '.') {
state = st_decimal;
} else {
state = st_literal;
inLiteral(ch);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x63ce0
testb $0x1, %al
jne 0x200a69
jmp 0x200a75
movq -0x18(%rbp), %rax
movl $0xf, (%rax)
jmp 0x200a9f
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %ea... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::presentEOF() | void
Tokenizer::presentEOF()
{
switch (state) {
case st_name:
case st_name_hex1:
case st_name_hex2:
case st_number:
case st_real:
case st_sign:
case st_decimal:
case st_literal:
QTC::TC("qpdf", "QPDFTokenizer EOF reading appendable token");
// Push any delimiter to th... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x15, %rax
ja 0x200ced
movq -0x10(%rbp), %rax
leaq 0x12dac5(%rip), %rcx # 0x32e734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1312b9(%rip), %... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::findEI(InputSource&) | void
Tokenizer::findEI(InputSource& input)
{
qpdf_offset_t last_offset = input.getLastOffset();
qpdf_offset_t pos = input.tell();
// Use QPDFWordTokenFinder to find EI surrounded by delimiters. Then read the next several
// tokens or up to EOF. If we find any suspicious-looking or tokens, this is proba... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rdi
callq 0x248c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::nextToken(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | bool
Tokenizer::nextToken(InputSource& input, std::string const& context, size_t max_len)
{
if (state != st_inline_image) {
reset();
}
qpdf_offset_t offset = input.fastTell();
while (state != st_token_ready) {
char ch;
if (!input.fastRead(ch)) {
presentEOF();
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0xd, (%rax)
je 0x20142e
movq -0x38(%rbp), %rdi
callq 0x1ff410
movq -0x10(%rbp), %rdi
callq 0x2022a0
movq %rax, -0x28(%rbp)
movq -0x38(... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::readToken(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, unsigned long) | QPDFTokenizer::Token
Tokenizer::readToken(InputSource& input, std::string const& context, bool allow_bad, size_t max_len)
{
nextToken(input, context, max_len);
Token token;
bool unread_char;
char char_to_unread;
getToken(token, unread_char, char_to_unread);
if (token.getType() == tt::tt_bad) {... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x98(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
(anonymous namespace)::QPDFWordTokenFinder::check() | bool
QPDFWordTokenFinder::check()
{
// Find a word token matching the given string, preceded by a delimiter, and followed by a
// delimiter or EOF.
Tokenizer tokenizer;
tokenizer.nextToken(is, "finder", str.size() + 2);
qpdf_offset_t pos = is.tell();
if (tokenizer.getType() != tt::tt_word || tok... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1ff680
movq -0x118(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x110(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1be40
movq -0x108(... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
InputSource::fastRead(char&) | inline bool
InputSource::fastRead(char& ch)
{
// Before calling fastRead, fastTell must be called to prepare the buffer. Once reading is
// complete, fastUnread must be called to set the correct file position.
if (buf_idx < buf_len) {
ch = buffer[buf_idx];
++(buf_idx);
++(last_offset... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x98(%rcx), %rax
cmpq 0x90(%rcx), %rax
jge 0x2023a1
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rcx
movb 0x10(%rax,%rcx), %dl
movq -0x18(%rbp), %rcx
movb %dl, (%rcx)
movq 0x98(%rax),... | /jberkenbilt[P]qpdf/libqpdf/qpdf/InputSource_private.hh |
QPDFWriter::Members::~Members() | QPDFWriter::Members::~Members()
{
if (file && close_file) {
fclose(file);
}
delete output_buffer;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x202d56
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x202d56
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1b610
jmp 0x202d54
jmp 0x202d56
movq -0x10(%rbp), %rax
movq 0x30... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setOutputFile(char const*, _IO_FILE*, bool) | void
QPDFWriter::setOutputFile(char const* description, FILE* file, bool close_file)
{
m->filename = description;
m->file = file;
m->close_file = close_file;
std::shared_ptr<Pipeline> p = std::make_shared<Pl_StdioFile>("qpdf output", file);
m->to_delete.push_back(p);
initializePipelineStack(p.ge... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x219250
movq -0x80(%rbp), %rcx
movq -0x60(%rbp), %rdi
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::initializePipelineStack(Pipeline*) | void
QPDFWriter::initializePipelineStack(Pipeline* p)
{
m->pipeline = new pl::Count(1, p);
m->to_delete.emplace_back(std::shared_ptr<Pipeline>(m->pipeline));
m->pipeline_stack.emplace_back(m->pipeline);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x58, %edi
callq 0x1b250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x2198e0
jmp 0x2032cc
movq -0x40(%rbp), %rdi
callq 0x21... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setOutputMemory() | void
QPDFWriter::setOutputMemory()
{
m->filename = "memory buffer";
m->buffer_pipeline = new Pl_Buffer("qpdf output");
m->to_delete.push_back(std::shared_ptr<Pipeline>(m->buffer_pipeline));
initializePipelineStack(m->buffer_pipeline);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x219250
leaq 0x12b904(%rip), %rcx # 0x32ecc4
movq %rcx, 0x10(%rax)
movl $0x38, %edi
callq 0x1b250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x12b8d9(%rip), %rsi # 0x32ecb8
xorl %... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setStreamDataMode(qpdf_stream_data_e) | void
QPDFWriter::setStreamDataMode(qpdf_stream_data_e mode)
{
switch (mode) {
case qpdf_s_uncompress:
m->stream_decode_level = std::max(qpdf_dl_generalized, m->stream_decode_level);
m->compress_streams = false;
break;
case qpdf_s_preserve:
m->stream_decode_level = qpdf_dl_no... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x2035ca
jmp 0x2035b3
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x20360d
jmp 0x2035bd
movl -0x18(%rbp), %eax
subl $0x2, %e... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setMinimumPDFVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void
QPDFWriter::setMinimumPDFVersion(std::string const& version, int extension_level)
{
bool set_version = false;
bool set_extension_level = false;
if (m->min_pdf_version.empty()) {
set_version = true;
set_extension_level = true;
} else {
int old_major = 0;
int old_minor... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x16(%rbp)
callq 0x219250
movq %rax, %rdi
addq $0x118, %rdi # imm = 0x118
callq 0x1b450
testb $0x1, %al
jne 0x2038ad
... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::parseVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&) const | void
QPDFWriter::parseVersion(std::string const& version, int& major, int& minor) const
{
major = QUtil::string_to_int(version.c_str());
minor = 0;
size_t p = version.find('.');
if ((p != std::string::npos) && (version.length() > p)) {
minor = QUtil::string_to_int(version.substr(p + 1).c_str());... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b180
movq %rax, %rdi
callq 0x2af070
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setExtraHeaderText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFWriter::setExtraHeaderText(std::string const& text)
{
m->extra_header_text = text;
if ((m->extra_header_text.length() > 0) && (*(m->extra_header_text.rbegin()) != '\n')) {
QTC::TC("qpdf", "QPDFWriter extra header text add newline");
m->extra_header_text += "\n";
} else {
QTC... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x219250
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x1c110
movq -0x28(%rbp), %rdi
callq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR2EncryptionParametersInsecure(char const*, char const*, bool, bool, bool, bool) | void
QPDFWriter::setR2EncryptionParametersInsecure(
char const* user_password,
char const* owner_password,
bool allow_print,
bool allow_modify,
bool allow_extract,
bool allow_annotate)
{
std::set<int> clear;
if (!allow_print) {
clear.insert(3);
}
if (!allow_modify) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movl %r9d, -0xd8(%rbp)
movl %r8d, -0xd4(%rbp)
movl %ecx, %eax
movl -0xd8(%rbp), %ecx
movq %rdx, %r8
movl -0xd4(%rbp), %edx
movq %r8, -0xd0(%rbp)
movq %rsi, %r8
movq %rdi, %r9
movq -0xd0(%rbp), %rdi
movb %al, %sil
movb 0x10(%rbp), %al
movq %r9, -0x8(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::interpretR3EncryptionParameters(std::set<int, std::less<int>, std::allocator<int>>&, char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, qpdf_r3_modify_e) | void
QPDFWriter::interpretR3EncryptionParameters(
std::set<int>& clear,
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl %r9d, %eax
movq %rcx, %r9
movq %rdx, %r10
movq %rsi, %r11
movq %rdi, %rbx
movb %al, %dil
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movb 0x28(%rbp), %al
movb 0x20(%rbp), %cl
movb 0x18(%rbp), %dl
movb 0x10(%rbp), %sil
movq %rbx, -0x10... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR6EncryptionParameters(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool) | void
QPDFWriter::setR6EncryptionParameters(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print,
bool encryp... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r10
movq %rsi, %r11
movq %rdi, %rbx
movb %r9b, %dil
movb %cl, %r9b
movb 0x30(%rbp), %al
movl 0x28(%rbp), %ecx
movb 0x20(%rbp), %cl
movb 0x18(%rbp), %dl
movb 0x10(%rbp), %sil
movq %rbx, -0x20(%rbp)
movq %r11, -0x28(%rbp)
movq %r10, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::generateID() | void
QPDFWriter::generateID()
{
// Generate the ID lazily so that we can handle the user's preference to use static or
// deterministic ID generation.
if (!m->id2.empty()) {
return;
}
QPDFObjectHandle trailer = m->pdf.getTrailer();
std::string result;
if (m->static_id) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x219250
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x1b450
testb $0x1, %al
jne 0x205047
jmp 0x2056cb
movq -0x1b0(%rbp), %rdi
callq 0x219250
movq (%rax), %rsi
leaq -0x18(%rbp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::copyEncryptionParameters(QPDF&) | void
QPDFWriter::copyEncryptionParameters(QPDF& qpdf)
{
m->preserve_encryption = false;
QPDFObjectHandle trailer = qpdf.getTrailer();
if (trailer.hasKey("/Encrypt")) {
generateID();
m->id1 = trailer.getKey("/ID").getArrayItem(0).getStringValue();
QPDFObjectHandle encrypt = trailer.ge... | pushq %rbp
movq %rsp, %rbp
subq $0x600, %rsp # imm = 0x600
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x4d8(%rbp)
callq 0x219250
movb $0x0, 0x49(%rax)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x617b0
leaq -0x41(%rbp), %rdi
movq %rdi, -0x4d0(%rbp)
callq 0x1be40
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::disableIncompatibleEncryption(int, int, int) | void
QPDFWriter::disableIncompatibleEncryption(int major, int minor, int extension_level)
{
if (!m->encrypted) {
return;
}
bool disable = false;
if (compareVersions(major, minor, 1, 3) < 0) {
disable = true;
} else {
int V = QUtil::string_to_int(m->encryption_dictionary["/V"... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x219250
testb $0x1, 0x48(%rax)
jne 0x207f13
jmp 0x2081fd
movq -0x88(%rbp), %rdi
movb $0x0, -0x15(%rbp)
movl -0xc(%rbp), %esi
movl -0x1... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeBinary(unsigned long long, unsigned int) | void
QPDFWriter::writeBinary(unsigned long long val, unsigned int bytes)
{
if (bytes > sizeof(unsigned long long)) {
throw std::logic_error("QPDFWriter::writeBinary called with too many bytes");
}
unsigned char data[sizeof(unsigned long long)];
for (unsigned int i = 0; i < bytes; ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x8, %rax
jbe 0x208374
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x126b5e(%rip), %rsi... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::activatePipelineStack(QPDFWriter::PipelinePopper&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>>) | void
QPDFWriter::activatePipelineStack(
PipelinePopper& pp, bool discard, std::string* str, std::unique_ptr<pl::Link> link)
{
pl::Count* c;
if (link) {
c = new pl::Count(m->next_stack_id, m->count_buffer, std::move(link));
} else if (discard) {
c = new pl::Count(m->next_stack_id, nullptr... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %r8, -0x68(%rbp)
movl %edx, %eax
movq %rdi, %rdx
movq -0x68(%rbp), %rdi
movq %rdx, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x219b20
testb $0x1,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::pushEncryptionFilter(QPDFWriter::PipelinePopper&) | void
QPDFWriter::pushEncryptionFilter(PipelinePopper& pp)
{
if (m->encrypted && (!m->cur_data_key.empty())) {
Pipeline* p = nullptr;
if (m->encrypt_use_aes) {
p = new Pl_AES_PDF(
"aes stream encryption",
m->pipeline,
true,
Q... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x219250
testb $0x1, 0x48(%rax)
je 0x2090ff
movq -0x40(%rbp), %rdi
callq 0x219250
movq %rax, %rdi
addq $0x190, %rdi # imm = 0x190
callq 0x1b450
testb $0x1, %al
jne 0x209... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::enqueueObject(QPDFObjectHandle) | void
QPDFWriter::enqueueObject(QPDFObjectHandle object)
{
if (object.isIndirect()) {
// This owner check can only be done for indirect objects. It is possible for a direct
// object to have an owning QPDF that is from another file if a direct QPDFObjectHandle from
// one file was insert into... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, -0x148(%rbp)
movq %rdi, %rax
movq -0x148(%rbp), %rdi
movq %rdi, -0x140(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
callq 0x1c1bf0
testb $0x1, %al
jne 0x2097b4
jmp 0x209c07
movq -0x140(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::unparseObject(QPDFObjectHandle, int, int, unsigned long, bool) | void
QPDFWriter::unparseObject(
QPDFObjectHandle object, int level, int flags, size_t stream_length, bool compress)
{
QPDFObjGen old_og = object.getObjGen();
int child_flags = flags & ~f_stream;
if (level < 0) {
throw std::logic_error("invalid level in QPDFWriter::unparseObject");
}
// F... | pushq %rbp
movq %rsp, %rbp
subq $0xf60, %rsp # imm = 0xF60
movq %rsi, -0xd08(%rbp)
movq %rdi, %rsi
movq -0xd08(%rbp), %rdi
movb %r9b, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::willFilterStream(QPDFObjectHandle, bool&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool
QPDFWriter::willFilterStream(
QPDFObjectHandle stream,
bool& compress_stream, // out only
bool& is_root_metadata, // out only
std::string* stream_data)
{
compress_stream = false;
is_root_metadata = false;
QPDFObjGen old_og = stream.getObjGen();
QPDFObjectHandle stream_dict = strea... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rsi, -0x240(%rbp)
movq %rdi, %rax
movq -0x240(%rbp), %rdi
movq %rdi, -0x230(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeObjectStreamOffsets(std::vector<long long, std::allocator<long long>>&, int) | void
QPDFWriter::writeObjectStreamOffsets(std::vector<qpdf_offset_t>& offsets, int first_obj)
{
qpdf_assert_debug(first_obj > 0);
bool is_first = true;
auto id = std::to_string(first_obj) + ' ';
for (auto& offset: offsets) {
if (is_first) {
is_first = false;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x20f589
jmp 0x20f5a8
leaq 0x11ffc3(%rip), %rdi # 0x32f553
leaq 0x11f956(%rip), %rsi # 0x32eeed
movl $0... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeObjectStream(QPDFObjectHandle) | void
QPDFWriter::writeObjectStream(QPDFObjectHandle object)
{
// Note: object might be null if this is a place-holder for an object stream that we are
// generating from scratch.
QPDFObjGen old_og = object.getObjGen();
qpdf_assert_debug(old_og.getGen() == 0);
int old_id = old_og.getObj();
int n... | pushq %rbp
movq %rsp, %rbp
subq $0x630, %rsp # imm = 0x630
movq %rsi, -0x598(%rbp)
movq %rdi, %rax
movq -0x598(%rbp), %rdi
movq %rdi, -0x590(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x588(%rbp)
callq 0x1c2e70
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1c... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeObject(QPDFObjectHandle, int) | void
QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index)
{
QPDFObjGen old_og = object.getObjGen();
if ((object_stream_index == -1) && (old_og.getGen() == 0) &&
(m->object_stream_to_objects.count(old_og.getObj()))) {
writeObjectStream(object);
return;
}
ind... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rsi, -0x1f0(%rbp)
movq %rdi, %rax
movq -0x1f0(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
callq 0x1c2e70
movq %rax, -0x1c(%rbp)
xorl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::initializeSpecialStreams() | void
QPDFWriter::initializeSpecialStreams()
{
// Mark all page content streams in case we are filtering or normalizing.
std::vector<QPDFObjectHandle> pages = m->pdf.getAllPages();
int num = 0;
for (auto& page: pages) {
m->page_object_to_seq[page.getObjGen()] = ++num;
QPDFObjectHandle con... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x219250
movq (%rax), %rdi
callq 0x2a7070
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0xab990
movl $0x0, -0x24(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::generateObjectStreams() | void
QPDFWriter::generateObjectStreams()
{
// Basic strategy: make a list of objects that can go into an object stream. Then figure out
// how many object streams are needed so that we can distribute objects approximately evenly
// without having any object stream exceed 100 members. We don't have to worr... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x219250
movq (%rax), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x21a740
movq -0xa8(%rbp), %rdi
callq 0x21a770
movq -0xa0(%rbp), %rdi
addq $0x63, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::write() | void
QPDFWriter::write()
{
doWriteSetup();
// Set up progress reporting. For linearized files, we write two passes. events_expected is an
// approximation, but it's good enough for progress reporting, which is mostly a guess anyway.
m->events_expected = QIntC::to_int(m->pdf.getObjectCount() * (m->linea... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2125a0
movq -0x18(%rbp), %rdi
callq 0x219250
movq (%rax), %rdi
callq 0x284ce0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x219250
movq %rax, %rcx
movq -0x28(%rbp), %rax
movb 0x4a(%rcx), %sil
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getWrittenXRefTable() | std::map<QPDFObjGen, QPDFXRefEntry>
QPDFWriter::getWrittenXRefTable()
{
std::map<QPDFObjGen, QPDFXRefEntry> result;
auto it = result.begin();
m->new_obj.forEach([&it, &result](auto id, auto const& item) -> void {
if (item.xref.getType() != 0) {
it = result.emplace_hint(it, QPDFObjGen(id... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x632a0
movq -0x78(%rbp), %rdi
callq 0x21aba0
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
ca... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::enqueueObjectsPCLm() | void
QPDFWriter::enqueueObjectsPCLm()
{
// Image transform stream content for page strip images. Each of this new stream has to come
// after every page image strip written in the pclm file.
std::string image_transform_content = "q /image Do Q\n";
// enqueue all pages first
std::vector<QPDFObjectHa... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x1be40
movq -0x1d0(%rbp), %rdx
leaq 0x117f7f(%rip), %rsi # 0x32fd07
leaq -0x28(%rbp), %rdi
callq 0x21b70
jmp 0x217d93
leaq -0... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
qpdf::pl::Count::write(unsigned char const*, unsigned long) | void
write(unsigned char const* buf, size_t len) final
{
if (len) {
if (str) {
str->append(reinterpret_cast<char const*>(buf), len);
return;
}
count += static_cast<qpdf_offset_t>(len);
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x219857
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x219825
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
mov... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
qpdf::pl::Count::Count(unsigned long, Pipeline*) | Count(unsigned long id, Pipeline* next = nullptr) :
Pipeline("", next),
id_(id),
pass_immediately_to_next(next)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x1160b9(%rip), %rsi # 0x32f9c0
callq 0x463f0
movq -0x20(%rbp), %rdi
leaq 0x275851(%rip), %rax # 0x48f168
addq $0x10, %rax
movq %... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
ObjTable<QPDFWriter::Object>::forEach(std::function<void (int, QPDFWriter::Object const&)>) | inline void
forEach(std::function<void(int, const T&)> fn)
{
int i = 0;
for (auto const& item: *this) {
fn(i++, item);
}
for (auto const& [id, item]: sparse_elements) {
fn(QIntC::to_int(id), item);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x14(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x226a40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x226a70
movq %rax, -0x30(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
QIntC::IntConverter<long long, unsigned long long, true, false>::error(long long) | 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
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2282f3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
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.