name string | code string | asm string | file string |
|---|---|---|---|
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 0x1c510
movq -0x100(%rbp), %rdi
callq 0x700a0
movq -0xf8(%rbp), %rdx
movq %rax, %rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::QPDFDictItems::iterator::iterator(QPDFObjectHandle&, bool) | QPDFObjectHandle::QPDFDictItems::iterator::iterator(QPDFObjectHandle& oh, bool for_begin) :
m(new Members(oh, for_begin))
{
updateIValue();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x2c72aa(%rip), %rcx # 0x49b000
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x48, %edi
callq 0x1c250
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::QPDFDictItems::iterator::Members::Members(QPDFObjectHandle&, bool) | QPDFObjectHandle::QPDFDictItems::iterator::Members::Members(QPDFObjectHandle& oh, bool for_begin) :
oh(oh)
{
this->keys = oh.getKeys();
this->iter = for_begin ? this->keys.begin() : this->keys.end();
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
callq 0xcf780
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::QPDFArrayItems::iterator::iterator(QPDFObjectHandle&, bool) | QPDFObjectHandle::QPDFArrayItems::iterator::iterator(QPDFObjectHandle& oh, bool for_begin) :
m(new Members(oh, for_begin))
{
updateIValue();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x2c6d52(%rip), %rcx # 0x49ae58
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x1c250
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::Tokenizer::getValue[abi:cxx11]() const | inline std::string const&
getValue() const
{
return (this->type == QPDFTokenizer::tt_name || this->type == QPDFTokenizer::tt_string)
? this->val
: this->raw_val;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x8, 0x8(%rax)
je 0x1d6550
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0x1d655e
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d656a
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rb... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFTokenizer_private.hh |
QPDFPageLabelDocumentHelper::pageLabelDict(qpdf_page_label_e, int, std::basic_string_view<char, std::char_traits<char>>) | QPDFObjectHandle
QPDFPageLabelDocumentHelper::pageLabelDict(
qpdf_page_label_e label_type, int start_num, std::string_view prefix)
{
auto num = QPDFObjectHandle::newDictionary();
switch (label_type) {
case pl_none:
break;
case pl_digits:
num.replaceKey("/S", "/D"_qpdf);
break... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x1d1a00
movl -0x1c(%rbp), %eax
movq %rax, -... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageLabelDocumentHelper.cc |
QPDFPageObjectHelper::forEachXObject(bool, std::function<void (QPDFObjectHandle&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>, std::function<bool (QPDFObjectHandle)>) | void
QPDFPageObjectHelper::forEachXObject(
bool recursive,
std::function<void(QPDFObjectHandle& obj, QPDFObjectHandle& xobj_dict, std::string const& key)>
action,
std::function<bool(QPDFObjectHandle)> selector)
{
QTC::TC(
"qpdf",
"QPDFPageObjectHelper::forEachXObject",
re... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rcx, -0x1a8(%rbp)
movq %rdx, -0x1a0(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movb -0x9(%rbp), %al
movb $0x0, -0x31... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getImages[abi:cxx11]() | std::map<std::string, QPDFObjectHandle>
QPDFPageObjectHelper::getImages()
{
std::map<std::string, QPDFObjectHandle> result;
forEachImage(
false, [&result](QPDFObjectHandle& obj, QPDFObjectHandle&, std::string const& key) {
result[key] = obj;
});
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1bf890
movq -0x68(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::filterContents(QPDFObjectHandle::TokenFilter*, Pipeline*) | void
QPDFPageObjectHelper::filterContents(QPDFObjectHandle::TokenFilter* filter, Pipeline* next)
{
if (oh().isFormXObject()) {
oh().filterAsContents(filter, next);
} else {
oh().filterPageContents(filter, next);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc9940
movq -0x68(%rbp), %rdi
callq 0x1d3460
movb %al, -0x59(%rbp)
jmp 0x1f2b4a
leaq -0x28(%rbp), %rdi
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::removeUnreferencedResources() | void
QPDFPageObjectHelper::removeUnreferencedResources()
{
// Accumulate a list of unresolved names across all nested form XObjects.
std::set<std::string> unresolved;
bool any_failures = false;
forEachFormXObject(
true,
[&any_failures, &unresolved](QPDFObjectHandle& obj, QPDFObjectHandle... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xcf780
movq -0xe0(%rbp), %rax
movb $0x0, -0x39(%rbp)
leaq -0x39(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getMatrixForTransformations(bool) | QPDFObjectHandle::Matrix
QPDFPageObjectHelper::getMatrixForTransformations(bool invert)
{
QPDFObjectHandle::Matrix matrix(1, 0, 0, 1, 0, 0);
QPDFObjectHandle bbox = getTrimBox(false);
if (!bbox.isRectangle()) {
return matrix;
}
QPDFObjectHandle rotate_obj = getAttribute("/Rotate", false);
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x1c8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1c0(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movsd 0x129be6(%rip), %xmm3 # 0x31e4d0
xorps %xmm5, %xmm5
movaps %... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::flattenRotation(QPDFAcroFormDocumentHelper*) | void
QPDFPageObjectHelper::flattenRotation(QPDFAcroFormDocumentHelper* afdh)
{
QPDF& qpdf = oh().getQPDF("QPDFPageObjectHelper::flattenRotation called with a direct object");
auto rotate_oh = oh().getKey("/Rotate");
int rotate = 0;
if (rotate_oh.isInteger()) {
rotate = rotate_oh.getIntValueAsInt... | pushq %rbp
movq %rsp, %rbp
subq $0x780, %rsp # imm = 0x780
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x620(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc9940
leaq -0x49(%rbp), %rdi
movq %rdi, -0x618(%rbp)
callq 0x1ce40
movq -0x618(%rbp), %rdx
leaq 0x141d47(%rip), %rsi # 0x3385... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
(anonymous namespace)::InlineImageTracker::handleToken(QPDFTokenizer::Token const&) | void
InlineImageTracker::handleToken(QPDFTokenizer::Token const& token)
{
if (state == st_bi) {
if (token.getType() == QPDFTokenizer::tt_inline_image) {
std::string image_data(token.getValue());
size_t len = image_data.length();
if (len >= this->min_size) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x210(%rbp)
cmpl $0x1, 0x78(%rax)
jne 0x1f8fdc
movq -0x10(%rbp), %rdi
callq 0x2d930
cmpl $0x11, %eax
jne 0x1f8ddb
movq -0x10(%rbp), %rdi
callq 0x2d960
movq %rax, %rsi
leaq... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFParser::parse(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFTokenizer&, bool&, QPDFObjectHandle::StringDecrypter*, QPDF*) | QPDFObjectHandle
QPDFParser::parse(
InputSource& input,
std::string const& object_description,
QPDFTokenizer& tokenizer,
bool& empty,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF* context)
{
return QPDFParser(
input,
make_description(input.getName(), objec... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::parse(qpdf::is::OffsetBuffer&, int, int, qpdf::Tokenizer&, QPDF&) | std::pair<QPDFObjectHandle, bool>
QPDFParser::parse(
is::OffsetBuffer& input, int stream_id, int obj_id, qpdf::Tokenizer& tokenizer, QPDF& context)
{
bool empty{false};
auto result = QPDFParser(
input,
std::make_shared<QPDFObject::Description>(
... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::QPDFParser(InputSource&, std::shared_ptr<std::variant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, QPDFObject::JSON_Descr, QPDFObject::ChildDescr, QPDFObject::ObjStreamDescr>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, qpdf::Tok... | QPDFParser(
InputSource& input,
std::shared_ptr<QPDFObject::Description> sp_description,
std::string const& object_description,
qpdf::Tokenizer& tokenizer,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF* context,
bool parse_pdf,
int stream_id = 0,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rdx
movq -0x48(%rbp), %rsi
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x3... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFParser.hh |
void QPDFParser::addScalar<QPDF_Integer, long long>(long long&&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
je 0x205c29
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x80370
cmpq $0x1388, %rax # imm = 0x1388
ja 0x205c1c
movq -0x38(%rbp), %rax
movq 0x60(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<QPDF_Name, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
je 0x205e09
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x80370
cmpq $0x1388, %rax # imm = 0x1388
ja 0x205dfc
movq -0x38(%rbp), %rax
movq 0x60(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
qpdf::Tokenizer::inTop(char) | void
Tokenizer::inTop(char ch)
{
switch (ch) {
case '(':
string_depth = 1;
state = st_in_string;
return;
case '<':
state = st_lt;
return;
case '>':
state = st_gt;
return;
case (')'):
type = tt::tt_bad;
QTC::TC("qpdf", "QPDFTo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x28, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x55, %eax
ja 0x209cac
movq -0x18(%rbp), %rax
leaq 0x12f355(%rip), %rcx # 0x338ef0
... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inString(char) | void
Tokenizer::inString(char ch)
{
switch (ch) {
case '\\':
state = st_string_escape;
return;
case '(':
val += ch;
++string_depth;
return;
case ')':
if (--string_depth == 0) {
type = tt::tt_string;
state = st_token_ready;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xa, %eax
je 0x209f44
jmp 0x209e7c
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x209f26
jmp 0x209e8a
movl -0x10(%rbp), %ea... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inNumber(char) | void
Tokenizer::inNumber(char ch)
{
if (util::is_digit(ch)) {
} else if (ch == '.') {
state = st_real;
} else if (isDelimiter(ch)) {
type = tt::tt_integer;
state = st_token_ready;
in_token = false;
char_to_unread = ch;
} else {
state = st_literal;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x6de90
testb $0x1, %al
jne 0x20a049
jmp 0x20a04b
jmp 0x20a09e
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %eax
jne 0x20a060
movq -0x18(%rbp), %rax
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inHexstring(char) | void
Tokenizer::inHexstring(char ch)
{
if (char hval = util::hex_decode_char(ch); hval < '\20') {
char_code = int(hval) << 4;
state = st_in_hexstring_2nd;
} else if (ch == '>') {
type = tt::tt_string;
state = st_token_ready;
} else if (isSpace(ch)) {
// ignore
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x3b7e0
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x10, %eax
jge 0x20a494
movq -0x90(%rbp), %rax
movsbl -0xa(%rbp), %ecx
shll $0x4, %e... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inBeforeToken(char) | void
Tokenizer::inBeforeToken(char ch)
{
// Note: we specifically do not use ctype here. It is locale-dependent.
if (isSpace(ch)) {
before_token = !include_ignorable;
in_token = include_ignorable;
if (include_ignorable) {
state = st_in_space;
}
} else if (ch == '... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x209730
testb $0x1, %al
jne 0x20aaa9
jmp 0x20aad4
movq -0x18(%rbp), %rax
movb 0x5(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x70(%ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::expectInlineImage(InputSource&) | void
Tokenizer::expectInlineImage(InputSource& input)
{
if (state == st_token_ready) {
reset();
} else if (state != st_before_token) {
throw std::logic_error(
"QPDFTokenizer::expectInlineImage called when tokenizer is in improper state");
}
findEI(input);
before_token = f... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x15, (%rax)
jne 0x20ad18
movq -0x28(%rbp), %rdi
callq 0x209390
jmp 0x20ad73
movq -0x28(%rbp), %rax
cmpl $0x14, (%rax)
je 0x20ad71
movl $0x10, %edi
callq 0x1c580
movq %rax, %rdi
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
InputSource::fastTell() | inline qpdf_offset_t
InputSource::fastTell()
{
if (buf_len == 0) {
loadBuffer();
} else {
auto curr = tell();
if (curr < buf_start || curr >= (buf_start + buf_len)) {
loadBuffer();
} else {
last_offset = curr;
buf_idx = curr - buf_start;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x90(%rax)
jne 0x20c249
movq -0x18(%rbp), %rdi
callq 0x20c410
jmp 0x20c2ae
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/InputSource_private.hh |
QPDFWriter::setOutputFilename(char const*) | void
QPDFWriter::setOutputFilename(char const* filename)
{
char const* description = filename;
FILE* f = nullptr;
bool close_file = false;
if (filename == nullptr) {
description = "standard output";
QTC::TC("qpdf", "QPDFWriter write to stdout");
f = stdout;
QUtil::binary_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x20cfe8
leaq 0x114d82(%rip), %rax # 0x321d3c
movq %rax, -0x18(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::initializePipelineStack(Pipeline*) | void
QPDFWriter::initializePipelineStack(Pipeline* p)
{
m->pipeline = new pl::Count(1, p);
m->to_delete.emplace_back(std::shared_ptr<Pipeline>(m->pipeline));
m->pipeline_stack.emplace_back(m->pipeline);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x58, %edi
callq 0x1c250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x223860
jmp 0x20d24c
movq -0x40(%rbp), %rdi
callq 0x22... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::parseVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&) const | void
QPDFWriter::parseVersion(std::string const& version, int& major, int& minor) const
{
major = QUtil::string_to_int(version.c_str());
minor = 0;
size_t p = version.find('.');
if ((p != std::string::npos) && (version.length() > p)) {
minor = QUtil::string_to_int(version.substr(p + 1).c_str());... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c180
movq %rax, %rdi
callq 0x2b8ff0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setEncryptionParameters(char const*, char const*, int, int, int, std::set<int, std::less<int>, std::allocator<int>>&) | void
QPDFWriter::setEncryptionParameters(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
std::set<int>& bits_to_clear)
{
// PDF specification refers to bits with the low bit numbered 1.
// We have to convert this into a bit field.
// Specification ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movq 0x10(%rbp), %rdi
movl $0x1,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR3EncryptionParametersInsecure(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e) | void
QPDFWriter::setR3EncryptionParametersInsecure(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print)
{
s... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %eax
movq %rdx, %r9
movq %rsi, %r10
movq %rdi, %r11
movb %al, %sil
movb %r8b, %dil
movb %cl, %r8b
movl 0x28(%rbp), %eax
movb 0x20(%rbp), %al
movb 0x18(%rbp), %cl
movb 0x10(%rbp), %dl
movq %r11, -0x20(%rbp)
movq %r10, -0x28(%rbp)
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR4EncryptionParametersInsecure(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool, bool) | void
QPDFWriter::setR4EncryptionParametersInsecure(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print,
boo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %r8d, %eax
movq %rdx, %r11
movq %rsi, %rbx
movq %rdi, %r14
movb %r9b, %r8b
movb %al, %r9b
movb %cl, %r10b
movb 0x38(%rbp), %al
movb 0x30(%rbp), %cl
movl 0x28(%rbp), %edx
movb 0x20(%rbp), %dl
movb 0x18(%rbp), %sil
movb 0x10(%rbp), %dil
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR6EncryptionParameters(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool) | void
QPDFWriter::setR6EncryptionParameters(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print,
bool encryp... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r10
movq %rsi, %r11
movq %rdi, %rbx
movb %r9b, %dil
movb %cl, %r9b
movb 0x30(%rbp), %al
movl 0x28(%rbp), %ecx
movb 0x20(%rbp), %cl
movb 0x18(%rbp), %dl
movb 0x10(%rbp), %sil
movq %rbx, -0x20(%rbp)
movq %r11, -0x28(%rbp)
movq %r10, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setEncryptionParametersInternal(int, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> con... | void
QPDFWriter::setEncryptionParametersInternal(
int V,
int R,
int key_len,
int P,
std::string const& O,
std::string const& U,
std::string const& OE,
std::string const& UE,
std::string const& Perms,
std::string const& id1,
std::string const& user_password,
std::string co... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x9e8, %rsp # imm = 0x9E8
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::disableIncompatibleEncryption(int, int, int) | void
QPDFWriter::disableIncompatibleEncryption(int major, int minor, int extension_level)
{
if (!m->encrypted) {
return;
}
bool disable = false;
if (compareVersions(major, minor, 1, 3) < 0) {
disable = true;
} else {
int V = QUtil::string_to_int(m->encryption_dictionary["/V"... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2231d0
testb $0x1, 0x48(%rax)
jne 0x211e93
jmp 0x21217d
movq -0x88(%rbp), %rdi
movb $0x0, -0x15(%rbp)
movl -0xc(%rbp), %esi
movl -0x1... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::bytesNeeded(long long) | unsigned int
QPDFWriter::bytesNeeded(long long n)
{
unsigned int bytes = 0;
while (n) {
++bytes;
n >>= 8;
}
return bytes;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x212271
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x212253
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::activatePipelineStack(QPDFWriter::PipelinePopper&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>>) | void
QPDFWriter::activatePipelineStack(
PipelinePopper& pp, bool discard, std::string* str, std::unique_ptr<pl::Link> link)
{
pl::Count* c;
if (link) {
c = new pl::Count(m->next_stack_id, m->count_buffer, std::move(link));
} else if (discard) {
c = new pl::Count(m->next_stack_id, nullptr... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %r8, -0x68(%rbp)
movl %edx, %eax
movq %rdi, %rdx
movq -0x68(%rbp), %rdi
movq %rdx, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x223aa0
testb $0x1,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::PipelinePopper::~PipelinePopper() | QPDFWriter::PipelinePopper::~PipelinePopper()
{
if (!stack_id) {
return;
}
qpdf_assert_debug(qw->m->pipeline_stack.size() >= 2);
qw->m->pipeline->finish();
qpdf_assert_debug(dynamic_cast<pl::Count*>(qw->m->pipeline_stack.back()) == qw->m->pipeline);
// It might be possible for this asser... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x212ae3
jmp 0x212e18
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2231d0
movq %rax, %rdi
addq $0x378, %rdi # imm = 0x378
callq 0x223bd0
cmpq $0x2, %rax
jb 0x212b06
jmp ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::pushMD5Pipeline(QPDFWriter::PipelinePopper&) | void
QPDFWriter::pushMD5Pipeline(PipelinePopper& pp)
{
if (!m->id2.empty()) {
// Can't happen in the code
throw std::logic_error(
"Deterministic ID computation enabled after ID generation has already occurred.");
}
qpdf_assert_debug(m->deterministic_id);
qpdf_assert_debug(m->... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2231d0
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x1c450
testb $0x1, %al
jne 0x213183
movl $0x10, %edi
callq 0x1c580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x12... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::assignCompressedObjectNumbers(QPDFObjGen) | void
QPDFWriter::assignCompressedObjectNumbers(QPDFObjGen og)
{
int objid = og.getObj();
if ((og.getGen() != 0) || (m->object_stream_to_objects.count(objid) == 0)) {
// This is not an object stream.
return;
}
// Reserve numbers for the objects that belong to this object stream.
for ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1d4860
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1d4870
cmpl $0x0, %eax
jne 0x213634
movq -0x48(%rbp), %rdi
callq 0x2231d0
movq %rax, %rdi
addq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::unparseChild(QPDFObjectHandle, int, int) | void
QPDFWriter::unparseChild(QPDFObjectHandle child, int level, int flags)
{
if (!m->linearized) {
enqueueObject(child);
}
if (child.isIndirect()) {
writeString(std::to_string(m->obj[child].renumber));
writeString(" 0 R");
} else {
unparseObject(child, level, flags);
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2231d0
testb $0x1, 0x4a(%rax)
jne 0x213f17
movq -0xa8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rb... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeObjectStream(QPDFObjectHandle) | void
QPDFWriter::writeObjectStream(QPDFObjectHandle object)
{
// Note: object might be null if this is a place-holder for an object stream that we are
// generating from scratch.
QPDFObjGen old_og = object.getObjGen();
qpdf_assert_debug(old_og.getGen() == 0);
int old_id = old_og.getObj();
int n... | pushq %rbp
movq %rsp, %rbp
subq $0x630, %rsp # imm = 0x630
movq %rsi, -0x598(%rbp)
movq %rdi, %rax
movq -0x598(%rbp), %rdi
movq %rdi, -0x590(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x588(%rbp)
callq 0x1ccdf0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeObject(QPDFObjectHandle, int) | void
QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index)
{
QPDFObjGen old_og = object.getObjGen();
if ((object_stream_index == -1) && (old_og.getGen() == 0) &&
(m->object_stream_to_objects.count(old_og.getObj()))) {
writeObjectStream(object);
return;
}
ind... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rsi, -0x1f0(%rbp)
movq %rdi, %rax
movq -0x1f0(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
callq 0x1ccdf0
movq %rax, -0x1c(%rbp)
xorl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::generateObjectStreams() | void
QPDFWriter::generateObjectStreams()
{
// Basic strategy: make a list of objects that can go into an object stream. Then figure out
// how many object streams are needed so that we can distribute objects approximately evenly
// without having any object stream exceed 100 members. We don't have to worr... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2231d0
movq (%rax), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2246c0
movq -0xa8(%rbp), %rdi
callq 0x2246f0
movq -0xa0(%rbp), %rdi
addq $0x63, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeLinearized() | void
QPDFWriter::writeLinearized()
{
// Optimize file and enqueue objects in order
std::map<int, int> stream_cache;
auto skip_stream_parameters = [this, &stream_cache](QPDFObjectHandle& stream) {
auto& result = stream_cache[stream.getObjectID()];
if (result == 0) {
bool compres... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xaa0, %rsp # imm = 0xAA0
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x7b8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x7c0(%rbp)
callq 0x224e50
movq -0x7c0(%rbp), %rax
movq -0x7b8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getWrittenXRefTable() | std::map<QPDFObjGen, QPDFXRefEntry>
QPDFWriter::getWrittenXRefTable()
{
std::map<QPDFObjGen, QPDFXRefEntry> result;
auto it = result.begin();
m->new_obj.forEach([&it, &result](auto id, auto const& item) -> void {
if (item.xref.getType() != 0) {
it = result.emplace_hint(it, QPDFObjGen(id... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6d450
movq -0x78(%rbp), %rdi
callq 0x224b20
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
ca... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeEncryptionDictionary() | void
QPDFWriter::writeEncryptionDictionary()
{
m->encryption_dict_objid = openObject(m->encryption_dict_objid);
writeString("<<");
for (auto const& iter: m->encryption_dictionary) {
writeString(" ");
writeString(iter.first);
writeString(" ");
writeString(iter.second);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2231d0
movq -0x90(%rbp), %rdi
movl 0x188(%rax), %esi
callq 0x213410
movq -0x90(%rbp), %rdi
movl %eax, -0x94(%rbp)
callq 0x2231d0
movl -0x94(%rbp), %ecx
movl %ecx, 0x188(%rax)
leaq -0x18(%rbp), %rdi
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeXRefTable(QPDFWriter::trailer_e, int, int, int, long long, bool, int, long long, long long, int) | qpdf_offset_t
QPDFWriter::writeXRefTable(
trailer_e which,
int first,
int last,
int size,
qpdf_offset_t prev,
bool suppress_offsets,
int hint_id,
qpdf_offset_t hint_offset,
qpdf_offset_t hint_length,
int linearization_pass)
{
writeString("xref\n");
writeString(std::to_str... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movl 0x30(%rbp), %eax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
andb $... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
qpdf::pl::Count::Count(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>>) | Count(unsigned long id, std::string& str, std::unique_ptr<Link> link = nullptr) :
Pipeline("", link ? link->next_pl.get() : nullptr),
str(&str),
link(std::move(link)),
id_(id)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x223aa0
testb $0x1, %al
jne 0x223b0a
jmp 0x223b2... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pipeline_private.hh |
ObjTable<QPDFWriter::Object>::resize(unsigned long) | void
resize(size_t a_size)
{
std::vector<T>::resize(a_size);
if (a_size > min_sparse) {
auto it = sparse_elements.begin();
auto end = sparse_elements.end();
while (it != end && it->first < a_size) {
std::vector<T>::operator[](it->first) = std::... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x22f610
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x48(%rcx), %rax
jbe 0x224876
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x22f6a0
movq -0x38(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
ObjTable<QPDFWriter::Object>::forEach(std::function<void (int, QPDFWriter::Object const&)>) | inline void
forEach(std::function<void(int, const T&)> fn)
{
int i = 0;
for (auto const& item: *this) {
fn(i++, item);
}
for (auto const& [id, item]: sparse_elements) {
fn(QIntC::to_int(id), item);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x14(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2309c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2309f0
movq %rax, -0x30(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
QIntC::IntConverter<int, unsigned long long, true, false>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1ce00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1c1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2324c2
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QPDFXRefEntry::QPDFXRefEntry(int, long long, int) | QPDFXRefEntry::QPDFXRefEntry(int type, qpdf_offset_t field1, int field2) :
type(type),
field1(field1),
field2(field2)
{
if ((type < 1) || (type > 2)) {
throw std::logic_error("invalid xref type " + std::to_string(type));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x1, -0xc(%rbp)
jl 0x233b10
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFXRefEntry.cc |
qpdf::Array::getAsVector() const | std::vector<QPDFObjectHandle>
Array::getAsVector() const
{
auto a = array();
if (a->sp) {
std::vector<QPDFObjectHandle> v;
v.reserve(size_t(size()));
for (auto const& item: a->sp->elements) {
v.resize(size_t(item.first), null_oh);
v.emplace_back(item.second);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x233f00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d4de0
testb $0x1, %al
jne 0x2340be
jmp 0x2341c0
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::cbegin() | Array::const_iterator
Array::cbegin()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.cbegin();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->cbegin();
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x236910
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2343b3
movq -0x18(%rbp), %rdi
callq 0x1d4de0
testb $0x1, %al
jne 0x23432b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x236b90
movq %rax, -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::crbegin() | Array::const_reverse_iterator
Array::crbegin()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.crbegin();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->crbe... | 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 0x236910
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2345a2
movq -0x18(%rbp), %rdi
callq 0x1d4de0
testb $0x1, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::at(int) const | std::pair<bool, QPDFObjectHandle>
Array::at(int n) const
{
auto a = array();
if (n < 0 || n >= size()) {
return {false, {}};
}
if (!a->sp) {
return {true, a->elements[size_t(n)]};
}
auto const& iter = a->sp->elements.find(n);
return {true, iter == a->sp->elements.end() ? null... | pushq %rbp
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)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x233f00
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2347b2
movq -0x88(%rbp), %rdi
movl... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayNItems() const | int
QPDFObjectHandle::getArrayNItems() const
{
if (auto array = as_array(strict)) {
return array.size();
}
typeWarning("array", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle array treating as empty");
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x6e610
movq -0x68(%rbp), %rdi
callq 0x4ce40
movb %al, -0x5a(%rbp)
jmp 0x235174
movb -0x5a(%rbp), %al
testb $0x1, %al
jne 0x23517d
jmp 0x23... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayItem(int) const | QPDFObjectHandle
QPDFObjectHandle::getArrayItem(int n) const
{
if (auto array = as_array(strict)) {
if (auto const [success, oh] = array.at(n); success) {
return oh;
} else {
objectWarning("returning null for out of bounds array access");
QTC::TC("qpdf", "QPDFObje... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x118(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x110(%rbp)
xorl %edx, %edx
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::setArrayFromVector(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>> const&) | void
QPDFObjectHandle::setArrayFromVector(std::vector<QPDFObjectHandle> const& items)
{
if (auto array = as_array(strict)) {
array.setFromVector(items);
} else {
typeWarning("array", "ignoring attempt to replace items");
QTC::TC("qpdf", "QPDFObjectHandle array ignoring replace items");
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x6e610
movq -0x68(%rbp), %rdi
callq 0x4ce40
movb %al, -0x5a(%rbp)
jmp 0x236108
movb -0x5a(%rbp), %al
testb $0x1, %al
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::appendItem(QPDFObjectHandle const&) | void
QPDFObjectHandle::appendItem(QPDFObjectHandle const& item)
{
if (auto array = as_array(strict)) {
array.push_back(item);
} else {
typeWarning("array", "ignoring attempt to append item");
QTC::TC("qpdf", "QPDFObjectHandle array ignoring append item");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x6e610
movq -0x68(%rbp), %rdi
callq 0x4ce40
movb %al, -0x5a(%rbp)
jmp 0x236478
movb -0x5a(%rbp), %al
testb $0x1, %al
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::eraseItemAndGetOld(int) | QPDFObjectHandle
QPDFObjectHandle::eraseItemAndGetOld(int at)
{
auto array = as_array(strict);
auto result = (array && at < array.size() && at >= 0) ? array.at(at).second : newNull();
eraseItem(at);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
xorl %edx, %edx
callq 0x6e610
movq -0x70(%rbp), %rdi
m... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::checkOwnership(QPDFObjectHandle const&) const | inline void
Array::checkOwnership(QPDFObjectHandle const& item) const
{
if (!item) {
throw std::logic_error("Attempting to add an uninitialized object to a QPDF_Array.");
}
if (qpdf() && item.qpdf() && qpdf() != item.qpdf()) {
throw std::logic_error(
"Attempting to add an object ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ce40
testb $0x1, %al
jne 0x236f08
movl $0x10, %edi
callq 0x1c580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x103ecd(%rip), %rsi # 0x3... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | QPDFObjectHandle
QPDFObjectHandle::getKey(std::string const& key) const
{
if (auto dict = as_dictionary(strict)) {
return dict.getKey(key);
}
typeWarning("dictionary", "returning null for attempted key retrieval");
QTC::TC("qpdf", "QPDFObjectHandle dictionary null for getKey");
static auto c... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
xorl %edx, %edx
callq 0x6e720
movq -0xb0(%rbp), %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::getKeys[abi:cxx11]() const | std::set<std::string>
QPDFObjectHandle::getKeys() const
{
if (auto dict = as_dictionary(strict)) {
return dict.getKeys();
}
typeWarning("dictionary", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle dictionary empty set for getKeys");
return {};
} | 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), %rsi
movq %rsi, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x6e720
movq -0x60(%rbp), %rdi
callq 0x4ce40
movb %al, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::getDictAsMap[abi:cxx11]() const | std::map<std::string, QPDFObjectHandle>
QPDFObjectHandle::getDictAsMap() const
{
if (auto dict = as_dictionary(strict)) {
return dict.getAsMap();
}
typeWarning("dictionary", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle dictionary empty map for asMap");
return {};
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x6e720
movq -0x60(%rbp), %rdi
callq 0x4ce40
movb %al, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::replaceKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceKey(std::string const& key, QPDFObjectHandle const& value)
{
if (auto dict = as_dictionary(strict)) {
checkOwnership(value);
dict.replaceKey(key, value);
return;
}
typeWarning("dictionary", "ignoring key replacement request");
QTC::TC("qpdf", "QPDFOb... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
xorl %edx, %edx
callq 0x6e720
movq -0x80(%rbp), %rdi
callq 0x4ce40
movb %al, -0x72(%rbp)
jmp 0x23b94f
movb -0x72(%rbp... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
qpdf::Stream::Stream(QPDF&, QPDFObjGen, QPDFObjectHandle, long long, unsigned long) | Stream::Stream(
QPDF& qpdf, QPDFObjGen og, QPDFObjectHandle stream_dict, qpdf_offset_t offset, size_t length) :
BaseHandle(QPDFObject::create<QPDF_Stream>(&qpdf, og, std::move(stream_dict), length))
{
auto descr = std::make_shared<QPDFObject::Description>(
qpdf.getFilename() + ", stream object " + o... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
m... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::getStreamJSON(int, qpdf_json_stream_data_e, qpdf_stream_decode_level_e, Pipeline*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | JSON
Stream::getStreamJSON(
int json_version,
qpdf_json_stream_data_e json_data,
qpdf_stream_decode_level_e decode_level,
Pipeline* p,
std::string const& data_filename)
{
Pl_Buffer pb{"streamjson"};
JSON::Writer jw{&pb, 0};
decode_level =
writeStreamJSON(json_version, jw, json_da... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::pipeStreamData(Pipeline*, bool*, int, qpdf_stream_decode_level_e, bool, bool) | bool
Stream::pipeStreamData(
Pipeline* pipeline,
bool* filterp,
int encode_flags,
qpdf_stream_decode_level_e decode_level,
bool suppress_warnings,
bool will_retry)
{
auto s = stream();
std::vector<std::shared_ptr<QPDFStreamFilter>> filters;
bool specialized_compression = false;
b... | pushq %rbp
movq %rsp, %rbp
subq $0x5f0, %rsp # imm = 0x5F0
movl %r9d, %eax
movl %ecx, -0x42c(%rbp)
movq %rdx, %rcx
movl -0x42c(%rbp), %edx
movq %rcx, -0x428(%rbp)
movq %rsi, %rcx
movq -0x428(%rbp), %rsi
movq %rcx, -0x420(%rbp)
movq %rdi, %r9
movq -0x420(%rbp), %rdi
movb %al, %cl
movb 0x10(%rbp), %al
movq %r9... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::pipeStreamData(Pipeline*, bool, bool, bool) | bool
QPDFObjectHandle::pipeStreamData(Pipeline* p, bool filter, bool normalize, bool compress)
{
int encode_flags = 0;
qpdf_stream_decode_level_e decode_level = qpdf_dl_none;
if (filter) {
decode_level = qpdf_dl_generalized;
if (normalize) {
encode_flags |= qpdf_ef_normalize;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
testb $0x1, -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::function<bool (Pipeline*, bool, bool)>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::function<bool(Pipeline*, bool, bool)> provider,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
auto sdp = std::shared_ptr<StreamDataProvider>(new FunctionProvider(provider));
as_stream(error).replaceStreamData(sdp, filter, decod... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x50, %edi
callq 0x1c250
movq -0x90(%rbp), %rsi
movq %rax, -0x88(%rbp)
movb $0x1, -0x5d(%rbp)
leaq -0x50(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
(anonymous namespace)::SF_Crypt::setDecodeParms(QPDFObjectHandle) | bool
setDecodeParms(QPDFObjectHandle decode_parms) override
{
if (decode_parms.isNull()) {
return true;
}
bool filterable = true;
for (auto const& key: decode_parms.getKeys()) {
if (((key == "/Type") || (key == "/Name")) &&
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rsi, -0x108(%rbp)
movq %rdi, %rax
movq -0x108(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x1c9770
testb $0x1, %al
jne 0x241926
jmp 0x24192f
movb $0x1, -0x1(%rbp)
jmp 0x241cf5
movq -0x100(%rbp), %rsi
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDF_String::writeJSON(int, JSON::Writer&) | void
QPDF_String::writeJSON(int json_version, JSON::Writer& p)
{
auto candidate = getUTF8Val();
if (json_version == 1) {
p << "\"" << JSON::Writer::encode_string(candidate) << "\"";
} else {
// See if we can unambiguously represent as Unicode.
if (QUtil::is_utf16(this->val) || QUtil:... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x138(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x250fd0
cmpl $0x1, -0xc(%rbp)
jne 0x250c88
movq -0x18(%rbp), %rdi
leaq 0xd26f4(%rip), %rsi # 0x3232e3
c... | /jberkenbilt[P]qpdf/libqpdf/QPDF_String.cc |
QPDF_String::useHexString() const | bool
QPDF_String::useHexString() const
{
// Heuristic: use the hexadecimal representation of a string if there are any non-printable (in
// PDF Doc encoding) characters or if too large of a proportion of the string consists of
// non-ASCII characters.
unsigned int non_ascii = 0;
for (auto const ch: ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c380
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1cf80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_String.cc |
QPDF::trim_user_password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDF::trim_user_password(std::string& user_password)
{
// Although unnecessary, this routine trims the padding string from the end of a user password.
// Its only purpose is for recovery of user passwords which is done in the test suite.
char const* cstr = user_password.c_str();
size_t len = user_p... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c180
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c850
movq %rax, -0x18(%rbp)
cmpq $0x20, -0x18(%rbp)
jae 0x2518a2
jmp 0x25195a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | std::string
QPDF::compute_encryption_key(std::string const& password, EncryptionData const& data)
{
if (data.getV() >= 5) {
// For V >= 5, the encryption key is generated and stored in the file, encrypted separately
// with both user and owner passwords.
return recover_encryption_key_with_pa... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x251630
cmpl $0x5, %eax
jl 0x251c10
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x251... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_Perms_value_V5_clear(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&, unsigned char*) | void
compute_Perms_value_V5_clear(
std::string const& encryption_key, QPDF::EncryptionData const& data, unsigned char k[16])
{
// From algorithm 3.10 from the PDF 1.7 extension level 3
unsigned long long extended_perms =
0xffffffff00000000LL | static_cast<unsigned long long>(data.getP());
for (i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x251680
cltq
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x2524bb
movq -0x2... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::getKeyForObject[abi:cxx11](std::shared_ptr<QPDF::EncryptionParameters>, QPDFObjGen, bool) | std::string
QPDF::getKeyForObject(std::shared_ptr<EncryptionParameters> encp, QPDFObjGen og, bool use_aes)
{
if (!encp->encrypted) {
throw std::logic_error("request for encryption key in non-encrypted PDF");
}
if (og != encp->cached_key_og) {
encp->cached_object_encryption_key = compute_dat... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %ecx, %eax
movq %rsi, -0x68(%rbp)
movq %rdi, %rcx
movq -0x68(%rbp), %rdi
movq %rcx, -0x60(%rbp)
movq %rcx, %rsi
movq %rsi, -0x58(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
callq 0x6f120
testb $0x1, (%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::decryptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, QPDFObjGen) | void
QPDF::decryptString(std::string& str, QPDFObjGen og)
{
if (!og.isIndirect()) {
return;
}
bool use_aes = false;
if (m->encp->encryption_V >= 4) {
switch (m->encp->cf_string) {
case e_none:
return;
case e_aes:
use_aes = true;
break;... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x308(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4dbd0
testb $0x1, %al
jne 0x2573f4
jmp 0x257b38
movq -0x308(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x6d... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::decryptStream(std::shared_ptr<QPDF::EncryptionParameters>, std::shared_ptr<InputSource>, QPDF&, Pipeline*&, QPDFObjGen, QPDFObjectHandle&, bool, std::unique_ptr<Pipeline, std::default_delete<Pipeline>>&) | void
QPDF::decryptStream(
std::shared_ptr<EncryptionParameters> encp,
std::shared_ptr<InputSource> file,
QPDF& qpdf_for_warning,
Pipeline*& pipeline,
QPDFObjGen og,
QPDFObjectHandle& stream_dict,
bool is_root_metadata,
std::unique_ptr<Pipeline>& decrypt_pipeline)
{
std::string type;
... | pushq %rbp
movq %rsp, %rbp
subq $0x740, %rsp # imm = 0x740
movq %rsi, -0x5b8(%rbp)
movq %rdi, -0x5b0(%rbp)
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al,... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_U_UE_value_V5(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&, QPDF::EncryptionData const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::... | static void
compute_U_UE_value_V5(
std::string const& user_password,
std::string const& encryption_key,
QPDF::EncryptionData const& data,
std::string& U,
std::string& UE)
{
// Algorithm 3.8 from the PDF 1.7 extension level 3
char k[16];
QUtil::initializeWithRandomBytes(reinterpret_cast<u... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
movl $0x10, %esi
callq 0x2bbc10
leaq -0x61(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x1ce... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_O_OE_value_V5(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&, QPDF::EncryptionData const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__c... | static void
compute_O_OE_value_V5(
std::string const& owner_password,
std::string const& encryption_key,
QPDF::EncryptionData const& data,
std::string const& U,
std::string& O,
std::string& OE)
{
// Algorithm 3.9 from the PDF 1.7 extension level 3
char k[16];
QUtil::initializeWithRan... | 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x150(%rbp)
movl $0x10, %esi
callq 0x2bbc10
leaq -0x61(%rbp), %rdi
movq %rdi, -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::isEncrypted(int&, int&, int&, QPDF::encryption_method_e&, QPDF::encryption_method_e&, QPDF::encryption_method_e&) | bool
QPDF::isEncrypted(
int& R,
int& P,
int& V,
encryption_method_e& stream_method,
encryption_method_e& string_method,
encryption_method_e& file_method)
{
if (m->encp->encrypted) {
QPDFObjectHandle trailer = getTrailer();
QPDFObjectHandle encrypt = trailer.getKey("/Encrypt")... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x6d820
movq %rax, %rdi
addq $0x108, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowExtractAll() | bool
QPDF::allowExtractAll()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = is_bit_set(P, 5);
}
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x25a910
testb $0x1, %al
jne 0x25af05
jmp 0x25af17
movl -0x10(%rbp), %edi
movl $0x5, %esi
callq 0x25aea0
andb $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowModifyOther() | bool
QPDF::allowModifyOther()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = is_bit_set(P, 4);
}
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x25a910
testb $0x1, %al
jne 0x25b175
jmp 0x25b187
movl -0x10(%rbp), %edi
movl $0x4, %esi
callq 0x25aea0
andb $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowModifyAll() | bool
QPDF::allowModifyAll()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = (is_bit_set(P, 4) && is_bit_set(P, 6));
if (R >= 3) {
status = status && (is_bit_set(P, 9) && is_bit_set(P, 11));
}
}
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x25a910
testb $0x1, %al
jne 0x25b1d5
jmp 0x25b254
movl -0x10(%rbp), %edi
movl $0x4, %esi
callq 0x25aea0
movb %al... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
check_owner_password_V4(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static bool
check_owner_password_V4(
std::string& user_password, std::string const& owner_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.7 from the PDF 1.7 Reference Manual
unsigned char key[OU_key_bytes_V4];
compute_O_rc4_key(user_password, owner_password, data, key);
unsigned char O... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
callq 0x25b550
movq -0x18(%rbp), %rdi
callq 0x2516a0
movq %rax, %rdi
callq 0x2b9430
movups (%r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_U_value_R2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static std::string
compute_U_value_R2(std::string const& user_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.4 from the PDF 1.7 Reference Manual
std::string k1 = QPDF::compute_encryption_key(user_password, data);
char udata[key_bytes];
pad_or_truncate_password_V4("", udata);
pad_short... | 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 -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x251bd0
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1ce40
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
is_binary_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | static bool
is_binary_string(std::string const& v, std::string& str)
{
if (v.substr(0, 2) == "b:") {
str = v.substr(2);
int count = 0;
for (char c: str) {
if (!util::is_hex_digit(c)) {
return false;
}
++count;
}
return (coun... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x2, %ecx
callq 0x1ce90
movq -0x98(%rbp), %rdi
leaq 0xdc603(%rip), %rsi # 0x33bd91
callq 0x3b910
movb %al, -0x8a(%rbp)
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::replaceObject(QPDFObjectHandle&&, JSON const&) | void
QPDF::JSONReactor::replaceObject(QPDFObjectHandle&& replacement, JSON const& value)
{
auto& tos = stack.back();
auto og = tos.object.getObjGen();
if (replacement.isIndirect() && !(replacement.isStream() && replacement.getObjGen() == og)) {
error(
replacement.getParsedOffset(),
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x68, %rdi
callq 0x265020
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ccdf0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::setNextStateIfDictionary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON const&, QPDF::JSONReactor::state_e) | bool
QPDF::JSONReactor::setNextStateIfDictionary(std::string const& key, JSON const& value, state_e next)
{
// Use this method when the next state is for processing a nested dictionary.
if (value.isDictionary()) {
this->next_state = next;
return true;
}
error(value.getStart(), "\"" + key... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rdi
callq 0x31580
testb $0x1, %al
jne 0x2609c1
jmp 0x2609d7
movq -0x80(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
provide_data(std::shared_ptr<InputSource>, long long, long long) | static std::function<void(Pipeline*)>
provide_data(std::shared_ptr<InputSource> is, qpdf_offset_t start, qpdf_offset_t end)
{
return [is, start, end](Pipeline* p) {
Pl_Base64 decode("base64-decode", p, Pl_Base64::a_decode);
p = &decode;
size_t bytes = QIntC::to_size(end - start);
cha... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x50110
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::arrayItem(JSON const&) | bool
QPDF::JSONReactor::arrayItem(JSON const& value)
{
if (stack.empty()) {
throw std::logic_error("stack is empty in arrayItem");
}
next_state = st_ignore;
auto state = stack.back().state;
if (state == st_qpdf) {
if (!this->saw_qpdf_meta) {
this->saw_qpdf_meta = true;
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x68, %rdi
callq 0x264fe0
testb $0x1, %al
jne 0x2632fd
jmp 0x263359
movl $0x10, %edi
callq 0x1c580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
leaq 0xd9f3e(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
writeJSONStreamFile(int, JSON::Writer&, qpdf::Stream&, int, qpdf_stream_decode_level_e, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
writeJSONStreamFile(
int version,
JSON::Writer& jw,
qpdf::Stream& stream,
int id,
qpdf_stream_decode_level_e decode_level,
std::string const& file_prefix)
{
auto filename = file_prefix + "-" + std::to_string(id);
auto* f = QUtil::safe_fopen(filename.c_str(), "wb");
Pl_StdioFile ... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0xb9d16(%rip), %rdx # 0x31d932
leaq -0x68(%rbp), %rdi
callq 0x2b790
movl -0x1c(%rbp), %esi
leaq -0x88(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::JSONReactor(QPDF&, std::shared_ptr<InputSource>, bool) | JSONReactor(QPDF& pdf, std::shared_ptr<InputSource> is, bool must_be_complete) :
pdf(pdf),
is(is),
must_be_complete(must_be_complete),
descr(
std::make_shared<QPDFObject::Description>(
QPDFObject::JSON_Descr(std::make_shared<std::string>(is->getName()), "")))
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xb0(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2656f0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq 0x2396ee(%rip), %rax ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::checkLinearization() | bool
QPDF::checkLinearization()
{
bool result = false;
try {
readLinearizationData();
result = checkLinearizationInternal();
} catch (std::runtime_error& e) {
linearizationWarning(
"error encountered while checking linearization data: " + std::string(e.what()));
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x267970
jmp 0x267815
movq -0x88(%rbp), %rdi
callq 0x269070
movb %al, -0x89(%rbp)
jmp 0x267829
movb -0x89(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x2678fc
movq %rax, %rcx... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::checkLinearizationInternal() | bool
QPDF::checkLinearizationInternal()
{
// All comments referring to the PDF spec refer to the spec for version 1.4.
// Check all values in linearization parameter dictionary
LinParameters& p = m->linp;
// L: file size in bytes -- checked by isLinearized
// O: object number of first page
s... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3e0(%rbp)
callq 0x6d820
movq -0x3e0(%rbp), %rdi
addq $0x328, %rax # imm = 0x328
movq %rax, -0x10(%rbp)
callq 0x2b0ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::readHintStream(Pipeline&, long long, unsigned long) | QPDFObjectHandle
QPDF::readHintStream(Pipeline& pl, qpdf_offset_t offset, size_t length)
{
QPDFObjGen og;
QPDFObjectHandle H =
readObjectAtOffset(false, offset, "linearization hint stream", QPDFObjGen(0, 0), og, false);
ObjCache& oc = m->obj_cache[og];
qpdf_offset_t min_end_offset = oc.end_befor... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x2c0(%rbp)
movq %rdi, %rax
movq %rax, -0x2b8(%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, -0x2b0(%rbp)
leaq -0x30(%rbp), %rdi
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::readHSharedObject(BitStream) | void
QPDF::readHSharedObject(BitStream h)
{
HSharedObject& t = m->shared_object_hints;
t.first_shared_obj = h.getBitsInt(32); // 1
t.first_shared_offset = h.getBitsInt(32); // 2
t.nshared_first_page = h.getBitsInt(32); // 3
t.nshared_total = h.getBitsInt(32); // 4
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d820
movq -0x38(%rbp), %rdi
addq $0x3c0, %rax # imm = 0x3C0
movq %rax, -0x10(%rbp)
movl $0x20, %esi
callq 0x293e0
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rb... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::checkHSharedObject(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>> const&, std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>&) | void
QPDF::checkHSharedObject(std::vector<QPDFObjectHandle> const& pages, std::map<int, int>& idx_to_obj)
{
// Implementation note 125 says shared object groups always contain only one object.
// Implementation note 128 says that Acrobat always nbits_nobjects to zero. Implementation note
// 130 says that A... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x338(%rbp)
callq 0x6d820
addq $0x3c0, %rax # imm = 0x3C0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.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.