name string | code string | asm string | file string |
|---|---|---|---|
QPDFPageObjectHelper::placeFormXObject(QPDFObjectHandle, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::Rectangle, bool, bool, bool) | std::string
QPDFPageObjectHelper::placeFormXObject(
QPDFObjectHandle fo,
std::string const& name,
QPDFObjectHandle::Rectangle rect,
bool invert_transformations,
bool allow_shrink,
bool allow_expand)
{
QPDFMatrix cm;
return placeFormXObject(fo, name, rect, cm, invert_transformations, allo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %r12d
movl %r8d, %ebp
movq %rcx, 0x40(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb0(%rsp), %r14
leaq 0x48(%rsp), %rdi
callq 0x68630
movq (%r13), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%r13), %rax
movq %rax, 0x38... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::placeFormXObject(QPDFObjectHandle, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::Rectangle, QPDFMatrix&, bool, bool, bool) | std::string
QPDFPageObjectHelper::placeFormXObject(
QPDFObjectHandle fo,
std::string const& name,
QPDFObjectHandle::Rectangle rect,
QPDFMatrix& cm,
bool invert_transformations,
bool allow_shrink,
bool allow_expand)
{
cm = getMatrixForFormXObjectPlacement(
fo, rect, invert_transfo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movb 0x138(%rsp), %al
movb 0x130(%rsp), %dil
leaq 0x110(%rsp), %rcx
movq (%rdx), %r8
movq %r8, 0x20(%rsp)
movq 0x8(%rdx), %rdx
movq %rdx, 0x28(%rsp)
testq %rdx, %rdx
je 0x12edac
movq 0x11a043(%rip), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::flattenRotation(QPDFAcroFormDocumentHelper*) | void
QPDFPageObjectHelper::flattenRotation(QPDFAcroFormDocumentHelper* afdh)
{
QPDF& qpdf = oh().getQPDF("QPDFPageObjectHelper::flattenRotation called with a direct object");
auto rotate_oh = oh().getKey("/Rotate");
int rotate = 0;
if (rotate_oh.isInteger()) {
rotate = rotate_oh.getIntValueAsInt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rsi, 0x78(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x12f181
movq 0x119c6d(%rip), %rcx # 0x248de0
cmpb $0x0, ... | /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
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, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x130434
movq 0x11... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x83a97(%rip), %rsi # 0x1b5875
leaq 0x70(%rsp), %rdi
callq 0x684c0
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x6ef20
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
movl $0x20, %edx
callq 0x9401a
leaq 0x9faa3(%rip), %rcx # 0x... | /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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x13821c
movb $0x0, 0xf(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x10(%rsp), %rdi
movq %rax,... | /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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0x1334d1
movl $0x1, %esi
callq 0x17d7f0
movb $0x0, (%r12)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::parse(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFTokenizer&, bool&, QPDFObjectHandle::StringDecrypter*, QPDF*) | QPDFObjectHandle
QPDFParser::parse(
InputSource& input,
std::string const& object_description,
QPDFTokenizer& tokenizer,
bool& empty,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF* context)
{
return QPDFParser(
input,
make_description(input.getName(), objec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1219a8
m... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rax... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, 0xf(%rsp)
movl $0x50, %edi
callq 0x68ab0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::parseRemainder(bool) | QPDFObjectHandle
QPDFParser::parseRemainder(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 file po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %edx, 0x74(%rsp)
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movl $0x0, 0x68(%rsi)
leaq 0x10(%rsp), %rbx
leaq 0x48(%rsi), %rax
movq %rax, 0xd0(%rsp)
leaq 0xb8(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x98(%rsp), %r... | /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... | movq %rsi, %rdx
movq 0x60(%rdi), %rsi
cmpl $0x1, 0x48(%rsi)
jne 0x13564a
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
addq $0x50, %rsi
callq 0x137062
testb $0x1, %dl
jne 0x13563d
movq %rbx, %rdi
callq 0x1362f4
movq 0x60(%rbx), %rax
movl $0x0, 0x48(%rax)
popq %rbx
retq
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x13701a
no... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::tooManyBadTokens() | bool
QPDFParser::tooManyBadTokens()
{
if (frame->olist.size() > 5'000 || frame->dict.size() > 5'000) {
warn(
"encountered errors while parsing an array or dictionary with more than 5000 "
"elements; giving up on reading object");
return true;
}
if (--max_bad_count > 0... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0x135740
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0x13579a
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x9c7b7(%rip), %rsi # 0x1d1f07
leaq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::warnDuplicateKey() | void
QPDFParser::warnDuplicateKey()
{
QTC::TC("qpdf", "QPDFParser duplicate dict key");
warn(
frame->offset,
"dictionary has duplicated key " + frame->key + "; last occurrence overrides earlier ones");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdx
movq 0x70(%rdx), %r14
addq $0x50, %rdx
leaq 0x9bc93(%rip), %rsi # 0x1d1fa6
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x6c310
leaq 0x9bc9e(%rip), %rsi # 0x1d1fc5
movq %r15, %rdi
callq 0x6b8d0
leaq 0x10(%rsp), %r15
movq %r15... | /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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x13641d
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b880
movl $0x80, %edi
callq 0x6a000
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x6aaa0
movq 0x1128ac(%rip), %rsi # 0x248ce8
movq 0x112825(%rip), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Null>() | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %rbx
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x70, %edi
callq 0x68ab0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x10d152(%rip), %rcx # 0x2435f8
movq %rcx, (%rax)
movb $0x2, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movq $-0x1, 0x68(%rax)... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFObjectHandle QPDFParser::withDescription<QPDF_Integer, long long>(long long&&) | QPDFObjectHandle
QPDFParser::withDescription(Args&&... args)
{
auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
obj->setDescription(context, description, start);
return {obj};
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r13
movl $0x70, %edi
callq 0x68ab0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x10cfee(%rip), %rax # 0x2435f8
movq %rax, (%r14)
leaq 0x10(%r14), %r12
movq %r13, 0x10... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFObjectHandle QPDFParser::withDescription<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&) | QPDFObjectHandle
QPDFParser::withDescription(Args&&... args)
{
auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
obj->setDescription(context, description, start);
return {obj};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x121c5c
movq (%r15), %r15
movq 0x20(%r14), %rax
movq 0x78(%r14), %r12
movq %rax, 0x48(%r15)
movq 0x28(%r14), %rax
movq %rax, 0x38(%r15)
leaq 0x40(%r15), %rdi
addq $0x3... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFObjectHandle QPDFParser::withDescription<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&) | QPDFObjectHandle
QPDFParser::withDescription(Args&&... args)
{
auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
obj->setDescription(context, description, start);
return {obj};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x121e54
movq (%r15), %r15
movq 0x20(%r14), %rax
movq 0x78(%r14), %r12
movq %rax, 0x48(%r15)
movq 0x28(%r14), %rax
movq %rax, 0x38(%r15)
leaq 0x40(%r15), %rdi
addq $0x3... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFObjectHandle QPDFParser::withDescription<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&) | QPDFObjectHandle
QPDFParser::withDescription(Args&&... args)
{
auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
obj->setDescription(context, description, start);
return {obj};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x121d58
movq (%r15), %r15
movq 0x20(%r14), %rax
movq 0x78(%r14), %r12
movq %rax, 0x48(%r15)
movq 0x28(%r14), %rax
movq %rax, 0x38(%r15)
leaq 0x40(%r15), %rdi
addq $0x3... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFObjectHandle QPDFParser::withDescription<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>>&) | QPDFObjectHandle
QPDFParser::withDescription(Args&&... args)
{
auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
obj->setDescription(context, description, start);
return {obj};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x120b86
movq (%r15), %r15
movq 0x20(%r14), %rax
movq 0x78(%r14), %r12
movq %rax, 0x48(%r15)
movq 0x28(%r14), %rax
movq %rax, 0x38(%r15)
leaq 0x40(%r15), %rdi
addq $0x3... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<QPDF_Integer, long long>(long long&&) | 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
je 0x136b84
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0x136b78
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0x136b84
movl $0x0, 0x6c(%rbx)
jmp 0x136c33
... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<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&) | 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
je 0x136c95
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0x136c8c
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0x136c95
movl $0x0, 0x6c(%rbx)
jmp 0x136cf4
... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<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&) | 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
je 0x136d55
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0x136d4c
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0x136d55
movl $0x0, 0x6c(%rbx)
jmp 0x136db4
... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
je 0x136ed5
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0x136ecc
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0x136ed5
movl $0x0, 0x6c(%rbx)
jmp 0x136f34
... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::StackFrame::StackFrame(InputSource&, QPDFParser::parser_state_e) | StackFrame(InputSource& input, parser_state_e state) :
state(state),
offset(input.tell())
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%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, 0x40(%rdi)
movl %edx, 0x48(%rdi)
leaq 0x60(%rdi), %r15
movq %r15, 0x50(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFParser.hh |
QPDFSystemError::createWhat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | std::string
QPDFSystemError::createWhat(std::string const& description, int system_errno)
{
std::string message;
#ifdef _MSC_VER
// "94" is mentioned in the MSVC docs, but it's still safe if the
// message is longer. strerror_s is a templated function that
// knows the size of buf and truncates.
ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFSystemError.cc |
QPDFSystemError::~QPDFSystemError() | ~QPDFSystemError() noexcept override = default; | pushq %rbx
movq %rdi, %rbx
movq 0x110ccb(%rip), %rax # 0x248c70
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x137fc4
movq (%rax), %rsi
incq %rsi
callq 0x68760
movq %rbx, %rdi
popq %rbx
jmp 0x6f2b0
nop
| /jberkenbilt[P]qpdf/include/qpdf/QPDFSystemError.hh |
qpdf::Tokenizer::reset() | void
Tokenizer::reset()
{
state = st_before_token;
type = tt::tt_bad;
val.clear();
raw_val.clear();
error_message = "";
before_token = true;
in_token = false;
char_to_unread = '\0';
inline_image_bytes = 0;
string_depth = 0;
bad = false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x14, (%rdi)
xorl %r14d, %r14d
movl %r14d, 0x8(%rdi)
movq %r14, 0x18(%rdi)
movq 0x10(%rdi), %rax
movb %r14b, (%rax)
movq %r14, 0x38(%rdi)
movq 0x30(%rdi), %rax
movb %r14b, (%rax)
addq $0x50, %rdi
movq 0x58(%rbx), %rdx
leaq 0x9ac05(%rip), %rcx # 0x1d2c26
xorl %e... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::Tokenizer() | Tokenizer::Tokenizer()
{
reset();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movw $0x0, 0x4(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r14
movq %r14, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x40(%rdi), %r12
movq %r12, 0x30(%rdi)
movq %rax, 0x38... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.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 %rbx
movq %rdi, %rbx
cmpl $0x5a, %esi
jg 0x138626
leal -0x28(%rsi), %eax
cmpl $0x16, %eax
ja 0x1386ea
leaq 0x99a4a(%rip), %rcx # 0x1d205c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xf, (%rbx)
jmp 0x1386e8
cmpl $0x7a, %esi
jg 0x138649
cmpl $0x5b, %esi
je 0x1386d2
cmpl $0x5d, %esi
jne 0x1386ea... | /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);
} | cmpb $0x3c, %sil
jne 0x138760
movl $0x6, 0x8(%rdi)
movl $0x15, (%rdi)
retq
movl $0x1, (%rdi)
movsbl %sil, %esi
jmp 0x138b14
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inGt(char) | void
Tokenizer::inGt(char ch)
{
if (ch == '>') {
type = tt::tt_dict_close;
state = st_token_ready;
} else {
type = tt::tt_bad;
QTC::TC("qpdf", "QPDFTokenizer bad >");
error_message = "unexpected >";
in_token = false;
char_to_unread = ch;
state = st... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x3e, %bpl
jne 0x138787
movl $0x5, 0x8(%rbx)
jmp 0x1387b2
movl $0x0, 0x8(%rbx)
leaq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rdx
leaq 0x99a7f(%rip), %rcx # 0x1d221c
movl $0xc, %r8d
xorl %esi, %esi
callq 0x6a930
movb $0x0, 0x71(%rbx)
movb %bpl, 0x72(%r... | /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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %ebp, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x138a53
movzbl %bpl, %eax
movl 0x88(%rbx), %ecx
movl 0x90(%rbx), %edx
leal (%rax,%rcx,8), %eax
addl $-0x30, %eax
movl %eax, 0x88(%rbx)
leal 0x1(%rdx), %ecx
movl %ecx, 0x90(%rbx)
cmpl $0x2, %edx
jl 0x138... | /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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1382e2
testb %al, %al
je 0x138aeb
movb $0x0, 0x71(%rbx)
movb %bpl, 0x72(%rbx)
movl $0x15, (%rbx)
leaq 0x30(%rbx), %r14
leaq 0x97496(%rip), %rsi # 0x1cff3d
movq %r14, %rdi
callq 0x6d210
movl $0xc, %ebp
testl %eax, %eax
je 0x138ae8
leaq 0x97e21(... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inNameHex2(char) | void
Tokenizer::inNameHex2(char ch)
{
if (char hval = util::hex_decode_char(ch); hval < '\20') {
char_code |= int(hval);
} else {
QTC::TC("qpdf", "QPDFTokenizer bad name 2");
error_message = "name with stray # will not work with PDF >= 1.2";
// Use null to encode a bad # -- this ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal -0x30(%r14), %ebp
cmpb $0xa, %bpl
jb 0x138fee
cmpb $0x61, %r14b
jl 0x138fdb
leal -0x57(%r14), %ebp
jmp 0x138fee
leal -0x37(%r14), %eax
cmpb $0x41, %r14b
movzbl %al, %eax
movl $0x10, %ebp
cmovgel %eax, %ebp
cmpb $0xf, %bpl
jg 0x... | /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 %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x15, %rax
ja 0x1391f5
leaq 0x98efd(%rip), %rcx # 0x1d20b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movl $0xc, %esi
callq 0x138320
movb $0x1, 0x71(%rbx)
jmp 0x139218
movl $0xe, 0x8(%rbx)
jmp 0x139218
movzbl 0x5(%rbx), %eax
shll $0x4, %e... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rbx
movq %rdi, 0x48(%rsp)
movq %rsi, %rdi
callq 0x6cf20
movq %rax, 0x40(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %r13
leaq 0x60(%rsp), %r14
xorl... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
(anonymous namespace)::QPDFWordTokenFinder::~QPDFWordTokenFinder() | ~QPDFWordTokenFinder() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x10cf25(%rip), %rax # 0x246c70
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x139d66
movq (%rax), %rsi
incq %rsi
callq 0x68760
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x68760
| /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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x13821c
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x98544(%rip), %rsi # 0x1d22e6
leaq 0x98543(%rip), %rdx # 0x1d22ec
movq %rsp, %rdi
callq 0x68bb0
movq 0x18(%rbx), %rcx
addq $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
QPDFTokenizer::Token::Token(QPDFTokenizer::token_type_e, 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Token(
token_type_e type,
std::string const& value,
std::string raw_value,
std::string error_message) :
type(type),
value(value),
raw_value(raw_value),
error_message(error_message)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq %rdi, %r12
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x68320
leaq 0x28(%... | /jberkenbilt[P]qpdf/include/qpdf/QPDFTokenizer.hh |
QPDFWriter::Members::Members(QPDF&) | QPDFWriter::Members::Members(QPDF& pdf) :
pdf(pdf),
root_og(pdf.getRoot().getObjGen().isIndirect() ? pdf.getRoot().getObjGen() : QPDFObjGen(-1, 0))
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6ac80
movq %r14, %rdi
callq 0x6ef20
movq %rax, %r14
testl %r14d, %r14d
je 0x13a21a
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6ac80
movq %rsp, %rdi
callq 0x6ef20
jmp 0x13a21f
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::Members::~Members() | QPDFWriter::Members::~Members()
{
if (file && close_file) {
fclose(file);
}
delete output_buffer;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x13a5e7
cmpb $0x1, 0x20(%rbx)
jne 0x13a5e7
callq 0x6a2b0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x13a605
movq %r14, %rdi
callq 0x6a8e0
movl $0x8, %esi
movq %r14, %rdi
callq 0x68760
movq 0x418(%rbx), %rdi
testq %rdi, %rdi
je 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::QPDFWriter(QPDF&, char const*, _IO_FILE*, bool) | QPDFWriter::QPDFWriter(QPDF& pdf, char const* description, FILE* file, bool close_file) :
m(new Members(pdf))
{
setOutputFile(description, file, close_file);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movl $0x430, %edi # imm = 0x430
callq 0x68ab0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x13a1d6
movq %r12, (%r15)
leaq 0x8(%r15), %r13
movq... | /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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r8
movq %rdx, (%r8)
movq (%rdi), %rax
movq %rsi, 0x10(%rax)
movq %rdx, 0x18(%rax)
movb %cl, 0x20(%rax)
leaq 0x20(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x979e8(%rip), %rcx # 0x1d23f8
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x58, %edi
callq 0x68ab0
movq %rax, %r14
leaq 0x98171(%rip), %rsi # 0x1d2c26
movq %rax, %rdi
movq %r15, %rdx
callq 0x6db00
leaq 0x10c2e1(%rip), %rax # 0x246da8
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getBufferSharedPointer() | std::shared_ptr<Buffer>
QPDFWriter::getBufferSharedPointer()
{
return std::shared_ptr<Buffer>(getBuffer());
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x30(%rax), %rsi
movq $0x0, 0x30(%rax)
movq %rsi, (%rdi)
addq $0x8, %rdi
callq 0x88586
movq %rbx, %rax
popq %rbx
retq
| /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
cmpq $0x0, 0x120(%rax)
je 0x13ae0f
xorl %eax, %eax
leaq 0x14(%rsp), %r12
movl %eax, (%r12)
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x10(%rsp), %r13
movl %eax, (%r13)
l... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rdi
callq 0x6e450
movl %eax, (%r14)
movl $0x0, (%rbx)
movq %r15, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0x6e3b0
cmpq $-0x1, %rax
je 0x13aedd
cmpq %rax, 0x8(%r15)
jbe 0x13... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::compareVersions(int, int, int, int) const | int
QPDFWriter::compareVersions(int major1, int minor1, int major2, int minor2) const
{
if (major1 < major2) {
return -1;
} else if (major1 > major2) {
return 1;
} else if (minor1 < minor2) {
return -1;
} else if (minor1 > minor2) {
return 1;
} else {
return 0... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %ecx, %esi
jl 0x13b1fe
movl $0x1, %eax
jg 0x13b1fe
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %r8d, %edx
jl 0x13b1fe
setg %al
movzbl %al, %eax
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setMinimumPDFVersion(PDFVersion const&) | void
QPDFWriter::setMinimumPDFVersion(PDFVersion const& v)
{
std::string version;
int extension_level;
v.getVersion(version, extension_level);
setMinimumPDFVersion(version, extension_level);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rax, %rdi
callq 0x6bf50
movl 0x4(%rsp), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d2c0
movq 0x8(%rsp), %rdi... | /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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x168, %r14d # imm = 0x168
movq (%rdi), %rdi
addq %r14, %rdi
callq 0x6e940
movq (%rbx), %rdi
movq 0x170(%rdi), %rax
testq %rax, %rax
je 0x13b2e2
addq %r14, %rdi
movq (%rdi), %rcx
cmpb $0xa, -0x1(%rcx,%rax)
jne 0x13b2ea
addq $0x8, %rsp
popq %rbx
popq %r14
... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setEncryptionParameters(char const*, char const*, int, int, int, std::set<int, std::less<int>, std::allocator<int>>&) | void
QPDFWriter::setEncryptionParameters(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
std::set<int>& bits_to_clear)
{
// PDF specification refers to bits with the low bit numbered 1.
// We have to convert this into a bit field.
// Specification ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, 0x40(%rsp)
movq 0x140(%rsp), %rbx
leaq 0x20(%rsp), %r13
movl $0x1, (%r13)
movq %rbx, %rdi
movq %r13, %rsi
callq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR4EncryptionParametersInsecure(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool, bool) | void
QPDFWriter::setR4EncryptionParametersInsecure(
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,
boo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r9d, %eax
movl %r8d, %r9d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb 0x60(%rsp), %dl
movb 0x68(%rsp), %sil
movb 0x70(%rsp), %dil
movl 0x78(%rsp), %r10d
leaq 0x8(%rsp), %r8
xorl %r11d, %r11d
movl %r11d, (%r8)
movq %r11, 0x8(%r8)
movq... | /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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r9d, %eax
movl %r8d, %r9d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb 0x60(%rsp), %dl
movb 0x68(%rsp), %sil
movb 0x70(%rsp), %dil
movl 0x78(%rsp), %r10d
leaq 0x8(%rsp), %r8
xorl %r11d, %r11d
movl %r11d, (%r8)
movq %r11, 0x8(%r8)
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setEncryptionParametersInternal(int, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> con... | void
QPDFWriter::setEncryptionParametersInternal(
int V,
int R,
int key_len,
int P,
std::string const& O,
std::string const& U,
std::string const& OE,
std::string const& UE,
std::string const& Perms,
std::string const& id1,
std::string const& user_password,
std::string co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r9, 0x128(%rsp)
movl %r8d, 0x4c(%rsp)
movq %rcx, 0x130(%rsp)
movl %edx, %r13d
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdi), %r14
movl %esi, 0xa8(%r14)
movl %edx, 0xac(%r14)
leaq 0x60(%rsp), %r15
movq %r15,... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movb $0x0, 0x49(%rax)
leaq 0x110(%rsp), %rdi
callq 0x6e7e0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x94a85(%rip), %rsi # 0x1d2422
leaq 0x94a86(%rip... | /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 %r14
pushq %rbx
pushq %rax
cmpl $0x9, %edx
jae 0x13e9aa
movl %edx, %eax
movl %edx, %edx
testl %eax, %eax
je 0x13e990
movq %rdx, %rax
decq %rax
movl %eax, %ecx
movb %sil, (%rsp,%rcx)
shrq $0x8, %rsi
testq %rax, %rax
jne 0x13e97e
movq (%rdi), %rax
movq 0x1c8(%rax), %rdi
movq %rsp, %rsi
callq 0x14c916
addq $0x8, %rs... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writePad(unsigned long) | void
QPDFWriter::writePad(size_t nspaces)
{
writeString(std::string(nspaces, ' '));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %r14
movq %r14, %rdi
movl $0x20, %edx
callq 0x6b1f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq (%rbx), %rax
movq 0x1c8(%rax), %rdi
callq 0x14c916
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x13ea99
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::PipelinePopper::~PipelinePopper() | QPDFWriter::PipelinePopper::~PipelinePopper()
{
if (!stack_id) {
return;
}
qpdf_assert_debug(qw->m->pipeline_stack.size() >= 2);
qw->m->pipeline->finish();
qpdf_assert_debug(dynamic_cast<pl::Count*>(qw->m->pipeline_stack.back()) == qw->m->pipeline);
// It might be possible for this asser... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x13ef23
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq 0x380(%rax), %rcx
subq 0x378(%rax), %rcx
cmpq $0x8, %rcx
jbe 0x13ef32
movq 0x1c8(%rax), %rdi
callq 0x14c9ee
movq (%rbx), %rax
movq (%rax), %r15
movq 0x38... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
cmpb $0x1, 0x48(%r12)
jne 0x13f0a6
cmpq $0x0, 0x198(%r12)
je 0x13f0a6
leaq 0x190(%r12), %r13
cmpb $0x1, 0x71(%r12)
jne 0x13f042
movl $0xa8, %edi
callq 0x68ab0
movq %rax, %r15
movq 0x1c8(%r12), ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::openObject(int) | int
QPDFWriter::openObject(int objid)
{
if (objid == 0) {
objid = m->next_objid++;
}
m->new_obj[objid].xref = QPDFXRefEntry(m->pipeline->getCount());
writeString(std::to_string(objid));
writeString(" 0 obj\n");
return objid;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r8
testl %esi, %esi
jne 0x13f381
movq (%r8), %rax
movl 0x298(%rax), %ebx
leal 0x1(%rbx), %ecx
movl %ecx, 0x298(%rax)
movq (%r8), %rdi
movq 0x1c8(%rdi), %rcx
movq 0x248(%rdi), %rax
movq 0x38(%rcx), %rdx
leaq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::closeObject(int) | void
QPDFWriter::closeObject(int objid)
{
// Write a newline before endobj as it makes the file easier to repair.
writeString("\nendobj\n");
writeStringQDF("\n");
auto& new_obj = m->new_obj[objid];
new_obj.length = m->pipeline->getCount() - new_obj.xref.getOffset();
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x1c8(%rax), %rdi
leaq 0x932c4(%rip), %rsi # 0x1d27d8
movl $0x8, %edx
callq 0x14c916
movq (%rbx), %rax
cmpb $0x1, 0x42(%rax)
jne 0x13f53f
movq 0x1c8(%rax), %rdi
leaq 0x936f0(%rip), %rsi # 0x1d2c25
movl $0x1, %edx
callq 0x14c... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6ab30
testb %al, %al
je 0x13f736
movq %r14, %rdi
callq 0x6c940
movq (%rbx), %rcx
cmpq (%rcx), %rax
jne 0x13faaa
movb 0x42(%rcx), %r12b
cmpb $0x1, %r12b
jne 0x13f784
leaq 0x10(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::unparseChild(QPDFObjectHandle, int, int) | void
QPDFWriter::unparseChild(QPDFObjectHandle child, int level, int flags)
{
if (!m->linearized) {
enqueueObject(child);
}
if (child.isIndirect()) {
writeString(std::to_string(m->obj[child].renumber));
writeString(" 0 R");
} else {
unparseObject(child, level, flags);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x0, 0x4a(%rax)
jne 0x13fbef
movq (%r15), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x13fbd3
movq 0x10921b(%rip... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeTrailer(QPDFWriter::trailer_e, int, bool, long long, int) | void
QPDFWriter::writeTrailer(
trailer_e which, int size, bool xref_stream, qpdf_offset_t prev, int linearization_pass)
{
QPDFObjectHandle trailer = getTrimmedTrailer();
if (xref_stream) {
m->cur_data_key.clear();
} else {
writeString("trailer <<");
}
writeStringQDF("\n");
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r9d, %r12d
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r13d
movq %rdi, %rbx
leaq 0xd8(%rsp), %rdi
movq %rbx, %rsi
callq 0x14374c
movq (%rbx), %rax
testl %ebp, %ebp
je 0x142a12
movq $0x0, 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getOriginalID1[abi:cxx11]() | std::string
QPDFWriter::getOriginalID1()
{
QPDFObjectHandle trailer = m->pdf.getTrailer();
if (trailer.hasKey("/ID")) {
return trailer.getKey("/ID").getArrayItem(0).getStringValue();
} else {
return "";
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6e7e0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8e9c4(%rip), %rsi # 0x1d242b
leaq 0x8e9c0(%rip), %rdx # 0x1d242e
movq %rsp, %rdi
callq 0x68bb0
leaq 0x20(%rsp), %rdi
movq ... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rdx, 0x68(%rsp)
movb %al, (%rdx)
movb %al, (%rcx)
movq %rsi, %rdi
callq 0x6ef20
movq %rax, 0xc0(%rsp)
leaq 0xb0(%rsp), %rdi
mo... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
testl %edx, %edx
jle 0x144760
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movl $0x1, %r15d
cmpl $0xa, %edx
jb 0x1444bc
movl $0x4, %r15d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x1444b3
cmp... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6ef20
movq %rax, 0x28(%rsp)
cmpl $-0x1, %r12d
jne 0x145f9d
cmpl $0x0, 0x2c(%rsp)
jne 0x145f9d
movq (%rbx), %rax
movl 0x28(%rsp), %ecx
movq 0x358(%rax), %rsi
addq $0... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::preserveObjectStreams() | void
QPDFWriter::preserveObjectStreams()
{
auto const& xref = QPDF::Writer::getXRefTable(m->pdf);
// Our object_to_object_stream map has to map ObjGen -> ObjGen since we may be generating object
// streams out of old objects that have generation numbers greater than zero. However in an
// existing PDF, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x92c70
movq %rax, %r15
leaq 0x8(%rax), %r12
movq (%rbx), %rax
movb $0x1, 0x240(%rax)
movq 0x18(%r15), %r14
cmpb $0x1, 0x43(%rax)
jne 0x146a46
cmpq %r12, %r14
je 0x146ba3
movabsq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::initializeTables(unsigned long) | void
QPDFWriter::initializeTables(size_t extra)
{
auto size = QIntC::to_size(QPDF::Writer::tableSize(m->pdf) + 100) + extra;
m->obj.resize(size);
m->new_obj.resize(size);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x18845a
addq %rax, %rbx
addq $0x64, %rbx
movl $0x1f0, %edi # imm = 0x1F0
addq (%r14), %rdi
movq %rbx, %rsi
callq 0x14cc26
movl $0x248, %edi # imm = 0x248
addq (%r14), %rdi
movq %rbx, %rsi
ad... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::prepareFileForWrite() | void
QPDFWriter::prepareFileForWrite()
{
m->pdf.fixDanglingReferences();
auto root = m->pdf.getRoot();
auto oh = root.getKey("/Extensions");
if (oh.isDictionary()) {
const bool extensions_indirect = oh.isIndirect();
if (extensions_indirect) {
QTC::TC("qpdf", "QPDFWriter make ... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x6b390
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
callq 0x6ac80
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x70c3c(%rip), %rsi # 0x1b7a49
leaq 0x70c40(%rip), %rdx # 0x1b7a54
mo... | /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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1470c8
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x6a2f0
movq %rax, %r14
movq (%rbx), %rax
movb 0x4a(%rax), %cl
shlq %cl, %r14
testq $-0x80000000, %r14 # imm = 0x80000000
je 0x1476ea
movq %r14, %rdi
callq 0xb820c
movq (%rbx), %rax
movl %r14d, 0x420(%rax)
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeLinearized() | void
QPDFWriter::writeLinearized()
{
// Optimize file and enqueue objects in order
std::map<int, int> stream_cache;
auto skip_stream_parameters = [this, &stream_cache](QPDFObjectHandle& stream) {
auto& result = stream_cache[stream.getObjectID()];
if (result == 0) {
bool compres... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, %rbx
leaq 0x2a0(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq (%rdi), %rsi
movq (%rsi), %rdi
addq $0x1f0, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getRenumberedObjGen(QPDFObjGen) | QPDFObjGen
QPDFWriter::getRenumberedObjGen(QPDFObjGen og)
{
return QPDFObjGen(m->obj[og].renumber, 0);
} | pushq %rax
movq (%rdi), %rdi
movslq %esi, %rsi
movq 0x1f0(%rdi), %rax
movq 0x1f8(%rdi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x149b11
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,4), %rax
jmp 0x149b1d
addq $0x1f0, %rdi ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeEncryptionDictionary() | void
QPDFWriter::writeEncryptionDictionary()
{
m->encryption_dict_objid = openObject(m->encryption_dict_objid);
writeString("<<");
for (auto const& iter: m->encryption_dictionary) {
writeString(" ");
writeString(iter.first);
writeString(" ");
writeString(iter.second);
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x188(%rax), %esi
callq 0x13f358
movq (%rbx), %rcx
movl %eax, 0x188(%rcx)
movq 0x1c8(%rcx), %rdi
leaq 0x88b00(%rip), %rsi # 0x1d2862
movl $0x2, %edx
callq 0x14c916
movq (%rbx), %r12
movq 0x90(%r12), %r14
subq $-0x80, %r12
... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeHeader() | void
QPDFWriter::writeHeader()
{
writeString("%PDF-");
writeString(m->final_pdf_version);
if (m->pclm) {
// PCLm version
writeString("\n%PCLm 1.0\n");
} else {
// This string of binary characters would not be valid UTF-8, so it really should be treated
// as binary.
... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x1c8(%rax), %rdi
leaq 0x6d947(%rip), %rsi # 0x1b77c6
movl $0x5, %edx
callq 0x14c916
movq (%rbx), %rax
movq 0xf0(%rax), %rsi
movq 0xf8(%rax), %rdx
movq 0x1c8(%rax), %rdi
callq 0x14c916
movq (%rbx), %rax
movq 0x1c8(%rax), %rdi
cmpb $0x1, 0x4b(%rax)
jne 0x149ec4
leaq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeHintStream(int) | void
QPDFWriter::writeHintStream(int hint_id)
{
std::string hint_buffer;
int S = 0;
int O = 0;
bool compressed = (m->compress_streams && !m->qdf_mode);
QPDF::Writer::generateHintStream(m->pdf, m->new_obj, m->obj, hint_buffer, S, O, compressed);
openObject(hint_id);
setDataKey(hint_id);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
movl %ebx, 0x34(%rsp)
movl %ebx, 0xc(%rsp)
movq (%rdi), %rdx
cmpb $0x1, 0x3a(%rdx)
jne 0x149f3a
movb 0x4... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeXRefStream(int, int, long long, QPDFWriter::trailer_e, int, int, int, long long, int, long long, long long, bool, int) | qpdf_offset_t
QPDFWriter::writeXRefStream(
int xref_id,
int max_id,
qpdf_offset_t max_offset,
trailer_e which,
int first,
int last,
int size,
qpdf_offset_t prev,
int hint_id,
qpdf_offset_t hint_offset,
qpdf_offset_t hint_length,
bool skip_compression,
int linearizatio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %r9d, %r13d
movl %r8d, %r12d
movl %esi, %r14d
movq %rdi, %r15
movq (%rdi), %rbx
movq 0x1c8(%rbx), %rax
movq 0x38(%rax), %rsi
leaq 0x8(%rsi), %rdi
addq $0x30, %rax
testq %rsi, %rsi
cmovneq %rdi, %rax
xorl %e... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::calculateXrefStreamPadding(long long) | size_t
QPDFWriter::calculateXrefStreamPadding(qpdf_offset_t xref_bytes)
{
// This routine is called right after a linearization first pass xref stream has been written
// without compression. Calculate the amount of padding that would be required in the worst
// case, assuming the number of uncompressed by... | pushq %rbx
leaq 0x3fff(%rsi), %rax
leaq 0x7ffe(%rsi), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0xe, %rcx
leaq (%rcx,%rcx,4), %rbx
addq $0x10, %rbx
cmpq $-0x13fff, %rsi # imm = 0xFFFEC001
jg 0x14bbf7
movq %rbx, %rdi
callq 0x74106
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::enqueueObjectsStandard() | void
QPDFWriter::enqueueObjectsStandard()
{
if (m->preserve_unreferenced_objects) {
QTC::TC("qpdf", "QPDFWriter preserve unreferenced standard");
for (auto const& oh: m->pdf.getAllObjects()) {
enqueueObject(oh);
}
}
// Put root first on queue.
QPDFObjectHandle traile... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, 0x43(%rax)
jne 0x14bc8c
movq (%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x6c9b0
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x14bc84
leaq 0x40(%rsp), %r14
movq 0xfd1a5(%rip), %r13 ... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x87022(%rip), %rsi # 0x1d2efb
leaq 0x87029(%rip), %rdx # 0x1d2f09
leaq 0x78(%rsp), %rdi
callq 0x68bb0
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x6cfc0
leaq 0xd0(... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDF::EncryptionData::EncryptionData(int, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, st... | EncryptionData(
int V,
int R,
int Length_bytes,
int P,
std::string const& O,
std::string const& U,
std::string const& OE,
std::string const& UE,
std::string const& Perms,
std::string const& id1,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq 0x60(%rsp), %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
addq $0x10, %rdi
leaq 0x20(%r12), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x10(%r12)
movq (%r9), %rsi
movq 0x8(%r9), %rd... | /jberkenbilt[P]qpdf/include/qpdf/QPDF.hh |
qpdf::pl::Count::finish() | void
finish() final
{
if (next()) {
if (!pass_immediately_to_next) {
next()->write(reinterpret_cast<unsigned char const*>(str->data()), str->size());
}
next()->finish();
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x14ca1d
cmpb $0x0, 0x50(%rbx)
jne 0x14ca12
movq 0x38(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>> qpdf::pl::create<qpdf::pl::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>>&) | std::unique_ptr<Link>
create(Args&&... args)
{
return std::make_unique<Link>(
nullptr, std::make_unique<P>("", nullptr, std::forward<Args>(args)...));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x38, %edi
callq 0x68ab0
movq %rax, %r14
leaq 0x8608c(%rip), %rsi # 0x1d2c26
movq %rax, %rdi
xorl %edx, %edx
callq 0x6db00
leaq 0xfa31d(%rip), %rax # 0x246ec8
movq %rax, (%r14)
movq %r15, 0x30(%r14)
movq %r14, (%rsp)
movl $0... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
ObjTable<QPDFWriter::NewObject>::resize(unsigned long) | void
resize(size_t a_size)
{
std::vector<T>::resize(a_size);
if (a_size > min_sparse) {
auto it = sparse_elements.begin();
auto end = sparse_elements.end();
while (it != end && it->first < a_size) {
std::vector<T>::operator[](it->first) = std::... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14e7cc
cmpq %r14, 0x48(%rbx)
jae 0x14cd13
movq 0x30(%rbx), %rax
leaq 0x20(%rbx), %r12
cmpq %r12, %rax
je 0x14ccfd
leaq 0x18(%rbx), %r15
movq 0x20(%rax), %rcx
cmpq %r14, %rcx
jae 0x14ccfd
movq (%rbx), %rdx
shlq $0x5, %rcx
movu... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>> qpdf::pl::create<Pl_PNGFilter, Pl_PNGFilter::action_e, unsigned int&>(std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>>, Pl_PNGFilter::action_e&&, unsigned int&) | std::unique_ptr<Link>
create(std::unique_ptr<Link> link, Args&&... args)
{
auto* next = link->next_pl.get();
return std::make_unique<Link>(
std::move(link), std::make_unique<P>("", next, std::forward<Args>(args)...));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rax), %rbp
movl $0x80, %edi
callq 0x68ab0
movq %rax, %r14
movl (%r13), %ecx
movl (%r12), %r8d
movl $0x8, (%rsp)
leaq 0x85ec3(%rip), %rsi # 0x... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
qpdf::pl::Count::~Count() | ~Count() final = default; | pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x14c9a4
movq 0xfbab0(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x14d020
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x68760
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
qpdf::pl::Count::~Count() | 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 %rbx
movq %rdi, %rbx
callq 0x14cfec
movl $0x58, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x68760
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
ObjTable<QPDFWriter::NewObject>::large_element(unsigned long) | T&
large_element(size_t idx)
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < min_sparse) {
min_sparse = idx;
}
if (idx < max_size) {
return sparse_elements[idx];
}
throw std::runtime_error("Impossibly large object id ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movb 0xffd1b(%rip), %al # 0x24d580
testb %al, %al
je 0x14d897
movq (%rsp), %rax
cmpq 0x48(%rbx), %rax
jae 0x14d877
movq %rax, 0x48(%rbx)
cmpq 0xffcfa(%rip), %rax # 0x24d578
jae 0x14d89e
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
qpdf::pl::String::~String() | ~String() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0xfa6f1(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x14e3de
movq (%rax), %rsi
incq %rsi
callq 0x68760
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x68760
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.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
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6d780
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x688a0
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x6ac30
movq %rsp, %rdi
callq 0x6dba0
leaq ... | /jberkenbilt[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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
testl %edx, %edx
je 0x14f612
movq %rdi, %rbx
movl $0x38, %edi
callq 0x68ab0
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xm... | /jberkenbilt[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 0x14f652
movq %rax, %r15
cmpq $0x0, (%rax)
je 0x14f7a2
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x14f652
movq (%rax), %rcx
testq %rcx, %rcx
je 0x14f7b6
movl (%rcx), %ec... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::end() | Array::iterator
Array::end()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.end();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->end();
}
return {}... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x151878
testq %rax, %rax
je 0x14f8f2
cmpq $0x0, (%rax)
je 0x14f8f6
leaq 0x10(%r14), %rbx
cmpq $0x0, 0x10(%r14)
jne 0x14f8e9
movq %rsp, %rdi
movq %r14, %rsi
callq 0x14f760
movl $0x18, %edi
callq 0x68ab0
movq %rsp, %r14
movq (%r14), %rcx
movq %rcx, ... | /jberkenbilt[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, %r14
callq 0x151878
testq %rax, %rax
je 0x14fa5a
cmpq $0x0, (%rax)
je 0x14fa5e
leaq 0x10(%r14), %rbx
cmpq $0x0, 0x10(%r14)
jne 0x14fa51
movq %rsp, %rdi
movq %r14, %rsi
callq 0x14f760
movl $0x18, %edi
callq 0x68ab0
movq %rsp, %r14
movq (%r14), %rcx
movq %rcx, ... | /jberkenbilt[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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x151878
testq %rax, %rax
je 0x14fc11
movq %rax, %r14
cmpq $0x0, (%rax)
je 0x14fc03
leaq 0x10(%r12), %r15
cmpq $0x0, 0x10(%r12)
jne 0x14fbfe
movq %rsp, %rdi
movq %r12, %rsi
callq 0x14f760
movl $... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::null() const | QPDFObjectHandle
Array::null() const
{
return null_oh;
} | movq %rdi, %rax
movq 0xfd964(%rip), %rcx # 0x24d5a8
movq %rcx, (%rdi)
movq 0xfd962(%rip), %rcx # 0x24d5b0
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x14fc6b
movq 0xf9182(%rip), %rdx # 0x248de0
cmpb $0x0, (%rdx)
je 0x14fc67
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::at(int) const | std::pair<bool, QPDFObjectHandle>
Array::at(int n) const
{
auto a = array();
if (n < 0 || n >= size()) {
return {false, {}};
}
if (!a->sp) {
return {true, a->elements[size_t(n)]};
}
auto const& iter = a->sp->elements.find(n);
return {true, iter == a->sp->elements.end() ? null... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14f652
testl %ebp, %ebp
js 0x14fd25
movq %rax, %r14
movq %r15, %rdi
callq 0x14f652
movq (%rax), %rcx
testq %rcx, %rcx
je 0x14fcc2
movl (%rcx), %ecx
jmp 0x14fcce
movq 0x10(%rax), %rcx
subq 0x8(%... | /jberkenbilt[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.