From 85d784952f8a7c4d8c9e614663ebc5b1eb747384 Mon Sep 17 00:00:00 2001 From: m-holger Date: Sun, 21 May 2023 14:42:34 +0100 Subject: Globally replace 'this->m->' with 'm->' Using search and replace. --- libqpdf/QPDFWriter.cc | 903 ++++++++++++++++++++++++-------------------------- 1 file changed, 434 insertions(+), 469 deletions(-) (limited to 'libqpdf/QPDFWriter.cc') diff --git a/libqpdf/QPDFWriter.cc b/libqpdf/QPDFWriter.cc index 99ff7c87..cad91d7c 100644 --- a/libqpdf/QPDFWriter.cc +++ b/libqpdf/QPDFWriter.cc @@ -106,30 +106,29 @@ QPDFWriter::setOutputFilename(char const* filename) void QPDFWriter::setOutputFile(char const* description, FILE* file, bool close_file) { - this->m->filename = description; - this->m->file = file; - this->m->close_file = close_file; + m->filename = description; + m->file = file; + m->close_file = close_file; std::shared_ptr p = std::make_shared("qpdf output", file); - this->m->to_delete.push_back(p); + m->to_delete.push_back(p); initializePipelineStack(p.get()); } void QPDFWriter::setOutputMemory() { - this->m->filename = "memory buffer"; - this->m->buffer_pipeline = new Pl_Buffer("qpdf output"); - this->m->to_delete.push_back( - std::shared_ptr(this->m->buffer_pipeline)); - initializePipelineStack(this->m->buffer_pipeline); + m->filename = "memory buffer"; + m->buffer_pipeline = new Pl_Buffer("qpdf output"); + m->to_delete.push_back(std::shared_ptr(m->buffer_pipeline)); + initializePipelineStack(m->buffer_pipeline); } Buffer* QPDFWriter::getBuffer() { - Buffer* result = this->m->output_buffer; - this->m->output_buffer = nullptr; + Buffer* result = m->output_buffer; + m->output_buffer = nullptr; return result; } @@ -142,14 +141,14 @@ QPDFWriter::getBufferSharedPointer() void QPDFWriter::setOutputPipeline(Pipeline* p) { - this->m->filename = "custom pipeline"; + m->filename = "custom pipeline"; initializePipelineStack(p); } void QPDFWriter::setObjectStreamMode(qpdf_object_stream_e mode) { - this->m->object_stream_mode = mode; + m->object_stream_mode = mode; } void @@ -157,69 +156,69 @@ QPDFWriter::setStreamDataMode(qpdf_stream_data_e mode) { switch (mode) { case qpdf_s_uncompress: - this->m->stream_decode_level = - std::max(qpdf_dl_generalized, this->m->stream_decode_level); - this->m->compress_streams = false; + m->stream_decode_level = + std::max(qpdf_dl_generalized, m->stream_decode_level); + m->compress_streams = false; break; case qpdf_s_preserve: - this->m->stream_decode_level = qpdf_dl_none; - this->m->compress_streams = false; + m->stream_decode_level = qpdf_dl_none; + m->compress_streams = false; break; case qpdf_s_compress: - this->m->stream_decode_level = - std::max(qpdf_dl_generalized, this->m->stream_decode_level); - this->m->compress_streams = true; + m->stream_decode_level = + std::max(qpdf_dl_generalized, m->stream_decode_level); + m->compress_streams = true; break; } - this->m->stream_decode_level_set = true; - this->m->compress_streams_set = true; + m->stream_decode_level_set = true; + m->compress_streams_set = true; } void QPDFWriter::setCompressStreams(bool val) { - this->m->compress_streams = val; - this->m->compress_streams_set = true; + m->compress_streams = val; + m->compress_streams_set = true; } void QPDFWriter::setDecodeLevel(qpdf_stream_decode_level_e val) { - this->m->stream_decode_level = val; - this->m->stream_decode_level_set = true; + m->stream_decode_level = val; + m->stream_decode_level_set = true; } void QPDFWriter::setRecompressFlate(bool val) { - this->m->recompress_flate = val; + m->recompress_flate = val; } void QPDFWriter::setContentNormalization(bool val) { - this->m->normalize_content_set = true; - this->m->normalize_content = val; + m->normalize_content_set = true; + m->normalize_content = val; } void QPDFWriter::setQDFMode(bool val) { - this->m->qdf_mode = val; + m->qdf_mode = val; } void QPDFWriter::setPreserveUnreferencedObjects(bool val) { - this->m->preserve_unreferenced_objects = val; + m->preserve_unreferenced_objects = val; } void QPDFWriter::setNewlineBeforeEndstream(bool val) { - this->m->newline_before_endstream = val; + m->newline_before_endstream = val; } void @@ -228,7 +227,7 @@ QPDFWriter::setMinimumPDFVersion( { bool set_version = false; bool set_extension_level = false; - if (this->m->min_pdf_version.empty()) { + if (m->min_pdf_version.empty()) { set_version = true; set_extension_level = true; } else { @@ -237,7 +236,7 @@ QPDFWriter::setMinimumPDFVersion( int min_major = 0; int min_minor = 0; parseVersion(version, old_major, old_minor); - parseVersion(this->m->min_pdf_version, min_major, min_minor); + parseVersion(m->min_pdf_version, min_major, min_minor); int compare = compareVersions(old_major, old_minor, min_major, min_minor); if (compare > 0) { @@ -248,7 +247,7 @@ QPDFWriter::setMinimumPDFVersion( set_version = true; set_extension_level = true; } else if (compare == 0) { - if (extension_level > this->m->min_extension_level) { + if (extension_level > m->min_extension_level) { QTC::TC("qpdf", "QPDFWriter increasing extension level"); set_extension_level = true; } @@ -256,10 +255,10 @@ QPDFWriter::setMinimumPDFVersion( } if (set_version) { - this->m->min_pdf_version = version; + m->min_pdf_version = version; } if (set_extension_level) { - this->m->min_extension_level = extension_level; + m->min_extension_level = extension_level; } } @@ -275,18 +274,18 @@ QPDFWriter::setMinimumPDFVersion(PDFVersion const& v) void QPDFWriter::forcePDFVersion(std::string const& version, int extension_level) { - this->m->forced_pdf_version = version; - this->m->forced_extension_level = extension_level; + m->forced_pdf_version = version; + m->forced_extension_level = extension_level; } void QPDFWriter::setExtraHeaderText(std::string const& text) { - this->m->extra_header_text = text; - if ((this->m->extra_header_text.length() > 0) && - (*(this->m->extra_header_text.rbegin()) != '\n')) { + m->extra_header_text = text; + if ((m->extra_header_text.length() > 0) && + (*(m->extra_header_text.rbegin()) != '\n')) { QTC::TC("qpdf", "QPDFWriter extra header text add newline"); - this->m->extra_header_text += "\n"; + m->extra_header_text += "\n"; } else { QTC::TC("qpdf", "QPDFWriter extra header text no newline"); } @@ -295,13 +294,13 @@ QPDFWriter::setExtraHeaderText(std::string const& text) void QPDFWriter::setStaticID(bool val) { - this->m->static_id = val; + m->static_id = val; } void QPDFWriter::setDeterministicID(bool val) { - this->m->deterministic_id = val; + m->deterministic_id = val; } void @@ -315,36 +314,36 @@ QPDFWriter::setStaticAesIV(bool val) void QPDFWriter::setSuppressOriginalObjectIDs(bool val) { - this->m->suppress_original_object_ids = val; + m->suppress_original_object_ids = val; } void QPDFWriter::setPreserveEncryption(bool val) { - this->m->preserve_encryption = val; + m->preserve_encryption = val; } void QPDFWriter::setLinearization(bool val) { - this->m->linearized = val; + m->linearized = val; if (val) { - this->m->pclm = false; + m->pclm = false; } } void QPDFWriter::setLinearizationPass1Filename(std::string const& filename) { - this->m->lin_pass1_filename = filename; + m->lin_pass1_filename = filename; } void QPDFWriter::setPCLm(bool val) { - this->m->pclm = val; + m->pclm = val; if (val) { - this->m->linearized = false; + m->linearized = false; } } @@ -429,8 +428,8 @@ QPDFWriter::setR4EncryptionParametersInsecure( allow_modify_other, print, qpdf_r3m_all); - this->m->encrypt_use_aes = use_aes; - this->m->encrypt_metadata = encrypt_metadata; + m->encrypt_use_aes = use_aes; + m->encrypt_metadata = encrypt_metadata; setEncryptionParameters(user_password, owner_password, 4, 4, 16, clear); } @@ -460,8 +459,8 @@ QPDFWriter::setR5EncryptionParameters( allow_modify_other, print, qpdf_r3m_all); - this->m->encrypt_use_aes = true; - this->m->encrypt_metadata = encrypt_metadata; + m->encrypt_use_aes = true; + m->encrypt_metadata = encrypt_metadata; setEncryptionParameters(user_password, owner_password, 5, 5, 32, clear); } @@ -491,8 +490,8 @@ QPDFWriter::setR6EncryptionParameters( allow_modify_other, print, qpdf_r3m_all); - this->m->encrypt_use_aes = true; - this->m->encrypt_metadata = encrypt_metadata; + m->encrypt_use_aes = true; + m->encrypt_metadata = encrypt_metadata; setEncryptionParameters(user_password, owner_password, 5, 6, 32, clear); } @@ -649,8 +648,8 @@ QPDFWriter::setEncryptionParameters( R, key_len, P, - this->m->encrypt_metadata, - this->m->id1, + m->encrypt_metadata, + m->id1, O, U); } else { @@ -661,8 +660,8 @@ QPDFWriter::setEncryptionParameters( R, key_len, P, - this->m->encrypt_metadata, - this->m->id1, + m->encrypt_metadata, + m->id1, encryption_key, O, U, @@ -680,7 +679,7 @@ QPDFWriter::setEncryptionParameters( OE, UE, Perms, - this->m->id1, + m->id1, user_password, encryption_key); } @@ -688,11 +687,11 @@ QPDFWriter::setEncryptionParameters( void QPDFWriter::copyEncryptionParameters(QPDF& qpdf) { - this->m->preserve_encryption = false; + m->preserve_encryption = false; QPDFObjectHandle trailer = qpdf.getTrailer(); if (trailer.hasKey("/Encrypt")) { generateID(); - this->m->id1 = trailer.getKey("/ID").getArrayItem(0).getStringValue(); + m->id1 = trailer.getKey("/ID").getArrayItem(0).getStringValue(); QPDFObjectHandle encrypt = trailer.getKey("/Encrypt"); int V = encrypt.getKey("/V").getIntValueAsInt(); int key_len = 5; @@ -701,7 +700,7 @@ QPDFWriter::copyEncryptionParameters(QPDF& qpdf) } if (encrypt.hasKey("/EncryptMetadata") && encrypt.getKey("/EncryptMetadata").isBool()) { - this->m->encrypt_metadata = + m->encrypt_metadata = encrypt.getKey("/EncryptMetadata").getBoolValue(); } if (V >= 4) { @@ -711,16 +710,13 @@ QPDFWriter::copyEncryptionParameters(QPDF& qpdf) // figuring out whether AES is used or not is complicated // with /StmF, /StrF, and /EFF all potentially having // different values. - this->m->encrypt_use_aes = true; + m->encrypt_use_aes = true; } QTC::TC( "qpdf", "QPDFWriter copy encrypt metadata", - this->m->encrypt_metadata ? 0 : 1); - QTC::TC( - "qpdf", - "QPDFWriter copy use_aes", - this->m->encrypt_use_aes ? 0 : 1); + m->encrypt_metadata ? 0 : 1); + QTC::TC("qpdf", "QPDFWriter copy use_aes", m->encrypt_use_aes ? 0 : 1); std::string OE; std::string UE; std::string Perms; @@ -743,7 +739,7 @@ QPDFWriter::copyEncryptionParameters(QPDF& qpdf) OE, UE, Perms, - this->m->id1, // this->m->id1 == the other file's id1 + m->id1, // m->id1 == the other file's id1 qpdf.getPaddedUserPassword(), encryption_key); } @@ -753,7 +749,7 @@ void QPDFWriter::disableIncompatibleEncryption( int major, int minor, int extension_level) { - if (!this->m->encrypted) { + if (!m->encrypted) { return; } @@ -761,10 +757,8 @@ QPDFWriter::disableIncompatibleEncryption( if (compareVersions(major, minor, 1, 3) < 0) { disable = true; } else { - int V = - QUtil::string_to_int(this->m->encryption_dictionary["/V"].c_str()); - int R = - QUtil::string_to_int(this->m->encryption_dictionary["/R"].c_str()); + int V = QUtil::string_to_int(m->encryption_dictionary["/V"].c_str()); + int R = QUtil::string_to_int(m->encryption_dictionary["/R"].c_str()); if (compareVersions(major, minor, 1, 4) < 0) { if ((V > 1) || (R > 2)) { disable = true; @@ -774,7 +768,7 @@ QPDFWriter::disableIncompatibleEncryption( disable = true; } } else if (compareVersions(major, minor, 1, 6) < 0) { - if (this->m->encrypt_use_aes) { + if (m->encrypt_use_aes) { disable = true; } } else if ( @@ -788,7 +782,7 @@ QPDFWriter::disableIncompatibleEncryption( } if (disable) { QTC::TC("qpdf", "QPDFWriter forced version disabled encryption"); - this->m->encrypted = false; + m->encrypted = false; } } @@ -844,74 +838,72 @@ QPDFWriter::setEncryptionParametersInternal( std::string const& user_password, std::string const& encryption_key) { - this->m->encryption_V = V; - this->m->encryption_R = R; - this->m->encryption_dictionary["/Filter"] = "/Standard"; - this->m->encryption_dictionary["/V"] = std::to_string(V); - this->m->encryption_dictionary["/Length"] = std::to_string(key_len * 8); - this->m->encryption_dictionary["/R"] = std::to_string(R); - this->m->encryption_dictionary["/P"] = std::to_string(P); - this->m->encryption_dictionary["/O"] = QPDF_String(O).unparse(true); - this->m->encryption_dictionary["/U"] = QPDF_String(U).unparse(true); + m->encryption_V = V; + m->encryption_R = R; + m->encryption_dictionary["/Filter"] = "/Standard"; + m->encryption_dictionary["/V"] = std::to_string(V); + m->encryption_dictionary["/Length"] = std::to_string(key_len * 8); + m->encryption_dictionary["/R"] = std::to_string(R); + m->encryption_dictionary["/P"] = std::to_string(P); + m->encryption_dictionary["/O"] = QPDF_String(O).unparse(true); + m->encryption_dictionary["/U"] = QPDF_String(U).unparse(true); if (V >= 5) { - this->m->encryption_dictionary["/OE"] = QPDF_String(OE).unparse(true); - this->m->encryption_dictionary["/UE"] = QPDF_String(UE).unparse(true); - this->m->encryption_dictionary["/Perms"] = - QPDF_String(Perms).unparse(true); + m->encryption_dictionary["/OE"] = QPDF_String(OE).unparse(true); + m->encryption_dictionary["/UE"] = QPDF_String(UE).unparse(true); + m->encryption_dictionary["/Perms"] = QPDF_String(Perms).unparse(true); } if (R >= 6) { setMinimumPDFVersion("1.7", 8); } else if (R == 5) { setMinimumPDFVersion("1.7", 3); } else if (R == 4) { - setMinimumPDFVersion(this->m->encrypt_use_aes ? "1.6" : "1.5"); + setMinimumPDFVersion(m->encrypt_use_aes ? "1.6" : "1.5"); } else if (R == 3) { setMinimumPDFVersion("1.4"); } else { setMinimumPDFVersion("1.3"); } - if ((R >= 4) && (!this->m->encrypt_metadata)) { - this->m->encryption_dictionary["/EncryptMetadata"] = "false"; + if ((R >= 4) && (!m->encrypt_metadata)) { + m->encryption_dictionary["/EncryptMetadata"] = "false"; } if ((V == 4) || (V == 5)) { // The spec says the value for the crypt filter key can be // anything, and xpdf seems to agree. However, Adobe Reader // won't open our files unless we use /StdCF. - this->m->encryption_dictionary["/StmF"] = "/StdCF"; - this->m->encryption_dictionary["/StrF"] = "/StdCF"; + m->encryption_dictionary["/StmF"] = "/StdCF"; + m->encryption_dictionary["/StrF"] = "/StdCF"; std::string method = - (this->m->encrypt_use_aes ? ((V < 5) ? "/AESV2" : "/AESV3") - : "/V2"); + (m->encrypt_use_aes ? ((V < 5) ? "/AESV2" : "/AESV3") : "/V2"); // The PDF spec says the /Length key is optional, but the PDF // previewer on some versions of MacOS won't open encrypted // files without it. - this->m->encryption_dictionary["/CF"] = + m->encryption_dictionary["/CF"] = "<< /StdCF << /AuthEvent /DocOpen /CFM " + method + " /Length " + std::string((V < 5) ? "16" : "32") + " >> >>"; } - this->m->encrypted = true; + m->encrypted = true; QPDF::EncryptionData encryption_data( - V, R, key_len, P, O, U, OE, UE, Perms, id1, this->m->encrypt_metadata); + V, R, key_len, P, O, U, OE, UE, Perms, id1, m->encrypt_metadata); if (V < 5) { - this->m->encryption_key = + m->encryption_key = QPDF::compute_encryption_key(user_password, encryption_data); } else { - this->m->encryption_key = encryption_key; + m->encryption_key = encryption_key; } } void QPDFWriter::setDataKey(int objid) { - this->m->cur_data_key = QPDF::compute_data_key( - this->m->encryption_key, + m->cur_data_key = QPDF::compute_data_key( + m->encryption_key, objid, 0, - this->m->encrypt_use_aes, - this->m->encryption_V, - this->m->encryption_R); + m->encrypt_use_aes, + m->encryption_V, + m->encryption_R); } unsigned int @@ -937,7 +929,7 @@ QPDFWriter::writeBinary(unsigned long long val, unsigned int bytes) data[bytes - i - 1] = static_cast(val & 0xff); val >>= 8; } - this->m->pipeline->write(data, bytes); + m->pipeline->write(data, bytes); } void @@ -950,7 +942,7 @@ QPDFWriter::writeString(std::string_view str) void QPDFWriter::writeBuffer(std::shared_ptr& b) { - this->m->pipeline->write(b->getBuffer(), b->getSize()); + m->pipeline->write(b->getBuffer(), b->getSize()); } void @@ -981,26 +973,26 @@ Pipeline* QPDFWriter::pushPipeline(Pipeline* p) { qpdf_assert_debug(dynamic_cast(p) == nullptr); - this->m->pipeline_stack.push_back(p); + m->pipeline_stack.push_back(p); return p; } void QPDFWriter::initializePipelineStack(Pipeline* p) { - this->m->pipeline = new Pl_Count("pipeline stack base", p); - this->m->to_delete.push_back(std::shared_ptr(this->m->pipeline)); - this->m->pipeline_stack.push_back(this->m->pipeline); + m->pipeline = new Pl_Count("pipeline stack base", p); + m->to_delete.push_back(std::shared_ptr(m->pipeline)); + m->pipeline_stack.push_back(m->pipeline); } void QPDFWriter::activatePipelineStack(PipelinePopper& pp) { - std::string stack_id("stack " + std::to_string(this->m->next_stack_id)); - auto* c = new Pl_Count(stack_id.c_str(), this->m->pipeline_stack.back()); - ++this->m->next_stack_id; - this->m->pipeline_stack.push_back(c); - this->m->pipeline = c; + std::string stack_id("stack " + std::to_string(m->next_stack_id)); + auto* c = new Pl_Count(stack_id.c_str(), m->pipeline_stack.back()); + ++m->next_stack_id; + m->pipeline_stack.push_back(c); + m->pipeline = c; pp.stack_id = stack_id; } @@ -1041,8 +1033,7 @@ QPDFWriter::PipelinePopper::~PipelinePopper() void QPDFWriter::adjustAESStreamLength(size_t& length) { - if (this->m->encrypted && (!this->m->cur_data_key.empty()) && - this->m->encrypt_use_aes) { + if (m->encrypted && (!m->cur_data_key.empty()) && m->encrypt_use_aes) { // Stream length will be padded with 1 to 16 bytes to end up // as a multiple of 16. It will also be prepended by 16 bits // of random data. @@ -1053,21 +1044,21 @@ QPDFWriter::adjustAESStreamLength(size_t& length) void QPDFWriter::pushEncryptionFilter(PipelinePopper& pp) { - if (this->m->encrypted && (!this->m->cur_data_key.empty())) { + if (m->encrypted && (!m->cur_data_key.empty())) { Pipeline* p = nullptr; - if (this->m->encrypt_use_aes) { + if (m->encrypt_use_aes) { p = new Pl_AES_PDF( "aes stream encryption", - this->m->pipeline, + m->pipeline, true, - QUtil::unsigned_char_pointer(this->m->cur_data_key), - this->m->cur_data_key.length()); + QUtil::unsigned_char_pointer(m->cur_data_key), + m->cur_data_key.length()); } else { p = new Pl_RC4( "rc4 stream encryption", - this->m->pipeline, - QUtil::unsigned_char_pointer(this->m->cur_data_key), - QIntC::to_int(this->m->cur_data_key.length())); + m->pipeline, + QUtil::unsigned_char_pointer(m->cur_data_key), + QIntC::to_int(m->cur_data_key.length())); } pushPipeline(p); } @@ -1086,38 +1077,38 @@ QPDFWriter::pushDiscardFilter(PipelinePopper& pp) void QPDFWriter::pushMD5Pipeline(PipelinePopper& pp) { - if (!this->m->id2.empty()) { + 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(this->m->deterministic_id); - qpdf_assert_debug(this->m->md5_pipeline == nullptr); - qpdf_assert_debug(this->m->pipeline->getCount() == 0); - this->m->md5_pipeline = new Pl_MD5("qpdf md5", this->m->pipeline); - this->m->md5_pipeline->persistAcrossFinish(true); - // Special case code in popPipelineStack clears this->m->md5_pipeline + qpdf_assert_debug(m->deterministic_id); + qpdf_assert_debug(m->md5_pipeline == nullptr); + qpdf_assert_debug(m->pipeline->getCount() == 0); + m->md5_pipeline = new Pl_MD5("qpdf md5", m->pipeline); + m->md5_pipeline->persistAcrossFinish(true); + // Special case code in popPipelineStack clears m->md5_pipeline // upon deletion. - pushPipeline(this->m->md5_pipeline); + pushPipeline(m->md5_pipeline); activatePipelineStack(pp); } void QPDFWriter::computeDeterministicIDData() { - qpdf_assert_debug(this->m->md5_pipeline != nullptr); - qpdf_assert_debug(this->m->deterministic_id_data.empty()); - this->m->deterministic_id_data = this->m->md5_pipeline->getHexDigest(); - this->m->md5_pipeline->enable(false); + qpdf_assert_debug(m->md5_pipeline != nullptr); + qpdf_assert_debug(m->deterministic_id_data.empty()); + m->deterministic_id_data = m->md5_pipeline->getHexDigest(); + m->md5_pipeline->enable(false); } int QPDFWriter::openObject(int objid) { if (objid == 0) { - objid = this->m->next_objid++; + objid = m->next_objid++; } - this->m->xref[objid] = QPDFXRefEntry(m->pipeline->getCount()); + m->xref[objid] = QPDFXRefEntry(m->pipeline->getCount()); writeString(std::to_string(objid)); writeString(" 0 obj\n"); return objid; @@ -1130,24 +1121,22 @@ QPDFWriter::closeObject(int objid) // repair. writeString("\nendobj\n"); writeStringQDF("\n"); - this->m->lengths[objid] = - this->m->pipeline->getCount() - this->m->xref[objid].getOffset(); + m->lengths[objid] = m->pipeline->getCount() - m->xref[objid].getOffset(); } void QPDFWriter::assignCompressedObjectNumbers(QPDFObjGen const& og) { int objid = og.getObj(); - if ((og.getGen() != 0) || - (this->m->object_stream_to_objects.count(objid) == 0)) { + 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 (auto const& iter: this->m->object_stream_to_objects[objid]) { - this->m->obj_renumber[iter] = this->m->next_objid++; + for (auto const& iter: m->object_stream_to_objects[objid]) { + m->obj_renumber[iter] = m->next_objid++; } } @@ -1161,7 +1150,7 @@ QPDFWriter::enqueueObject(QPDFObjectHandle object) // file was insert into another file without copying. Doing // that is safe even if the original QPDF gets destroyed, // which just disconnects the QPDFObjectHandle from its owner. - if (object.getOwningQPDF() != &(this->m->pdf)) { + if (object.getOwningQPDF() != &(m->pdf)) { QTC::TC("qpdf", "QPDFWriter foreign object"); throw std::logic_error( "QPDFObjectHandle from different QPDF found while writing." @@ -1169,7 +1158,7 @@ QPDFWriter::enqueueObject(QPDFObjectHandle object) " another file."); } - if (this->m->qdf_mode && object.isStreamOfType("/XRef")) { + if (m->qdf_mode && object.isStreamOfType("/XRef")) { // As a special case, do not output any extraneous XRef // streams in QDF mode. Doing so will confuse fix-qdf, // which expects to see only one XRef stream at the end of @@ -1183,41 +1172,40 @@ QPDFWriter::enqueueObject(QPDFObjectHandle object) QPDFObjGen og = object.getObjGen(); - if (this->m->obj_renumber.count(og) == 0) { - if (this->m->object_to_object_stream.count(og)) { + if (m->obj_renumber.count(og) == 0) { + if (m->object_to_object_stream.count(og)) { // This is in an object stream. Don't process it // here. Instead, enqueue the object stream. Object // streams always have generation 0. - int stream_id = this->m->object_to_object_stream[og]; + int stream_id = m->object_to_object_stream[og]; // Detect loops by storing invalid object ID 0, which // will get overwritten later. - this->m->obj_renumber[og] = 0; - enqueueObject(this->m->pdf.getObjectByID(stream_id, 0)); + m->obj_renumber[og] = 0; + enqueueObject(m->pdf.getObjectByID(stream_id, 0)); } else { - this->m->object_queue.push_back(object); - this->m->obj_renumber[og] = this->m->next_objid++; + m->object_queue.push_back(object); + m->obj_renumber[og] = m->next_objid++; if ((og.getGen() == 0) && - this->m->object_stream_to_objects.count(og.getObj())) { + m->object_stream_to_objects.count(og.getObj())) { // For linearized files, uncompressed objects go // at end, and we take care of assigning numbers // to them elsewhere. - if (!this->m->linearized) { + if (!m->linearized) { assignCompressedObjectNumbers(og); } - } else if ( - (!this->m->direct_stream_lengths) && object.isStream()) { + } else if ((!m->direct_stream_lengths) && object.isStream()) { // reserve next object ID for length - ++this->m->next_objid; + ++m->next_objid; } } - } else if (this->m->obj_renumber[og] == 0) { + } else if (m->obj_renumber[og] == 0) { // This can happen if a specially constructed file // indicates that an object stream is inside itself. QTC::TC("qpdf", "QPDFWriter ignore self-referential object stream"); } return; - } else if (!this->m->linearized) { + } else if (!m->linearized) { if (object.isArray()) { for (auto& item: object.getArrayAsVector()) { enqueueObject(item); @@ -1237,12 +1225,12 @@ QPDFWriter::enqueueObject(QPDFObjectHandle object) void QPDFWriter::unparseChild(QPDFObjectHandle child, int level, int flags) { - if (!this->m->linearized) { + if (!m->linearized) { enqueueObject(child); } if (child.isIndirect()) { QPDFObjGen old_og = child.getObjGen(); - int new_id = this->m->obj_renumber[old_og]; + int new_id = m->obj_renumber[old_og]; writeString(std::to_string(new_id)); writeString(" 0 R"); } else { @@ -1260,7 +1248,7 @@ QPDFWriter::writeTrailer( { QPDFObjectHandle trailer = getTrimmedTrailer(); if (xref_stream) { - this->m->cur_data_key.clear(); + m->cur_data_key.clear(); } else { writeString("trailer <<"); } @@ -1278,10 +1266,10 @@ QPDFWriter::writeTrailer( writeString(std::to_string(size)); if (which == t_lin_first) { writeString(" /Prev "); - qpdf_offset_t pos = this->m->pipeline->getCount(); + qpdf_offset_t pos = m->pipeline->getCount(); writeString(std::to_string(prev)); - writePad(QIntC::to_size( - pos - this->m->pipeline->getCount() + 21)); + writePad( + QIntC::to_size(pos - m->pipeline->getCount() + 21)); } } else { unparseChild(trailer.getKey(key), 1, 0); @@ -1313,20 +1301,20 @@ QPDFWriter::writeTrailer( } writeString("<00000000000000000000000000000000>"); } else { - if ((linearization_pass == 0) && (this->m->deterministic_id)) { + if ((linearization_pass == 0) && (m->deterministic_id)) { computeDeterministicIDData(); } generateID(); - writeString(QPDF_String(this->m->id1).unparse(true)); - writeString(QPDF_String(this->m->id2).unparse(true)); + writeString(QPDF_String(m->id1).unparse(true)); + writeString(QPDF_String(m->id2).unparse(true)); } writeString("]"); if (which != t_lin_second) { // Write reference to encryption dictionary - if (this->m->encrypted) { + if (m->encrypted) { writeString(" /Encrypt "); - writeString(std::to_string(this->m->encryption_dict_objid)); + writeString(std::to_string(m->encryption_dict_objid)); writeString(" 0 R"); } } @@ -1353,14 +1341,14 @@ QPDFWriter::willFilterStream( is_metadata = true; } bool filter = - (stream.isDataModified() || this->m->compress_streams || - this->m->stream_decode_level); + (stream.isDataModified() || m->compress_streams || + m->stream_decode_level); bool filter_on_write = stream.getFilterOnWrite(); if (!filter_on_write) { QTC::TC("qpdf", "QPDFWriter getFilterOnWrite false"); filter = false; } - if (filter_on_write && this->m->compress_streams) { + if (filter_on_write && m->compress_streams) { // Don't filter if the stream is already compressed with // FlateDecode. This way we don't make it worse if the // original file used a better Flate algorithm, and we @@ -1368,7 +1356,7 @@ QPDFWriter::willFilterStream( // recompressing stuff. This can be overridden with // setRecompressFlate(true). QPDFObjectHandle filter_obj = stream_dict.getKey("/Filter"); - if ((!this->m->recompress_flate) && (!stream.isDataModified()) && + if ((!m->recompress_flate) && (!stream.isDataModified()) && filter_obj.isName() && ((filter_obj.getName() == "/FlateDecode") || (filter_obj.getName() == "/Fl"))) { @@ -1379,17 +1367,17 @@ QPDFWriter::willFilterStream( bool normalize = false; bool uncompress = false; if (filter_on_write && is_metadata && - ((!this->m->encrypted) || (this->m->encrypt_metadata == false))) { + ((!m->encrypted) || (m->encrypt_metadata == false))) { QTC::TC("qpdf", "QPDFWriter not compressing metadata"); filter = true; compress_stream = false; uncompress = true; } else if ( - filter_on_write && this->m->normalize_content && - this->m->normalized_streams.count(old_og)) { + filter_on_write && m->normalize_content && + m->normalized_streams.count(old_og)) { normalize = true; filter = true; - } else if (filter_on_write && filter && this->m->compress_streams) { + } else if (filter_on_write && filter && m->compress_streams) { compress_stream = true; QTC::TC("qpdf", "QPDFWriter compressing uncompressed stream"); } @@ -1401,12 +1389,11 @@ QPDFWriter::willFilterStream( activatePipelineStack(pp_stream_data); try { filtered = stream.pipeStreamData( - this->m->pipeline, + m->pipeline, (((filter && normalize) ? qpdf_ef_normalize : 0) | ((filter && compress_stream) ? qpdf_ef_compress : 0)), - (filter - ? (uncompress ? qpdf_dl_all : this->m->stream_decode_level) - : qpdf_dl_none), + (filter ? (uncompress ? qpdf_dl_all : m->stream_decode_level) + : qpdf_dl_none), false, (attempt == 1)); } catch (std::runtime_error& e) { @@ -1516,7 +1503,7 @@ QPDFWriter::unparseObject( } } - bool need_extensions_adbe = (this->m->final_extension_level > 0); + bool need_extensions_adbe = (m->final_extension_level > 0); if (is_root) { if (need_extensions_adbe) { @@ -1526,7 +1513,7 @@ QPDFWriter::unparseObject( QTC::TC( "qpdf", "QPDFWriter create Extensions", - this->m->qdf_mode ? 0 : 1); + m->qdf_mode ? 0 : 1); extensions = object.replaceKeyAndGetNew( "/Extensions", QPDFObjectHandle::newDictionary()); } @@ -1545,20 +1532,19 @@ QPDFWriter::unparseObject( QPDFObjectHandle adbe = extensions.getKey("/ADBE"); if (adbe.isDictionary() && adbe.getKey("/BaseVersion") - .isNameAndEquals("/" + this->m->final_pdf_version) && + .isNameAndEquals("/" + m->final_pdf_version) && adbe.getKey("/ExtensionLevel").isInteger() && (adbe.getKey("/ExtensionLevel").getIntValue() == - this->m->final_extension_level)) { + m->final_extension_level)) { QTC::TC("qpdf", "QPDFWriter preserve ADBE"); } else { if (need_extensions_adbe) { extensions.replaceKey( "/ADBE", QPDFObjectHandle::parse( - "<< /BaseVersion /" + this->m->final_pdf_version + + "<< /BaseVersion /" + m->final_pdf_version + " /ExtensionLevel " + - std::to_string(this->m->final_extension_level) + - " >>")); + std::to_string(m->final_extension_level) + " >>")); } else { QTC::TC("qpdf", "QPDFWriter remove ADBE"); extensions.removeKey("/ADBE"); @@ -1645,10 +1631,10 @@ QPDFWriter::unparseObject( writeStringQDF(" "); writeString("/Length "); - if (this->m->direct_stream_lengths) { + if (m->direct_stream_lengths) { writeString(std::to_string(stream_length)); } else { - writeString(std::to_string(this->m->cur_stream_length_id)); + writeString(std::to_string(m->cur_stream_length_id)); writeString(" 0 R"); } if (compress && (flags & f_filtered)) { @@ -1662,9 +1648,9 @@ QPDFWriter::unparseObject( writeString(">>"); } else if (tc == ::ot_stream) { // Write stream data to a buffer. - int new_id = this->m->obj_renumber[old_og]; - if (!this->m->direct_stream_lengths) { - this->m->cur_stream_length_id = new_id + 1; + int new_id = m->obj_renumber[old_og]; + if (!m->direct_stream_lengths) { + m->cur_stream_length_id = new_id + 1; } flags |= f_stream; @@ -1677,44 +1663,44 @@ QPDFWriter::unparseObject( } QPDFObjectHandle stream_dict = object.getDict(); - this->m->cur_stream_length = stream_data->getSize(); - if (is_metadata && this->m->encrypted && (!this->m->encrypt_metadata)) { + m->cur_stream_length = stream_data->getSize(); + if (is_metadata && m->encrypted && (!m->encrypt_metadata)) { // Don't encrypt stream data for the metadata stream - this->m->cur_data_key.clear(); + m->cur_data_key.clear(); } - adjustAESStreamLength(this->m->cur_stream_length); + adjustAESStreamLength(m->cur_stream_length); unparseObject( - stream_dict, 0, flags, this->m->cur_stream_length, compress_stream); + stream_dict, 0, flags, m->cur_stream_length, compress_stream); unsigned char last_char = '\0'; writeString("\nstream\n"); { PipelinePopper pp_enc(this); pushEncryptionFilter(pp_enc); writeBuffer(stream_data); - last_char = this->m->pipeline->getLastChar(); + last_char = m->pipeline->getLastChar(); } - if (this->m->newline_before_endstream || - (this->m->qdf_mode && (last_char != '\n'))) { + if (m->newline_before_endstream || + (m->qdf_mode && (last_char != '\n'))) { writeString("\n"); - this->m->added_newline = true; + m->added_newline = true; } else { - this->m->added_newline = false; + m->added_newline = false; } writeString("endstream"); } else if (tc == ::ot_string) { std::string val; - if (this->m->encrypted && (!(flags & f_in_ostream)) && - (!(flags & f_no_encryption)) && (!this->m->cur_data_key.empty())) { + if (m->encrypted && (!(flags & f_in_ostream)) && + (!(flags & f_no_encryption)) && (!m->cur_data_key.empty())) { val = object.getStringValue(); - if (this->m->encrypt_use_aes) { + if (m->encrypt_use_aes) { Pl_Buffer bufpl("encrypted string"); Pl_AES_PDF pl( "aes encrypt string", &bufpl, true, - QUtil::unsigned_char_pointer(this->m->cur_data_key), - this->m->cur_data_key.length()); + QUtil::unsigned_char_pointer(m->cur_data_key), + m->cur_data_key.length()); pl.writeString(val); pl.finish(); auto buf = bufpl.getBufferSharedPointer(); @@ -1727,8 +1713,8 @@ QPDFWriter::unparseObject( char* tmp = tmp_ph.get(); size_t vlen = val.length(); RC4 rc4( - QUtil::unsigned_char_pointer(this->m->cur_data_key), - QIntC::to_int(this->m->cur_data_key.length())); + QUtil::unsigned_char_pointer(m->cur_data_key), + QIntC::to_int(m->cur_data_key.length())); auto data = QUtil::unsigned_char_pointer(tmp); rc4.process(data, vlen, data); val = QPDF_String(std::string(tmp, vlen)).unparse(); @@ -1769,7 +1755,7 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) QPDFObjGen old_og = object.getObjGen(); qpdf_assert_debug(old_og.getGen() == 0); int old_id = old_og.getObj(); - int new_id = this->m->obj_renumber[old_og]; + int new_id = m->obj_renumber[old_og]; std::vector offsets; qpdf_offset_t first = 0; @@ -1797,14 +1783,14 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) PipelinePopper pp_discard(this); pushDiscardFilter(pp_discard); writeObjectStreamOffsets(offsets, first_obj); - first += this->m->pipeline->getCount(); + first += m->pipeline->getCount(); } // Set up a stream to write the stream data into a buffer. Pipeline* next = pushPipeline(new Pl_Buffer("object stream")); - if ((this->m->compress_streams || - (this->m->stream_decode_level == qpdf_dl_none)) && - (!this->m->qdf_mode)) { + if ((m->compress_streams || + (m->stream_decode_level == qpdf_dl_none)) && + (!m->qdf_mode)) { compressed = true; next = pushPipeline(new Pl_Flate( "compress object stream", next, Pl_Flate::a_deflate)); @@ -1814,17 +1800,17 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) } int count = -1; - for (auto const& obj: this->m->object_stream_to_objects[old_id]) { + for (auto const& obj: m->object_stream_to_objects[old_id]) { ++count; - int new_obj = this->m->obj_renumber[obj]; + int new_obj = m->obj_renumber[obj]; if (first_obj == -1) { first_obj = new_obj; } - if (this->m->qdf_mode) { + if (m->qdf_mode) { writeString( "%% Object stream: object " + std::to_string(new_obj) + ", index " + std::to_string(count)); - if (!this->m->suppress_original_object_ids) { + if (!m->suppress_original_object_ids) { writeString( "; original object ID: " + std::to_string(obj.getObj())); @@ -1841,13 +1827,13 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) writeString("\n"); } if (pass == 1) { - offsets.push_back(this->m->pipeline->getCount()); + offsets.push_back(m->pipeline->getCount()); // To avoid double-counting objects being written in // object streams for progress reporting, decrement in // pass 1. indicateProgress(true, false); } - QPDFObjectHandle obj_to_write = this->m->pdf.getObject(obj); + QPDFObjectHandle obj_to_write = m->pdf.getObject(obj); if (obj_to_write.isStream()) { // This condition occurred in a fuzz input. Ideally we // should block it at at parse time, but it's not @@ -1859,7 +1845,7 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) } writeObject(obj_to_write, count); - this->m->xref[new_obj] = QPDFXRefEntry(new_id, count); + m->xref[new_obj] = QPDFXRefEntry(new_id, count); } } @@ -1894,7 +1880,7 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) writeStringQDF("\n"); writeStringNoQDF(" "); writeString(">>\nstream\n"); - if (this->m->encrypted) { + if (m->encrypted) { QTC::TC("qpdf", "QPDFWriter encrypt object stream"); } { @@ -1902,11 +1888,11 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) pushEncryptionFilter(pp_enc); writeBuffer(stream_buffer); } - if (this->m->newline_before_endstream) { + if (m->newline_before_endstream) { writeString("\n"); } writeString("endstream"); - this->m->cur_data_key.clear(); + m->cur_data_key.clear(); closeObject(new_id); } @@ -1916,27 +1902,27 @@ QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index) QPDFObjGen old_og = object.getObjGen(); if ((object_stream_index == -1) && (old_og.getGen() == 0) && - (this->m->object_stream_to_objects.count(old_og.getObj()))) { + (m->object_stream_to_objects.count(old_og.getObj()))) { writeObjectStream(object); return; } indicateProgress(false, false); - int new_id = this->m->obj_renumber[old_og]; - if (this->m->qdf_mode) { - if (this->m->page_object_to_seq.count(old_og)) { + int new_id = m->obj_renumber[old_og]; + if (m->qdf_mode) { + if (m->page_object_to_seq.count(old_og)) { writeString("%% Page "); - writeString(std::to_string(this->m->page_object_to_seq[old_og])); + writeString(std::to_string(m->page_object_to_seq[old_og])); writeString("\n"); } - if (this->m->contents_to_page_seq.count(old_og)) { + if (m->contents_to_page_seq.count(old_og)) { writeString("%% Contents for page "); - writeString(std::to_string(this->m->contents_to_page_seq[old_og])); + writeString(std::to_string(m->contents_to_page_seq[old_og])); writeString("\n"); } } if (object_stream_index == -1) { - if (this->m->qdf_mode && (!this->m->suppress_original_object_ids)) { + if (m->qdf_mode && (!m->suppress_original_object_ids)) { writeString( "%% Original object ID: " + object.getObjGen().unparse(' ') + "\n"); @@ -1944,21 +1930,21 @@ QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index) openObject(new_id); setDataKey(new_id); unparseObject(object, 0, 0); - this->m->cur_data_key.clear(); + m->cur_data_key.clear(); closeObject(new_id); } else { unparseObject(object, 0, f_in_ostream); writeString("\n"); } - if ((!this->m->direct_stream_lengths) && object.isStream()) { - if (this->m->qdf_mode) { - if (this->m->added_newline) { + if ((!m->direct_stream_lengths) && object.isStream()) { + if (m->qdf_mode) { + if (m->added_newline) { writeString("%QDF: ignore_newline\n"); } } openObject(new_id + 1); - writeString(std::to_string(this->m->cur_stream_length)); + writeString(std::to_string(m->cur_stream_length)); closeObject(new_id + 1); } } @@ -1966,7 +1952,7 @@ QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index) std::string QPDFWriter::getOriginalID1() { - QPDFObjectHandle trailer = this->m->pdf.getTrailer(); + QPDFObjectHandle trailer = m->pdf.getTrailer(); if (trailer.hasKey("/ID")) { return trailer.getKey("/ID").getArrayItem(0).getStringValue(); } else { @@ -1980,15 +1966,15 @@ QPDFWriter::generateID() // Generate the ID lazily so that we can handle the user's // preference to use static or deterministic ID generation. - if (!this->m->id2.empty()) { + if (!m->id2.empty()) { return; } - QPDFObjectHandle trailer = this->m->pdf.getTrailer(); + QPDFObjectHandle trailer = m->pdf.getTrailer(); std::string result; - if (this->m->static_id) { + if (m->static_id) { // For test suite use only... static unsigned char tmp[] = { 0x31, @@ -2024,8 +2010,8 @@ QPDFWriter::generateID() // ID regardless of the output file's name. std::string seed; - if (this->m->deterministic_id) { - if (this->m->deterministic_id_data.empty()) { + if (m->deterministic_id) { + if (m->deterministic_id_data.empty()) { QTC::TC("qpdf", "QPDFWriter deterministic with no data"); throw std::logic_error( "INTERNAL ERROR: QPDFWriter::generateID has no" @@ -2033,10 +2019,10 @@ QPDFWriter::generateID() " deterministic ID and file encryption are requested" " together."); } - seed += this->m->deterministic_id_data; + seed += m->deterministic_id_data; } else { seed += std::to_string(QUtil::get_current_time()); - seed += this->m->filename; + seed += m->filename; seed += " "; } seed += " QPDF "; @@ -2063,11 +2049,11 @@ QPDFWriter::generateID() // word and generate a new second word. Otherwise, we'll use the // generated ID for both. - this->m->id2 = result; + m->id2 = result; // Note: keep /ID from old file even if --static-id was given. - this->m->id1 = getOriginalID1(); - if (this->m->id1.empty()) { - this->m->id1 = this->m->id2; + m->id1 = getOriginalID1(); + if (m->id1.empty()) { + m->id1 = m->id2; } } @@ -2076,10 +2062,10 @@ QPDFWriter::initializeSpecialStreams() { // Mark all page content streams in case we are filtering or // normalizing. - std::vector pages = this->m->pdf.getAllPages(); + std::vector pages = m->pdf.getAllPages(); int num = 0; for (auto& page: pages) { - this->m->page_object_to_seq[page.getObjGen()] = ++num; + m->page_object_to_seq[page.getObjGen()] = ++num; QPDFObjectHandle contents = page.getKey("/Contents"); std::vector contents_objects; if (contents.isArray()) { @@ -2093,8 +2079,8 @@ QPDFWriter::initializeSpecialStreams() } for (auto const& c: contents_objects) { - this->m->contents_to_page_seq[c] = num; - this->m->normalized_streams.insert(c); + m->contents_to_page_seq[c] = num; + m->normalized_streams.insert(c); } } } @@ -2103,7 +2089,7 @@ void QPDFWriter::preserveObjectStreams() { std::map omap; - QPDF::Writer::getObjectStreamData(this->m->pdf, omap); + QPDF::Writer::getObjectStreamData(m->pdf, omap); if (omap.empty()) { return; } @@ -2118,19 +2104,19 @@ QPDFWriter::preserveObjectStreams() // source PDF, it also prevents unreferenced objects from being // included. std::set eligible; - if (!this->m->preserve_unreferenced_objects) { + if (!m->preserve_unreferenced_objects) { std::vector eligible_v = - QPDF::Writer::getCompressibleObjGens(this->m->pdf); + QPDF::Writer::getCompressibleObjGens(m->pdf); eligible = std::set(eligible_v.begin(), eligible_v.end()); } QTC::TC( "qpdf", "QPDFWriter preserve object streams", - this->m->preserve_unreferenced_objects ? 0 : 1); + m->preserve_unreferenced_objects ? 0 : 1); for (auto iter: omap) { QPDFObjGen og(iter.first, 0); - if (eligible.count(og) || this->m->preserve_unreferenced_objects) { - this->m->object_to_object_stream[og] = iter.second; + if (eligible.count(og) || m->preserve_unreferenced_objects) { + m->object_to_object_stream[og] = iter.second; } else { QTC::TC("qpdf", "QPDFWriter exclude from object stream"); } @@ -2151,7 +2137,7 @@ QPDFWriter::generateObjectStreams() // This code doesn't do anything with /Extends. std::vector eligible = - QPDF::Writer::getCompressibleObjGens(this->m->pdf); + QPDF::Writer::getCompressibleObjGens(m->pdf); size_t n_object_streams = (eligible.size() + 99U) / 100U; if (n_object_streams == 0) { return; @@ -2173,11 +2159,10 @@ QPDFWriter::generateObjectStreams() // Construct a new null object as the "original" object // stream. The rest of the code knows that this means // we're creating the object stream from scratch. - cur_ostream = - this->m->pdf.makeIndirectObject(QPDFObjectHandle::newNull()) - .getObjectID(); + cur_ostream = m->pdf.makeIndirectObject(QPDFObjectHandle::newNull()) + .getObjectID(); } - this->m->object_to_object_stream[iter] = cur_ostream; + m->object_to_object_stream[iter] = cur_ostream; ++n; } } @@ -2188,7 +2173,7 @@ QPDFWriter::getTrimmedTrailer() // Remove keys from the trailer that necessarily have to be // replaced when writing the file. - QPDFObjectHandle trailer = this->m->pdf.getTrailer().unsafeShallowCopy(); + QPDFObjectHandle trailer = m->pdf.getTrailer().unsafeShallowCopy(); // Remove encryption keys trailer.removeKey("/ID"); @@ -2216,8 +2201,8 @@ QPDFWriter::prepareFileForWrite() // Make document extension level information direct as required by // the spec. - this->m->pdf.fixDanglingReferences(); - QPDFObjectHandle root = this->m->pdf.getRoot(); + m->pdf.fixDanglingReferences(); + QPDFObjectHandle root = m->pdf.getRoot(); for (auto const& key: root.getKeys()) { QPDFObjectHandle oh = root.getKey(key); if ((key == "/Extensions") && (oh.isDictionary())) { @@ -2245,76 +2230,74 @@ QPDFWriter::prepareFileForWrite() void QPDFWriter::doWriteSetup() { - if (this->m->did_write_setup) { + if (m->did_write_setup) { return; } - this->m->did_write_setup = true; + m->did_write_setup = true; // Do preliminary setup - if (this->m->linearized) { - this->m->qdf_mode = false; + if (m->linearized) { + m->qdf_mode = false; } - if (this->m->pclm) { - this->m->stream_decode_level = qpdf_dl_none; - this->m->compress_streams = false; - this->m->encrypted = false; + if (m->pclm) { + m->stream_decode_level = qpdf_dl_none; + m->compress_streams = false; + m->encrypted = false; } - if (this->m->qdf_mode) { - if (!this->m->normalize_content_set) { - this->m->normalize_content = true; + if (m->qdf_mode) { + if (!m->normalize_content_set) { + m->normalize_content = true; } - if (!this->m->compress_streams_set) { - this->m->compress_streams = false; + if (!m->compress_streams_set) { + m->compress_streams = false; } - if (!this->m->stream_decode_level_set) { - this->m->stream_decode_level = qpdf_dl_generalized; + if (!m->stream_decode_level_set) { + m->stream_decode_level = qpdf_dl_generalized; } } - if (this->m->encrypted) { + if (m->encrypted) { // Encryption has been explicitly set - this->m->preserve_encryption = false; + m->preserve_encryption = false; } else if ( - this->m->normalize_content || this->m->stream_decode_level || - this->m->pclm || this->m->qdf_mode) { + m->normalize_content || m->stream_decode_level || m->pclm || + m->qdf_mode) { // Encryption makes looking at contents pretty useless. If // the user explicitly encrypted though, we still obey that. - this->m->preserve_encryption = false; + m->preserve_encryption = false; } - if (this->m->preserve_encryption) { - copyEncryptionParameters(this->m->pdf); + if (m->preserve_encryption) { + copyEncryptionParameters(m->pdf); } - if (!this->m->forced_pdf_version.empty()) { + if (!m->forced_pdf_version.empty()) { int major = 0; int minor = 0; - parseVersion(this->m->forced_pdf_version, major, minor); - disableIncompatibleEncryption( - major, minor, this->m->forced_extension_level); + parseVersion(m->forced_pdf_version, major, minor); + disableIncompatibleEncryption(major, minor, m->forced_extension_level); if (compareVersions(major, minor, 1, 5) < 0) { QTC::TC("qpdf", "QPDFWriter forcing object stream disable"); - this->m->object_stream_mode = qpdf_o_disable; + m->object_stream_mode = qpdf_o_disable; } } - if (this->m->qdf_mode || this->m->normalize_content || - this->m->stream_decode_level) { + if (m->qdf_mode || m->normalize_content || m->stream_decode_level) { initializeSpecialStreams(); } - if (this->m->qdf_mode) { + if (m->qdf_mode) { // Generate indirect stream lengths for qdf mode since fix-qdf // uses them for storing recomputed stream length data. // Certain streams such as object streams, xref streams, and // hint streams always get direct stream lengths. - this->m->direct_stream_lengths = false; + m->direct_stream_lengths = false; } - switch (this->m->object_stream_mode) { + switch (m->object_stream_mode) { case qpdf_o_disable: // no action required break; @@ -2330,18 +2313,18 @@ QPDFWriter::doWriteSetup() // no default so gcc will warn for missing case tag } - if (this->m->linearized) { + if (m->linearized) { // Page dictionaries are not allowed to be compressed objects. - for (auto& page: this->m->pdf.getAllPages()) { + for (auto& page: m->pdf.getAllPages()) { QPDFObjGen og = page.getObjGen(); - if (this->m->object_to_object_stream.count(og)) { + if (m->object_to_object_stream.count(og)) { QTC::TC("qpdf", "QPDFWriter uncompressing page dictionary"); - this->m->object_to_object_stream.erase(og); + m->object_to_object_stream.erase(og); } } } - if (this->m->linearized || this->m->encrypted) { + if (m->linearized || m->encrypted) { // The document catalog is not allowed to be compressed in // linearized files either. It also appears that Adobe Reader // 8.0.0 has a bug that prevents it from being able to handle @@ -2349,33 +2332,31 @@ QPDFWriter::doWriteSetup() // disable them in that case as well. if (m->object_to_object_stream.count(m->root_og)) { QTC::TC("qpdf", "QPDFWriter uncompressing root"); - this->m->object_to_object_stream.erase(m->root_og); + m->object_to_object_stream.erase(m->root_og); } } // Generate reverse mapping from object stream to objects - for (auto const& iter: this->m->object_to_object_stream) { + for (auto const& iter: m->object_to_object_stream) { QPDFObjGen const& obj = iter.first; int stream = iter.second; - this->m->object_stream_to_objects[stream].insert(obj); - this->m->max_ostream_index = std::max( - this->m->max_ostream_index, - QIntC::to_int(this->m->object_stream_to_objects[stream].size()) - - 1); + m->object_stream_to_objects[stream].insert(obj); + m->max_ostream_index = std::max( + m->max_ostream_index, + QIntC::to_int(m->object_stream_to_objects[stream].size()) - 1); } - if (!this->m->object_stream_to_objects.empty()) { + if (!m->object_stream_to_objects.empty()) { setMinimumPDFVersion("1.5"); } - setMinimumPDFVersion( - this->m->pdf.getPDFVersion(), this->m->pdf.getExtensionLevel()); - this->m->final_pdf_version = this->m->min_pdf_version; - this->m->final_extension_level = this->m->min_extension_level; - if (!this->m->forced_pdf_version.empty()) { + setMinimumPDFVersion(m->pdf.getPDFVersion(), m->pdf.getExtensionLevel()); + m->final_pdf_version = m->min_pdf_version; + m->final_extension_level = m->min_extension_level; + if (!m->forced_pdf_version.empty()) { QTC::TC("qpdf", "QPDFWriter using forced PDF version"); - this->m->final_pdf_version = this->m->forced_pdf_version; - this->m->final_extension_level = this->m->forced_extension_level; + m->final_pdf_version = m->forced_pdf_version; + m->final_extension_level = m->forced_extension_level; } } @@ -2387,25 +2368,25 @@ QPDFWriter::write() // Set up progress reporting. For linearized files, we write two // passes. events_expected is an approximation, but it's good // enough for progress reporting, which is mostly a guess anyway. - this->m->events_expected = QIntC::to_int( - this->m->pdf.getObjectCount() * (this->m->linearized ? 2 : 1)); + m->events_expected = + QIntC::to_int(m->pdf.getObjectCount() * (m->linearized ? 2 : 1)); prepareFileForWrite(); - if (this->m->linearized) { + if (m->linearized) { writeLinearized(); } else { writeStandard(); } - this->m->pipeline->finish(); - if (this->m->close_file) { - fclose(this->m->file); + m->pipeline->finish(); + if (m->close_file) { + fclose(m->file); } - this->m->file = nullptr; - if (this->m->buffer_pipeline) { - this->m->output_buffer = this->m->buffer_pipeline->getBuffer(); - this->m->buffer_pipeline = nullptr; + m->file = nullptr; + if (m->buffer_pipeline) { + m->output_buffer = m->buffer_pipeline->getBuffer(); + m->buffer_pipeline = nullptr; } indicateProgress(false, true); } @@ -2413,7 +2394,7 @@ QPDFWriter::write() QPDFObjGen QPDFWriter::getRenumberedObjGen(QPDFObjGen og) { - return QPDFObjGen(this->m->obj_renumber[og], 0); + return QPDFObjGen(m->obj_renumber[og], 0); } std::map @@ -2421,7 +2402,7 @@ QPDFWriter::getWrittenXRefTable() { std::map result; - for (auto const& iter: this->m->xref) { + for (auto const& iter: m->xref) { if (iter.first != 0 && iter.second.getType() != 0) { result[QPDFObjGen(iter.first, 0)] = iter.second; } @@ -2441,31 +2422,31 @@ QPDFWriter::enqueuePart(std::vector& part) void QPDFWriter::writeEncryptionDictionary() { - this->m->encryption_dict_objid = openObject(this->m->encryption_dict_objid); + m->encryption_dict_objid = openObject(m->encryption_dict_objid); writeString("<<"); - for (auto const& iter: this->m->encryption_dictionary) { + for (auto const& iter: m->encryption_dictionary) { writeString(" "); writeString(iter.first); writeString(" "); writeString(iter.second); } writeString(" >>"); - closeObject(this->m->encryption_dict_objid); + closeObject(m->encryption_dict_objid); } std::string QPDFWriter::getFinalVersion() { doWriteSetup(); - return this->m->final_pdf_version; + return m->final_pdf_version; } void QPDFWriter::writeHeader() { writeString("%PDF-"); - writeString(this->m->final_pdf_version); - if (this->m->pclm) { + writeString(m->final_pdf_version); + if (m->pclm) { // PCLm version writeString("\n%PCLm 1.0\n"); } else { @@ -2489,13 +2470,7 @@ QPDFWriter::writeHintStream(int hint_id) int S = 0; int O = 0; QPDF::Writer::generateHintStream( - this->m->pdf, - this->m->xref, - this->m->lengths, - this->m->obj_renumber_no_gen, - hint_buffer, - S, - O); + m->pdf, m->xref, m->lengths, m->obj_renumber_no_gen, hint_buffer, S, O); openObject(hint_id); setDataKey(hint_id); @@ -2513,7 +2488,7 @@ QPDFWriter::writeHintStream(int hint_id) writeString(std::to_string(hlen)); writeString(" >>\nstream\n"); - if (this->m->encrypted) { + if (m->encrypted) { QTC::TC("qpdf", "QPDFWriter encrypted hint stream"); } unsigned char last_char = '\0'; @@ -2521,7 +2496,7 @@ QPDFWriter::writeHintStream(int hint_id) PipelinePopper pp_enc(this); pushEncryptionFilter(pp_enc); writeBuffer(hint_buffer); - last_char = this->m->pipeline->getLastChar(); + last_char = m->pipeline->getLastChar(); } if (last_char != '\n') { @@ -2557,7 +2532,7 @@ QPDFWriter::writeXRefTable( writeString(std::to_string(first)); writeString(" "); writeString(std::to_string(last - first + 1)); - qpdf_offset_t space_before_zero = this->m->pipeline->getCount(); + qpdf_offset_t space_before_zero = m->pipeline->getCount(); writeString("\n"); for (int i = first; i <= last; ++i) { if (i == 0) { @@ -2565,7 +2540,7 @@ QPDFWriter::writeXRefTable( } else { qpdf_offset_t offset = 0; if (!suppress_offsets) { - offset = this->m->xref[i].getOffset(); + offset = m->xref[i].getOffset(); if ((hint_id != 0) && (i != hint_id) && (offset >= hint_offset)) { offset += hint_length; @@ -2625,7 +2600,7 @@ QPDFWriter::writeXRefStream( bool skip_compression, int linearization_pass) { - qpdf_offset_t xref_offset = this->m->pipeline->getCount(); + qpdf_offset_t xref_offset = m->pipeline->getCount(); qpdf_offset_t space_before_zero = xref_offset - 1; // field 1 contains offsets and object stream identifiers @@ -2633,19 +2608,18 @@ QPDFWriter::writeXRefStream( std::max(bytesNeeded(max_offset + hint_length), bytesNeeded(max_id)); // field 2 contains object stream indices - unsigned int f2_size = bytesNeeded(this->m->max_ostream_index); + unsigned int f2_size = bytesNeeded(m->max_ostream_index); unsigned int esize = 1 + f1_size + f2_size; // Must store in xref table in advance of writing the actual data // rather than waiting for openObject to do it. - this->m->xref[xref_id] = QPDFXRefEntry(m->pipeline->getCount()); + m->xref[xref_id] = QPDFXRefEntry(m->pipeline->getCount()); Pipeline* p = pushPipeline(new Pl_Buffer("xref stream")); bool compressed = false; - if ((this->m->compress_streams || - (this->m->stream_decode_level == qpdf_dl_none)) && - (!this->m->qdf_mode)) { + if ((m->compress_streams || (m->stream_decode_level == qpdf_dl_none)) && + (!m->qdf_mode)) { compressed = true; if (!skip_compression) { // Write the stream dictionary for compression but don't @@ -2662,7 +2636,7 @@ QPDFWriter::writeXRefStream( PipelinePopper pp_xref(this, &xref_data); activatePipelineStack(pp_xref); for (int i = first; i <= last; ++i) { - QPDFXRefEntry& e = this->m->xref[i]; + QPDFXRefEntry& e = m->xref[i]; switch (e.getType()) { case 0: writeBinary(0, 1); @@ -2781,8 +2755,7 @@ QPDFWriter::writeLinearized() // Optimize file and enqueue objects in order discardGeneration( - this->m->object_to_object_stream, - this->m->object_to_object_stream_no_gen); + m->object_to_object_stream, m->object_to_object_stream_no_gen); auto skip_stream_parameters = [this](QPDFObjectHandle& stream) { bool compress_stream; @@ -2794,8 +2767,8 @@ QPDFWriter::writeLinearized() } }; - this->m->pdf.optimize( - this->m->object_to_object_stream_no_gen, true, skip_stream_parameters); + m->pdf.optimize( + m->object_to_object_stream_no_gen, true, skip_stream_parameters); std::vector part4; std::vector part6; @@ -2803,8 +2776,8 @@ QPDFWriter::writeLinearized() std::vector part8; std::vector part9; QPDF::Writer::getLinearizedParts( - this->m->pdf, - this->m->object_to_object_stream_no_gen, + m->pdf, + m->object_to_object_stream_no_gen, part4, part6, part7, @@ -2832,11 +2805,11 @@ QPDFWriter::writeLinearized() QIntC::to_int(part7.size() + part8.size() + part9.size()); int second_half_first_obj = 1; int after_second_half = 1 + second_half_uncompressed; - this->m->next_objid = after_second_half; + m->next_objid = after_second_half; int second_half_xref = 0; - bool need_xref_stream = (!this->m->object_to_object_stream.empty()); + bool need_xref_stream = (!m->object_to_object_stream.empty()); if (need_xref_stream) { - second_half_xref = this->m->next_objid++; + second_half_xref = m->next_objid++; } // Assign numbers to all compressed objects in the second half. std::vector* vecs2[] = {&part7, &part8, &part9}; @@ -2845,26 +2818,26 @@ QPDFWriter::writeLinearized() assignCompressedObjectNumbers(oh.getObjGen()); } } - int second_half_end = this->m->next_objid - 1; - int second_trailer_size = this->m->next_objid; + int second_half_end = m->next_objid - 1; + int second_trailer_size = m->next_objid; // First half objects - int first_half_start = this->m->next_objid; - int lindict_id = this->m->next_objid++; + int first_half_start = m->next_objid; + int lindict_id = m->next_objid++; int first_half_xref = 0; if (need_xref_stream) { - first_half_xref = this->m->next_objid++; - } - int part4_first_obj = this->m->next_objid; - this->m->next_objid += QIntC::to_int(part4.size()); - int after_part4 = this->m->next_objid; - if (this->m->encrypted) { - this->m->encryption_dict_objid = this->m->next_objid++; - } - int hint_id = this->m->next_objid++; - int part6_first_obj = this->m->next_objid; - this->m->next_objid += QIntC::to_int(part6.size()); - int after_part6 = this->m->next_objid; + first_half_xref = m->next_objid++; + } + int part4_first_obj = m->next_objid; + m->next_objid += QIntC::to_int(part4.size()); + int after_part4 = m->next_objid; + if (m->encrypted) { + m->encryption_dict_objid = m->next_objid++; + } + int hint_id = m->next_objid++; + int part6_first_obj = m->next_objid; + m->next_objid += QIntC::to_int(part6.size()); + int after_part6 = m->next_objid; // Assign numbers to all compressed objects in the first half std::vector* vecs1[] = {&part4, &part6}; for (int i = 0; i < 2; ++i) { @@ -2872,8 +2845,8 @@ QPDFWriter::writeLinearized() assignCompressedObjectNumbers(oh.getObjGen()); } } - int first_half_end = this->m->next_objid - 1; - int first_trailer_size = this->m->next_objid; + int first_half_end = m->next_objid - 1; + int first_trailer_size = m->next_objid; int part4_end_marker = part4.back().getObjectID(); int part6_end_marker = part6.back().getObjectID(); @@ -2885,26 +2858,26 @@ QPDFWriter::writeLinearized() qpdf_offset_t first_xref_end = 0; qpdf_offset_t second_xref_end = 0; - this->m->next_objid = part4_first_obj; + m->next_objid = part4_first_obj; enqueuePart(part4); - if (this->m->next_objid != after_part4) { + if (m->next_objid != after_part4) { // This can happen with very botched files as in the fuzzer // test. There are likely some faulty assumptions in // calculateLinearizationData throw std::runtime_error("error encountered after" " writing part 4 of linearized data"); } - this->m->next_objid = part6_first_obj; + m->next_objid = part6_first_obj; enqueuePart(part6); - if (this->m->next_objid != after_part6) { + if (m->next_objid != after_part6) { throw std::runtime_error("error encountered after" " writing part 6 of linearized data"); } - this->m->next_objid = second_half_first_obj; + m->next_objid = second_half_first_obj; enqueuePart(part7); enqueuePart(part8); enqueuePart(part9); - if (this->m->next_objid != after_second_half) { + if (m->next_objid != after_second_half) { throw std::runtime_error("error encountered after" " writing part 9 of linearized data"); } @@ -2919,16 +2892,16 @@ QPDFWriter::writeLinearized() auto pp_md5 = std::make_shared(this); for (int pass = 1; pass <= 2; ++pass) { if (pass == 1) { - if (!this->m->lin_pass1_filename.empty()) { - lin_pass1_file = QUtil::safe_fopen( - this->m->lin_pass1_filename.c_str(), "wb"); + if (!m->lin_pass1_filename.empty()) { + lin_pass1_file = + QUtil::safe_fopen(m->lin_pass1_filename.c_str(), "wb"); pushPipeline( new Pl_StdioFile("linearization pass1", lin_pass1_file)); activatePipelineStack(*pp_pass1); } else { pushDiscardFilter(*pp_pass1); } - if (this->m->deterministic_id) { + if (m->deterministic_id) { pushMD5Pipeline(*pp_md5); } } @@ -2945,14 +2918,12 @@ QPDFWriter::writeLinearized() // dictionary must appear within the first 1024 characters of // the file. - qpdf_offset_t pos = this->m->pipeline->getCount(); + qpdf_offset_t pos = m->pipeline->getCount(); openObject(lindict_id); writeString("<<"); if (pass == 2) { - std::vector const& pages = - this->m->pdf.getAllPages(); - int first_page_object = - this->m->obj_renumber[pages.at(0).getObjGen()]; + std::vector const& pages = m->pdf.getAllPages(); + int first_page_object = m->obj_renumber[pages.at(0).getObjGen()]; int npages = QIntC::to_int(pages.size()); writeString(" /Linearized 1 /L "); @@ -2960,7 +2931,7 @@ QPDFWriter::writeLinearized() // Implementation note 121 states that a space is // mandatory after this open bracket. writeString(" /H [ "); - writeString(std::to_string(this->m->xref[hint_id].getOffset())); + writeString(std::to_string(m->xref[hint_id].getOffset())); writeString(" "); writeString(std::to_string(hint_length)); writeString(" ] /O "); @@ -2975,19 +2946,19 @@ QPDFWriter::writeLinearized() writeString(" >>"); closeObject(lindict_id); static int const pad = 200; - writePad(QIntC::to_size(pos - this->m->pipeline->getCount() + pad)); + writePad(QIntC::to_size(pos - m->pipeline->getCount() + pad)); writeString("\n"); // If the user supplied any additional header text, write it // here after the linearization parameter dictionary. - writeString(this->m->extra_header_text); + writeString(m->extra_header_text); // Part 3: first page cross reference table and trailer. - qpdf_offset_t first_xref_offset = this->m->pipeline->getCount(); + qpdf_offset_t first_xref_offset = m->pipeline->getCount(); qpdf_offset_t hint_offset = 0; if (pass == 2) { - hint_offset = this->m->xref[hint_id].getOffset(); + hint_offset = m->xref[hint_id].getOffset(); } if (need_xref_stream) { // Must pad here too. @@ -3002,7 +2973,7 @@ QPDFWriter::writeLinearized() // it's smaller. first_half_max_obj_offset = 1 << 25; } - pos = this->m->pipeline->getCount(); + pos = m->pipeline->getCount(); writeXRefStream( first_half_xref, first_half_end, @@ -3017,18 +2988,18 @@ QPDFWriter::writeLinearized() hint_length, (pass == 1), pass); - qpdf_offset_t endpos = this->m->pipeline->getCount(); + qpdf_offset_t endpos = m->pipeline->getCount(); if (pass == 1) { // Pad so we have enough room for the real xref // stream. writePad(calculateXrefStreamPadding(endpos - pos)); - first_xref_end = this->m->pipeline->getCount(); + first_xref_end = m->pipeline->getCount(); } else { // Pad so that the next object starts at the same // place as in pass 1. writePad(QIntC::to_size(first_xref_end - endpos)); - if (this->m->pipeline->getCount() != first_xref_end) { + if (m->pipeline->getCount() != first_xref_end) { throw std::logic_error( "insufficient padding for first pass xref stream; " "first_xref_end=" + @@ -3054,25 +3025,24 @@ QPDFWriter::writeLinearized() // Parts 4 through 9 - for (auto const& cur_object: this->m->object_queue) { + for (auto const& cur_object: m->object_queue) { if (cur_object.getObjectID() == part6_end_marker) { - first_half_max_obj_offset = this->m->pipeline->getCount(); + first_half_max_obj_offset = m->pipeline->getCount(); } writeObject(cur_object); if (cur_object.getObjectID() == part4_end_marker) { - if (this->m->encrypted) { + if (m->encrypted) { writeEncryptionDictionary(); } if (pass == 1) { - this->m->xref[hint_id] = - QPDFXRefEntry(m->pipeline->getCount()); + m->xref[hint_id] = QPDFXRefEntry(m->pipeline->getCount()); } else { // Part 5: hint stream writeBuffer(hint_buffer); } } if (cur_object.getObjectID() == part6_end_marker) { - part6_end_offset = this->m->pipeline->getCount(); + part6_end_offset = m->pipeline->getCount(); } } @@ -3080,9 +3050,9 @@ QPDFWriter::writeLinearized() // Part 11: main cross reference table and trailer - second_xref_offset = this->m->pipeline->getCount(); + second_xref_offset = m->pipeline->getCount(); if (need_xref_stream) { - pos = this->m->pipeline->getCount(); + pos = m->pipeline->getCount(); space_before_zero = writeXRefStream( second_half_xref, second_half_end, @@ -3097,7 +3067,7 @@ QPDFWriter::writeLinearized() 0, (pass == 1), pass); - qpdf_offset_t endpos = this->m->pipeline->getCount(); + qpdf_offset_t endpos = m->pipeline->getCount(); if (pass == 1) { // Pad so we have enough room for the real xref @@ -3105,18 +3075,17 @@ QPDFWriter::writeLinearized() // how we calculate the padding. writePad(calculateXrefStreamPadding(endpos - pos)); writeString("\n"); - second_xref_end = this->m->pipeline->getCount(); + second_xref_end = m->pipeline->getCount(); } else { // Make the file size the same. writePad(QIntC::to_size( second_xref_end + hint_length - 1 - - this->m->pipeline->getCount())); + m->pipeline->getCount())); writeString("\n"); // If this assertion fails, maybe we didn't have // enough padding above. - if (this->m->pipeline->getCount() != - second_xref_end + hint_length) { + if (m->pipeline->getCount() != second_xref_end + hint_length) { throw std::logic_error("count mismatch after xref stream;" " possible insufficient padding?"); } @@ -3138,26 +3107,26 @@ QPDFWriter::writeLinearized() writeString(std::to_string(first_xref_offset)); writeString("\n%%EOF\n"); - discardGeneration(this->m->obj_renumber, this->m->obj_renumber_no_gen); + discardGeneration(m->obj_renumber, m->obj_renumber_no_gen); if (pass == 1) { - if (this->m->deterministic_id) { + if (m->deterministic_id) { QTC::TC( "qpdf", "QPDFWriter linearized deterministic ID", need_xref_stream ? 0 : 1); computeDeterministicIDData(); pp_md5 = nullptr; - qpdf_assert_debug(this->m->md5_pipeline == nullptr); + qpdf_assert_debug(m->md5_pipeline == nullptr); } // Close first pass pipeline - file_size = this->m->pipeline->getCount(); + file_size = m->pipeline->getCount(); pp_pass1 = nullptr; // Save hint offset since it will be set to zero by // calling openObject. - qpdf_offset_t hint_offset1 = this->m->xref[hint_id].getOffset(); + qpdf_offset_t hint_offset1 = m->xref[hint_id].getOffset(); // Write hint stream to a buffer { @@ -3169,7 +3138,7 @@ QPDFWriter::writeLinearized() hint_length = QIntC::to_offset(hint_buffer->getSize()); // Restore hint offset - this->m->xref[hint_id] = QPDFXRefEntry(hint_offset1); + m->xref[hint_id] = QPDFXRefEntry(hint_offset1); if (lin_pass1_file) { // Write some debugging information fprintf( @@ -3198,9 +3167,9 @@ QPDFWriter::writeLinearized() void QPDFWriter::enqueueObjectsStandard() { - if (this->m->preserve_unreferenced_objects) { + if (m->preserve_unreferenced_objects) { QTC::TC("qpdf", "QPDFWriter preserve unreferenced standard"); - for (auto const& oh: this->m->pdf.getAllObjects()) { + for (auto const& oh: m->pdf.getAllObjects()) { enqueueObject(oh); } } @@ -3227,7 +3196,7 @@ QPDFWriter::enqueueObjectsPCLm() std::string image_transform_content = "q /image Do Q\n"; // enqueue all pages first - std::vector all = this->m->pdf.getAllPages(); + std::vector all = m->pdf.getAllPages(); for (auto& page: all) { // enqueue page enqueueObject(page); @@ -3239,8 +3208,8 @@ QPDFWriter::enqueueObjectsPCLm() QPDFObjectHandle strips = page.getKey("/Resources").getKey("/XObject"); for (auto const& image: strips.getKeys()) { enqueueObject(strips.getKey(image)); - enqueueObject(QPDFObjectHandle::newStream( - &this->m->pdf, image_transform_content)); + enqueueObject( + QPDFObjectHandle::newStream(&m->pdf, image_transform_content)); } } @@ -3253,54 +3222,51 @@ void QPDFWriter::indicateProgress(bool decrement, bool finished) { if (decrement) { - --this->m->events_seen; + --m->events_seen; return; } - ++this->m->events_seen; + ++m->events_seen; - if (!this->m->progress_reporter.get()) { + if (!m->progress_reporter.get()) { return; } - if (finished || (this->m->events_seen >= this->m->next_progress_report)) { + if (finished || (m->events_seen >= m->next_progress_report)) { int percentage = (finished ? 100 - : this->m->next_progress_report == 0 + : m->next_progress_report == 0 ? 0 : std::min( - 99, - 1 + - ((100 * this->m->events_seen) / - this->m->events_expected))); - this->m->progress_reporter->reportProgress(percentage); + 99, 1 + ((100 * m->events_seen) / m->events_expected))); + m->progress_reporter->reportProgress(percentage); } - int increment = std::max(1, (this->m->events_expected / 100)); - while (this->m->events_seen >= this->m->next_progress_report) { - this->m->next_progress_report += increment; + int increment = std::max(1, (m->events_expected / 100)); + while (m->events_seen >= m->next_progress_report) { + m->next_progress_report += increment; } } void QPDFWriter::registerProgressReporter(std::shared_ptr pr) { - this->m->progress_reporter = pr; + m->progress_reporter = pr; } void QPDFWriter::writeStandard() { auto pp_md5 = std::make_shared(this); - if (this->m->deterministic_id) { + if (m->deterministic_id) { pushMD5Pipeline(*pp_md5); } // Start writing writeHeader(); - writeString(this->m->extra_header_text); + writeString(m->extra_header_text); - if (this->m->pclm) { + if (m->pclm) { enqueueObjectsPCLm(); } else { enqueueObjectsStandard(); @@ -3314,38 +3280,37 @@ QPDFWriter::writeStandard() } // Write out the encryption dictionary, if any - if (this->m->encrypted) { + if (m->encrypted) { writeEncryptionDictionary(); } // Now write out xref. next_objid is now the number of objects. - qpdf_offset_t xref_offset = this->m->pipeline->getCount(); - if (this->m->object_stream_to_objects.empty()) { + qpdf_offset_t xref_offset = m->pipeline->getCount(); + if (m->object_stream_to_objects.empty()) { // Write regular cross-reference table - writeXRefTable( - t_normal, 0, this->m->next_objid - 1, this->m->next_objid); + writeXRefTable(t_normal, 0, m->next_objid - 1, m->next_objid); } else { // Write cross-reference stream. - int xref_id = this->m->next_objid++; + int xref_id = m->next_objid++; writeXRefStream( xref_id, xref_id, xref_offset, t_normal, 0, - this->m->next_objid - 1, - this->m->next_objid); + m->next_objid - 1, + m->next_objid); } writeString("startxref\n"); writeString(std::to_string(xref_offset)); writeString("\n%%EOF\n"); - if (this->m->deterministic_id) { + if (m->deterministic_id) { QTC::TC( "qpdf", "QPDFWriter standard deterministic ID", - this->m->object_stream_to_objects.empty() ? 0 : 1); + m->object_stream_to_objects.empty() ? 0 : 1); pp_md5 = nullptr; - qpdf_assert_debug(this->m->md5_pipeline == nullptr); + qpdf_assert_debug(m->md5_pipeline == nullptr); } } -- cgit v1.2.3-70-g09d2