name string | code string | asm string | file string |
|---|---|---|---|
QPDFAcroFormDocumentHelper::disableDigitalSignatures() | void
QPDFAcroFormDocumentHelper::disableDigitalSignatures()
{
qpdf.removeSecurityRestrictions();
std::set<QPDFObjGen> to_remove;
auto fields = getFormFields();
for (auto& f: fields) {
auto ft = f.getFieldType();
if (ft == "/Sig") {
auto oh = f.getObjectHandle();
t... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
movq 0x8(%rax), %rdi
callq 0x62670
leaq -0x38(%rbp), %rdi
callq 0x43980
movq -0x170(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa2940
jmp 0xa3d2e
leaq -0x50(%rbp), %rax
movq %rax, -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
(anonymous namespace)::ResourceReplacer::ResourceReplacer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std:... | ResourceReplacer::ResourceReplacer(
std::map<std::string, std::map<std::string, std::string>> const& dr_map,
std::map<std::string, std::map<std::string, std::set<size_t>>> const& rnames)
{
// We have:
// * dr_map[resource_type][key] == new_key
// * rnames[resource_type][key] == set of offsets
//... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x23310
movq -0xd8(%rbp), %rdi
leaq 0x3e71f3(%rip), %rax # 0x48bf58
addq $0x10, %rax
movq %rax, (%rdi)
movq $0x0, 0x10(%rdi)
add... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAnnotationObjectHelper::getAppearanceState[abi:cxx11]() | std::string
QPDFAnnotationObjectHelper::getAppearanceState()
{
if (oh().getKey("/AS").isName()) {
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AS present");
return oh().getKey("/AS").getName();
}
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AS absent");
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbf790
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1be40
movq -0xb8(%rbp), %rdx
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFAnnotationObjectHelper::getFlags() | int
QPDFAnnotationObjectHelper::getFlags()
{
QPDFObjectHandle flags_obj = oh().getKey("/F");
return flags_obj.isInteger() ? flags_obj.getIntValueAsInt() : 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xbf790
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x25439b(%rip), %rsi # 0x31276f
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0xbe3df
leaq -0x18(%rbp), %rdi
... | /jberkenbilt[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.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 0xc59e0
movq 0x178(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc5ca0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc0c55
leaq 0x24cbe7(%rip), %rdi # 0x30d6cf
leaq 0x251f42... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::completionCommon(bool) | void
QPDFArgParser::completionCommon(bool zsh)
{
std::string progname = m->argv[0];
std::string executable;
std::string appdir;
std::string appimage;
if (QUtil::get_env(m->progname_env.c_str(), &executable)) {
progname = executable;
} else if (QUtil::get_env("APPDIR", &appdir) && QUtil::... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0xc59e0
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x158(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::parseArgs() | void
QPDFArgParser::parseArgs()
{
selectMainOptionTable();
checkCompletion();
handleArgFileArguments();
for (m->cur_arg = 1; m->cur_arg < m->argc; ++m->cur_arg) {
bool help_option = false;
bool end_option = false;
auto oep = m->option_table->end();
char const* arg = m->ar... | pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp # imm = 0x3D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x328(%rbp)
callq 0xc06e0
movq -0x328(%rbp), %rdi
callq 0xc25c0
movq -0x328(%rbp), %rdi
callq 0xc1810
movq -0x328(%rbp), %rdi
callq 0xc59e0
movl $0x1, 0x50(%rax)
movq -0x328(%rbp), %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::doFinalChecks() | void
QPDFArgParser::doFinalChecks()
{
if (m->option_table != &(m->main_option_table)) {
QTC::TC("libtests", "QPDFArgParser missing --");
usage("missing -- at end of " + m->option_table_name + " options");
}
if (m->final_check_handler != nullptr) {
m->final_check_handler();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc59e0
movq -0x68(%rbp), %rdi
movq 0x178(%rax), %rax
movq %rax, -0x60(%rbp)
callq 0xc59e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq $0x118, %rcx # imm = 0x118
cmpq %rcx, %rax
je 0xc4227
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::insertCompletions(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, QPDFArgParser::OptionEntry, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char... | void
QPDFArgParser::insertCompletions(
option_table_t& option_table, std::string const& choice_option, std::string const& extra_prefix)
{
if (!choice_option.empty()) {
addChoicesToCompletions(option_table, choice_option, extra_prefix);
} else if ((!m->bash_cur.empty()) && (m->bash_cur.at(0) == '-'))... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0xc46e4
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::addOptionHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<cha... | void
QPDFArgParser::addOptionHelp(
std::string const& option_name,
std::string const& topic,
std::string const& short_text,
std::string const& long_text)
{
if (!((option_name.length() > 2) && (option_name.at(0) == '-') && (option_name.at(1) == '-'))) {
QTC::TC("libtests", "QPDFArgParser bad ... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b850
cmpq $0x2, %rax
jbe 0xc4c24
movq -0x10(%rbp), %rdi
xor... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::getTopHelp(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFArgParser::getTopHelp(std::ostringstream& msg)
{
msg << "Run \"" << m->whoami << " --help=topic\" for help on a topic." << std::endl
<< "Run \"" << m->whoami << " --help=--option\" for help on an option." << std::endl
<< "Run \"" << m->whoami << " --help=all\" to see all available help." <<... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x24ded2(%rip), %rsi # 0x312fc5
callq 0x1b860
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xc59e0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x10... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::getTopicHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFArgParser::HelpTopic const&, std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFArgParser::getTopicHelp(std::string const& name, HelpTopic const& ht, std::ostringstream& msg)
{
if (ht.long_text.empty()) {
msg << ht.short_text << std::endl;
} else {
msg << ht.long_text;
}
if (!ht.options.empty()) {
msg << std::endl << "Related options:" << std::endl;... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b450
testb $0x1, %al
jne 0xc5493
jmp 0xc54b1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QIntC::IntConverter<unsigned long, int, false, true>::convert(unsigned long const&) | inline static To
convert(From const& i)
{
// From is unsigned, and to is signed. Convert To's max to the
// unsigned version of To and compare i against that.
auto maxval = static_cast<typename to_u<To>::type>(std::numeric_limits<To>::max());
if (i > maxva... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x632c0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xcd49f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xcd4b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
no... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
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 0xcd4f3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QPDFCryptoProvider::getImpl() | std::shared_ptr<QPDFCryptoImpl>
QPDFCryptoProvider::getImpl()
{
QPDFCryptoProvider& p = getInstance();
if (p.m->default_provider.empty()) {
throw std::logic_error("QPDFCryptoProvider::getImpl called with no default provider.");
}
return p.getImpl_internal(p.m->default_provider);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
callq 0xcefe0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf780
movq %rax, %rdi
callq 0x1b450
testb $0x1, %al
jne 0xcef57
jmp 0xcefa7
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFCryptoProvider.cc |
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 0xcf780
movq %rax, %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xcfc10
cmpq $0x0, %rax
jne 0xcf421
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x70(%rb... | /jberkenbilt[P]qpdf/libqpdf/QPDFCryptoProvider.cc |
QPDFEFStreamObjectHelper::QPDFEFStreamObjectHelper(QPDFObjectHandle) | QPDFEFStreamObjectHelper::QPDFEFStreamObjectHelper(QPDFObjectHandle oh) :
QPDFObjectHelper(oh),
m(new Members())
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x42b80
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xbf6e0
jmp 0xd29e4
leaq -0x20(%rbp), %rdi
callq 0x23380
movq -0x40(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::getParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFEFStreamObjectHelper::getParam(std::string const& pkey)
{
auto params = oh().getDict().getKey("/Params");
if (params.isDictionary()) {
return params.getKey(pkey);
}
return QPDFObjectHandle::newNull();
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xbf790
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2360f0
jm... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::getCreationDate[abi:cxx11]() | std::string
QPDFEFStreamObjectHelper::getCreationDate()
{
auto val = getParam("/CreationDate");
if (val.isString()) {
return val.getUTF8Value();
}
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x2407ba(%rip), %rsi # 0x3136a8
... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::getModDate[abi:cxx11]() | std::string
QPDFEFStreamObjectHelper::getModDate()
{
auto val = getParam("/ModDate");
if (val.isString()) {
return val.getUTF8Value();
}
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x240668(%rip), %rsi # 0x3136b6
... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::getSize() | size_t
QPDFEFStreamObjectHelper::getSize()
{
auto val = getParam("/Size");
if (val.isInteger()) {
return QIntC::to_size(val.getUIntValueAsUInt());
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x240520(%rip), %rsi # 0x3136bf
leaq -0x40(%rbp), %rdi
callq 0x21b70
jmp 0xd31aa
movq -0x70(%rbp), %rsi
leaq -0x20(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::getSubtype[abi:cxx11]() | std::string
QPDFEFStreamObjectHelper::getSubtype()
{
auto val = oh().getDict().getKey("/Subtype");
if (val.isName()) {
auto n = val.getName();
if (n.length() > 1) {
return n.substr(1);
}
}
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xbf790
movq -0xa8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2360f0
jmp 0xd32da
leaq -0x71(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::setSubtype(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFEFStreamObjectHelper&
QPDFEFStreamObjectHelper::setSubtype(std::string const& subtype)
{
oh().getDict().replaceKey("/Subtype", QPDFObjectHandle::newName("/" + subtype));
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xbf790
movq -0xa0(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2360f0
jmp 0xd40c0
leaq -0x61(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFFileSpecObjectHelper::setFilename(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&) | QPDFFileSpecObjectHelper&
QPDFFileSpecObjectHelper::setFilename(
std::string const& unicode_name, std::string const& compat_name)
{
auto uf = QPDFObjectHandle::newUnicodeString(unicode_name);
oh().replaceKey("/UF", uf);
if (compat_name.empty()) {
QTC::TC("qpdf", "QPDFFileSpecObjectHelper empty c... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1c7160
movq -0xf8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xbf790
jmp 0xda441
leaq... | /jberkenbilt[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFormFieldObjectHelper::getFullyQualifiedName[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getFullyQualifiedName()
{
std::string result;
QPDFObjectHandle node = oh();
QPDFObjGen::set seen;
while (!node.isNull() && seen.add(node)) {
if (node.getKey("/T").isString()) {
if (!result.empty()) {
QTC::TC("qpdf", "QPDFFormFiel... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x190(%rbp)
movq %rdi, %rax
movq %rax, -0x188(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0x180(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xbf... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getPartialName[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getPartialName()
{
std::string result;
if (oh().getKey("/T").isString()) {
result = oh().getKey("/T").getUTF8Value();
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0xe0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xbf790
... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getAlternativeName[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getAlternativeName()
{
if (oh().getKey("/TU").isString()) {
QTC::TC("qpdf", "QPDFFormFieldObjectHelper TU present");
return oh().getKey("/TU").getUTF8Value();
}
QTC::TC("qpdf", "QPDFFormFieldObjectHelper TU absent");
return getFullyQualifiedName();
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbf790
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1be40
movq -0xb8(%rbp), %rdx
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getDefaultAppearance[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getDefaultAppearance()
{
auto value = getInheritableFieldValue("/DA");
bool looked_in_acroform = false;
if (!value.isString()) {
value = getFieldFromAcroForm("/DA");
looked_in_acroform = true;
}
std::string result;
if (value.isString()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1be40
movq -0xb8(%rbp), %rdx
leaq 0x23566e(%rip), %rsi # 0x3121eb
... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isCheckbox() | bool
QPDFFormFieldObjectHelper::isCheckbox()
{
return ((getFieldType() == "/Btn") && ((getFlags() & (ff_btn_radio | ff_btn_pushbutton)) == 0));
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xdbb40
movq -0x40(%rbp), %rdi
leaq 0x235044(%rip), %rsi # 0x3121d0
callq 0x315c0
movb %al, -0x35(%rbp)
jmp 0xdd196
movb -0x35(%rbp), %cl
xorl %eax, %eax
... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isChecked() | bool
QPDFFormFieldObjectHelper::isChecked()
{
return isCheckbox() && getValue().isName() && (getValue().getName() != "/Off");
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xdd160
movb %al, %cl
movb $0x0, -0x21(%rbp)
movb $0x0, -0x69(%rbp)
movb $0x0, -0x6a(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6b(%rbp)
jne 0xdd239
jmp 0xdd2ba
movq -0x78(%rbp), %rsi
leaq -0x2... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getChoices[abi:cxx11]() | std::vector<std::string>
QPDFFormFieldObjectHelper::getChoices()
{
std::vector<std::string> result;
if (!isChoice()) {
return result;
}
for (auto const& item: getInheritableFieldValue("/Opt").as_array()) {
if (item.isString()) {
result.emplace_back(item.getUTF8Value());
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x83ee0
movq -0xc8(%rbp), %rdi
callq 0xdd4b0
movb %al, -0xb9(%rbp)
j... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::setRadioButtonValue(QPDFObjectHandle) | void
QPDFFormFieldObjectHelper::setRadioButtonValue(QPDFObjectHandle name)
{
// Set the value of a radio button field. This has the following specific behavior:
// * If this is a radio button field that has a parent that is also a radio button field and has
// no explicit /V, call itself on the parent
... | pushq %rbp
movq %rsp, %rbp
subq $0x570, %rsp # imm = 0x570
movq %rsi, -0x450(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x448(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbf790
leaq -0x51(%rbp), %rdi
movq %rdi, -0x440(%rbp)
callq 0x1be40
movq -0x440(%rbp), %rdx
leaq 0x2332be... | /jberkenbilt[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 0x23310
movq -0x50(%rbp), %rdi
leaq 0x3aa817(%rip), %rax # 0x48c5d0
movq %rax, (%rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFJob::createQPDF() | std::unique_ptr<QPDF>
QPDFJob::createQPDF()
{
checkConfiguration();
std::unique_ptr<QPDF> pdf_sp;
try {
processFile(pdf_sp, m->infilename.get(), m->password.get(), true, true);
} catch (QPDFExc& e) {
if (e.getErrorCode() == qpdf_e_password) {
// Allow certain operations to wo... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdi, -0x2a8(%rbp)
movq %rdi, %rax
movq %rax, -0x2a0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0xe5d20
leaq -0x18(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x1107d0
movq -0x298(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::checkConfiguration() | void
QPDFJob::checkConfiguration()
{
// Do final checks for command-line consistency. (I always think this is called doFinalChecks,
// so I'm putting that in a comment.)
if (m->replace_input) {
// Check for --empty appears later after we have checked m->infilename.
if (m->outfilename) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x110590
testb $0x1, 0x3c9(%rax)
je 0xe5f24
movq -0x2d8(%rbp), %rdi
callq 0x110590
movq %rax, %rdi
addq $0x3e0, %rdi # imm = 0x3E0
callq 0x110b50
testb $0x1, %al
jne... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::handlePageSpecs(QPDF&, std::vector<std::unique_ptr<QPDF, std::default_delete<QPDF>>, std::allocator<std::unique_ptr<QPDF, std::default_delete<QPDF>>>>&) | void
QPDFJob::handlePageSpecs(QPDF& pdf, std::vector<std::unique_ptr<QPDF>>& page_heap)
{
// Parse all page specifications and translate them into lists of actual pages.
// Handle "." as a shortcut for the input file
for (auto& page_spec: m->page_specs) {
if (page_spec.filename == ".") {
... | pushq %rbp
movq %rsp, %rbp
subq $0xde0, %rsp # imm = 0xDE0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xaa0(%rbp)
callq 0x110590
addq $0x380, %rax # imm = 0x380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1128e0
movq %rax, -0x28(... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::handleTransformations(QPDF&) | void
QPDFJob::handleTransformations(QPDF& pdf)
{
QPDFPageDocumentHelper dh(pdf);
std::shared_ptr<QPDFAcroFormDocumentHelper> afdh;
auto make_afdh = [&]() {
if (!afdh.get()) {
afdh = std::make_shared<QPDFAcroFormDocumentHelper>(pdf);
}
};
if (m->remove_restrictions) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp # imm = 0x4B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1e0e10
leaq -0x40(%rbp), %rdi
callq 0xab700
movq -0x438(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq %rax, -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doInspection(QPDF&) | void
QPDFJob::doInspection(QPDF& pdf)
{
auto& cout = *m->log->getInfo();
if (m->check) {
doCheck(pdf);
}
if (m->show_npages) {
QTC::TC("qpdf", "QPDFJob npages");
cout << pdf.getRoot().getKey("/Pages").getKey("/Count").getIntValue() << "\n";
}
if (m->show_encryption) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x110590
movq %rax, %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x1af7f0
leaq -0x28(%rbp), %rdi
callq 0x63db0
movq %ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::writeOutfile(QPDF&) | void
QPDFJob::writeOutfile(QPDF& pdf)
{
std::shared_ptr<char> temp_out;
if (m->replace_input) {
// Append but don't prepend to the path to generate a temporary name. This saves us from
// having to split the path by directory and non-directory.
temp_out = QUtil::make_shared_cstr(std::str... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1103e0
movq -0x168(%rbp), %rdi
callq 0x110590
testb $0x1, 0x3c9(%rax)
je 0xee066
movq -0x168(%rbp), %rdi
callq 0x110590
movq %ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.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), %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONPageLabels(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONPageLabels(Pipeline* p, bool& first, QPDF& pdf)
{
JSON j_labels = JSON::makeArray();
QPDFPageLabelDocumentHelper pldh(pdf);
long long npages = QIntC::to_longlong(QPDFPageDocumentHelper(pdf).getAllPages().size());
if (pldh.hasPageLabels()) {
std::vector<QPDFObjectHandle> label... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26c90
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1e3560
jmp 0xf41ce
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSON(QPDF&, Pipeline*) | void
QPDFJob::doJSON(QPDF& pdf, Pipeline* p)
{
// qpdf guarantees that no new top-level keys whose names start with "x-" will be added. These
// are reserved for users.
std::string captured_json;
std::shared_ptr<Pl_String> pl_str;
if (m->test_json_schema) {
pl_str = std::make_shared<Pl_Stri... | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x328(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1b510
leaq -0x48(%rbp), %rdi
callq 0x1112a0
movq -0x328(%rbp), %rdi
callq 0x110590
testb $0x1, 0x318(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
maybe_set_pagemode(QPDF&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void
maybe_set_pagemode(QPDF& pdf, std::string const& pagemode)
{
auto root = pdf.getRoot();
if (root.getKey("/PageMode").isNull()) {
root.replaceKey("/PageMode", QPDFObjectHandle::newName(pagemode));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x610c0
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be40
movq -0xa8(%rbp), %rdx
leaq 0x219f5a(%rip), %rsi # 0x319c38
leaq -0x50(%rbp), %rdi
callq 0x21b70
jmp 0xffce9
... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::shouldRemoveUnreferencedResources(QPDF&) | bool
QPDFJob::shouldRemoveUnreferencedResources(QPDF& pdf)
{
if (m->remove_unreferenced_page_resources == QPDFJob::re_no) {
return false;
} else if (m->remove_unreferenced_page_resources == QPDFJob::re_yes) {
return true;
}
// Unreferenced resources are common in files where resources d... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x330(%rbp)
callq 0x110590
cmpl $0x2, 0x150(%rax)
jne 0x100ae5
movb $0x0, -0x1(%rbp)
jmp 0x101770
movq -0x330(%rbp), %rdi
callq 0x110590
cmpl $0x1, 0x150(%rax)
jne 0x100... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::maybeFixWritePassword(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFJob::maybeFixWritePassword(int R, std::string& password)
{
switch (m->password_mode) {
case QPDFJob::pm_bytes:
QTC::TC("qpdf", "QPDFJob password mode bytes");
break;
case QPDFJob::pm_hex_bytes:
QTC::TC("qpdf", "QPDFJob password mode hex-bytes");
password = QUtil::he... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x110590
movl 0xc4(%rax), %eax
movl %eax, -0xcc(%rbp)
testl %eax, %eax
je 0x102368
jmp 0x102348
movl -0xcc(%rbp), %eax
subl $0x1, %e... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
parse_version(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>>&, int&) | static void
parse_version(std::string const& full_version_string, std::string& version, int& extension_level)
{
auto vp = QUtil::make_unique_cstr(full_version_string);
char* v = vp.get();
char* p1 = strchr(v, '.');
char* p2 = (p1 ? strchr(1 + p1, '.') : nullptr);
if (p2 && *(p2 + 1)) {
*p2++... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2b0030
leaq -0x20(%rbp), %rdi
callq 0xc56d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x1b7f0
movq %rax, -0x30(%rbp)
cmpq $0x0, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::writeJSON(QPDF&) | void
QPDFJob::writeJSON(QPDF& pdf)
{
// File pipeline must have block scope so it will be closed after write.
std::shared_ptr<QUtil::FileCloser> fc;
std::shared_ptr<Pipeline> fp;
if (m->outfilename.get()) {
QTC::TC("qpdf", "QPDFJob write json to file");
if (m->json_stream_prefix.empty())... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x113680
leaq -0x30(%rbp), %rdi
callq 0x1136a0
movq -0xa8(%rbp), %rdi
callq 0x110590
movq %rax, %rdi
addq $0x3e0, %rdi # imm = 0x3E0
callq 0x11080... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ArgParser::argEncPositional(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
ArgParser::argEncPositional(std::string const& arg)
{
if (used_enc_password_args) {
usage("positional and dashed encryption arguments may not be mixed");
}
this->accumulated_args.push_back(arg);
if (this->accumulated_args.size() < 3) {
return;
}
user_password = this->accumu... | 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, 0xca(%rax)
je 0x13cf9b
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1be40
movq -0x78(%rbp), %rdx
leaq 0x1e078d(%rip), %rsi # 0x31d6c9
leaq -0x30(%rbp), %rdi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
(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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x70, %rdi
callq 0xe36a0
testb $0x1, %al
jne 0x13d119
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1be40
movq -0x58(%rbp), %rdx
leaq 0x1e060c(%rip), %rsi # 0x31d6c9
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
add_help(QPDFArgParser&) | static void add_help(QPDFArgParser& ap)
{
add_help_1(ap);
add_help_2(ap);
add_help_3(ap);
add_help_4(ap);
add_help_5(ap);
add_help_6(ap);
add_help_7(ap);
add_help_8(ap);
ap.addHelpFooter("For detailed help, visit the qpdf manual: https://qpdf.readthedocs.io\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15b520
movq -0x8(%rbp), %rdi
callq 0x15d890
movq -0x8(%rbp), %rdi
callq 0x15fd60
movq -0x8(%rbp), %rdi
callq 0x162320
movq -0x8(%rbp), %rdi
callq 0x1647f0
movq -0x8(%rbp), %rdi
callq 0x166d40
movq -0x8(%rbp), %rdi
callq 0x16... | /jberkenbilt[P]qpdf/libqpdf/qpdf/auto_job_help.hh |
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 %rbp
movq %rsp, %rbp
subq $0xe90, %rsp # imm = 0xE90
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xbb8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xbb0(%rbp)
callq 0x1be40
movq -0xbb0(%rbp), %rdx
leaq 0x1c0c53(%rip), %rsi # 0x31e51b
leaq -0x28(%rbp), %rdi
callq 0x21b70
jmp 0x15d8d3
leaq -0... | /jberkenbilt[P]qpdf/libqpdf/qpdf/auto_job_help.hh |
add_help_3(QPDFArgParser&) | static void add_help_3(QPDFArgParser& ap)
{
ap.addOptionHelp("--encryption-file-password", "transformation", "supply password for --copy-encryption", R"(--encryption-file-password=password
If the file named in --copy-encryption requires a password, use
this option to supply the password.
)");
ap.addOptionHelp("--qdf",... | pushq %rbp
movq %rsp, %rbp
subq $0xef0, %rsp # imm = 0xEF0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc08(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc00(%rbp)
callq 0x1be40
movq -0xc00(%rbp), %rdx
leaq 0x1bf5c5(%rip), %rsi # 0x31f35d
leaq -0x28(%rbp), %rdi
callq 0x21b70
jmp 0x15fda3
leaq -0... | /jberkenbilt[P]qpdf/libqpdf/qpdf/auto_job_help.hh |
QPDFJob::Config::inputFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::inputFile(std::string const& filename)
{
if (o.m->infilename == nullptr) {
o.m->infilename = QUtil::make_shared_cstr(filename);
} else {
usage("input file has already been given");
}
return this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rdi
callq 0x110590
movq %rax, %rdi
addq $0x3d0, %rdi # imm = 0x3D0
xorl %eax, %eax
movl %eax, %esi
callq 0x110b70
testb $0x1, %al
jne 0x16ea49
jmp 0x16ea80
movq ... | /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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0x16f92e
movq -0x10(%rbp), %rdi
leaq 0x1ad6de(%rip), %rsi # 0x31d001
callq 0x315c0
testb $0x1, %al
jne 0x16f92e
jmp 0x16f946
m... | /jberkenbilt[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 0x2b1120
testb $0x1, %al
jne 0x171bdd
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1b1c0
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::moddate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::AttConfig*
QPDFJob::AttConfig::moddate(std::string const& parameter)
{
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
usage(std::string(parameter) + " is not a valid PDF timestamp");
}
this->att.moddate = 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 0x2b1120
testb $0x1, %al
jne 0x171cad
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1b1c0
movq... | /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 %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... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::EncConfig::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::EncConfig*
QPDFJob::EncConfig::print(std::string const& parameter)
{
if (config->o.m->keylen == 40) {
config->o.m->r2_print = (parameter == "y");
} else if (parameter == "full") {
config->o.m->r3_print = qpdf_r3p_full;
} else if (parameter == "low") {
config->o.m->r3_print =... | 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 0x110590
cmpl $0x28, 0x110(%rax)
jne 0x173831
movq -0x10(%rbp), %rdi
leaq 0x1a5b93(%rip), %rsi # 0x31939a
callq 0x315c0
movb %al, %cl
movq -0... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
(anonymous namespace)::Handlers::Handlers(bool, std::shared_ptr<QPDFJob::Config>) | Handlers::Handlers(bool partial, std::shared_ptr<QPDFJob::Config> c_main) :
partial(partial),
c_main(c_main)
{
initHandlers();
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x70(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1ad6f0
movq -0x70(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, 0x18(... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.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 0x1ad8a0
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rsi
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, ... | /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 %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 0xc5bf0
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x18b0f0
jmp 0x183928
movq -0x70(%rbp), %rdi
leaq -0... | /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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rsi, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x1b510
leaq -0x58(%rbp), %rdi
movq %rdi, -0x128(%rbp)
call... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginArray(std::function<void (JSON)>, std::function<void ()>) | 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 $0x120, %rsp # imm = 0x120
movq %rsi, -0xe8(%rbp)
movq %rdx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1ad8a0
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rsi
movq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addParameter(std::function<void (char const*)>)::$_0::~$_0() | 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 -0x8(%rbp), %rdi
callq 0x1ad950
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addParameter(std::function<void (char const*)>)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) 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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b180
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1aed40
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /jberkenbilt[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 0x1aebd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /jberkenbilt[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 0x16ded0
movq %rax, %rdi
callq 0x16ed90
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /jberkenbilt[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 0x1aed80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /jberkenbilt[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 0xc5bf0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFLogger::Members::Members() | QPDFLogger::Members::Members() :
p_discard(new Pl_Discard()),
p_real_stdout(new Pl_OStream("standard output", std::cout)),
p_stdout(new Pl_Track("track stdout", p_real_stdout.get())),
p_stderr(new Pl_OStream("standard error", std::cerr)),
p_info(p_stdout),
p_warn(nullptr),
p_error(p_stderr),... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movl $0x30, %edi
callq 0x1b250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x4d560
jmp 0x1af253
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x1b0680
movq -0x28(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
(anonymous namespace)::Pl_Track::Pl_Track(char const*, Pipeline*) | Pl_Track(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_Track with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x463f0
movq -0x30(%rbp), %rax
leaq 0x2def04(%rip), %rcx # 0x48e388
addq $0x10, %rcx
movq %rcx, (%rax)
movb ... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.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 0x1251d0
testb $0x1, %al
jne 0x1afdf6
jmp 0x1afe5c
movq -0x18(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFMatrix::QPDFMatrix() | QPDFMatrix::QPDFMatrix() :
a(1.0),
b(0.0),
c(0.0),
d(1.0),
e(0.0),
f(0.0)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x1617fc(%rip), %xmm0 # 0x313a10
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x1617e0(%rip), %xmm0 # 0x313a10
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::QPDFMatrix(double, double, double, double, double, double) | QPDFMatrix::QPDFMatrix(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 ... | /jberkenbilt[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 0x1b2b4e
jmp 0x1b2b2d
movl -0xa4(%rbp), %eax
subl $0xb4, %eax
je 0x1b2b85
jmp 0x1b2b3c
movl -0xa4(%rbp), %eax
subl $0x10e,... | /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 %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 0x1b3290
movq -0xc0(%rbp), %rdx
leaq -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::operator==(QPDFMatrix const&) const | bool
QPDFMatrix::operator==(QPDFMatrix const& rhs) const
{
return (
(this->a == rhs.a) && (this->b == rhs.b) && (this->c == rhs.c) && (this->d == rhs.d) &&
(this->e == rhs.e) && (this->f == rhs.f));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
ucomisd (%rcx), %xmm0
movb %al, -0x11(%rbp)
jne 0x1b31da
jp 0x1b31da
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rcx
xorl %... | /jberkenbilt[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 ... | /jberkenbilt[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 0x1b5860
movq %rax, %rdi
callq 0x1b5880
movq %rax, -0x... | /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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b5910
movq -0xc0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b4670
jmp 0x1b4eea
movq -0xc0(... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
(anonymous namespace)::NameTreeDetails::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.getUTF8Va... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x42b80
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq (%rdi)... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::insert(long long, QPDFObjectHandle) | QPDFNumberTreeObjectHelper::iterator
QPDFNumberTreeObjectHelper::insert(numtree_number key, QPDFObjectHandle value)
{
auto i = m->impl->insert(QPDFObjectHandle::newInteger(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 0x1b9490
movq %rax, %rdi
callq 0x1b5880
movq %rax, -0x... | /jberkenbilt[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 0x1b80c0
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1b81a0
jmp 0x1b86f5
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1b7f80
movb %al, -0x89(%rbp)
jmp 0x1b870a... | /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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b8280
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1b81a0
jmp 0x1b87e5
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1b7f80
movb %al, -0x89(%rbp)
jmp 0x1b87fa... | /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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x42b80
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi)... | /jberkenbilt[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 0x1b9fa3
callq 0x213f0
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x1b9fa3
leaq -0x188(%rbp), %rdi
callq 0x1be00
movq ... | /jberkenbilt[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 0x2d4559(%rip), %rax # 0x48e788
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1b5730
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
m... | /jberkenbilt[P]qpdf/include/qpdf/QPDFNumberTreeObjectHelper.hh |
qpdf::Name::analyzeJSONEncoding(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::pair<bool, bool>
Name::analyzeJSONEncoding(const std::string& name)
{
int tail = 0; // Number of continuation characters expected.
bool tail2 = false; // Potential overlong 3 octet utf-8.
bool tail3 = false; // potential overlong 4 octet
bool needs_escaping = false;
for (auto const& it: n... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x16(%rbp)
movb $0x0, -0x17(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b380
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bf80
movq %rax, -0x30(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.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 0x1bc81d
jmp 0x1bc82f
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b1c0
jmp 0x1bc9d2
movq -0x68(%rbp),... | /jberkenbilt[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 0x1ca9f0
movl %eax, %ecx
movq %rcx, -0x218(%rbp)
subl $0xf, %eax
ja 0x1bdf29
movq -0x218... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::write_json(int, JSON::Writer&) const | void
BaseHandle::write_json(int json_version, JSON::Writer& p) const
{
switch (resolved_type_code()) {
case ::ot_uninitialized:
throw std::logic_error(
"QPDFObjectHandle: attempting to get JSON from a uninitialized object");
break; // unreachable
case ::ot_null:
case ::ot_ope... | pushq %rbp
movq %rsp, %rbp
subq $0x550, %rsp # imm = 0x550
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3f8(%rbp)
callq 0x1ca9f0
movl %eax, %ecx
movq %rcx, -0x3f0(%rbp)
subl $0xf, %eax
ja 0x1bf090
movq -0x3f0(%rbp), %rax
leaq 0x16da7a(%rip), %rcx #... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::writeJSON(int, JSON::Writer&, bool) const | void
QPDFObjectHandle::writeJSON(int json_version, JSON::Writer& p, bool dereference_indirect) const
{
if (!dereference_indirect && isIndirect()) {
p << "\"" << getObjGen().unparse(' ') << " R\"";
} else if (!obj) {
throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHand... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1bf1e0
movq -0x70(%rbp), %rdi
callq 0x1c1bf0
testb $0x1, %al
jne 0x1bf141
jmp 0x1bf... | /jberkenbilt[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 0x1bf2af
movq -0xa0(%rbp), %rdi
callq 0x1cb060
testb $0x1, %al
jne 0x1bf2aa
jmp 0x1bf2af
jmp 0x1bf506
movq -0xa0(%rbp), %rdi
callq 0... | /jberkenbilt[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 0x1cbee0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1bfa24
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1bfabc
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1be4... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::typeWarning(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
QPDFObjectHandle::typeWarning(char const* expected_type, std::string const& warning) const
{
QPDF* context = nullptr;
std::string description;
// Type checks above guarantee that the object has been dereferenced. Nevertheless, dereference
// throws exceptions in the test suite
if (!obj) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b510
movq -0x1d8(%rbp), %rdi
callq 0x43890
testb $0x1, %al
jne 0x1bfcb5
movl $0x1... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isDictionaryOfType(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::isDictionaryOfType(std::string const& type, std::string const& subtype) const
{
return isDictionary() && (type.empty() || getKey("/Type").isNameAndEquals(type)) &&
(subtype.empty() || getKey("/Subtype").isNameAndEquals(subtype));
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1c0130
movb %al, %cl
movb $0x0, -0x52(%rbp)
movb $0x0, -0x65(%rbp)
movb $0x0, -0x66(%rbp)
movb $0x0, -0x9a(%rbp)
movb $0x0, -0x9b(%rbp)
movb $0x0, -0x9c(... | /jberkenbilt[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 0x1bf9f0
movq %rax, -0x18(%rbp)
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jge 0x1c0a11
leaq 0x1715bc(%rip), %rdi # 0x331f38
leaq 0x16b68b(%rip), %rsi # 0x32c00e
xorl %... | /jberkenbilt[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 0x43890
testb $0x1, %al
jne 0x1c0b24
jmp 0x1c0c58
movq -0x118(%rbp), ... | /jberkenbilt[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 0x1bf9f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x1c0f77
leaq 0x171056(%rip), %rdi # 0x331f38
leaq 0x16b241(%rip), %rsi # 0x32c12a
xorl %edx, %edx
callq 0x25230
leaq -0x39(%rbp), %rdi
... | /jberkenbilt[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 0x1c00a0
testb $0x1, %al
jne 0x1c14de
jmp 0x1c14f8
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq -0x60(%rbp), %rdi
movq %... | /jberkenbilt[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.