name string | code string | asm string | file string |
|---|---|---|---|
JSON::JSON_array::write(Pipeline*, unsigned long) const | void
JSON::JSON_array::write(Pipeline* p, size_t depth) const
{
bool first = true;
writeArrayOpen(p, first, depth);
for (auto const& element: elements) {
writeArrayItem(p, first, element, 1 + depth);
}
writeArrayClose(p, first, depth);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x19(%rbp), %rsi
callq 0x26370
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::unparse[abi:cxx11]() const | std::string
JSON::unparse() const
{
if (!m) {
return "null";
}
std::string s;
Pl_String p("unparse", nullptr, s);
write(&p, 0);
return s;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2f5f0
testb $0x1, %al
jne 0x2713a
leaq -0x11(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be40
movq -0x78(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::forEachArrayItem(std::function<void (JSON)>) const | bool
JSON::forEachArrayItem(std::function<void(JSON value)> fn) const
{
if (auto v = m ? dynamic_cast<JSON_array const*>(m->value.get()) : nullptr) {
for (auto const& i: v->elements) {
fn(JSON(i));
}
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2f5f0
testb $0x1, %al
jne 0x2804a
jmp 0x2809b
movq -0x68(%rbp), %rdi
callq 0x2f610
movq %rax, %rdi
callq 0x2f870
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
j... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::checkSchemaInternal(JSON::JSON_value*, JSON::JSON_value*, unsigned long, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_t... | bool
JSON::checkSchemaInternal(
JSON_value* this_v,
JSON_value* sch_v,
unsigned long flags,
std::list<std::string>& errors,
std::string prefix)
{
auto* this_arr = dynamic_cast<JSON_array*>(this_v);
auto* this_dict = dynamic_cast<JSON_dictionary*>(this_v);
auto* sch_arr = dynamic_cast<JS... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %r8, -0x4f0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4e8(%rbp)
cmpq $0x0, %rax
je 0x2833e
movq -0x4e8(%rbp), %rdi
leaq 0x462abb(%... | /qpdf[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::parse() | JSON
JSONParser::parse()
{
while (!done) {
getToken();
handleToken();
}
if (parser_state != ps_done) {
QTC::TC("libtests", "JSON parse premature EOF");
throw std::runtime_error("JSON: premature end of input");
}
auto const& tos = stack.back().item;
if (reactor && ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb 0x4040(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x29895
jmp 0x298a9
movq -0x30(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | JSON
JSON::parse(std::string const& s)
{
BufferInputSource bis("json input", s);
JSONParser jp(bis, nullptr);
return jp.parse();
} | pushq %rbp
movq %rsp, %rbp
subq $0x4200, %rsp # imm = 0x4200
movq %rdi, -0x4200(%rbp)
movq %rdi, %rax
movq %rax, -0x41f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x119(%rbp), %rdi
movq %rdi, -0x41f0(%rbp)
callq 0x1be40
movq -0x41f0(%rbp), %rdx
leaq 0x2e4397(%rip), %rsi # 0x30ddbc
leaq -0x11... | /qpdf[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::getToken() | void
JSONParser::getToken()
{
token.clear();
// Keep track of UTF-16 surrogate pairs.
unsigned long high_surrogate = 0;
qpdf_offset_t high_offset = 0;
while (true) {
if (p == (buf + bytes)) {
p = buf;
bytes = is.read(buf, sizeof(buf));
if (bytes == 0) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
addq $0x4048, %rdi # imm = 0x4048
callq 0x1b7d0
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x250(%rbp), %rdx
movq 0x4020(%rdx), %rax
movq %rdx, %rcx
addq $0x14, %r... | /qpdf[P]qpdf/libqpdf/JSON.cc |
Pl_Base64::encode(unsigned char const*, unsigned long) | void
Pl_Base64::encode(unsigned char const* data, size_t len)
{
unsigned char const* p = data;
while (len > 0) {
this->buf[this->pos++] = *p;
if (this->pos == 3) {
flush();
}
++p;
--len;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x49592
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rcx), %dl
movq 0x38(%rax), %r... | /qpdf[P]qpdf/libqpdf/Pl_Base64.cc |
QPDFAcroFormDocumentHelper::analyze() | void
QPDFAcroFormDocumentHelper::analyze()
{
if (m->cache_valid) {
return;
}
m->cache_valid = true;
QPDFObjectHandle acroform = qpdf.getRoot().getKey("/AcroForm");
if (!(acroform.isDictionary() && acroform.hasKey("/Fields"))) {
return;
}
QPDFObjectHandle fields = acroform.get... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
addq $0x10, %rdi
callq 0xaa3c0
testb $0x1, (%rax)
je 0x9fd4d
jmp 0xa0732
movq -0x2e8(%rbp), %rdi
addq $0x10, %rdi
callq 0xaa3c0
movq %rax, %rcx
movq -0x2e8(%rbp), %rax
movb $0x1, (%r... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getOrCreateAcroForm() | QPDFObjectHandle
QPDFAcroFormDocumentHelper::getOrCreateAcroForm()
{
auto acroform = qpdf.getRoot().getKey("/AcroForm");
if (!acroform.isDictionary()) {
acroform = qpdf.getRoot().replaceKeyAndGetNew(
"/AcroForm", qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary()));
}
return a... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movb $0x0, -0x11(%rbp)
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x61930
leaq -0x49(%rbp)... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::adjustAppearanceStream(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<c... | void
QPDFAcroFormDocumentHelper::adjustAppearanceStream(
QPDFObjectHandle stream, std::map<std::string, std::map<std::string, std::string>> dr_map)
{
// We don't have to modify appearance streams or their resource dictionaries for them to display
// properly, but we need to do so to make them save to regene... | pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movq %rsi, -0x408(%rbp)
movq %rdx, -0x400(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3f8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2368a0
leaq -0x59(%rbp), %rdi
movq %rdi, -0x3f0(%rbp)
cal... | /qpdf[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFArgParser::Members::Members(int, char const* const*, char const*) | QPDFArgParser::Members::Members(int argc, char const* const argv[], char const* progname_env) :
argc(argc),
argv(argv),
progname_env(progname_env),
cur_arg(0),
bash_completion(false),
zsh_completion(false),
option_table(nullptr),
final_check_handler(nullptr)
{
auto tmp = QUtil::make... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::selectOptionTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFArgParser::selectOptionTable(std::string const& name)
{
auto t = m->option_tables.find(name);
if (t == m->option_tables.end()) {
QTC::TC("libtests", "QPDFArgParser select unregistered table");
throw std::logic_error("QPDFArgParser: selecting unregistered option table " + name);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xc6250
movq %rax, %rdi
addq $0xe8, %rdi
movq -0x10(%rbp), %rsi
callq 0xc6270
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xc6250
movq %rax, %rdi
addq $0xe8, %rdi
callq 0xc... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::registerArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFArgParser::OptionEntry&
QPDFArgParser::registerArg(std::string const& arg)
{
if (0 != m->option_table->count(arg)) {
QTC::TC("libtests", "QPDFArgParser duplicate handler");
throw std::logic_error(
"QPDFArgParser: adding a duplicate handler for option " + arg + " in " +
m-... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xc6250
movq 0x178(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc6510
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc14c5
leaq 0x24c447(%rip), %rdi # 0x30d79f
leaq 0x2517a2... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::handleCompletion() | void
QPDFArgParser::handleCompletion()
{
std::string extra_prefix;
if (m->completions.empty()) {
// Detect --option=... Bash treats the = as a word separator.
std::string choice_option;
if (m->bash_cur.empty() && (m->bash_prev.length() > 2) && (m->bash_prev.at(0) == '-') &&
(... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b510
movq -0x180(%rbp), %rdi
callq 0xc6250
movq %rax, %rdi
addq $0xb8, %rdi
callq 0xc6b30
testb $0x1, %al
jne 0xc42f7
jmp 0xc47eb
leaq -0x48(%rbp), %r... | /qpdf[P]qpdf/libqpdf/QPDFArgParser.cc |
QIntC::IntConverter<unsigned long, int, false, true>::error(unsigned 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 unsigned type to a " << sizeof(To) << "-byte signed type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0xcdd63
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QPDFCryptoProvider::setDefaultProvider_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFCryptoProvider::setDefaultProvider_internal(std::string const& name)
{
if (!m->providers.count(name)) {
throw std::logic_error(
"QPDFCryptoProvider: request to set default provider to unknown implementation \"" +
name + "\"");
}
m->default_provider = name;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xcfff0
movq %rax, %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xd0480
cmpq $0x0, %rax
jne 0xcfc91
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x70(%rb... | /qpdf[P]qpdf/libqpdf/QPDFCryptoProvider.cc |
QPDFEFStreamObjectHelper::createEFStream(QPDF&, std::function<void (Pipeline*)>) | QPDFEFStreamObjectHelper
QPDFEFStreamObjectHelper::createEFStream(QPDF& qpdf, std::function<void(Pipeline*)> provider)
{
auto stream = qpdf.newStream();
stream.replaceStreamData(provider, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
return newFromStream(stream);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5e700
movq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2f4e0
jmp... | /qpdf[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFFileSpecObjectHelper::getDescription[abi:cxx11]() | std::string
QPDFFileSpecObjectHelper::getDescription()
{
std::string result;
auto desc = oh().getKey("/Desc");
if (desc.isString()) {
result = desc.getUTF8Value();
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0x98(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xc0000
jmp 0xd9dda
leaq -0x69(%rb... | /qpdf[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFileSpecObjectHelper::getFilenames[abi:cxx11]() | std::map<std::string, std::string>
QPDFFileSpecObjectHelper::getFilenames()
{
std::map<std::string, std::string> result;
for (auto const& i: name_keys) {
auto k = oh().getKey(i);
if (k.isString()) {
result[i] = k.getUTF8Value();
}
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xaa450
leaq 0x3b84c1(%rip), %rax # 0x4925d0
movq %rax, -0x20(%rbp)
leaq 0x3b84b6(%rip), %r... | /qpdf[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFileSpecObjectHelper::getEmbeddedFileStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFFileSpecObjectHelper::getEmbeddedFileStream(std::string const& key)
{
auto ef = oh().getKey("/EF");
if (!ef.isDictionary()) {
return QPDFObjectHandle::newNull();
}
if (!key.empty()) {
return ef.getKey(key);
}
for (auto const& i: name_keys) {
auto k = ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xc0000
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1be40
movq -0xa0(%rbp), %rdx
lea... | /qpdf[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFormFieldObjectHelper::generateTextAppearance(QPDFAnnotationObjectHelper&) | void
QPDFFormFieldObjectHelper::generateTextAppearance(QPDFAnnotationObjectHelper& aoh)
{
QPDFObjectHandle AS = aoh.getAppearanceStream("/N");
if (AS.isNull()) {
QTC::TC("qpdf", "QPDFFormFieldObjectHelper create AS from scratch");
QPDFObjectHandle::Rectangle rect = aoh.getRect();
QPDFObj... | pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x6f0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6e8(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x6e0(%rbp)
callq 0x1be40
movq -0x6e0(%rbp), %rdx
leaq 0x232145(%rip), %rsi ... | /qpdf[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
(anonymous namespace)::ValueSetter::ValueSetter(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::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::a... | ValueSetter::ValueSetter(
std::string const& DA,
std::string const& V,
std::vector<std::string> const& opt,
double tf,
QPDFObjectHandle::Rectangle const& bbox) :
DA(DA),
V(V),
opt(opt),
tf(tf),
bbox(bbox)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x23b70
movq -0x50(%rbp), %rdi
leaq 0x3a9fa7(%rip), %rax # 0x48c5d0
movq %rax, (%rdi... | /qpdf[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFJob::doJSONPages(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONPages(Pipeline* p, bool& first, QPDF& pdf)
{
JSON::writeDictionaryKey(p, first, "pages", 1);
bool first_page = true;
JSON::writeArrayOpen(p, first_page, 2);
QPDFPageLabelDocumentHelper pldh(pdf);
QPDFOutlineDocumentHelper odh(pdf);
int pageno = -1;
for (auto& ph: QPDFPage... | pushq %rbp
movq %rsp, %rbp
subq $0xaa0, %rsp # imm = 0xAA0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x9a8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x9a0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x998(%rbp)
leaq -0x41(%rbp), %... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONOutlines(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONOutlines(Pipeline* p, bool& first, QPDF& pdf)
{
std::map<QPDFObjGen, int> page_numbers;
int n = 0;
for (auto const& ph: QPDFPageDocumentHelper(pdf).getAllPages()) {
QPDFObjectHandle oh = ph.getObjectHandle();
page_numbers[oh.getObjGen()] = ++n;
}
JSON j_outlines ... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x63ba0
movl $0x0, -0x54(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONEncrypt(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONEncrypt(Pipeline* p, bool& first, QPDF& pdf)
{
int R = 0;
int P = 0;
int V = 0;
QPDF::encryption_method_e stream_method = QPDF::e_none;
QPDF::encryption_method_e string_method = QPDF::e_none;
QPDF::encryption_method_e file_method = QPDF::e_none;
bool is_encrypted = pdf.is... | pushq %rbp
movq %rsp, %rbp
subq $0x9f0, %rsp # imm = 0x9F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8a0(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONAttachments(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONAttachments(Pipeline* p, bool& first, QPDF& pdf)
{
auto to_iso8601 = [](std::string const& d) {
// Convert PDF date to iso8601 if not empty; if empty, return
// empty.
std::string iso8601;
QUtil::pdf_time_to_iso8601(d, iso8601);
return iso8601;
};
... | pushq %rbp
movq %rsp, %rbp
subq $0x770, %rsp # imm = 0x770
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x271e0
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xd4da0
jmp 0xf9ac3
leaq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
call... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::json_schema(int, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*) | JSON
QPDFJob::json_schema(int json_version, std::set<std::string>* keys)
{
// Style: use all lower-case keys with no dashes or underscores. Choose array or dictionary
// based on indexing. For example, we use a dictionary for objects because we want to index by
// object ID and an array for pages because we... | pushq %rbp
movq %rsp, %rbp
subq $0x8e0, %rsp # imm = 0x8E0
movq %rdi, -0x6c0(%rbp)
movq %rdi, %rax
movq %rax, -0x6b8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x271e0
leaq -0x51(%rbp), %rdi
movq %rdi, -0x6b0(%rbp)
callq 0x1be40
movq -0x6b0(%rbp), %r... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doProcess(std::unique_ptr<QPDF, std::default_delete<QPDF>>&, std::function<void (QPDF*, char const*)>, char const*, bool, bool, bool) | void
QPDFJob::doProcess(
std::unique_ptr<QPDF>& pdf,
std::function<void(QPDF*, char const*)> fn,
char const* password,
bool empty,
bool used_for_input,
bool main_input)
{
// If a password has been specified but doesn't work, try other passwords that are equivalent in
// different charact... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movl %r9d, -0x1dc(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x1dc(%rbp), %ecx
movq %r8, -0x1d8(%rbp)
movq %rdx, -0x1d0(%rbp)
movq %rsi, %r8
movq -0x1d8(%rbp), %rsi
movq %rdi, %r9
movq -0x1d0(%rbp), %rdi
movb %al, %dl
movb 0x10(%rbp), %al
movq %r9, -... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ImageOptimizer::evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool
ImageOptimizer::evaluate(std::string const& description)
{
// Note: passing nullptr as pipeline (first argument) just tests whether we can filter.
if (!image.pipeStreamData(nullptr, 0, decode_level, true)) {
QTC::TC("qpdf", "QPDFJob image optimize no pipeline");
o.doIfVerbose([&](Pipeline& ... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
movq %rax, %rdi
addq $0x38, %rdi
movl 0x30(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %edx
callq 0x236d20
testb $... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ImageOptimizer::provideStreamData(QPDFObjGen const&, Pipeline*) | void
ImageOptimizer::provideStreamData(QPDFObjGen const&, Pipeline* pipeline)
{
std::shared_ptr<Pipeline> p = makePipeline("", pipeline);
if (p == nullptr) {
// Should not be possible
image.warnIfPossible(
"unable to create pipeline after previous success; image data will be lost");
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1be40
movq -0x90(%rbp), %rdx
leaq 0x2277f6(%rip), %rsi # 0x32faf6
leaq -0x48(%rbp), %rdi
callq 0x223d0
jmp... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::initializeFromArgv(char const* const*, char const*) | void
QPDFJob::initializeFromArgv(char const* const argv[], char const* progname_env)
{
if (progname_env == nullptr) {
progname_env = "QPDF_EXECUTABLE";
}
int argc = 0;
for (auto k = argv; *k; ++k) {
++argc;
}
QPDFArgParser qap(argc, argv, progname_env);
setMessagePrefix(qap.g... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12f034
leaq 0x1ee07d(%rip), %rax # 0x31d0ad
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rb... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::parseOptions() | void
ArgParser::parseOptions()
{
try {
this->ap.parseArgs();
} catch (std::runtime_error& e) {
usage(e.what());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xc3460
jmp 0x12f31b
jmp 0x12f3a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x12f3db
movq -0x10(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argVersion() | void
ArgParser::argVersion()
{
auto whoami = this->ap.getProgname();
*QPDFLogger::defaultLogger()->getInfo()
<< whoami << " version " << QPDF::QPDFVersion() << "\n"
<< "Run " << whoami << " --copyright to see copyright and license information.\n";
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xc4ae0
leaq -0x48(%rbp), %rdi
callq 0x1afcc0
jmp 0x138c57
leaq -0x48(%rbp), %rdi
callq 0x64360
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x1afdd0
jmp 0x138c70
leaq -0x38(%rbp), %rdi
c... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argShowCrypto() | void
ArgParser::argShowCrypto()
{
auto crypto = QPDFCryptoProvider::getRegisteredImpls();
std::string default_crypto = QPDFCryptoProvider::getDefaultProvider();
*QPDFLogger::defaultLogger()->getInfo() << default_crypto << "\n";
for (auto const& iter: crypto) {
if (iter != default_crypto) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcfec0
leaq -0x58(%rbp), %rdi
callq 0xcffb0
jmp 0x139113
leaq -0x88(%rbp), %rdi
callq 0x1afcc0
jmp 0x139121
leaq -0x88(%rbp), %rdi
callq 0x64360
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
callq 0x1afdd0
jmp 0x139... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argZopfli() | void
ArgParser::argZopfli()
{
auto logger = QPDFLogger::defaultLogger();
if (Pl_Flate::zopfli_supported()) {
if (Pl_Flate::zopfli_enabled()) {
logger->info("zopfli support is enabled, and zopfli is active\n");
} else {
logger->info("zopfli support is enabled but not activ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1afcc0
callq 0x4f200
movb %al, -0x25(%rbp)
jmp 0x13946f
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x13947b
jmp 0x139567
callq 0x4e090
movb %al, -0x26(%rbp)
jmp 0x139485
movb -0x26(%rbp), %al
testb $0x1, %al
jne 0x13948e
jmp... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argPagesPositional(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
ArgParser::argPagesPositional(std::string const& arg)
{
if (!called_pages_file) {
c_pages->file(arg);
called_pages_file = true;
return;
}
if (called_pages_range) {
c_pages->file(arg);
called_pages_range = false;
return;
}
// This could be a range ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0xc8(%rax)
jne 0x13d0cd
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
callq 0x16ed30
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x172960
movq -0x70(%rbp), %rax
movb $0x1, 0xc8(%r... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc6a20
movq -0x10(%rbp), %rdi
leaq 0x1a1e30(%rip), %rsi # 0x312f42
callq 0x31e60
movb %al, -0x99(%rbp)
jmp 0x17111f
movb -0x99(%rbp), %al
testb $0x1, %al... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::passwordMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::passwordMode(std::string const& parameter)
{
if (parameter == "bytes") {
o.m->password_mode = QPDFJob::pm_bytes;
} else if (parameter == "hex-bytes") {
o.m->password_mode = QPDFJob::pm_hex_bytes;
} else if (parameter == "unicode") {
o.m->password_mod... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1a829f(%rip), %rsi # 0x319612
callq 0x31e60
testb $0x1, %al
jne 0x17137e
jmp 0x171399
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x110e00
movl $0x0, ... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::jobJsonFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::jobJsonFile(std::string const& parameter)
{
try {
o.initializeFromJson(QUtil::read_file_into_string(parameter.c_str()), true);
} catch (std::exception& e) {
throw std::runtime_error(
"error with job-json file " + std::string(parameter) + ": " + e.wha... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq (%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b180
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2b2b30
jmp 0x171acf
movq -0x138(%... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::creationdate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::AttConfig*
QPDFJob::AttConfig::creationdate(std::string const& parameter)
{
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
usage(std::string(parameter) + " is not a valid PDF timestamp");
}
this->att.creationdate = parameter;
return this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b1950
testb $0x1, %al
jne 0x1721bd
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1b1c0
movq... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::endAddAttachment() | QPDFJob::Config*
QPDFJob::AttConfig::endAddAttachment()
{
static std::string now = QUtil::qpdf_time_to_pdf_time(QUtil::get_current_qpdf_time());
if (this->att.path.empty()) {
usage("add attachment: no file specified");
}
std::string last_element = QUtil::path_basename(this->att.path);
if (la... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpb $0x0, 0x320207(%rip) # 0x492618
jne 0x172467
leaq 0x3201fe(%rip), %rdi # 0x492618
callq 0x1b530
cmpl $0x0, %eax
je 0x172467
leaq -0x24(%rbp), %rdi
callq 0x2b0cd0
jmp 0x17242f
leaq 0x3201c2(%rip), %r... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::UOConfig::endUnderlayOverlay() | QPDFJob::Config*
QPDFJob::UOConfig::endUnderlayOverlay()
{
if (config->o.m->under_overlay->filename.empty()) {
usage(config->o.m->under_overlay->which + " file not specified");
}
config->o.m->under_overlay = nullptr;
return this->config;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq (%rax), %rdi
callq 0x110e00
movq 0x378(%rax), %rdi
addq $0x20, %rdi
callq 0x1b450
testb $0x1, %al
jne 0x172f75
jmp 0x172fcc
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
cal... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movq (%ra... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
movq (%rax), %rdi
callq 0x110e00
cmpl $0x0, 0x110(%rax)
jne 0x173c08
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1be40
movq -0x50(%rbp), %rdx
leaq 0x1b46a9(%rip), %rsi # 0x328259... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::EncConfig::modify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::EncConfig*
QPDFJob::EncConfig::modify(std::string const& parameter)
{
if (config->o.m->keylen == 40) {
config->o.m->r2_modify = (parameter == "y");
} else if (parameter == "all") {
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = true;
config->o.m->r3... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rax
movq (%rax), %rdi
callq 0x110e00
cmpl $0x28, 0x110(%rax)
jne 0x173fa1
movq -0x10(%rbp), %rdi
leaq 0x1a54f3(%rip), %rsi # 0x31946a
callq 0x31e60
movb %al, %cl
movq -0... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1ade80
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rsi
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, ... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc6460
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x18b6d0
jmp 0x183f08
movq -0x70(%rbp), %rdi
leaq -0... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addParameter(std::function<void (char const*)>)::$_0::$_0($_0 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1af1b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::setupReplaceInput()::$_0::operator()() const | 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x16e4b0
movq %rax, %rdi
callq 0x16f370
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::$_1($_1&&) | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1af360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc6cb0
addq $0x10, %rsp
popq %rbp
retq
nop
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::$_1($_1 const&) | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc6460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginUnderOverlay(JSON const&) | void
Handlers::beginUnderOverlay(JSON const& j)
{
// File has to be processed before items, so handle it here.
std::string file;
if (!j.getDictItem("file").getString(file)) {
QTC::TC("qpdf", "QPDFJob json over/under no file");
usage("file is required in underlay/overlay specification");
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1b510
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be40
movq -0xa8(%rbp), %rdx
leaq 0x181d19(%rip),... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFLogger::setInfo(std::shared_ptr<Pipeline>) | void
QPDFLogger::setInfo(std::shared_ptr<Pipeline> p)
{
if (p == nullptr) {
if (m->p_save == m->p_stdout) {
p = m->p_stderr;
} else {
p = m->p_stdout;
}
}
m->p_info = p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1257b0
testb $0x1, %al
jne 0x1b03d6
jmp 0x1b043c
movq -0x18(%... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::setSave(std::shared_ptr<Pipeline>, bool) | void
QPDFLogger::setSave(std::shared_ptr<Pipeline> p, bool only_if_not_set)
{
if (only_if_not_set && (m->p_save != nullptr)) {
return;
}
if (m->p_save == p) {
return;
}
if (p == m->p_stdout) {
auto pt = dynamic_cast<Pl_Track*>(p.get());
if (pt->getUsed()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x40(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x11(%rbp)
je 0x1b055d
movq -0x38(%rbp), %rdi
callq 0x1b0d90
movq %rax, %rdi
addq $0x70, %rdi
xorl ... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFMatrix::QPDFMatrix(QPDFObjectHandle::Matrix const&) | QPDFMatrix::QPDFMatrix(QPDFObjectHandle::Matrix const& m) :
a(m.a),
b(m.b),
c(m.c),
d(m.d),
e(m.e),
f(m.f)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rcx
... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::unparse[abi:cxx11]() const | std::string
QPDFMatrix::unparse() const
{
return (
QUtil::double_to_string(fix_rounding(a), 5) + " " +
QUtil::double_to_string(fix_rounding(b), 5) + " " +
QUtil::double_to_string(fix_rounding(c), 5) + " " +
QUtil::double_to_string(fix_rounding(d), 5) + " " +
QUtil::double_to_... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x220(%rbp)
movq %rdi, %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
movsd (%rax), %xmm0
callq 0x1b2e50
leaq -0x150(%rbp), %rdi
movq %rdi, -0x208(%rbp)
movl $0x5, ... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa4(%rbp)
subl $0x5a, %eax
je 0x1b312e
jmp 0x1b310d
movl -0xa4(%rbp), %eax
subl $0xb4, %eax
je 0x1b3165
jmp 0x1b311c
movl -0xa4(%rbp), %eax
subl $0x10e,... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0xe0(%rbp)
movq %rdi, -0xd8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1b3870
movq -0xc0(%rbp), %rdx
leaq -0x... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFObjectHandle::Matrix::Matrix(double, double, double, double, double, double) | Matrix(double a, double b, double c, double d, double e, double f) :
a(a),
b(b),
c(c),
d(d),
e(e),
f(f)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd ... | /qpdf[P]qpdf/include/qpdf/QPDFObjectHandle.hh |
QPDFNameTreeObjectHelper::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle) | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::insert(std::string const& key, QPDFObjectHandle value)
{
auto i = m->impl->insert(QPDFObjectHandle::newUnicodeString(key), value);
return {std::make_shared<NNTreeIterator>(i)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rcx, -0xe0(%rbp)
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x1b5e40
movq %rax, %rdi
callq 0x1b5e60
movq %rax, -0x... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::find(long long, bool) | QPDFNumberTreeObjectHelper::iterator
QPDFNumberTreeObjectHelper::find(numtree_number key, bool return_prev_if_not_found)
{
auto i = m->impl->find(QPDFObjectHandle::newInteger(key), return_prev_if_not_found);
return {std::make_shared<NNTreeIterator>(i)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x1b9a70
movq %rax, %rdi
callq 0x1b5e60
movq %rax... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::getMin() | QPDFNumberTreeObjectHelper::numtree_number
QPDFNumberTreeObjectHelper::getMin()
{
auto i = begin();
if (i == end()) {
return 0;
}
return i->first;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b86a0
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1b8780
jmp 0x1b8cd5
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1b8560
movb %al, -0x89(%rbp)
jmp 0x1b8cea... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
void QIntC::range_check_subtract_error<long long>(long long const&, long long const&) | void
range_check_subtract_error(T const& cur, T const& delta)
{
if ((delta > 0) && ((std::numeric_limits<T>::min() + delta) > cur)) {
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "subtracting " << delta << " from " << cur
<< " woul... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jle 0x1ba583
callq 0x21c50
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x1ba583
leaq -0x188(%rbp), %rdi
callq 0x1be00
movq ... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QPDFNumberTreeObjectHelper::iterator::iterator(QPDFNumberTreeObjectHelper::iterator const&) | class QPDF_DLL_PRIVATE iterator
{
friend class QPDFNumberTreeObjectHelper;
public:
typedef std::pair<numtree_number, QPDFObjectHandle> T;
using iterator_category = std::bidirectional_iterator_tag;
using value_type = T;
using difference_type = long;
using pointe... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x2d3f79(%rip), %rax # 0x48e788
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1b5d10
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
m... | /qpdf[P]qpdf/include/qpdf/QPDFNumberTreeObjectHelper.hh |
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
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq %rdi, -0x2f8(%rbp)
movq %rdi, %rax
movq %rax, -0x2f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0x6a9d0
cmpl $0x9, %eax
jne 0x1bb0b6
movl $0x2, %eax
movl %eax, -0x2fc(%rbp)
jmp 0x1bb0d... | /qpdf[P]qpdf/libqpdf/QPDFObject.cc |
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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0x1bcdfd
jmp 0x1bce0f
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b1c0
jmp 0x1bcfb2
movq -0x68(%rbp),... | /qpdf[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
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x1d8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x1cafd0
movl %eax, %ecx
movq %rcx, -... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::unparse[abi:cxx11]() const | std::string
BaseHandle::unparse() const
{
switch (resolved_type_code()) {
case ::ot_uninitialized:
throw std::logic_error("QPDFObjectHandle: attempting to unparse an uninitialized object");
return ""; // does not return
case ::ot_reserved:
throw std::logic_error("QPDFObjectHandle: at... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x1cafd0
movl %eax, %ecx
movq %rcx, -0x218(%rbp)
subl $0xf, %eax
ja 0x1be509
movq -0x218... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::disconnect(bool) | void
BaseHandle::disconnect(bool only_direct)
{
// QPDF::~QPDF() calls disconnect for indirect objects, so we don't do that here.
if (only_direct && indirect()) {
return;
}
switch (raw_type_code()) {
case ::ot_array:
{
auto& a = std::get<QPDF_Array>(obj->value);
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1bf88f
movq -0xa0(%rbp), %rdi
callq 0x1cb640
testb $0x1, %al
jne 0x1bf88a
jmp 0x1bf88f
jmp 0x1bfae6
movq -0xa0(%rbp), %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObject::getStringValue[abi:cxx11]() const | std::string
QPDFObject::getStringValue() const
{
switch (getResolvedTypeCode()) {
case ::ot_real:
return std::get<QPDF_Real>(value).val;
case ::ot_string:
return std::get<QPDF_String>(value).val;
case ::ot_name:
return std::get<QPDF_Name>(value).name;
case ::ot_operator:
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1cc170
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0xa, %eax
ja 0x1bfbdc
movq -0x28(%rbp), %rax
l... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1bfe00
testb $0x1, %al
jne 0x1bfec2
jmp 0x1bfeda
movq -0x70(%rbp), %rdi
callq 0x1bffd0
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1bffb2
movq -0x70(%rbp), %rdi
callq 0x1bfe30
testb $0x1, %al
... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getIntValue() const | long long
QPDFObjectHandle::getIntValue() const
{
if (auto integer = as<QPDF_Integer>()) {
return integer->val;
} else {
typeWarning("integer", "returning 0");
QTC::TC("qpdf", "QPDFObjectHandle integer returning 0");
return 0;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1cc4c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c0004
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c009c
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1be4... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1bfe30
testb $0x1, %al
jne 0x1c00de
jmp 0x1c00f8
movq -0x50(%rbp), %rdi
callq 0x66760
movq -0x60(%rbp), %rdi
movq %... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getBoolValue() const | bool
QPDFObjectHandle::getBoolValue() const
{
if (auto boolean = as<QPDF_Bool>()) {
return boolean->val;
} else {
typeWarning("boolean", "returning false");
QTC::TC("qpdf", "QPDFObjectHandle boolean returning false");
return false;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1cc330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c0dd4
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1c0e68
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getIntValueAsInt() const | int
QPDFObjectHandle::getIntValueAsInt() const
{
int result = 0;
long long v = getIntValue();
if (v < INT_MIN) {
QTC::TC("qpdf", "QPDFObjectHandle int returning INT_MIN");
warnIfPossible("requested value of integer is too small; returning INT_MIN");
result = INT_MIN;
} else if (v... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x1bffd0
movq %rax, -0x18(%rbp)
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jge 0x1c0ff1
leaq 0x171100(%rip), %rdi # 0x33205c
leaq 0x16b17b(%rip), %rsi # 0x32c0de
xorl %... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::warnIfPossible(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
QPDFObjectHandle::warnIfPossible(std::string const& warning) const
{
QPDF* context = nullptr;
std::string description;
if (obj && obj->getDescription(context, description)) {
warn(context, QPDFExc(qpdf_e_damaged_pdf, "", description, 0, warning));
} else {
*QPDFLogger::defaultLogger... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1b510
movq -0x118(%rbp), %rdi
callq 0x440f0
testb $0x1, %al
jne 0x1c1104
jmp 0x1c1238
movq -0x118(%rbp), ... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getUIntValue() const | unsigned long long
QPDFObjectHandle::getUIntValue() const
{
long long v = getIntValue();
if (v < 0) {
QTC::TC("qpdf", "QPDFObjectHandle uint returning 0");
warnIfPossible("unsigned value request for negative number; returning 0");
return 0;
} else {
return static_cast<unsigne... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1bffd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x1c1419
leaq 0x170ccd(%rip), %rdi # 0x33205c
leaq 0x16ae0a(%rip), %rsi # 0x32c1a0
xorl %edx, %edx
callq 0x25a90
leaq -0x39(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getUIntValueAsUInt() const | unsigned int
QPDFObjectHandle::getUIntValueAsUInt() const
{
long long v = getIntValue();
if (v < 0) {
QTC::TC("qpdf", "QPDFObjectHandle uint uint returning 0");
warnIfPossible("unsigned integer value request for negative number; returning 0");
return 0;
} else if (v > UINT_MAX) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1bffd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x1c1557
leaq 0x170b9a(%rip), %rdi # 0x33205c
leaq 0x16ad31(%rip), %rsi # 0x32c1fa
xorl %edx, %edx
callq 0x25a90
leaq -0x39(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getStringValue[abi:cxx11]() const | std::string
QPDFObjectHandle::getStringValue() const
{
if (isString()) {
return obj->getStringValue();
} else {
typeWarning("string", "returning empty string");
QTC::TC("qpdf", "QPDFObjectHandle string returning empty string");
return "";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c0650
testb $0x1, %al
jne 0x1c177e
jmp 0x1c1798
movq -0x50(%rbp), %rdi
callq 0x66760
movq -0x60(%rbp), %rdi
movq %... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getOperatorValue[abi:cxx11]() const | std::string
QPDFObjectHandle::getOperatorValue() const
{
if (isOperator()) {
return obj->getStringValue();
} else {
typeWarning("operator", "returning fake value");
QTC::TC("qpdf", "QPDFObjectHandle operator returning fake value");
return "QPDFFAKE";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c0680
testb $0x1, %al
jne 0x1c1abe
jmp 0x1c1ad8
movq -0x50(%rbp), %rdi
callq 0x66760
movq -0x60(%rbp), %rdi
movq %... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getInlineImageValue[abi:cxx11]() const | std::string
QPDFObjectHandle::getInlineImageValue() const
{
if (isInlineImage()) {
return obj->getStringValue();
} else {
typeWarning("inlineimage", "returning empty data");
QTC::TC("qpdf", "QPDFObjectHandle inlineimage returning empty data");
return "";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c06b0
testb $0x1, %al
jne 0x1c1c5e
jmp 0x1c1c78
movq -0x50(%rbp), %rdi
callq 0x66760
movq -0x60(%rbp), %rdi
movq %... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isOrHasName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool
QPDFObjectHandle::isOrHasName(std::string const& value) const
{
if (isNameAndEquals(value)) {
return true;
} else if (isArray()) {
for (auto& item: getArrayAsVector()) {
if (item.isNameAndEquals(value)) {
return true;
}
}
}
return fals... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c0830
testb $0x1, %al
jne 0x1c1e5a
jmp 0x1c1e63
movb $0x1, -0x1(%rbp)
jmp 0x1c1f32
movq -0x70(%rbp), %rdi
callq 0x1c06e0
testb $0x1, %al
jne 0x1c1e75
jm... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::makeResourcesIndirect(QPDF&) | void
QPDFObjectHandle::makeResourcesIndirect(QPDF& owning_qpdf)
{
for (auto const& i1: as_dictionary()) {
for (auto& i2: i1.second.as_dictionary()) {
if (!i2.second.null() && !i2.second.isIndirect()) {
i2.second = owning_qpdf.makeIndirectObject(i2.second);
}
}... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x3, %edx
callq 0x64de0
movq -0xb8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64ec0
movq %rax, -0xb0(%rbp)
jmp 0x1c1f99
movq -0xb0(%rb... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::mergeResources(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<s... | void
QPDFObjectHandle::mergeResources(
QPDFObjectHandle other, std::map<std::string, std::map<std::string, std::string>>* conflicts)
{
if (!(isDictionary() && other.isDictionary())) {
QTC::TC("qpdf", "QPDFObjectHandle merge top type mismatch");
return;
}
auto make_og_to_name = [](QPDFOb... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rsi, -0x3a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1c0710
testb $0x1, %al
jne 0x1c2234
jmp 0x1c2244
movq -0x3a8(%rbp), %rdi
callq 0x1c0710
testb $0x1, %al
... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::shallowCopy() | QPDFObjectHandle
QPDFObjectHandle::shallowCopy()
{
if (!obj) {
throw std::logic_error("operation attempted on uninitialized QPDFObjectHandle");
}
return {copy()};
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x440f0
testb $0x1, %al
jne 0x1c2fec
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getUniqueResourceName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::al... | std::string
QPDFObjectHandle::getUniqueResourceName(
std::string const& prefix, int& min_suffix, std::set<std::string>* namesp) const
{
std::set<std::string> names = (namesp ? *namesp : getResourceNames());
int max_suffix = min_suffix + QIntC::to_int(names.size());
while (min_suffix <= max_suffix) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1c3501
movq -0x28(%rbp), %r... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parse(QPDF*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFObjectHandle::parse(
QPDF* context, std::string const& object_str, std::string const& object_description)
{
// BufferInputSource does not modify the input, but Buffer either requires a string& or copies
// the string.
Buffer buf(const_cast<std::string&>(object_str));
auto input ... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x200b0
leaq -0x131(%rbp), %rdi
movq %rdi, ... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::pipePageContents(Pipeline*) | void
QPDFObjectHandle::pipePageContents(Pipeline* p)
{
std::string description = "page object " + getObjGen().unparse(' ');
std::string all_description;
this->getKey("/Contents").pipeContentStreams(p, description, all_description);
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1c3450
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
leaq -0x58(%rbp), %rsi
movl $0x20, %edx
callq 0x64a30
movq -0xc8(%rbp), %rdx
leaq 0x1682d7(%rip), %rsi... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1c3450
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x60(%rbp), %rsi
movl $0x20, %edx
callq 0x64a30
movq -0xb0(%rbp), %rdx
le... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::filterAsContents(QPDFObjectHandle::TokenFilter*, Pipeline*) | void
QPDFObjectHandle::filterAsContents(TokenFilter* filter, Pipeline* next)
{
auto description = "token filter for object " + getObjGen().unparse(' ');
Pl_QPDFTokenizer token_pipeline(description.c_str(), filter, next);
this->pipeStreamData(&token_pipeline, 0, qpdf_dl_specialized);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1c3450
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x60(%rbp), %rsi
movl $0x20, %edx
callq 0x64a30
movq -0xb0(%rbp), %rdx
le... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parseContentStream_data(std::shared_ptr<Buffer>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::ParserCallbacks*, QPDF*) | void
QPDFObjectHandle::parseContentStream_data(
std::shared_ptr<Buffer> stream_data,
std::string const& description,
ParserCallbacks* callbacks,
QPDF* context)
{
size_t stream_length = stream_data->getSize();
auto input = BufferInputSource(description, stream_data.get());
Tokenizer tokenizer... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x390(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x1cca10
movq %rax, %rdi
callq 0x202c0
movq -0x390(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x388(%r... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newArray(QPDFObjectHandle::Matrix const&) | QPDFObjectHandle
QPDFObjectHandle::newArray(Matrix const& matrix)
{
return newArray(
{newReal(matrix.a),
newReal(matrix.b),
newReal(matrix.c),
newReal(matrix.d),
newReal(matrix.e),
newReal(matrix.f)});
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorl %esi, %esi
movl $0x1, %edx
callq 0x1c75e0
jmp 0x1... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newArray(QPDFMatrix const&) | QPDFObjectHandle
QPDFObjectHandle::newArray(QPDFMatrix const& matrix)
{
return newArray(
{newReal(matrix.a),
newReal(matrix.b),
newReal(matrix.c),
newReal(matrix.d),
newReal(matrix.e),
newReal(matrix.f)});
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorl %esi, %esi
movl $0x1, %edx
callq 0x1c75e0
jmp 0x1... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newStream(QPDF*, std::shared_ptr<Buffer>) | QPDFObjectHandle
QPDFObjectHandle::newStream(QPDF* qpdf, std::shared_ptr<Buffer> data)
{
if (qpdf == nullptr) {
throw std::runtime_error("attempt to create stream in null qpdf object");
}
QTC::TC("qpdf", "QPDFObjectHandle newStream with data");
return qpdf->newStream(data);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c81ca
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
l... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newReserved(QPDF*) | QPDFObjectHandle
QPDFObjectHandle::newReserved(QPDF* qpdf)
{
if (qpdf == nullptr) {
throw std::runtime_error("attempt to create reserved object in null qpdf object");
}
return qpdf->newReserved();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c8362
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1646c6(%rip), %rsi # 0x32c9f3
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::makeDirect(QPDFObjGen::set&, bool) | void
QPDFObjectHandle::makeDirect(QPDFObjGen::set& visited, bool stop_at_streams)
{
assertInitialized();
auto cur_og = getObjGen();
if (!visited.add(cur_og)) {
QTC::TC("qpdf", "QPDFObjectHandle makeDirect loop");
throw std::runtime_error("loop detected while converting object from indirect ... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0x1c8c50
movq -0x178(%rbp), %rdi
callq 0x1c3450
movq %rax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::copyStream() | QPDFObjectHandle
QPDFObjectHandle::copyStream()
{
assertStream();
QPDFObjectHandle result = newStream(this->getOwningQPDF());
QPDFObjectHandle dict = result.getDict();
QPDFObjectHandle old_dict = getDict();
for (auto& iter: QPDFDictItems(old_dict)) {
if (iter.second.isIndirect()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1c44e0
movq -0x118(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x1c4090
movq -0x110(%rbp)... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1b510
movq -0x100(%rbp), %rdi
callq 0x66760
movq -0xf8(%rbp), %rdx
movq %rax, %rdi... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.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.