name string | code string | asm string | file string |
|---|---|---|---|
(anonymous namespace)::ArgParser::argEncUserPassword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
ArgParser::argEncUserPassword(std::string const& arg)
{
if (!accumulated_args.empty()) {
usage("positional and dashed encryption arguments may not be mixed");
}
this->used_enc_password_args = true;
this->user_password = arg;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
je 0xed48e
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xd5741(%rip), %rsi # 0x1c2b99
leaq 0xd5775(%rip), %rdx # 0x1c2bd4
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x68... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argEncBits(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
ArgParser::argEncBits(std::string const& arg)
{
if (!accumulated_args.empty()) {
usage("positional and dashed encryption arguments may not be mixed");
}
int keylen = 0;
if (arg == "40") {
keylen = 40;
this->ap.selectOptionTable(O_40_BIT_ENCRYPTION);
} else if (arg == "12... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
je 0xed5d9
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd55f0(%rip), %rsi # 0x1c2b99
leaq 0xd5624(%rip), %rdx # 0x1c2bd4
movq %rsp, %rdi
callq 0x68bb0
movq %rsp, %rsi
movq %rbx, %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
add_help_2(QPDFArgParser&) | static void add_help_2(QPDFArgParser& ap)
{
ap.addOptionHelp("--verbose", "general", "print additional information", R"(Output additional information about various things qpdf is
doing, including information about files created and operations
performed.
)");
ap.addOptionHelp("--progress", "general", "show progress when... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xcf59c(%rip), %rsi # 0x1c39e2
leaq 0xcf59e(%rip), %rdx # 0x1c39eb
leaq 0x40(%rsp), %rdi
callq 0x68bb0
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcf390(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/auto_job_help.hh |
add_help_5(QPDFArgParser&) | static void add_help_5(QPDFArgParser& ap)
{
ap.addOptionHelp("--remove-info", "modification", "remove file information", R"(Exclude file information (except modification date) from the output file.
)");
ap.addOptionHelp("--remove-metadata", "modification", "remove metadata", R"(Exclude metadata from the output file.
)"... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xcf61f(%rip), %rsi # 0x1c7197
leaq 0xcf625(%rip), %rdx # 0x1c71a4
leaq 0x40(%rsp), %rdi
callq 0x68bb0
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd11c2(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/auto_job_help.hh |
QPDFJob::Config::outputFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::outputFile(std::string const& filename)
{
if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
o.m->outfilename = QUtil::make_shared_cstr(filename);
} else {
usage("output file has already been given");
}
return this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
cmpq $0x0, 0x3e0(%rax)
jne 0xfa26d
cmpb $0x0, 0x3c9(%rax)
je 0xfa2ba
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd2e42(%rip), %rsi # 0x1cd0bf
leaq 0xd2e5d(%rip), %rdx # 0x1cd0e1
movq %rsp, %r14
movq %r1... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::collate() | QPDFJob::Config*
QPDFJob::Config::collate()
{
return collate("");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd87fa(%rip), %rdx # 0x1d2c26
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x68bb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x685a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfa45b
movq 0x10(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::decrypt() | QPDFJob::Config*
QPDFJob::Config::decrypt()
{
o.m->decrypt = true;
o.m->encrypt = false;
o.m->copy_encryption = false;
return this;
} | movq %rdi, %rax
movq (%rdi), %rcx
movq (%rcx), %rcx
movb $0x1, 0x59(%rcx)
xorl %edx, %edx
movb %dl, 0xc0(%rcx)
movb %dl, 0x8a(%rcx)
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::flattenAnnotations(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::flattenAnnotations(std::string const& parameter)
{
o.m->flatten_annotations = true;
if (parameter == "screen") {
o.m->flatten_annotations_forbidden |= an_no_view;
} else if (parameter == "print") {
o.m->flatten_annotations_required |= an_print;
} else if... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x189(%rax)
leaq 0xc7d2b(%rip), %rsi # 0x1c24fe
movq %r14, %rdi
callq 0x6d210
testl %eax, %eax
je 0xfa847
leaq 0xce7ba(%rip), %rsi # 0x1c8fa0
movq %r14, %rdi
callq 0x6d210
testl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::json(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::json(std::string const& parameter)
{
if (parameter.empty() || (parameter == "latest")) {
o.m->json_version = JSON::LATEST;
} else {
o.m->json_version = QUtil::string_to_int(parameter.c_str());
}
if ((o.m->json_version < 1) || (o.m->json_version > JSON::L... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, %ebp
cmpq $0x0, 0x8(%rsi)
je 0xfa9cf
leaq 0xc7b4c(%rip), %rsi # 0x1c2505
movq %r14, %rdi
callq 0x6d210
testl %eax, %eax
je 0xfa9cf
movq (%r14), %rdi
callq 0x6e450
movl %eax, %ebp
movq (%rbx), %rax
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::jsonOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::jsonOutput(std::string const& parameter)
{
o.m->json_output = true;
json(parameter);
if (!o.m->json_stream_data_set) {
// No need to set json_stream_data_set -- that indicates explicit use of --json-stream-data.
o.m->json_stream_data = qpdf_sj_inline;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x3f1(%rax)
callq 0x6d5f0
movq (%rbx), %rax
movq (%rax), %r14
cmpb $0x0, 0x2f4(%r14)
jne 0xfac77
movl $0x1, 0x2f0(%r14)
cmpb $0x0, 0x140(%r14)
jne 0xfac8c
movl $0x0, 0x13c(%r14)
leaq 0x18(%rsp), %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::normalizeContent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::normalizeContent(std::string const& parameter)
{
o.m->normalize_set = true;
o.m->normalize = (parameter == "y");
return this;
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq (%rcx), %rcx
movb $0x1, 0x141(%rcx)
leaq 0xcba60(%rip), %rsi # 0x1c68ad
movq %rax, %rdi
callq 0x6d210
testl %eax, %eax
movq (%rbx), %rax
movq (%rax), %rax
sete 0x142(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::password(std::string const& parameter)
{
o.m->password = QUtil::make_shared_cstr(parameter);
return this;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6e1a0
movq (%rbx), %rax
movq (%rax), %rax
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x50(%rax), %rdi
movups %xmm0, 0x48(%rax)
testq %rdi, %rdi
je 0xfaf14
callq 0x69d60
movq 0x8(%rsp), %rdi
testq %rdi, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::removeAttachment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::removeAttachment(std::string const& parameter)
{
o.m->attachments_to_remove.push_back(parameter);
return this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %r15
leaq 0x240(%r15), %r14
movq %r14, %rdi
callq 0x69e70
movq %rax, %rdi
movq %r14, %rsi
callq 0x690b0
incq 0x250(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::showAttachment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::showAttachment(std::string const& parameter)
{
o.m->attachment_to_show = parameter;
o.m->require_outfile = false;
return this;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movl $0x220, %edi # imm = 0x220
addq (%rax), %rdi
callq 0x6e940
movq (%rbx), %rax
movq (%rax), %rax
movb $0x0, 0x3c8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::splitPages(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::splitPages(std::string const& parameter)
{
int n = (parameter.empty() ? 1 : QUtil::string_to_int(parameter.c_str()));
o.m->split_pages = n;
return this;
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xfb1b7
movq (%rsi), %rdi
callq 0x6e450
jmp 0xfb1bc
movl $0x1, %eax
movq (%rbx), %rcx
movq (%rcx), %rcx
movl %eax, 0x5c(%rcx)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::passwordFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::passwordFile(std::string const& parameter)
{
std::list<std::string> lines;
if (parameter == "-") {
QTC::TC("qpdf", "QPDFJob_config password stdin");
lines = QUtil::read_lines_from_file(std::cin);
} else {
QTC::TC("qpdf", "QPDFJob_config password file... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
leaq 0xbe4d6(%rip), %rsi # 0x1b9742
movq %r14, %rdi
callq 0x6d210
testl %eax, %eax
je 0xfb287
movq (%r14), %rsi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x6cb70
jmp ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::decodeLevel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::decodeLevel(std::string const& parameter)
{
o.m->decode_level_set = true;
if (parameter == "none") {
o.m->decode_level = qpdf_dl_none;
} else if (parameter == "generalized") {
o.m->decode_level = qpdf_dl_generalized;
} else if (parameter == "specialized"... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x140(%rax)
leaq 0xc3adb(%rip), %rsi # 0x1bf0d2
movq %r14, %rdi
callq 0x6d210
testl %eax, %eax
je 0xfb67e
leaq 0xc3acd(%rip), %rsi # 0x1bf0d7
movq %r14, %rdi
callq 0x6d210
testl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::showObject(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::showObject(std::string const& parameter)
{
QPDFJob::parse_object_id(parameter, o.m->show_trailer, o.m->show_obj, o.m->show_gen);
o.m->require_outfile = false;
return this;
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq (%rcx), %rcx
leaq 0x1f2(%rcx), %rsi
leaq 0x1f4(%rcx), %rdx
addq $0x1f8, %rcx # imm = 0x1F8
movq %rax, %rdi
callq 0xcecc0
movq (%rbx), %rax
movq (%rax), %rax
movb $0x0, 0x3c8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::CopyAttConfig::CopyAttConfig(QPDFJob::Config*) | QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
config(c)
{
} | movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::mimetype(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::AttConfig*
QPDFJob::AttConfig::mimetype(std::string const& parameter)
{
if (parameter.find('/') == std::string::npos) {
usage("mime type should be specified as type/subtype");
}
this->att.mimetype = parameter;
return this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x6e3b0
cmpq $-0x1, %rax
jne 0xfc23e
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xd10a5(%rip), %rsi # 0x1cd2b0
leaq 0xd10cb(%rip), %rdx # 0x1cd2dd
leaq 0x8(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::overlay() | std::shared_ptr<QPDFJob::UOConfig>
QPDFJob::Config::overlay()
{
o.m->overlay.emplace_back("overlay");
o.m->under_overlay = &o.m->overlay.back();
return std::shared_ptr<UOConfig>(new UOConfig(this));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movl $0x360, %edi # imm = 0x360
addq (%rax), %rdi
leaq 0xc9eff(%rip), %rsi # 0x1c6807
callq 0xfd9ee
movq (%r14), %rax
movq (%rax), %rax
movq $-0x100, %rcx
addq 0x368(%rax), %rcx
movq %rcx, 0x378(%rax)
movl $0x8, %edi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::underlay() | std::shared_ptr<QPDFJob::UOConfig>
QPDFJob::Config::underlay()
{
o.m->underlay.emplace_back("underlay");
o.m->under_overlay = &o.m->underlay.back();
return std::shared_ptr<UOConfig>(new UOConfig(this));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movl $0x348, %edi # imm = 0x348
addq (%rax), %rdi
leaq 0xc9f38(%rip), %rsi # 0x1c68a6
callq 0xfda2a
movq (%r14), %rax
movq (%rax), %rax
movq $-0x100, %rcx
addq 0x350(%rax), %rcx
movq %rcx, 0x378(%rax)
movl $0x8, %edi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::UOConfig::repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::UOConfig*
QPDFJob::UOConfig::repeat(std::string const& parameter)
{
if (!parameter.empty()) {
config->o.parseNumrange(parameter.c_str(), 0);
}
config->o.m->under_overlay->repeat_nr = parameter;
return this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xfcc43
movq (%rbx), %rax
movq (%rax), %rsi
movq (%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xc5b48
movq (%r15), %rdi
testq %rdi, %rdi
je 0xfcc43
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::encrypt(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::shared_ptr<QPDFJob::EncConfig>
QPDFJob::Config::encrypt(
int keylen, std::string const& user_password, std::string const& owner_password)
{
o.m->keylen = keylen;
if (keylen == 256) {
o.m->use_aes = true;
}
o.m->user_password = user_password;
o.m->owner_password = owner_password;
... | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rdi
movl %edx, 0x110(%rdi)
cmpl $0x100, %edx # imm = 0x100
jne 0xfccf3
movb $0x1, 0x127(%rdi)
addq $0xd0, %rdi
movq %rcx, %rsi
callq 0x6e940
movq (%r14), %rax
movl $0xf0, %edi
addq (%rax), %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::EncConfig::endEncrypt() | QPDFJob::Config*
QPDFJob::EncConfig::endEncrypt()
{
if (config->o.m->keylen == 0) {
usage("encryption key length is required");
}
config->o.m->encrypt = true;
config->o.m->decrypt = false;
config->o.m->copy_encryption = false;
return this->config;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x110(%rax)
jne 0xfd48c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd0074(%rip), %rsi # 0x1cd4d0
leaq 0xd008e(%rip), %rdx # 0x1cd4f1
movq %rsp, %r14
movq %r14, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
(anonymous namespace)::Handlers::pushKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
Handlers::pushKey(std::string const& key)
{
auto new_jh = std::make_shared<JSONHandler>();
this->jh->addDictKeyHandler(key, new_jh);
this->jh = new_jh.get();
this->json_handlers.emplace_back(std::move(new_jh));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x10f712
movq 0x20(%rbx), %rdi
movq (%r15), %rcx
movq 0x8(%r15), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addBare(std::function<void ()>) | void
Handlers::addBare(bare_handler_t fn)
{
jh->addStringHandler([this, fn](std::string const& path, std::string const& parameter) {
if (!parameter.empty()) {
QTC::TC("qpdf", "QPDFJob json bare not empty");
usage(path + ": value must be the empty string");
} else {
... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x20(%rdi), %r14
leaq 0x28(%rsp), %rbx
movq %rdi, -0x8(%rbx)
movq %rbx, %rdi
callq 0x6d310
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x28, %edi
callq 0x68ab0
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addChoices(char const**, bool, std::function<void (char const*)>) | void
Handlers::addChoices(char const** choices, bool required, param_handler_t fn)
{
jh->addStringHandler(
[fn, choices, required, this](std::string const& path, std::string const& parameter) {
char const* p = parameter.c_str();
bool matches = false;
if ((!required) && (p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x6d130
movq %r14, 0x20(%r12)
movb %bpl, 0x28(%r12)
movq %r15, 0x30(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
mova... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginEncrypt(JSON) | void
Handlers::beginEncrypt(JSON j)
{
// This method is only called if the overall JSON structure matches the schema, so we already
// know that keys that are present have the right types.
int key_len = 0;
std::string user_password;
std::string owner_password;
bool user_password_seen = false;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
leaq 0x88(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movb %al, 0xb(%rsp)
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginAddAttachment(JSON) | void
Handlers::beginAddAttachment(JSON)
{
this->c_att = c_main->addAttachment();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x68620
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x50(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
testq %rdi, %rdi
je 0x10a650
callq 0x69d60
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x10a... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::endPagesArray() | void
Handlers::endPagesArray()
{
c_pages->endPages();
c_pages = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x6ad40
xorps %xmm0, %xmm0
movq 0x60(%rbx), %rdi
movups %xmm0, 0x58(%rbx)
testq %rdi, %rdi
je 0x10a77b
popq %rbx
jmp 0x69d60
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginOverlay(JSON) | void
Handlers::beginOverlay(JSON j)
{
this->c_uo = c_main->overlay();
beginUnderOverlay(j);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x6df30
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x70(%r14), %rdi
movups %xmm0, 0x68(%r14)
testq %rdi, %rdi
je 0x10a932
callq 0x69d60
movq 0x8(%rsp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginUnderlay(JSON) | void
Handlers::beginUnderlay(JSON j)
{
this->c_uo = c_main->underlay();
beginUnderOverlay(j);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x6cce0
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x70(%r14), %rdi
movups %xmm0, 0x68(%r14)
testq %rdi, %rdi
je 0x10a9bc
callq 0x69d60
movq 0x8(%rsp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFLogger::Members::~Members() | QPDFLogger::Members::~Members()
{
p_stdout->finish();
p_stderr->finish();
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x10fb70
callq 0x69d60
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x10fb7e
callq 0x69d60
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x10f... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::info(char const*) | void
QPDFLogger::info(char const* s)
{
getInfo(false)->writeCStr(s);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x6e980
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6da90
movq 0x10(%rsp), %rdi
addq $0x18, %rsp
testq %rdi, %rdi
je 0x10fd59
popq %rbx
popq %r14
jmp 0x69d60
popq %rbx
popq %r14
retq
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::warn(char const*) | void
QPDFLogger::warn(char const* s)
{
getWarn(false)->writeCStr(s);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x6a9c0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6da90
movq 0x10(%rsp), %rdi
addq $0x18, %rsp
testq %rdi, %rdi
je 0x10ff01
popq %rbx
popq %r14
jmp 0x69d60
popq %rbx
popq %r14
retq
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::getWarn(bool) | std::shared_ptr<Pipeline>
QPDFLogger::getWarn(bool null_okay)
{
if (m->p_warn) {
return m->p_warn;
}
return getError(null_okay);
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x10ff51
movq %rcx, (%rbx)
movq 0x58(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x10ff62
movq 0x138e99(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x10ff5e
incl 0x8(%rax)
jmp 0x10ff62
movzbl %dl, %edx
movq %rbx, %rdi
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::error(char const*) | void
QPDFLogger::error(char const* s)
{
getError(false)->writeCStr(s);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x6db70
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6da90
movq 0x10(%rsp), %rdi
addq $0x18, %rsp
testq %rdi, %rdi
je 0x110077
popq %rbx
popq %r14
jmp 0x69d60
popq %rbx
popq %r14
retq
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::discard() | std::shared_ptr<Pipeline>
QPDFLogger::discard()
{
return m->p_discard;
} | movq %rdi, %rax
movq (%rsi), %rcx
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x1101f5
movq 0x138bf8(%rip), %rdx # 0x248de0
cmpb $0x0, (%rdx)
je 0x1101f1
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFMatrix::rotatex90(int) | void
QPDFMatrix::rotatex90(int angle)
{
switch (angle) {
case 90:
concat(QPDFMatrix(0, 1, -1, 0, 0, 0));
break;
case 180:
concat(QPDFMatrix(-1, 0, 0, -1, 0, 0));
break;
case 270:
concat(QPDFMatrix(0, -1, 1, 0, 0, 0));
break;
default:
// ignore
... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x10e, %esi # imm = 0x10E
je 0x1117c7
cmpl $0xb4, %esi
je 0x1117a6
cmpl $0x5a, %esi
jne 0x1117fb
leaq 0x8(%rsp), %r14
movsd 0xa8aac(%rip), %xmm1 # 0x1ba248
movsd 0xbe99c(%rip), %xmm2 # 0x1d0140
jmp 0x1117dc
leaq 0x8(%rsp), %r14
movsd 0xbe98d(... | /jberkenbilt[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::transformRectangle(QPDFObjectHandle::Rectangle) const | QPDFObjectHandle::Rectangle
QPDFMatrix::transformRectangle(QPDFObjectHandle::Rectangle r) const
{
std::vector<double> tx(4);
std::vector<double> ty(4);
transform(r.llx, r.lly, tx.at(0), ty.at(0));
transform(r.llx, r.ury, tx.at(1), ty.at(1));
transform(r.urx, r.lly, tx.at(2), ty.at(2));
transform... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x20, %edi
callq 0x68ab0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x20, %edi
callq 0x68ab0
leaq 0x20(%rsp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movsd (%rcx), %xmm8
movsd... | /jberkenbilt[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFNameTreeObjectHelper::iterator::updateIValue() | void
QPDFNameTreeObjectHelper::iterator::updateIValue()
{
if (impl->valid()) {
auto p = *impl;
this->ivalue.first = p->first.getUTF8Value();
this->ivalue.second = p->second;
} else {
this->ivalue.first = "";
this->ivalue.second = QPDFObjectHandle();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x80066
testb %al, %al
je 0x111df6
movq 0x8(%rbx), %r14
leaq 0x130e3d(%rip), %rax # 0x242bf0
leaq 0x30(%rsp), %r15
movq %rax, -0x10(%r15)
movq 0x8(%r14), %rax
movq %rax, -0x8(%r15)
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::iterator::insertAfter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle) | void
QPDFNameTreeObjectHelper::iterator::insertAfter(std::string const& key, QPDFObjectHandle value)
{
impl->insertAfter(QPDFObjectHandle::newUnicodeString(key), value);
updateIValue();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x10(%rsp), %rdi
callq 0x6e2a0
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x111f75
movq 0x136e79(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x111f71
incl... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::end() const | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::end() const
{
return {std::make_shared<NNTreeIterator>(m->impl->end())};
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x832c6
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %r14, %rcx
callq 0x112c04
leaq 0x131fc0(%rip), %rax # 0x2440c0
movq %rax, (%rbx... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::findObject(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle&) | bool
QPDFNameTreeObjectHelper::findObject(std::string const& name, QPDFObjectHandle& oh)
{
auto i = find(name);
if (i == end()) {
return false;
}
oh = i->second;
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq %rsp, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x69ed0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x6a360
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x83148
movl %eax, %ebp
leaq 0x48(%rsp), %rdi
callq 0xbb934... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::getAsMap[abi:cxx11]() const | std::map<std::string, QPDFObjectHandle>
QPDFNameTreeObjectHelper::getAsMap() const
{
std::map<std::string, QPDFObjectHandle> result;
result.insert(begin(), end());
return result;
} | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x50(%rsp), %rdi
callq 0x69510
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6a360
leaq 0x50(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
(anonymous namespace)::NameTreeDetails::itemsKey[abi:cxx11]() const | std::string const&
itemsKey() const override
{
static std::string k("/Names");
return k;
} | pushq %rbx
movb 0x13ae11(%rip), %al # 0x24d510
testb %al, %al
je 0x11270c
leaq 0x13ade6(%rip), %rax # 0x24d4f0
popq %rbx
retq
leaq 0x13adfd(%rip), %rdi # 0x24d510
callq 0x69d10
testl %eax, %eax
je 0x112703
leaq 0x13addd(%rip), %rax # 0x24d500
movq %rax, 0x13adc6(%rip) # 0x24d4f0
leaq 0x13adbf(%rip), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::iterator::updateIValue() | void
QPDFNumberTreeObjectHelper::iterator::updateIValue()
{
if (impl->valid()) {
auto p = *impl;
this->ivalue.first = p->first.getIntValue();
this->ivalue.second = p->second;
} else {
this->ivalue.first = 0;
this->ivalue.second = QPDFObjectHandle();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x80066
testb %al, %al
je 0x11343f
movq 0x8(%rbx), %r14
leaq 0x12f7f4(%rip), %rax # 0x242bf0
leaq 0x10(%rsp), %r15
movq %rax, -0x10(%r15)
movq 0x8(%r14), %rax
movq %rax, -0x8(%r15)
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::iterator::insertAfter(long long, QPDFObjectHandle) | void
QPDFNumberTreeObjectHelper::iterator::insertAfter(numtree_number key, QPDFObjectHandle value)
{
impl->insertAfter(QPDFObjectHandle::newInteger(key), value);
updateIValue();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x10(%rsp), %rdi
callq 0x6a820
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x113571
movq 0x13587d(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x11356d
incl... | /jberkenbilt[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::remove(long long, QPDFObjectHandle*) | bool
QPDFNumberTreeObjectHelper::remove(numtree_number key, QPDFObjectHandle* value)
{
return m->impl->remove(QPDFObjectHandle::newInteger(key), value);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq 0x28(%rdi), %rax
movq (%rax), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x6a820
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x85306
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x113ab3
callq 0x69d60
movl %ebx, %eax
addq $0x10... | /jberkenbilt[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::getMax() | QPDFNumberTreeObjectHelper::numtree_number
QPDFNumberTreeObjectHelper::getMax()
{
auto i = last();
if (i == end()) {
return 0;
}
return i->first;
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x6b260
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x68ba0
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x83148
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0x114090
testb %bl, %bl
je 0x113ba3
xorl %ebx, %ebx
jmp 0x113bb0
movq %rsp, %... | /jberkenbilt[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::getAsMap() const | std::map<QPDFNumberTreeObjectHelper::numtree_number, QPDFObjectHandle>
QPDFNumberTreeObjectHelper::getAsMap() const
{
std::map<numtree_number, QPDFObjectHandle> result;
result.insert(begin(), end());
return result;
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x38(%rsp), %rdi
callq 0x6aa50
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x68ba0
leaq 0x38(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
(anonymous namespace)::NumberTreeDetails::compareKeys(QPDFObjectHandle, QPDFObjectHandle) const | int
compareKeys(QPDFObjectHandle a, QPDFObjectHandle b) const override
{
if (!(keyValid(a) && keyValid(b))) {
// We don't call this without calling keyValid first
throw std::logic_error("comparing invalid keys");
}
auto as = a.getIntVal... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x113f78
movq 0x134e76(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x113f74
incl 0x8(%rax)
jmp 0x113f78
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFObject::getDescription[abi:cxx11]() | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbp
movb 0x30(%rsi), %al
xorl %ecx, %ecx
cmpb $0x8, %al
sete %cl
cmpb $0x9, %al
movl $0x2, %r15d
cmovneq %rcx, %r15
movq 0x38(%rsi), %rdi
testq %rdi, %rdi
je 0x1148d2
movzbl 0x38(%rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDFObject.cc |
QPDFObject::ChildDescr::~ChildDescr() | ChildDescr(
std::shared_ptr<QPDFObject> parent,
std::string_view const& static_descr,
std::string var_descr) :
parent(parent),
static_descr(static_descr),
var_descr(var_descr)
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x115944
movq (%rax), %rsi
incq %rsi
callq 0x68760
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x11597a
movq 0x13348c(%rip), %rax # 0x248de0
cmpb $0x0, (%rax)
je 0x115964
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
qpdf::Name::normalize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
Name::normalize(std::string const& name)
{
if (name.empty()) {
return name;
}
std::string result;
result += name.at(0);
for (size_t i = 1; i < name.length(); ++i) {
char ch = name.at(i);
// Don't use locale/ctype here; follow PDF spec guidelines.
if (ch ==... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testq %rdx, %rdx
je 0x115ec5
movq %rax, (%rsp)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::copy(bool) const | std::shared_ptr<QPDFObject>
BaseHandle::copy(bool shallow) const
{
switch (resolved_type_code()) {
case ::ot_uninitialized:
throw std::logic_error("QPDFObjectHandle: attempting to copy an uninitialized object");
return {}; // does not return
case ::ot_reserved:
return QPDFObject::cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x115f66
movsbl 0x30(%rcx), %eax
cmpl $0xd, %eax
jne 0x115f68
movq 0x48(%rcx), %rdi
movq 0x50(%rcx), %rsi
callq 0x182b0a
movq (%rax), %rax
movsbl 0x30(... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getNumericValue() const | double
QPDFObjectHandle::getNumericValue() const
{
if (isInteger()) {
return static_cast<double>(getIntValue());
} else if (isReal()) {
return atof(getRealValue().c_str());
} else {
typeWarning("number", "returning 0");
QTC::TC("qpdf", "QPDFObjectHandle numeric non-numeric");... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x6c2a0
testb %al, %al
je 0x118377
movq %rbx, %rdi
callq 0x6db80
cvtsi2sd %rax, %xmm0
jmp 0x118417
movq %rbx, %rdi
callq 0x68120
testb %al, %al
je 0x1183c6
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6cc50
movq (%r14), %rbx
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getRealValue[abi:cxx11]() const | std::string
QPDFObjectHandle::getRealValue() const
{
if (isReal()) {
return obj->getStringValue();
} else {
typeWarning("real", "returning 0.0");
QTC::TC("qpdf", "QPDFObjectHandle real returning 0.0");
return "0.0";
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x68120
testb %al, %al
je 0x118500
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x11803a
jmp 0x11856b
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xb8504(%rip), %rsi # 0x1d0a15
leaq 0xb850a(%rip), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isStreamOfType(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&) const | bool
QPDFObjectHandle::isStreamOfType(std::string const& type, std::string const& subtype) const
{
return isStream() && getDict().isDictionaryOfType(type, subtype);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x695d0
movl %eax, %ebx
testb %al, %al
je 0x11914a
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x6ae50
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6bdb0
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getValueAsUTF8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | bool
QPDFObjectHandle::getValueAsUTF8(std::string& value) const
{
if (auto str = as<QPDF_String>()) {
value = str->getUTF8Val();
return true;
}
return false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
callq 0x121616
movq %rax, %rbx
testq %rax, %rax
je 0x1199b6
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15a2ca
movq %r14, %rdi
movq %r15, %rsi
callq 0x6abd0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1199b6
movq 0x10(%rsp), ... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getValueAsInlineImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | bool
QPDFObjectHandle::getValueAsInlineImage(std::string& value) const
{
if (!isInlineImage()) {
return false;
}
value = obj->getStringValue();
return true;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x6bf60
movl %eax, %ebx
testb %al, %al
je 0x119bf5
movq (%r15), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x11803a
movq %r14, %rdi
movq %r15, %rsi
callq 0x6abd0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x119bf5
mo... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, 0xd0(%rsp)
movq %rcx, %rdi
movq %rdx, 0xc8(%rsp)
movq %rdx, %rsi
callq 0x6e940
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %r14, (%rsp)
movq $0x0, 0x10(%r14)
movq (%rb... | /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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x11bb1f
movq 0x50(%rax), %rax
jmp 0x11bb21
xorl %eax, %eax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %r15
movq %r15, %rdi
movl $0x20, %edx
callq 0x9401a
leaq 0xb5d81(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newInteger(long long) | QPDFObjectHandle
QPDFObjectHandle::newInteger(long long value)
{
return {QPDFObject::create<QPDF_Integer>(value)};
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x70, %edi
callq 0x68ab0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x127285(%rip), %rcx # 0x2435f8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movq %rbx, 0x10(%rax)
movb $0x4, 0x40(%rax)
xorps %xmm0, %xmm0
movups %... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getJSON(int, bool) const | JSON
QPDFObjectHandle::getJSON(int json_version, bool dereference_indirect) const
{
if ((!dereference_indirect) && isIndirect()) {
return JSON::makeString(unparse());
} else if (!obj) {
throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHandle");
} else {
Pl_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
jne 0x11ca46
movq (%r14), %rax
testq %rax, %rax
je 0x11ca46
cmpl $0x0, 0x50(%rax)
je 0x11ca46
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e540
movq... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x69620
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xb3fa0(%rip), %rsi # 0x1d0c42
leaq 0xb3fa... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::filterPageContents(QPDFObjectHandle::TokenFilter*, Pipeline*) | void
QPDFObjectHandle::filterPageContents(TokenFilter* filter, Pipeline* next)
{
auto description = "token filter for page object " + getObjGen().unparse(' ');
Pl_QPDFTokenizer token_pipeline(description.c_str(), filter, next);
this->pipePageContents(&token_pipeline);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x11d8f2
movq 0x50(%rax), %rax
jmp 0x11d8f4
xorl %eax, %eax
leaq 0x60(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movl $0x20, %edx
callq 0x9401a
leaq... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parseContentStream(QPDFObjectHandle, QPDFObjectHandle::ParserCallbacks*) | void
QPDFObjectHandle::parseContentStream(QPDFObjectHandle stream_or_array, ParserCallbacks* callbacks)
{
stream_or_array.parseContentStream_internal("content stream objects", callbacks);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xb3171(%rip), %rsi # 0x1d0d15
leaq 0xb3180(%rip), %rdx # 0x1d0d2b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x68bb0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newInlineImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFObjectHandle::newInlineImage(std::string const& value)
{
return {QPDFObject::create<QPDF_InlineImage>(value)};
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x121f50
movq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::addTokenFilter(std::shared_ptr<QPDFObjectHandle::TokenFilter>) | void
QPDFObjectHandle::addTokenFilter(std::shared_ptr<TokenFilter> filter)
{
return as_stream(error).addTokenFilter(filter);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x11e3e3
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x11e3e7
cmpl $0xd, %eax
jne 0x11e3f5
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x182b0a
jmp 0x11e3ec
xorl %eax, %eax
jmp 0x11e3f8
call... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFObjectHandle::newString(std::string const& str)
{
return {QPDFObject::create<QPDF_String>(str)};
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x121d58
movq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movsd (%rsi), %xmm0
leaq 0x28(%rsp), %r15
movq %r15, %r14
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x68ff0
leaq 0x38(%rsp), %r14
movsd 0x8(%r12), %xmm0
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x68ff0
... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newDictionary() | QPDFObjectHandle
QPDFObjectHandle::newDictionary()
{
return newDictionary(std::map<std::string, QPDFObjectHandle>());
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %rsp, %rsi
callq 0x6cb40
movq %rsp, %rdi
callq 0x947ea
movq %rbx, %rax
addq $0x30, %rsp
pop... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::objectWarning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
QPDFObjectHandle::objectWarning(std::string const& warning) const
{
QPDF* context = nullptr;
std::string description;
// Type checks above guarantee that the object is initialized.
obj->getDescription(context, description);
// Null context handled by warn
warn(context, QPDFExc(qpdf_e_object... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
xorl %eax, %eax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
movq (%rdi), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1222dc
movq (%rsp), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::assertType(char const*, bool) const | void
QPDFObjectHandle::assertType(char const* type_name, bool istype) const
{
if (!istype) {
throw std::runtime_error(
std::string("operation for ") + type_name + " attempted on object of type " +
QPDFObjectHandle(*this).getTypeName());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testl %edx, %edx
je 0x11f8bf
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x88(%rsp), %r12
movq %r12, -0x10(%r12)
le... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1208cc
movq 0x50(%rax), %rax
jmp 0x1208ce
xorl %eax, %eax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %r15
movq %r15, %rdi
movl $0x20, %edx
callq 0x9401a
leaq 0xb0fd4(%rip), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Name, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x68320
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Array, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>, bool>(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&&, bool&&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movzbl (%rdx), %edx
movq %rsp, %rdi
callq 0x14f54c
movq $0x0, (%rbx)
movl $0x70, %edi
callq 0x68ab0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x1225d9(%rip), %rcx # 0x2435f8
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x8(%rs... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Name, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x68320
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_String, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x68320
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_Array, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&>(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x1242b2
movq $0x0, (%rbx)
movl $0x70, %edi
callq 0x68ab0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x1214dc(%rip), %rcx # 0x2435f8
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x8(%rsp), %rdi
movq -0x8(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFOutlineObjectHelper::Accessor::create(QPDFObjectHandle, QPDFOutlineDocumentHelper&, int) | static QPDFOutlineObjectHelper
create(QPDFObjectHandle oh, QPDFOutlineDocumentHelper& dh, int depth)
{
return {oh, dh, depth};
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1252e6
movq 0x123b08(%rip), %rsi # 0x248de0
cmpb $0x0, (%rsi)
je 0x1252e2
incl 0x8(%rax)
jmp 0x1252e6
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1264ac
movq... | /jberkenbilt[P]qpdf/include/qpdf/QPDFOutlineObjectHelper.hh |
QPDFOutlineObjectHelper::getDestPage() | QPDFObjectHandle
QPDFOutlineObjectHelper::getDestPage()
{
QPDFObjectHandle dest = getDest();
if ((dest.isArray()) && (dest.getArrayNItems() > 0)) {
return dest.getArrayItem(0);
}
return QPDFObjectHandle::newNull();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x69990
movq %r14, %rdi
callq 0x6c8b0
testb %al, %al
je 0x12707c
leaq 0x8(%rsp), %rdi
callq 0x6f1d0
testl %eax, %eax
jle 0x12707c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6ac00
jmp 0x127084
movq %rbx, %... | /jberkenbilt[P]qpdf/libqpdf/QPDFOutlineObjectHelper.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movl %r9d, 0xbc(%rsp)
movl %r8d, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, 0x160(%rsp)
movq %rcx, %rdi
callq 0x68b70
movb %al, 0x7(%rsp)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%... | /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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
leaq 0x11b783(%rip), %rax # 0x244708
movq %rax, (%rdi)
movl $0x10, %edi
callq 0x68ab0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x10(%rbx)
leaq 0x18(%rbx), %r14
movq %r14, %rdi
movq %... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %r8, %r13
movq %rcx, %r14
movq %rdx, 0x68(%rsp)
movq %rsi, %r12
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
movq %rsi, 0x80(%rsp)
movq %r12, %rdx
callq 0x6eab0
movq %rbx, %rdi
callq 0x6db30
testb %al, %... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageLabelDocumentHelper.cc |
QPDFPageObjectHelper::getAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::function<QPDFObjectHandle ()>, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getAttribute(
std::string const& name,
bool copy_if_shared,
std::function<QPDFObjectHandle()> get_fallback,
bool copy_if_fallback)
{
const bool is_form_xobject = oh().isFormXObject();
bool inherited = false;
auto dict = is_form_xobject ? oh().getDict() ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, %r12d
movq %r8, %r13
movl %ecx, 0x3c(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x12a7fa
movq 0x11e5f4(%rip)... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getCropBox(bool, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getCropBox(bool copy_if_shared, bool copy_if_fallback)
{
return getAttribute(
"/CropBox",
copy_if_shared,
[this, copy_if_shared]() { return this->getMediaBox(copy_if_shared); },
copy_if_fallback);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xa66bb(%rip), %rsi # 0x1d14aa
leaq 0xa66bc(%rip), %rdx # 0x1d14b2
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x6... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xa65ce(%rip), %rsi # 0x1d14b3
leaq 0xa65cf(%rip), %rdx # 0x1d14bb
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x6... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::forEachImage(bool, std::function<void (QPDFObjectHandle&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>) | void
QPDFPageObjectHelper::forEachImage(
bool recursive,
std::function<void(QPDFObjectHandle& obj, QPDFObjectHandle& xobj_dict, std::string const& key)>
action)
{
forEachXObject(recursive, action, [](QPDFObjectHandle obj) { return obj.isImage(); });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x13242e
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x69e4(%rip), %rax # 0x1320f4
movq %rax, 0x18(%rcx)
leaq 0x6a39(%rip), %rax # 0x132154
movq %rax, ... | /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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rdi, (%rdx)
leaq 0x6916(%rip), %... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getFormXObjects[abi:cxx11]() | std::map<std::string, QPDFObjectHandle>
QPDFPageObjectHelper::getFormXObjects()
{
std::map<std::string, QPDFObjectHandle> result;
forEachFormXObject(
false, [&result](QPDFObjectHandle& obj, QPDFObjectHandle&, std::string const& key) {
result[key] = obj;
});
return result;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rdi, (%rdx)
leaq 0x68b4(%rip), %... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x12bad3
leaq 0x110(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d6ad(%rip), %rsi # 0x1b90c4
leaq 0x8d6b0(%rip), %rdx # 0x1b90ce
leaq 0x100(%rsp), %rdi
callq 0x68bb0
leaq 0x78... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x50(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x28(%rsp)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x12c458
movq 0x11c996(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getPageContents() | std::vector<QPDFObjectHandle>
QPDFPageObjectHelper::getPageContents()
{
return oh().getPageContents();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x12c653
movq 0x11c79b(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x12c64f
incl 0x8(%rax)
jmp 0x12c653
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6cd30
m... | /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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x12ca69
movq 0x11c385(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x12ca65
incl 0x8(%rax)
jmp 0x12ca69
lock
incl 0x8(%rax)
movq %rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::removeUnreferencedResources() | void
QPDFPageObjectHelper::removeUnreferencedResources()
{
// Accumulate a list of unresolved names across all nested form XObjects.
std::set<std::string> unresolved;
bool any_failures = false;
forEachFormXObject(
true,
[&any_failures, &unresolved](QPDFObjectHandle& obj, QPDFObjectHandle... | pushq %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x80(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%r... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x12d7cd
movq 0x11b621(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x12d7c9
incl 0x8(%rax)
jmp 0x12d7cd
lock
incl 0x8(... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getFormXObjectForPage(bool) | QPDFObjectHandle
QPDFPageObjectHelper::getFormXObjectForPage(bool handle_transformations)
{
auto result =
oh().getQPDF("QPDFPageObjectHelper::getFormXObjectForPage called with a direct object")
.newStream();
QPDFObjectHandle newdict = result.getDict();
newdict.replaceKey("/Type", QPDFObj... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x12dd09
movq 0x11b0e5(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x12dd05
incl 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.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.