From f7978db1f604083c16733952d2b01d3b0f4b0a6a Mon Sep 17 00:00:00 2001 From: m-holger Date: Sat, 23 Jul 2022 16:48:28 +0100 Subject: [PATCH] QPDFObjGen : tidy QPDF private methods Change method signatures to use QPDFObjGen. Use QPDFObjGen methods where possible. Remove redundant QPDF::objGenToIndirect. --- include/qpdf/QPDF.hh | 53 +++++--------- libqpdf/QPDF.cc | 134 +++++++++++++--------------------- libqpdf/QPDFObjectHandle.cc | 2 +- libqpdf/QPDF_Stream.cc | 3 +- libqpdf/QPDF_encryption.cc | 29 +++----- libqpdf/QPDF_json.cc | 8 +- libqpdf/QPDF_linearization.cc | 30 +++----- libqpdf/QPDF_optimization.cc | 4 +- libqpdf/QPDF_pages.cc | 5 +- 9 files changed, 103 insertions(+), 165 deletions(-) diff --git a/include/qpdf/QPDF.hh b/include/qpdf/QPDF.hh index aba3369e..ae5c89e2 100644 --- a/include/qpdf/QPDF.hh +++ b/include/qpdf/QPDF.hh @@ -815,9 +815,9 @@ class QPDF private: static std::shared_ptr - resolve(QPDF* qpdf, int objid, int generation) + resolve(QPDF* qpdf, QPDFObjGen const& og) { - return qpdf->resolve(objid, generation); + return qpdf->resolve(og); } static bool objectChanged( @@ -879,8 +879,7 @@ class QPDF static bool pipeStreamData( QPDF* qpdf, - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t offset, size_t length, QPDFObjectHandle dict, @@ -889,8 +888,7 @@ class QPDF bool will_retry) { return qpdf->pipeStreamData( - objid, - generation, + og, offset, length, dict, @@ -959,8 +957,7 @@ class QPDF std::string user_password; std::string encryption_key; std::string cached_object_encryption_key; - int cached_key_objid; - int cached_key_generation; + QPDFObjGen cached_key_og; bool user_password_matched; bool owner_password_matched; }; @@ -973,8 +970,7 @@ class QPDF ForeignStreamData( std::shared_ptr encp, std::shared_ptr file, - int foreign_objid, - int foreign_generation, + QPDFObjGen const& foreign_og, qpdf_offset_t offset, size_t length, QPDFObjectHandle local_dict); @@ -982,8 +978,7 @@ class QPDF private: std::shared_ptr encp; std::shared_ptr file; - int foreign_objid; - int foreign_generation; + QPDFObjGen foreign_og; qpdf_offset_t offset; size_t length; QPDFObjectHandle local_dict; @@ -1017,14 +1012,13 @@ class QPDF friend class QPDF; public: - StringDecrypter(QPDF* qpdf, int objid, int gen); + StringDecrypter(QPDF* qpdf, QPDFObjGen const& og); virtual ~StringDecrypter() = default; virtual void decryptString(std::string& val); private: QPDF* qpdf; - int objid; - int gen; + QPDFObjGen og; }; class ResolveRecorder @@ -1127,17 +1121,15 @@ class QPDF void insertXrefEntry( int obj, int f0, qpdf_offset_t f1, int f2, bool overwrite = false); void setLastObjectDescription( - std::string const& description, int objid, int generation); + std::string const& description, QPDFObjGen const& og); QPDFObjectHandle readObject( std::shared_ptr, std::string const& description, - int objid, - int generation, + QPDFObjGen const& og, bool in_object_stream); size_t recoverStreamLength( std::shared_ptr input, - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t stream_offset); QPDFTokenizer::Token readToken(std::shared_ptr, size_t max_len = 0); @@ -1149,16 +1141,15 @@ class QPDF QPDFObjGen const& exp_og, QPDFObjGen& og); bool objectChanged(QPDFObjGen const& og, std::shared_ptr& oph); - std::shared_ptr resolve(int objid, int generation); + std::shared_ptr resolve(QPDFObjGen const& og); void resolveObjectsInStream(int obj_stream_number); void stopOnError(std::string const& message); - QPDFObjectHandle reserveObjectIfNotExists(int objid, int gen); - QPDFObjectHandle reserveStream(int objid, int gen); + QPDFObjectHandle reserveObjectIfNotExists(QPDFObjGen const& og); + QPDFObjectHandle reserveStream(QPDFObjGen const& og); // Calls finish() on the pipeline when done but does not delete it bool pipeStreamData( - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t offset, size_t length, QPDFObjectHandle dict, @@ -1174,8 +1165,7 @@ class QPDF std::shared_ptr encp, std::shared_ptr file, QPDF& qpdf_for_warning, - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t offset, size_t length, QPDFObjectHandle dict, @@ -1228,10 +1218,9 @@ class QPDF void initializeEncryption(); static std::string getKeyForObject( std::shared_ptr encp, - int objid, - int generation, + QPDFObjGen const& og, bool use_aes); - void decryptString(std::string&, int objid, int generation); + void decryptString(std::string&, QPDFObjGen const& og); static std::string compute_encryption_key_from_password( std::string const& password, EncryptionData const& data); static std::string recover_encryption_key_with_password( @@ -1245,8 +1234,7 @@ class QPDF std::shared_ptr file, QPDF& qpdf_for_warning, Pipeline*& pipeline, - int objid, - int generation, + QPDFObjGen const& og, QPDFObjectHandle& stream_dict, std::vector>& heap); @@ -1569,7 +1557,6 @@ class QPDF void dumpHSharedObject(); void dumpHGeneric(HGeneric&); qpdf_offset_t adjusted_offset(qpdf_offset_t offset); - QPDFObjectHandle objGenToIndirect(QPDFObjGen const&); void calculateLinearizationData(std::map const& object_stream_data); void pushOutlinesToPart( diff --git a/libqpdf/QPDF.cc b/libqpdf/QPDF.cc index 97303471..a24c17e6 100644 --- a/libqpdf/QPDF.cc +++ b/libqpdf/QPDF.cc @@ -113,15 +113,13 @@ namespace QPDF::ForeignStreamData::ForeignStreamData( std::shared_ptr encp, std::shared_ptr file, - int foreign_objid, - int foreign_generation, + QPDFObjGen const& foreign_og, qpdf_offset_t offset, size_t length, QPDFObjectHandle local_dict) : encp(encp), file(file), - foreign_objid(foreign_objid), - foreign_generation(foreign_generation), + foreign_og(foreign_og), offset(offset), length(length), local_dict(local_dict) @@ -176,17 +174,16 @@ QPDF::CopiedStreamDataProvider::registerForeignStream( this->foreign_stream_data[local_og] = foreign_stream; } -QPDF::StringDecrypter::StringDecrypter(QPDF* qpdf, int objid, int gen) : +QPDF::StringDecrypter::StringDecrypter(QPDF* qpdf, QPDFObjGen const& og) : qpdf(qpdf), - objid(objid), - gen(gen) + og(og) { } void QPDF::StringDecrypter::decryptString(std::string& val) { - qpdf->decryptString(val, objid, gen); + qpdf->decryptString(val, og); } std::string const& @@ -205,8 +202,6 @@ QPDF::EncryptionParameters::EncryptionParameters() : cf_stream(e_none), cf_string(e_none), cf_file(e_none), - cached_key_objid(0), - cached_key_generation(0), user_password_matched(false), owner_password_matched(false) { @@ -631,7 +626,7 @@ QPDF::reconstruct_xref(QPDFExc& e) (!this->m->trailer.isInitialized()) && (t1 == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "trailer"))) { QPDFObjectHandle t = - readObject(this->m->file, "trailer", 0, 0, false); + readObject(this->m->file, "trailer", QPDFObjGen(), false); if (!t.isDictionary()) { // Oh well. It was worth a try. } else { @@ -969,7 +964,7 @@ QPDF::read_xrefTable(qpdf_offset_t xref_offset) // Set offset to previous xref table if any QPDFObjectHandle cur_trailer = - readObject(this->m->file, "trailer", 0, 0, false); + readObject(this->m->file, "trailer", QPDFObjGen(), false); if (!cur_trailer.isDictionary()) { QTC::TC("qpdf", "QPDF missing trailer"); throw QPDFExc( @@ -1341,7 +1336,7 @@ QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2, bool overwrite) break; case 2: - this->m->xref_table[QPDFObjGen(obj, 0)] = QPDFXRefEntry(f0, f1, f2); + this->m->xref_table[QPDFObjGen(obj)] = QPDFXRefEntry(f0, f1, f2); break; default: @@ -1362,7 +1357,7 @@ QPDF::showXRefTable() for (auto const& iter: this->m->xref_table) { QPDFObjGen const& og = iter.first; QPDFXRefEntry const& entry = iter.second; - cout << og.getObj() << "/" << og.getGen() << ": "; + cout << og.unparse('/') << ": "; switch (entry.getType()) { case 1: cout << "uncompressed; offset = " << entry.getOffset(); @@ -1478,18 +1473,17 @@ QPDF::getAllObjects() void QPDF::setLastObjectDescription( - std::string const& description, int objid, int generation) + std::string const& description, QPDFObjGen const& og) { this->m->last_object_description.clear(); if (!description.empty()) { this->m->last_object_description += description; - if (objid > 0) { + if (og.isIndirect()) { this->m->last_object_description += ": "; } } - if (objid > 0) { - this->m->last_object_description += - "object " + QPDFObjGen(objid, generation).unparse(' '); + if (og.isIndirect()) { + this->m->last_object_description += "object " + og.unparse(' '); } } @@ -1497,19 +1491,17 @@ QPDFObjectHandle QPDF::readObject( std::shared_ptr input, std::string const& description, - int objid, - int generation, + QPDFObjGen const& og, bool in_object_stream) { - setLastObjectDescription(description, objid, generation); + setLastObjectDescription(description, og); qpdf_offset_t offset = input->tell(); bool empty = false; std::shared_ptr decrypter_ph; StringDecrypter* decrypter = 0; if (this->m->encp->encrypted && (!in_object_stream)) { - decrypter_ph = - std::make_shared(this, objid, generation); + decrypter_ph = std::make_shared(this, og); decrypter = decrypter_ph.get(); } QPDFObjectHandle object = QPDFObjectHandle::parse( @@ -1651,18 +1643,13 @@ QPDF::readObject( } catch (QPDFExc& e) { if (this->m->attempt_recovery) { warn(e); - length = recoverStreamLength( - input, objid, generation, stream_offset); + length = recoverStreamLength(input, og, stream_offset); } else { throw e; } } object = QPDFObjectHandle::Factory::newStream( - this, - QPDFObjGen(objid, generation), - object, - stream_offset, - length); + this, og, object, stream_offset, length); } else { input->seek(cur_offset, SEEK_SET); } @@ -1690,8 +1677,7 @@ QPDF::findEndstream() size_t QPDF::recoverStreamLength( std::shared_ptr input, - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t stream_offset) { // Try to reconstruct stream length by looking for @@ -1716,11 +1702,10 @@ QPDF::recoverStreamLength( if (length) { qpdf_offset_t this_obj_offset = 0; - QPDFObjGen this_obj(0, 0); + QPDFObjGen this_og; // Make sure this is inside this object for (auto const& iter: this->m->xref_table) { - QPDFObjGen const& og = iter.first; QPDFXRefEntry const& entry = iter.second; if (entry.getType() == 1) { qpdf_offset_t obj_offset = entry.getOffset(); @@ -1728,12 +1713,11 @@ QPDF::recoverStreamLength( ((this_obj_offset == 0) || (this_obj_offset > obj_offset))) { this_obj_offset = obj_offset; - this_obj = og; + this_og = iter.first; } } } - if (this_obj_offset && (this_obj.getObj() == objid) && - (this_obj.getGen() == generation)) { + if (this_obj_offset && (this_og == og)) { // Well, we found endstream\nendobj within the space // allowed for this object, so we're probably in good // shape. @@ -1791,7 +1775,7 @@ QPDF::readObjectAtOffset( check_og = false; try_recovery = false; } else { - setLastObjectDescription(description, exp_og.getObj(), exp_og.getGen()); + setLastObjectDescription(description, exp_og); } if (!this->m->attempt_recovery) { @@ -1895,8 +1879,7 @@ QPDF::readObjectAtOffset( } } - QPDFObjectHandle oh = - readObject(this->m->file, description, og.getObj(), og.getGen(), false); + QPDFObjectHandle oh = readObject(this->m->file, description, og, false); if (!(readToken(this->m->file) == QPDFTokenizer::Token(QPDFTokenizer::tt_word, "endobj"))) { @@ -1972,12 +1955,11 @@ QPDF::objectChanged(QPDFObjGen const& og, std::shared_ptr& oph) } std::shared_ptr -QPDF::resolve(int objid, int generation) +QPDF::resolve(QPDFObjGen const& og) { // Check object cache before checking xref table. This allows us // to insert things into the object cache that don't actually // exist in the file. - QPDFObjGen og(objid, generation); if (this->m->resolving.count(og)) { // This can happen if an object references itself directly or // indirectly in some key that has to be resolved during @@ -2131,13 +2113,13 @@ QPDF::resolveObjectsInStream(int obj_stream_number) // xref table and only cache what would actually be resolved here. for (auto const& iter: offsets) { int obj = iter.first; - QPDFObjGen og(obj, 0); + QPDFObjGen og(obj); QPDFXRefEntry const& entry = this->m->xref_table[og]; if ((entry.getType() == 2) && (entry.getObjStreamNumber() == obj_stream_number)) { int offset = iter.second; input->seek(offset, SEEK_SET); - QPDFObjectHandle oh = readObject(input, "", obj, 0, true); + QPDFObjectHandle oh = readObject(input, "", og, true); this->m->obj_cache[og] = ObjCache( QPDFObjectHandle::ObjAccessor::getObject(oh), end_before_space, @@ -2163,21 +2145,20 @@ QPDF::makeIndirectObject(QPDFObjectHandle oh) } QPDFObjectHandle -QPDF::reserveObjectIfNotExists(int objid, int gen) +QPDF::reserveObjectIfNotExists(QPDFObjGen const& og) { - QPDFObjGen og(objid, gen); if ((!this->m->obj_cache.count(og)) && (!this->m->xref_table.count(og))) { - resolve(objid, gen); - replaceObject(objid, gen, QPDFObjectHandle::Factory::makeReserved()); + resolve(og); + replaceObject(og, QPDFObjectHandle::Factory::makeReserved()); } - return getObjectByID(objid, gen); + return getObjectByObjGen(og); } QPDFObjectHandle -QPDF::reserveStream(int objid, int gen) +QPDF::reserveStream(QPDFObjGen const& og) { return QPDFObjectHandle::Factory::newStream( - this, QPDFObjGen(objid, gen), QPDFObjectHandle::newDictionary(), 0, 0); + this, og, QPDFObjectHandle::newDictionary(), 0, 0); } QPDFObjectHandle @@ -2193,13 +2174,13 @@ QPDF::getObjectByID(int objid, int generation) } void -QPDF::replaceObject(QPDFObjGen const& og, QPDFObjectHandle oh) +QPDF::replaceObject(int objid, int generation, QPDFObjectHandle oh) { - replaceObject(og.getObj(), og.getGen(), oh); + replaceObject(QPDFObjGen(objid, generation), oh); } void -QPDF::replaceObject(int objid, int generation, QPDFObjectHandle oh) +QPDF::replaceObject(QPDFObjGen const& og, QPDFObjectHandle oh) { if (oh.isIndirect()) { QTC::TC("qpdf", "QPDF replaceObject called with indirect object"); @@ -2208,10 +2189,9 @@ QPDF::replaceObject(int objid, int generation, QPDFObjectHandle oh) } // Force new object to appear in the cache - resolve(objid, generation); + resolve(og); // Replace the object in the object cache - QPDFObjGen og(objid, generation); this->m->ever_replaced_objects = true; this->m->obj_cache[og] = ObjCache(QPDFObjectHandle::ObjAccessor::getObject(oh), -1, -1); @@ -2511,8 +2491,7 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign) auto foreign_stream_data = std::make_shared( foreign_stream_qpdf->m->encp, foreign_stream_qpdf->m->file, - foreign.getObjectID(), - foreign.getGeneration(), + foreign.getObjGen(), stream->getOffset(), stream->getLength(), dict); @@ -2526,20 +2505,19 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign) } void -QPDF::swapObjects(QPDFObjGen const& og1, QPDFObjGen const& og2) +QPDF::swapObjects(int objid1, int generation1, int objid2, int generation2) { - swapObjects(og1.getObj(), og1.getGen(), og2.getObj(), og2.getGen()); + swapObjects( + QPDFObjGen(objid1, generation1), QPDFObjGen(objid2, generation2)); } void -QPDF::swapObjects(int objid1, int generation1, int objid2, int generation2) +QPDF::swapObjects(QPDFObjGen const& og1, QPDFObjGen const& og2) { // Force objects to be loaded into cache; then swap them in the // cache. - resolve(objid1, generation1); - resolve(objid2, generation2); - QPDFObjGen og1(objid1, generation1); - QPDFObjGen og2(objid2, generation2); + resolve(og1); + resolve(og2); ObjCache t = this->m->obj_cache[og1]; this->m->ever_replaced_objects = true; this->m->obj_cache[og1] = this->m->obj_cache[og2]; @@ -2723,8 +2701,7 @@ QPDF::pipeStreamData( std::shared_ptr encp, std::shared_ptr file, QPDF& qpdf_for_warning, - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t offset, size_t length, QPDFObjectHandle stream_dict, @@ -2735,14 +2712,7 @@ QPDF::pipeStreamData( std::vector> to_delete; if (encp->encrypted) { decryptStream( - encp, - file, - qpdf_for_warning, - pipeline, - objid, - generation, - stream_dict, - to_delete); + encp, file, qpdf_for_warning, pipeline, og, stream_dict, to_delete); } bool success = false; @@ -2780,8 +2750,7 @@ QPDF::pipeStreamData( "", file->getLastOffset(), ("error decoding stream data for object " + - QPDFObjGen(objid, generation).unparse(' ') + ": " + - e.what()))); + og.unparse(' ') + ": " + e.what()))); if (will_retry) { qpdf_for_warning.warn( // line-break @@ -2807,8 +2776,7 @@ QPDF::pipeStreamData( bool QPDF::pipeStreamData( - int objid, - int generation, + QPDFObjGen const& og, qpdf_offset_t offset, size_t length, QPDFObjectHandle stream_dict, @@ -2820,8 +2788,7 @@ QPDF::pipeStreamData( this->m->encp, this->m->file, *this, - objid, - generation, + og, offset, length, stream_dict, @@ -2844,8 +2811,7 @@ QPDF::pipeForeignStreamData( foreign->encp, foreign->file, *this, - foreign->foreign_objid, - foreign->foreign_generation, + foreign->foreign_og, foreign->offset, foreign->length, foreign->local_dict, diff --git a/libqpdf/QPDFObjectHandle.cc b/libqpdf/QPDFObjectHandle.cc index 779a61ed..e7a98090 100644 --- a/libqpdf/QPDFObjectHandle.cc +++ b/libqpdf/QPDFObjectHandle.cc @@ -3098,7 +3098,7 @@ QPDFObjectHandle::dereference() } if (this->obj.get() == 0) { std::shared_ptr obj = - QPDF::Resolver::resolve(this->qpdf, getObjectID(), getGeneration()); + QPDF::Resolver::resolve(this->qpdf, getObjGen()); if (obj.get() == 0) { // QPDF::resolve never returns an uninitialized object, but // check just in case. diff --git a/libqpdf/QPDF_Stream.cc b/libqpdf/QPDF_Stream.cc index c0644532..c8290286 100644 --- a/libqpdf/QPDF_Stream.cc +++ b/libqpdf/QPDF_Stream.cc @@ -658,8 +658,7 @@ QPDF_Stream::pipeStreamData( QTC::TC("qpdf", "QPDF_Stream pipe original stream data"); if (!QPDF::Pipe::pipeStreamData( this->qpdf, - this->objid, - this->generation, + QPDFObjGen(this->objid, this->generation), this->offset, this->length, this->stream_dict, diff --git a/libqpdf/QPDF_encryption.cc b/libqpdf/QPDF_encryption.cc index 95d5ea37..8c35b992 100644 --- a/libqpdf/QPDF_encryption.cc +++ b/libqpdf/QPDF_encryption.cc @@ -1075,8 +1075,7 @@ QPDF::initializeEncryption() std::string QPDF::getKeyForObject( std::shared_ptr encp, - int objid, - int generation, + QPDFObjGen const& og, bool use_aes) { if (!encp->encrypted) { @@ -1084,26 +1083,24 @@ QPDF::getKeyForObject( "request for encryption key in non-encrypted PDF"); } - if (!((objid == encp->cached_key_objid) && - (generation == encp->cached_key_generation))) { + if (og != encp->cached_key_og) { encp->cached_object_encryption_key = compute_data_key( encp->encryption_key, - objid, - generation, + og.getObj(), + og.getGen(), use_aes, encp->encryption_V, encp->encryption_R); - encp->cached_key_objid = objid; - encp->cached_key_generation = generation; + encp->cached_key_og = og; } return encp->cached_object_encryption_key; } void -QPDF::decryptString(std::string& str, int objid, int generation) +QPDF::decryptString(std::string& str, QPDFObjGen const& og) { - if (objid == 0) { + if (!og.isIndirect()) { return; } bool use_aes = false; @@ -1139,8 +1136,7 @@ QPDF::decryptString(std::string& str, int objid, int generation) } } - std::string key = - getKeyForObject(this->m->encp, objid, generation, use_aes); + std::string key = getKeyForObject(this->m->encp, og, use_aes); try { if (use_aes) { QTC::TC("qpdf", "QPDF_encryption aes decode string"); @@ -1175,8 +1171,8 @@ QPDF::decryptString(std::string& str, int objid, int generation) this->m->file->getName(), this->m->last_object_description, this->m->file->getLastOffset(), - "error decrypting string for object " + - QPDFObjGen(objid, generation).unparse() + ": " + e.what()); + "error decrypting string for object " + og.unparse() + ": " + + e.what()); } } @@ -1186,8 +1182,7 @@ QPDF::decryptStream( std::shared_ptr file, QPDF& qpdf_for_warning, Pipeline*& pipeline, - int objid, - int generation, + QPDFObjGen const& og, QPDFObjectHandle& stream_dict, std::vector>& heap) { @@ -1282,7 +1277,7 @@ QPDF::decryptStream( break; } } - std::string key = getKeyForObject(encp, objid, generation, use_aes); + std::string key = getKeyForObject(encp, og, use_aes); std::shared_ptr new_pipeline; if (use_aes) { QTC::TC("qpdf", "QPDF_encryption aes decode stream"); diff --git a/libqpdf/QPDF_json.cc b/libqpdf/QPDF_json.cc index 1db9018c..5527318c 100644 --- a/libqpdf/QPDF_json.cc +++ b/libqpdf/QPDF_json.cc @@ -371,9 +371,10 @@ QPDF::JSONReactor::containerEnd(JSON const& value) QPDFObjectHandle QPDF::JSONReactor::reserveObject(int obj, int gen) { - auto oh = pdf.reserveObjectIfNotExists(obj, gen); + QPDFObjGen og(obj, gen); + auto oh = pdf.reserveObjectIfNotExists(og); if (oh.isReserved()) { - this->reserved.insert(QPDFObjGen(obj, gen)); + this->reserved.insert(og); } return oh; } @@ -495,8 +496,7 @@ QPDF::JSONReactor::dictionaryItem(std::string const& key, JSON const& value) QTC::TC("qpdf", "QPDF_json updating existing stream"); } else { this->this_stream_needs_data = true; - replacement = - pdf.reserveStream(tos.getObjectID(), tos.getGeneration()); + replacement = pdf.reserveStream(tos.getObjGen()); replaceObject(tos, replacement, value); } } else { diff --git a/libqpdf/QPDF_linearization.cc b/libqpdf/QPDF_linearization.cc index cb4d721f..5fa432e0 100644 --- a/libqpdf/QPDF_linearization.cc +++ b/libqpdf/QPDF_linearization.cc @@ -706,7 +706,7 @@ QPDF::getUncompressedObject( return obj; } else { int repl = (*(object_stream_data.find(obj.getObjectID()))).second; - return objGenToIndirect(QPDFObjGen(repl, 0)); + return getObjectByObjGen(QPDFObjGen(repl)); } } @@ -1143,12 +1143,6 @@ QPDF::dumpHGeneric(HGeneric& t) << "group_length: " << t.group_length << "\n"; } -QPDFObjectHandle -QPDF::objGenToIndirect(QPDFObjGen const& og) -{ - return getObjectByID(og.getObj(), og.getGen()); -} - void QPDF::calculateLinearizationData(std::map const& object_stream_data) { @@ -1387,9 +1381,9 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) stopOnError("found other than one root while" " calculating linearization data"); } - this->m->part4.push_back(objGenToIndirect(*(lc_root.begin()))); + this->m->part4.push_back(getObjectByObjGen(*(lc_root.begin()))); for (auto const& og: lc_open_document) { - this->m->part4.push_back(objGenToIndirect(og)); + this->m->part4.push_back(getObjectByObjGen(og)); } // Part 6: first page objects. Note: implementation note 124 @@ -1418,11 +1412,11 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) // hint tables. for (auto const& og: lc_first_page_private) { - this->m->part6.push_back(objGenToIndirect(og)); + this->m->part6.push_back(getObjectByObjGen(og)); } for (auto const& og: lc_first_page_shared) { - this->m->part6.push_back(objGenToIndirect(og)); + this->m->part6.push_back(getObjectByObjGen(og)); } // Place the outline dictionary if it goes in the first page section. @@ -1468,7 +1462,7 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) for (auto const& og: this->m->obj_user_to_objects[ou]) { if (lc_other_page_private.count(og)) { lc_other_page_private.erase(og); - this->m->part7.push_back(objGenToIndirect(og)); + this->m->part7.push_back(getObjectByObjGen(og)); ++this->m->c_page_offset_data.entries.at(i).nobjects; } } @@ -1485,7 +1479,7 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) // Order is unimportant. for (auto const& og: lc_other_page_shared) { - this->m->part8.push_back(objGenToIndirect(og)); + this->m->part8.push_back(getObjectByObjGen(og)); } // Part 9: other objects @@ -1507,7 +1501,7 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) for (auto const& og: pages_ogs) { if (lc_other.count(og)) { lc_other.erase(og); - this->m->part9.push_back(objGenToIndirect(og)); + this->m->part9.push_back(getObjectByObjGen(og)); } } @@ -1537,7 +1531,7 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) for (auto const& og: ogs) { if (lc_thumbnail_private.count(og)) { lc_thumbnail_private.erase(og); - this->m->part9.push_back(objGenToIndirect(og)); + this->m->part9.push_back(getObjectByObjGen(og)); } } } @@ -1550,7 +1544,7 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) // Place shared thumbnail objects for (auto const& og: lc_thumbnail_shared) { - this->m->part9.push_back(objGenToIndirect(og)); + this->m->part9.push_back(getObjectByObjGen(og)); } // Place outlines unless in first page @@ -1560,7 +1554,7 @@ QPDF::calculateLinearizationData(std::map const& object_stream_data) // Place all remaining objects for (auto const& og: lc_other) { - this->m->part9.push_back(objGenToIndirect(og)); + this->m->part9.push_back(getObjectByObjGen(og)); } // Make sure we got everything exactly once. @@ -1662,7 +1656,7 @@ QPDF::pushOutlinesToPart( lc_outlines.erase(outlines_og); part.push_back(outlines); for (auto const& og: lc_outlines) { - part.push_back(objGenToIndirect(og)); + part.push_back(getObjectByObjGen(og)); ++this->m->c_outline_data.nobjects; } } diff --git a/libqpdf/QPDF_optimization.cc b/libqpdf/QPDF_optimization.cc index 1fd6da6f..cafdbe64 100644 --- a/libqpdf/QPDF_optimization.cc +++ b/libqpdf/QPDF_optimization.cc @@ -252,9 +252,7 @@ QPDF::pushInheritedAttributesToPageInternal( if ((warn_skipped_keys) && (cur_pages.hasKey("/Parent"))) { QTC::TC("qpdf", "QPDF unknown key not inherited"); setLastObjectDescription( - "Pages object", - cur_pages.getObjectID(), - cur_pages.getGeneration()); + "Pages object", cur_pages.getObjGen()); warn( qpdf_e_pages, this->m->last_object_description, diff --git a/libqpdf/QPDF_pages.cc b/libqpdf/QPDF_pages.cc index bd3f80a6..e1a3b2c1 100644 --- a/libqpdf/QPDF_pages.cc +++ b/libqpdf/QPDF_pages.cc @@ -207,8 +207,7 @@ QPDF::insertPageobjToPage( // that causes this to happen. setLastObjectDescription( "page " + QUtil::int_to_string(pos) + " (numbered from zero)", - og.getObj(), - og.getGen()); + og); throw QPDFExc( qpdf_e_pages, this->m->file->getName(), @@ -334,7 +333,7 @@ QPDF::findPage(QPDFObjGen const& og) auto it = this->m->pageobj_to_pages_pos.find(og); if (it == this->m->pageobj_to_pages_pos.end()) { QTC::TC("qpdf", "QPDF_pages findPage not found"); - setLastObjectDescription("page object", og.getObj(), og.getGen()); + setLastObjectDescription("page object", og); throw QPDFExc( qpdf_e_pages, this->m->file->getName(),