From a68703b07e928be0eeb909c0e777e13e88cbf86d Mon Sep 17 00:00:00 2001 From: Jay Berkenbilt Date: Sat, 9 Apr 2022 14:35:56 -0400 Subject: Replace PointerHolder with std::shared_ptr in library sources only (patrepl and cleanpatch are my own utilities) patrepl s/PointerHolder/std::shared_ptr/g {include,libqpdf}/qpdf/*.hh patrepl s/PointerHolder/std::shared_ptr/g libqpdf/*.cc patrepl s/make_pointer_holder/std::make_shared/g libqpdf/*.cc patrepl s/make_array_pointer_holder/QUtil::make_shared_array/g libqpdf/*.cc patrepl s,qpdf/std::shared_ptr,qpdf/PointerHolder, **/*.cc **/*.hh git restore include/qpdf/PointerHolder.hh cleanpatch ./format-code --- libqpdf/Buffer.cc | 2 +- libqpdf/ClosedFileInputSource.cc | 2 +- libqpdf/FileInputSource.cc | 4 +-- libqpdf/OffsetInputSource.cc | 2 +- libqpdf/Pl_Buffer.cc | 12 +++---- libqpdf/Pl_DCT.cc | 2 +- libqpdf/Pl_PNGFilter.cc | 4 +-- libqpdf/Pl_QPDFTokenizer.cc | 2 +- libqpdf/Pl_RC4.cc | 2 +- libqpdf/Pl_TIFFPredictor.cc | 2 +- libqpdf/QPDF.cc | 61 +++++++++++++++++----------------- libqpdf/QPDFAcroFormDocumentHelper.cc | 6 ++-- libqpdf/QPDFEFStreamObjectHelper.cc | 3 +- libqpdf/QPDFFormFieldObjectHelper.cc | 2 +- libqpdf/QPDFJob.cc | 23 +++++++------ libqpdf/QPDFJob_config.cc | 2 +- libqpdf/QPDFObjectHandle.cc | 57 +++++++++++++++---------------- libqpdf/QPDFOutlineDocumentHelper.cc | 2 +- libqpdf/QPDFOutlineObjectHelper.cc | 4 +-- libqpdf/QPDFPageLabelDocumentHelper.cc | 2 +- libqpdf/QPDFPageObjectHelper.cc | 17 +++++----- libqpdf/QPDFTokenizer.cc | 11 +++--- libqpdf/QPDFWriter.cc | 26 +++++++-------- libqpdf/QPDF_Stream.cc | 18 +++++----- libqpdf/QPDF_encryption.cc | 11 +++--- libqpdf/QPDF_linearization.cc | 2 +- libqpdf/QUtil.cc | 20 +++++------ libqpdf/qpdf-c.cc | 31 +++++++++-------- libqpdf/qpdf/JSONHandler.hh | 2 +- libqpdf/qpdf/OffsetInputSource.hh | 5 +-- libqpdf/qpdf/Pl_PNGFilter.hh | 4 +-- libqpdf/qpdf/Pl_RC4.hh | 2 +- libqpdf/qpdf/Pl_TIFFPredictor.hh | 2 +- libqpdf/qpdf/QPDF_Stream.hh | 20 +++++------ 34 files changed, 186 insertions(+), 181 deletions(-) (limited to 'libqpdf') diff --git a/libqpdf/Buffer.cc b/libqpdf/Buffer.cc index af35803a..91bacc8e 100644 --- a/libqpdf/Buffer.cc +++ b/libqpdf/Buffer.cc @@ -52,7 +52,7 @@ void Buffer::copy(Buffer const& rhs) { if (this != &rhs) { - this->m = PointerHolder(new Members(rhs.m->size, 0, true)); + this->m = std::shared_ptr(new Members(rhs.m->size, 0, true)); if (this->m->size) { memcpy(this->m->buf, rhs.m->buf, this->m->size); } diff --git a/libqpdf/ClosedFileInputSource.cc b/libqpdf/ClosedFileInputSource.cc index a4c52c92..69e819c9 100644 --- a/libqpdf/ClosedFileInputSource.cc +++ b/libqpdf/ClosedFileInputSource.cc @@ -26,7 +26,7 @@ void ClosedFileInputSource::before() { if (0 == this->m->fis.get()) { - this->m->fis = make_pointer_holder(); + this->m->fis = std::make_shared(); this->m->fis->setFilename(this->m->filename.c_str()); this->m->fis->seek(this->m->offset, SEEK_SET); this->m->fis->setLastOffset(this->last_offset); diff --git a/libqpdf/FileInputSource.cc b/libqpdf/FileInputSource.cc index 4b36ea0c..c502b2a8 100644 --- a/libqpdf/FileInputSource.cc +++ b/libqpdf/FileInputSource.cc @@ -26,7 +26,7 @@ FileInputSource::FileInputSource() : void FileInputSource::setFilename(char const* filename) { - this->m = PointerHolder(new Members(true)); + this->m = std::shared_ptr(new Members(true)); this->m->filename = filename; this->m->file = QUtil::safe_fopen(filename, "rb"); } @@ -34,7 +34,7 @@ FileInputSource::setFilename(char const* filename) void FileInputSource::setFile(char const* description, FILE* filep, bool close_file) { - this->m = PointerHolder(new Members(close_file)); + this->m = std::shared_ptr(new Members(close_file)); this->m->filename = description; this->m->file = filep; this->seek(0, SEEK_SET); diff --git a/libqpdf/OffsetInputSource.cc b/libqpdf/OffsetInputSource.cc index 4a828386..cf050f2e 100644 --- a/libqpdf/OffsetInputSource.cc +++ b/libqpdf/OffsetInputSource.cc @@ -5,7 +5,7 @@ #include OffsetInputSource::OffsetInputSource( - PointerHolder proxied, qpdf_offset_t global_offset) : + std::shared_ptr proxied, qpdf_offset_t global_offset) : proxied(proxied), global_offset(global_offset) { diff --git a/libqpdf/Pl_Buffer.cc b/libqpdf/Pl_Buffer.cc index dba91e0f..a65a97f5 100644 --- a/libqpdf/Pl_Buffer.cc +++ b/libqpdf/Pl_Buffer.cc @@ -30,13 +30,13 @@ void Pl_Buffer::write(unsigned char* buf, size_t len) { if (this->m->data.get() == 0) { - this->m->data = make_pointer_holder(len); + this->m->data = std::make_shared(len); } size_t cur_size = this->m->data->getSize(); size_t left = cur_size - this->m->total_size; if (left < len) { size_t new_size = std::max(this->m->total_size + len, 2 * cur_size); - auto b = make_pointer_holder(new_size); + auto b = std::make_shared(new_size); memcpy(b->getBuffer(), this->m->data->getBuffer(), this->m->total_size); this->m->data = b; } @@ -72,14 +72,14 @@ Pl_Buffer::getBuffer() unsigned char* p = b->getBuffer(); memcpy(p, this->m->data->getBuffer(), this->m->total_size); } - this->m = PointerHolder(new Members()); + this->m = std::shared_ptr(new Members()); return b; } -PointerHolder +std::shared_ptr Pl_Buffer::getBufferSharedPointer() { - return PointerHolder(getBuffer()); + return std::shared_ptr(getBuffer()); } void @@ -97,5 +97,5 @@ Pl_Buffer::getMallocBuffer(unsigned char** buf, size_t* len) } else { *buf = nullptr; } - this->m = PointerHolder(new Members()); + this->m = std::shared_ptr(new Members()); } diff --git a/libqpdf/Pl_DCT.cc b/libqpdf/Pl_DCT.cc index 90e8a676..974a6327 100644 --- a/libqpdf/Pl_DCT.cc +++ b/libqpdf/Pl_DCT.cc @@ -95,7 +95,7 @@ Pl_DCT::finish() { this->m->buf.finish(); - // Using a PointerHolder here and passing it into compress + // Using a std::shared_ptr here and passing it into compress // and decompress causes a memory leak with setjmp/longjmp. Just // use a pointer and delete it. Buffer* b = this->m->buf.getBuffer(); diff --git a/libqpdf/Pl_PNGFilter.cc b/libqpdf/Pl_PNGFilter.cc index 14754fd1..dea8db9f 100644 --- a/libqpdf/Pl_PNGFilter.cc +++ b/libqpdf/Pl_PNGFilter.cc @@ -48,9 +48,9 @@ Pl_PNGFilter::Pl_PNGFilter( } this->bytes_per_row = bpr & UINT_MAX; this->buf1 = - make_array_pointer_holder(this->bytes_per_row + 1); + QUtil::make_shared_array(this->bytes_per_row + 1); this->buf2 = - make_array_pointer_holder(this->bytes_per_row + 1); + QUtil::make_shared_array(this->bytes_per_row + 1); memset(this->buf1.get(), 0, this->bytes_per_row + 1); memset(this->buf2.get(), 0, this->bytes_per_row + 1); this->cur_row = this->buf1.get(); diff --git a/libqpdf/Pl_QPDFTokenizer.cc b/libqpdf/Pl_QPDFTokenizer.cc index 1f2b35b4..dfca0b5d 100644 --- a/libqpdf/Pl_QPDFTokenizer.cc +++ b/libqpdf/Pl_QPDFTokenizer.cc @@ -44,7 +44,7 @@ void Pl_QPDFTokenizer::finish() { this->m->buf.finish(); - auto input = PointerHolder( + auto input = std::shared_ptr( // line-break new BufferInputSource( "tokenizer data", this->m->buf.getBuffer(), true)); diff --git a/libqpdf/Pl_RC4.cc b/libqpdf/Pl_RC4.cc index 17da3f53..b8d9645a 100644 --- a/libqpdf/Pl_RC4.cc +++ b/libqpdf/Pl_RC4.cc @@ -12,7 +12,7 @@ Pl_RC4::Pl_RC4( out_bufsize(out_bufsize), rc4(key_data, key_len) { - this->outbuf = make_array_pointer_holder(out_bufsize); + this->outbuf = QUtil::make_shared_array(out_bufsize); } Pl_RC4::~Pl_RC4() diff --git a/libqpdf/Pl_TIFFPredictor.cc b/libqpdf/Pl_TIFFPredictor.cc index 628e075b..9230f895 100644 --- a/libqpdf/Pl_TIFFPredictor.cc +++ b/libqpdf/Pl_TIFFPredictor.cc @@ -41,7 +41,7 @@ Pl_TIFFPredictor::Pl_TIFFPredictor( } this->bytes_per_row = bpr & UINT_MAX; this->cur_row = - make_array_pointer_holder(this->bytes_per_row); + QUtil::make_shared_array(this->bytes_per_row); memset(this->cur_row.get(), 0, this->bytes_per_row); } diff --git a/libqpdf/QPDF.cc b/libqpdf/QPDF.cc index a6c7621e..6a571c8c 100644 --- a/libqpdf/QPDF.cc +++ b/libqpdf/QPDF.cc @@ -106,8 +106,8 @@ class InvalidInputSource: public InputSource }; QPDF::ForeignStreamData::ForeignStreamData( - PointerHolder encp, - PointerHolder file, + std::shared_ptr encp, + std::shared_ptr file, int foreign_objid, int foreign_generation, qpdf_offset_t offset, @@ -138,7 +138,7 @@ QPDF::CopiedStreamDataProvider::provideStreamData( bool suppress_warnings, bool will_retry) { - PointerHolder foreign_data = + std::shared_ptr foreign_data = this->foreign_stream_data[QPDFObjGen(objid, generation)]; bool result = false; if (foreign_data.get()) { @@ -165,7 +165,8 @@ QPDF::CopiedStreamDataProvider::registerForeignStream( void QPDF::CopiedStreamDataProvider::registerForeignStream( - QPDFObjGen const& local_og, PointerHolder foreign_stream) + QPDFObjGen const& local_og, + std::shared_ptr foreign_stream) { this->foreign_stream_data[local_og] = foreign_stream; } @@ -249,7 +250,7 @@ QPDF::~QPDF() // If two objects are mutually referential (through each object // having an array or dictionary that contains an indirect // reference to the other), the circular references in the - // PointerHolder objects will prevent the objects from being + // std::shared_ptr objects will prevent the objects from being // deleted. Walk through all objects in the object cache, which // is those objects that we read from the file, and break all // resolved references. At this point, obviously no one is still @@ -274,7 +275,7 @@ QPDF::processFile(char const* filename, char const* password) { FileInputSource* fi = new FileInputSource(); fi->setFilename(filename); - processInputSource(PointerHolder(fi), password); + processInputSource(std::shared_ptr(fi), password); } void @@ -283,7 +284,7 @@ QPDF::processFile( { FileInputSource* fi = new FileInputSource(); fi->setFile(description, filep, close_file); - processInputSource(PointerHolder(fi), password); + processInputSource(std::shared_ptr(fi), password); } void @@ -294,7 +295,7 @@ QPDF::processMemoryFile( char const* password) { processInputSource( - PointerHolder( + std::shared_ptr( // line-break new BufferInputSource( description, @@ -305,7 +306,7 @@ QPDF::processMemoryFile( void QPDF::processInputSource( - PointerHolder source, char const* password) + std::shared_ptr source, char const* password) { this->m->file = source; parse(password); @@ -314,7 +315,7 @@ QPDF::processInputSource( void QPDF::closeInputSource() { - this->m->file = PointerHolder(new InvalidInputSource()); + this->m->file = std::shared_ptr(new InvalidInputSource()); } void @@ -425,7 +426,7 @@ QPDF::findHeader() // offsets in the file are such that 0 points to the // beginning of the header. QTC::TC("qpdf", "QPDF global offset"); - this->m->file = PointerHolder( + this->m->file = std::shared_ptr( new OffsetInputSource(this->m->file, global_offset)); } } @@ -1182,7 +1183,7 @@ QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj) // that this multiplication does not cause an overflow. size_t expected_size = entry_size * num_entries; - PointerHolder bp = xref_obj.getStreamData(qpdf_dl_specialized); + std::shared_ptr bp = xref_obj.getStreamData(qpdf_dl_specialized); size_t actual_size = bp->getSize(); if (expected_size != actual_size) { @@ -1516,7 +1517,7 @@ QPDF::setLastObjectDescription( QPDFObjectHandle QPDF::readObject( - PointerHolder input, + std::shared_ptr input, std::string const& description, int objid, int generation, @@ -1526,11 +1527,11 @@ QPDF::readObject( qpdf_offset_t offset = input->tell(); bool empty = false; - PointerHolder decrypter_ph; + std::shared_ptr decrypter_ph; StringDecrypter* decrypter = 0; if (this->m->encp->encrypted && (!in_object_stream)) { decrypter_ph = - make_pointer_holder(this, objid, generation); + std::make_shared(this, objid, generation); decrypter = decrypter_ph.get(); } QPDFObjectHandle object = QPDFObjectHandle::parse( @@ -1706,7 +1707,7 @@ QPDF::findEndstream() size_t QPDF::recoverStreamLength( - PointerHolder input, + std::shared_ptr input, int objid, int generation, qpdf_offset_t stream_offset) @@ -1784,7 +1785,7 @@ QPDF::recoverStreamLength( } QPDFTokenizer::Token -QPDF::readToken(PointerHolder input, size_t max_len) +QPDF::readToken(std::shared_ptr input, size_t max_len) { return this->m->tokenizer.readToken( input, this->m->last_object_description, true, max_len); @@ -1971,7 +1972,7 @@ QPDF::readObjectAtOffset( } bool -QPDF::objectChanged(QPDFObjGen const& og, PointerHolder& oph) +QPDF::objectChanged(QPDFObjGen const& og, std::shared_ptr& oph) { // See if the object cached at og, if any, is the one passed in. // QPDFObjectHandle uses this to detect outdated handles to @@ -1992,7 +1993,7 @@ QPDF::objectChanged(QPDFObjGen const& og, PointerHolder& oph) return (c->second.object.get() != oph.get()); } -PointerHolder +std::shared_ptr QPDF::resolve(int objid, int generation) { // Check object cache before checking xref table. This allows us @@ -2011,7 +2012,7 @@ QPDF::resolve(int objid, int generation) this->m->file->getLastOffset(), ("loop detected resolving object " + QUtil::int_to_string(objid) + " " + QUtil::int_to_string(generation)))); - return PointerHolder(new QPDF_Null); + return std::shared_ptr(new QPDF_Null); } ResolveRecorder rr(this, og); @@ -2071,7 +2072,7 @@ QPDF::resolve(int objid, int generation) ObjCache(QPDFObjectHandle::ObjAccessor::getObject(oh), -1, -1); } - PointerHolder result(this->m->obj_cache[og].object); + std::shared_ptr result(this->m->obj_cache[og].object); if (!result->hasDescription()) { result->setDescription( this, @@ -2135,8 +2136,8 @@ QPDF::resolveObjectsInStream(int obj_stream_number) std::map offsets; - PointerHolder bp = obj_stream.getStreamData(qpdf_dl_specialized); - auto input = PointerHolder( + std::shared_ptr bp = obj_stream.getStreamData(qpdf_dl_specialized); + auto input = std::shared_ptr( // line-break new BufferInputSource( (this->m->file->getName() + " object stream " + @@ -2496,7 +2497,7 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign) this->m->copied_stream_data_provider = new CopiedStreamDataProvider(*this); this->m->copied_streams = - PointerHolder( + std::shared_ptr( this->m->copied_stream_data_provider); } QPDFObjGen local_og(result.getObjGen()); @@ -2513,7 +2514,7 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign) throw std::logic_error("unable to retrieve underlying" " stream object from foreign stream"); } - PointerHolder stream_buffer = stream->getStreamDataBuffer(); + std::shared_ptr stream_buffer = stream->getStreamDataBuffer(); if ((foreign_stream_qpdf->m->immediate_copy_from) && (stream_buffer.get() == 0)) { // Pull the stream data into a buffer before attempting @@ -2527,7 +2528,7 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign) old_dict.getKey("/DecodeParms")); stream_buffer = stream->getStreamDataBuffer(); } - PointerHolder stream_provider = + std::shared_ptr stream_provider = stream->getStreamDataProvider(); if (stream_buffer.get()) { QTC::TC("qpdf", "QPDF copy foreign stream with buffer"); @@ -2543,7 +2544,7 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign) dict.getKey("/Filter"), dict.getKey("/DecodeParms")); } else { - auto foreign_stream_data = make_pointer_holder( + auto foreign_stream_data = std::make_shared( foreign_stream_qpdf->m->encp, foreign_stream_qpdf->m->file, foreign.getObjectID(), @@ -2758,8 +2759,8 @@ QPDF::getCompressibleObjGens() bool QPDF::pipeStreamData( - PointerHolder encp, - PointerHolder file, + std::shared_ptr encp, + std::shared_ptr file, QPDF& qpdf_for_warning, int objid, int generation, @@ -2870,7 +2871,7 @@ QPDF::pipeStreamData( bool QPDF::pipeForeignStreamData( - PointerHolder foreign, + std::shared_ptr foreign, Pipeline* pipeline, bool suppress_warnings, bool will_retry) diff --git a/libqpdf/QPDFAcroFormDocumentHelper.cc b/libqpdf/QPDFAcroFormDocumentHelper.cc index 276fc542..8a01f556 100644 --- a/libqpdf/QPDFAcroFormDocumentHelper.cc +++ b/libqpdf/QPDFAcroFormDocumentHelper.cc @@ -772,7 +772,7 @@ QPDFAcroFormDocumentHelper::adjustAppearanceStream( QTC::TC("qpdf", "QPDFAcroFormDocumentHelper AP parse error"); } auto rr = new ResourceReplacer(dr_map, rf.getNamesByResourceType()); - auto tf = PointerHolder(rr); + auto tf = std::shared_ptr(rr); stream.addTokenFilter(tf); } catch (std::exception& e) { // No way to reproduce in test suite right now since error @@ -792,13 +792,13 @@ QPDFAcroFormDocumentHelper::transformAnnotations( QPDF* from_qpdf, QPDFAcroFormDocumentHelper* from_afdh) { - PointerHolder afdhph; + std::shared_ptr afdhph; if (!from_qpdf) { // Assume these are from the same QPDF. from_qpdf = &this->qpdf; from_afdh = this; } else if ((from_qpdf != &this->qpdf) && (!from_afdh)) { - afdhph = make_pointer_holder(*from_qpdf); + afdhph = std::make_shared(*from_qpdf); from_afdh = afdhph.get(); } bool foreign = (from_qpdf != &this->qpdf); diff --git a/libqpdf/QPDFEFStreamObjectHelper.cc b/libqpdf/QPDFEFStreamObjectHelper.cc index de11e30f..6b3555bf 100644 --- a/libqpdf/QPDFEFStreamObjectHelper.cc +++ b/libqpdf/QPDFEFStreamObjectHelper.cc @@ -92,7 +92,8 @@ QPDFEFStreamObjectHelper::getChecksum() } QPDFEFStreamObjectHelper -QPDFEFStreamObjectHelper::createEFStream(QPDF& qpdf, PointerHolder data) +QPDFEFStreamObjectHelper::createEFStream( + QPDF& qpdf, std::shared_ptr data) { return newFromStream(QPDFObjectHandle::newStream(&qpdf, data)); } diff --git a/libqpdf/QPDFFormFieldObjectHelper.cc b/libqpdf/QPDFFormFieldObjectHelper.cc index ffec2683..917e9339 100644 --- a/libqpdf/QPDFFormFieldObjectHelper.cc +++ b/libqpdf/QPDFFormFieldObjectHelper.cc @@ -915,6 +915,6 @@ QPDFFormFieldObjectHelper::generateTextAppearance( AS.addTokenFilter( // line-break - PointerHolder( + std::shared_ptr( new ValueSetter(DA, V, opt, tf, bbox))); } diff --git a/libqpdf/QPDFJob.cc b/libqpdf/QPDFJob.cc index 99cf867f..f714c5d2 100644 --- a/libqpdf/QPDFJob.cc +++ b/libqpdf/QPDFJob.cc @@ -1879,7 +1879,7 @@ QPDFJob::processFile( std::shared_ptr QPDFJob::processInputSource( - PointerHolder is, char const* password, bool used_for_input) + std::shared_ptr is, char const* password, bool used_for_input) { auto f1 = std::mem_fn(&QPDF::processInputSource); auto fn = std::bind(f1, std::placeholders::_1, is, std::placeholders::_2); @@ -2238,7 +2238,7 @@ QPDFJob::handleTransformations(QPDF& pdf) m->oi_min_height, m->oi_min_area, image); - PointerHolder sdp(io); + std::shared_ptr sdp(io); if (io->evaluate( "image " + name + " on page " + QUtil::int_to_string(pageno))) { @@ -2494,17 +2494,17 @@ QPDFJob::handlePageSpecs( cout << prefix << ": processing " << page_spec.filename << std::endl; }); - PointerHolder is; + std::shared_ptr is; ClosedFileInputSource* cis = 0; if (!m->keep_files_open) { QTC::TC("qpdf", "QPDFJob keep files open n"); cis = new ClosedFileInputSource(page_spec.filename.c_str()); - is = PointerHolder(cis); + is = std::shared_ptr(cis); cis->stayOpen(true); } else { QTC::TC("qpdf", "QPDFJob keep files open y"); FileInputSource* fis = new FileInputSource(); - is = PointerHolder(fis); + is = std::shared_ptr(fis); fis->setFilename(page_spec.filename.c_str()); } std::shared_ptr qpdf_ph = @@ -3064,12 +3064,13 @@ QPDFJob::setWriterOptions(QPDF& pdf, QPDFWriter& w) w.forcePDFVersion(version, extension_level); } if (m->progress && m->outfilename) { - w.registerProgressReporter(PointerHolder( - // line-break - new ProgressReporter( - *(this->m->cout), - this->m->message_prefix, - m->outfilename.get()))); + w.registerProgressReporter( + std::shared_ptr( + // line-break + new ProgressReporter( + *(this->m->cout), + this->m->message_prefix, + m->outfilename.get()))); } } diff --git a/libqpdf/QPDFJob_config.cc b/libqpdf/QPDFJob_config.cc index 286e4056..8bd9cc2e 100644 --- a/libqpdf/QPDFJob_config.cc +++ b/libqpdf/QPDFJob_config.cc @@ -685,7 +685,7 @@ QPDFJob::Config::showObject(std::string const& parameter) QPDFJob::Config* QPDFJob::Config::jobJsonFile(std::string const& parameter) { - PointerHolder file_buf; + std::shared_ptr file_buf; size_t size; QUtil::read_file_into_memory(parameter.c_str(), file_buf, size); try { diff --git a/libqpdf/QPDFObjectHandle.cc b/libqpdf/QPDFObjectHandle.cc index b142f432..d6fe8b9e 100644 --- a/libqpdf/QPDFObjectHandle.cc +++ b/libqpdf/QPDFObjectHandle.cc @@ -252,7 +252,7 @@ QPDFObjectHandle::setObjectDescriptionFromInput( QPDFObjectHandle object, QPDF* context, std::string const& description, - PointerHolder input, + std::shared_ptr input, qpdf_offset_t offset) { object.setObjectDescription( @@ -1337,14 +1337,14 @@ QPDFObjectHandle::replaceDict(QPDFObjectHandle new_dict) dynamic_cast(obj.get())->replaceDict(new_dict); } -PointerHolder +std::shared_ptr QPDFObjectHandle::getStreamData(qpdf_stream_decode_level_e level) { assertStream(); return dynamic_cast(obj.get())->getStreamData(level); } -PointerHolder +std::shared_ptr QPDFObjectHandle::getRawStreamData() { assertStream(); @@ -1410,7 +1410,7 @@ QPDFObjectHandle::pipeStreamData( void QPDFObjectHandle::replaceStreamData( - PointerHolder data, + std::shared_ptr data, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms) { @@ -1426,7 +1426,7 @@ QPDFObjectHandle::replaceStreamData( QPDFObjectHandle const& decode_parms) { assertStream(); - auto b = make_pointer_holder(data.length()); + auto b = std::make_shared(data.length()); unsigned char* bp = b->getBuffer(); memcpy(bp, data.c_str(), data.length()); dynamic_cast(obj.get())->replaceStreamData( @@ -1435,7 +1435,7 @@ QPDFObjectHandle::replaceStreamData( void QPDFObjectHandle::replaceStreamData( - PointerHolder provider, + std::shared_ptr provider, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms) { @@ -1487,7 +1487,7 @@ QPDFObjectHandle::replaceStreamData( { assertStream(); auto sdp = - PointerHolder(new FunctionProvider(provider)); + std::shared_ptr(new FunctionProvider(provider)); dynamic_cast(obj.get())->replaceStreamData( sdp, filter, decode_parms); } @@ -1500,7 +1500,7 @@ QPDFObjectHandle::replaceStreamData( { assertStream(); auto sdp = - PointerHolder(new FunctionProvider(provider)); + std::shared_ptr(new FunctionProvider(provider)); dynamic_cast(obj.get())->replaceStreamData( sdp, filter, decode_parms); } @@ -1694,7 +1694,7 @@ QPDFObjectHandle::coalesceContentStreams() QPDFObjectHandle new_contents = newStream(qpdf); this->replaceKey("/Contents", new_contents); - auto provider = PointerHolder( + auto provider = std::shared_ptr( new CoalesceProvider(*this, contents)); new_contents.replaceStreamData(provider, newNull(), newNull()); } @@ -1772,7 +1772,7 @@ QPDFObjectHandle::parse( std::string const& object_str, std::string const& object_description) { - auto input = PointerHolder( + auto input = std::shared_ptr( new BufferInputSource("parsed object", object_str)); QPDFTokenizer tokenizer; bool empty = false; @@ -1908,13 +1908,13 @@ QPDFObjectHandle::parseContentStream_internal( void QPDFObjectHandle::parseContentStream_data( - PointerHolder stream_data, + std::shared_ptr stream_data, std::string const& description, ParserCallbacks* callbacks, QPDF* context) { size_t stream_length = stream_data->getSize(); - auto input = PointerHolder( + auto input = std::shared_ptr( new BufferInputSource(description, stream_data.get())); QPDFTokenizer tokenizer; tokenizer.allowEOF(); @@ -1969,14 +1969,14 @@ QPDFObjectHandle::parseContentStream_data( } void -QPDFObjectHandle::addContentTokenFilter(PointerHolder filter) +QPDFObjectHandle::addContentTokenFilter(std::shared_ptr filter) { coalesceContentStreams(); this->getKey("/Contents").addTokenFilter(filter); } void -QPDFObjectHandle::addTokenFilter(PointerHolder filter) +QPDFObjectHandle::addTokenFilter(std::shared_ptr filter) { assertStream(); return dynamic_cast(obj.get())->addTokenFilter(filter); @@ -1984,7 +1984,7 @@ QPDFObjectHandle::addTokenFilter(PointerHolder filter) QPDFObjectHandle QPDFObjectHandle::parse( - PointerHolder input, + std::shared_ptr input, std::string const& object_description, QPDFTokenizer& tokenizer, bool& empty, @@ -1997,7 +1997,7 @@ QPDFObjectHandle::parse( QPDFObjectHandle QPDFObjectHandle::parseInternal( - PointerHolder input, + std::shared_ptr input, std::string const& object_description, QPDFTokenizer& tokenizer, bool& empty, @@ -2698,7 +2698,7 @@ QPDFObjectHandle::newStream(QPDF* qpdf) } QPDFObjectHandle -QPDFObjectHandle::newStream(QPDF* qpdf, PointerHolder data) +QPDFObjectHandle::newStream(QPDF* qpdf, std::shared_ptr data) { QTC::TC("qpdf", "QPDFObjectHandle newStream with data"); QPDFObjectHandle result = newStream(qpdf); @@ -2836,26 +2836,27 @@ QPDFObjectHandle::copyObject( this->objid = 0; this->generation = 0; - PointerHolder new_obj; + std::shared_ptr new_obj; if (isBool()) { QTC::TC("qpdf", "QPDFObjectHandle clone bool"); - new_obj = PointerHolder(new QPDF_Bool(getBoolValue())); + new_obj = std::shared_ptr(new QPDF_Bool(getBoolValue())); } else if (isNull()) { QTC::TC("qpdf", "QPDFObjectHandle clone null"); - new_obj = PointerHolder(new QPDF_Null()); + new_obj = std::shared_ptr(new QPDF_Null()); } else if (isInteger()) { QTC::TC("qpdf", "QPDFObjectHandle clone integer"); - new_obj = PointerHolder(new QPDF_Integer(getIntValue())); + new_obj = std::shared_ptr(new QPDF_Integer(getIntValue())); } else if (isReal()) { QTC::TC("qpdf", "QPDFObjectHandle clone real"); - new_obj = PointerHolder(new QPDF_Real(getRealValue())); + new_obj = std::shared_ptr(new QPDF_Real(getRealValue())); } else if (isName()) { QTC::TC("qpdf", "QPDFObjectHandle clone name"); - new_obj = PointerHolder(new QPDF_Name(getName())); + new_obj = std::shared_ptr(new QPDF_Name(getName())); } else if (isString()) { QTC::TC("qpdf", "QPDFObjectHandle clone string"); - new_obj = PointerHolder(new QPDF_String(getStringValue())); + new_obj = + std::shared_ptr(new QPDF_String(getStringValue())); } else if (isArray()) { QTC::TC("qpdf", "QPDFObjectHandle clone array"); std::vector items; @@ -2868,7 +2869,7 @@ QPDFObjectHandle::copyObject( visited, cross_indirect, first_level_only, stop_at_streams); } } - new_obj = PointerHolder(new QPDF_Array(items)); + new_obj = std::shared_ptr(new QPDF_Array(items)); } else if (isDictionary()) { QTC::TC("qpdf", "QPDFObjectHandle clone dictionary"); std::set keys = getKeys(); @@ -2883,7 +2884,7 @@ QPDFObjectHandle::copyObject( visited, cross_indirect, first_level_only, stop_at_streams); } } - new_obj = PointerHolder(new QPDF_Dictionary(items)); + new_obj = std::shared_ptr(new QPDF_Dictionary(items)); } else { throw std::logic_error("QPDFObjectHandle::makeDirectInternal: " "unknown object type"); @@ -3172,12 +3173,12 @@ QPDFObjectHandle::dereference() this->obj = nullptr; } if (this->obj.get() == 0) { - PointerHolder obj = + std::shared_ptr obj = QPDF::Resolver::resolve(this->qpdf, this->objid, this->generation); if (obj.get() == 0) { // QPDF::resolve never returns an uninitialized object, but // check just in case. - this->obj = PointerHolder(new QPDF_Null()); + this->obj = std::shared_ptr(new QPDF_Null()); } else if (dynamic_cast(obj.get())) { // Do not resolve } else { diff --git a/libqpdf/QPDFOutlineDocumentHelper.cc b/libqpdf/QPDFOutlineDocumentHelper.cc index 6f3711de..3f30ebe0 100644 --- a/libqpdf/QPDFOutlineDocumentHelper.cc +++ b/libqpdf/QPDFOutlineDocumentHelper.cc @@ -100,7 +100,7 @@ QPDFOutlineDocumentHelper::resolveNamedDest(QPDFObjectHandle name) QPDFObjectHandle dests = names.getKey("/Dests"); if (dests.isDictionary()) { this->m->names_dest = - make_pointer_holder( + std::make_shared( dests, this->qpdf); } } diff --git a/libqpdf/QPDFOutlineObjectHelper.cc b/libqpdf/QPDFOutlineObjectHelper.cc index 713c1412..0c2a30b4 100644 --- a/libqpdf/QPDFOutlineObjectHelper.cc +++ b/libqpdf/QPDFOutlineObjectHelper.cc @@ -31,13 +31,13 @@ QPDFOutlineObjectHelper::QPDFOutlineObjectHelper( QPDFObjectHandle cur = oh.getKey("/First"); while (!cur.isNull()) { QPDFOutlineObjectHelper new_ooh(cur, dh, 1 + depth); - new_ooh.m->parent = make_pointer_holder(*this); + new_ooh.m->parent = std::make_shared(*this); this->m->kids.push_back(new_ooh); cur = cur.getKey("/Next"); } } -PointerHolder +std::shared_ptr QPDFOutlineObjectHelper::getParent() { return this->m->parent; diff --git a/libqpdf/QPDFPageLabelDocumentHelper.cc b/libqpdf/QPDFPageLabelDocumentHelper.cc index d626be1a..05f080f0 100644 --- a/libqpdf/QPDFPageLabelDocumentHelper.cc +++ b/libqpdf/QPDFPageLabelDocumentHelper.cc @@ -16,7 +16,7 @@ QPDFPageLabelDocumentHelper::QPDFPageLabelDocumentHelper(QPDF& qpdf) : { QPDFObjectHandle root = qpdf.getRoot(); if (root.hasKey("/PageLabels")) { - this->m->labels = make_pointer_holder( + this->m->labels = std::make_shared( root.getKey("/PageLabels"), this->qpdf); } } diff --git a/libqpdf/QPDFPageObjectHelper.cc b/libqpdf/QPDFPageObjectHelper.cc index 988068f3..4706cb27 100644 --- a/libqpdf/QPDFPageObjectHelper.cc +++ b/libqpdf/QPDFPageObjectHelper.cc @@ -556,7 +556,7 @@ QPDFPageObjectHelper::pipeContents(Pipeline* p) void QPDFPageObjectHelper::addContentTokenFilter( - PointerHolder token_filter) + std::shared_ptr token_filter) { if (this->oh.isFormXObject()) { this->oh.addTokenFilter(token_filter); @@ -776,7 +776,7 @@ QPDFPageObjectHelper::getFormXObjectForPage(bool handle_transformations) " XObject created from page will not work"); } newdict.replaceKey("/BBox", bbox); - auto provider = PointerHolder( + auto provider = std::shared_ptr( new ContentProvider(this->oh)); result.replaceStreamData( provider, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull()); @@ -1060,9 +1060,9 @@ QPDFPageObjectHelper::flattenRotation(QPDFAcroFormDocumentHelper* afdh) std::vector new_annots; std::vector new_fields; std::set old_fields; - PointerHolder afdhph; + std::shared_ptr afdhph; if (!afdh) { - afdhph = make_pointer_holder(*qpdf); + afdhph = std::make_shared(*qpdf); afdh = afdhph.get(); } afdh->transformAnnotations( @@ -1101,10 +1101,10 @@ QPDFPageObjectHelper::copyAnnotations( std::vector new_annots; std::vector new_fields; std::set old_fields; - PointerHolder afdhph; - PointerHolder from_afdhph; + std::shared_ptr afdhph; + std::shared_ptr from_afdhph; if (!afdh) { - afdhph = make_pointer_holder(*this_qpdf); + afdhph = std::make_shared(*this_qpdf); afdh = afdhph.get(); } if (this_qpdf == from_qpdf) { @@ -1116,8 +1116,7 @@ QPDFPageObjectHelper::copyAnnotations( " is not from the same QPDF as from_page"); } } else { - from_afdhph = - make_pointer_holder(*from_qpdf); + from_afdhph = std::make_shared(*from_qpdf); from_afdh = from_afdhph.get(); } diff --git a/libqpdf/QPDFTokenizer.cc b/libqpdf/QPDFTokenizer.cc index ade64cb2..0486fbc9 100644 --- a/libqpdf/QPDFTokenizer.cc +++ b/libqpdf/QPDFTokenizer.cc @@ -23,7 +23,8 @@ is_delimiter(char ch) class QPDFWordTokenFinder: public InputSource::Finder { public: - QPDFWordTokenFinder(PointerHolder is, std::string const& str) : + QPDFWordTokenFinder( + std::shared_ptr is, std::string const& str) : is(is), str(str) { @@ -34,7 +35,7 @@ class QPDFWordTokenFinder: public InputSource::Finder virtual bool check(); private: - PointerHolder is; + std::shared_ptr is; std::string str; }; @@ -503,7 +504,7 @@ QPDFTokenizer::presentEOF() } void -QPDFTokenizer::expectInlineImage(PointerHolder input) +QPDFTokenizer::expectInlineImage(std::shared_ptr input) { if (this->m->state != st_top) { throw std::logic_error("QPDFTokenizer::expectInlineImage called" @@ -514,7 +515,7 @@ QPDFTokenizer::expectInlineImage(PointerHolder input) } void -QPDFTokenizer::findEI(PointerHolder input) +QPDFTokenizer::findEI(std::shared_ptr input) { if (!input.get()) { return; @@ -645,7 +646,7 @@ QPDFTokenizer::betweenTokens() QPDFTokenizer::Token QPDFTokenizer::readToken( - PointerHolder input, + std::shared_ptr input, std::string const& context, bool allow_bad, size_t max_len) diff --git a/libqpdf/QPDFWriter.cc b/libqpdf/QPDFWriter.cc index f8320899..ef7c33ed 100644 --- a/libqpdf/QPDFWriter.cc +++ b/libqpdf/QPDFWriter.cc @@ -153,10 +153,10 @@ QPDFWriter::getBuffer() return result; } -PointerHolder +std::shared_ptr QPDFWriter::getBufferSharedPointer() { - return PointerHolder(getBuffer()); + return std::shared_ptr(getBuffer()); } void @@ -1081,7 +1081,7 @@ QPDFWriter::writeString(std::string const& str) } void -QPDFWriter::writeBuffer(PointerHolder& b) +QPDFWriter::writeBuffer(std::shared_ptr& b) { this->m->pipeline->write(b->getBuffer(), b->getSize()); } @@ -1485,7 +1485,7 @@ QPDFWriter::willFilterStream( QPDFObjectHandle stream, bool& compress_stream, bool& is_metadata, - PointerHolder* stream_data) + std::shared_ptr* stream_data) { compress_stream = false; is_metadata = false; @@ -1819,7 +1819,7 @@ QPDFWriter::unparseObject( flags |= f_stream; bool compress_stream = false; bool is_metadata = false; - PointerHolder stream_data; + std::shared_ptr stream_data; if (willFilterStream( object, compress_stream, is_metadata, &stream_data)) { flags |= f_filtered; @@ -1924,7 +1924,7 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) // Generate stream itself. We have to do this in two passes so we // can calculate offsets in the first pass. - PointerHolder stream_buffer; + std::shared_ptr stream_buffer; int first_obj = -1; bool compressed = false; for (int pass = 1; pass <= 2; ++pass) { @@ -2667,7 +2667,7 @@ QPDFWriter::writeHeader() void QPDFWriter::writeHintStream(int hint_id) { - PointerHolder hint_buffer; + std::shared_ptr hint_buffer; int S = 0; int O = 0; QPDF::Writer::generateHintStream( @@ -2839,7 +2839,7 @@ QPDFWriter::writeXRefStream( p = pushPipeline( new Pl_PNGFilter("pngify xref", p, Pl_PNGFilter::a_encode, esize)); } - PointerHolder xref_data; + std::shared_ptr xref_data; { PipelinePopper pp_xref(this, &xref_data); activatePipelineStack(pp_xref); @@ -3098,13 +3098,13 @@ QPDFWriter::writeLinearized() } qpdf_offset_t hint_length = 0; - PointerHolder hint_buffer; + std::shared_ptr hint_buffer; // Write file in two passes. Part numbers refer to PDF spec 1.4. FILE* lin_pass1_file = 0; - auto pp_pass1 = make_pointer_holder(this); - auto pp_md5 = make_pointer_holder(this); + auto pp_pass1 = std::make_shared(this); + auto pp_md5 = std::make_shared(this); for (int pass = 1; pass <= 2; ++pass) { if (pass == 1) { if (!this->m->lin_pass1_filename.empty()) { @@ -3489,7 +3489,7 @@ QPDFWriter::indicateProgress(bool decrement, bool finished) } void -QPDFWriter::registerProgressReporter(PointerHolder pr) +QPDFWriter::registerProgressReporter(std::shared_ptr pr) { this->m->progress_reporter = pr; } @@ -3497,7 +3497,7 @@ QPDFWriter::registerProgressReporter(PointerHolder pr) void QPDFWriter::writeStandard() { - auto pp_md5 = make_pointer_holder(this); + auto pp_md5 = std::make_shared(this); if (this->m->deterministic_id) { pushMD5Pipeline(*pp_md5); } diff --git a/libqpdf/QPDF_Stream.cc b/libqpdf/QPDF_Stream.cc index 1521cc99..219f159a 100644 --- a/libqpdf/QPDF_Stream.cc +++ b/libqpdf/QPDF_Stream.cc @@ -221,19 +221,19 @@ QPDF_Stream::getLength() const return this->length; } -PointerHolder +std::shared_ptr QPDF_Stream::getStreamDataBuffer() const { return this->stream_data; } -PointerHolder +std::shared_ptr QPDF_Stream::getStreamDataProvider() const { return this->stream_provider; } -PointerHolder +std::shared_ptr QPDF_Stream::getStreamData(qpdf_stream_decode_level_e decode_level) { Pl_Buffer buf("stream data buffer"); @@ -251,7 +251,7 @@ QPDF_Stream::getStreamData(qpdf_stream_decode_level_e decode_level) return buf.getBufferSharedPointer(); } -PointerHolder +std::shared_ptr QPDF_Stream::getRawStreamData() { Pl_Buffer buf("stream data buffer"); @@ -438,7 +438,7 @@ QPDF_Stream::pipeStreamData( // objects. std::vector> to_delete; - PointerHolder normalizer; + std::shared_ptr normalizer; std::shared_ptr new_pipeline; if (filter) { if (encode_flags & qpdf_ef_compress) { @@ -449,7 +449,7 @@ QPDF_Stream::pipeStreamData( } if (encode_flags & qpdf_ef_normalize) { - normalizer = make_pointer_holder(); + normalizer = std::make_shared(); new_pipeline = std::make_shared( "normalizer", normalizer.get(), pipeline); to_delete.push_back(new_pipeline); @@ -586,7 +586,7 @@ QPDF_Stream::pipeStreamData( void QPDF_Stream::replaceStreamData( - PointerHolder data, + std::shared_ptr data, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms) { @@ -597,7 +597,7 @@ QPDF_Stream::replaceStreamData( void QPDF_Stream::replaceStreamData( - PointerHolder provider, + std::shared_ptr provider, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms) { @@ -608,7 +608,7 @@ QPDF_Stream::replaceStreamData( void QPDF_Stream::addTokenFilter( - PointerHolder token_filter) + std::shared_ptr token_filter) { this->token_filters.push_back(token_filter); } diff --git a/libqpdf/QPDF_encryption.cc b/libqpdf/QPDF_encryption.cc index 86e2a906..8166fc0d 100644 --- a/libqpdf/QPDF_encryption.cc +++ b/libqpdf/QPDF_encryption.cc @@ -754,7 +754,8 @@ QPDF::recover_encryption_key_with_password( } QPDF::encryption_method_e -QPDF::interpretCF(PointerHolder encp, QPDFObjectHandle cf) +QPDF::interpretCF( + std::shared_ptr encp, QPDFObjectHandle cf) { if (cf.isName()) { std::string filter = cf.getName(); @@ -1079,7 +1080,7 @@ QPDF::initializeEncryption() std::string QPDF::getKeyForObject( - PointerHolder encp, + std::shared_ptr encp, int objid, int generation, bool use_aes) @@ -1165,7 +1166,7 @@ QPDF::decryptString(std::string& str, int objid, int generation) } else { QTC::TC("qpdf", "QPDF_encryption rc4 decode string"); size_t vlen = str.length(); - // Using PointerHolder guarantees that tmp will + // Using std::shared_ptr guarantees that tmp will // be freed even if rc4.process throws an exception. auto tmp = QUtil::make_unique_cstr(str); RC4 rc4(QUtil::unsigned_char_pointer(key), toI(key.length())); @@ -1188,8 +1189,8 @@ QPDF::decryptString(std::string& str, int objid, int generation) void QPDF::decryptStream( - PointerHolder encp, - PointerHolder file, + std::shared_ptr encp, + std::shared_ptr file, QPDF& qpdf_for_warning, Pipeline*& pipeline, int objid, diff --git a/libqpdf/QPDF_linearization.cc b/libqpdf/QPDF_linearization.cc index 7c5fa4fa..cdeb89a9 100644 --- a/libqpdf/QPDF_linearization.cc +++ b/libqpdf/QPDF_linearization.cc @@ -2120,7 +2120,7 @@ QPDF::generateHintStream( std::map const& xref, std::map const& lengths, std::map const& obj_renumber, - PointerHolder& hint_buffer, + std::shared_ptr& hint_buffer, int& S, int& O) { diff --git a/libqpdf/QUtil.cc b/libqpdf/QUtil.cc index 11ced38d..42b9e017 100644 --- a/libqpdf/QUtil.cc +++ b/libqpdf/QUtil.cc @@ -445,7 +445,7 @@ QUtil::os_wrapper(std::string const& description, int status) } #ifdef _WIN32 -static PointerHolder +static std::shared_ptr win_convert_filename(char const* filename) { // Convert the utf-8 encoded filename argument to wchar_t*. First, @@ -454,7 +454,7 @@ win_convert_filename(char const* filename) std::string u16 = QUtil::utf8_to_utf16(filename); size_t len = u16.length(); size_t wlen = (len / 2) - 1; - PointerHolder wfilenamep(true, new wchar_t[wlen + 1]); + auto wfilenamep = QUtil::make_shared_array(wlen + 1); wchar_t* wfilename = wfilenamep.get(); wfilename[wlen] = 0; for (unsigned int i = 2; i < len; i += 2) { @@ -471,9 +471,9 @@ QUtil::safe_fopen(char const* filename, char const* mode) { FILE* f = 0; #ifdef _WIN32 - PointerHolder wfilenamep = win_convert_filename(filename); + std::shared_ptr wfilenamep = win_convert_filename(filename); wchar_t* wfilename = wfilenamep.get(); - PointerHolder wmodep(true, new wchar_t[strlen(mode) + 1]); + auto wmodep = QUtil::make_shared_array(strlen(mode) + 1); wchar_t* wmode = wmodep.get(); wmode[strlen(mode)] = 0; for (size_t i = 0; i < strlen(mode); ++i) { @@ -612,7 +612,7 @@ void QUtil::remove_file(char const* path) { #ifdef _WIN32 - PointerHolder wpath = win_convert_filename(path); + std::shared_ptr wpath = win_convert_filename(path); os_wrapper(std::string("remove ") + path, _wunlink(wpath.get())); #else os_wrapper(std::string("remove ") + path, unlink(path)); @@ -628,8 +628,8 @@ QUtil::rename_file(char const* oldname, char const* newname) } catch (QPDFSystemError&) { // ignore } - PointerHolder wold = win_convert_filename(oldname); - PointerHolder wnew = win_convert_filename(newname); + std::shared_ptr wold = win_convert_filename(oldname); + std::shared_ptr wnew = win_convert_filename(newname); os_wrapper( std::string("rename ") + oldname + " " + newname, _wrename(wold.get(), wnew.get())); @@ -824,7 +824,7 @@ QUtil::get_env(std::string const& var, std::string* value) } if (value) { - PointerHolder t = PointerHolder(true, new char[len + 1]); + auto t = QUtil::make_shared_array(len + 1); ::GetEnvironmentVariable(var.c_str(), t.get(), len); *value = t.get(); } @@ -1173,14 +1173,14 @@ QUtil::is_number(char const* p) void QUtil::read_file_into_memory( - char const* filename, PointerHolder& file_buf, size_t& size) + char const* filename, std::shared_ptr& file_buf, size_t& size) { FILE* f = safe_fopen(filename, "rb"); FileCloser fc(f); fseek(f, 0, SEEK_END); size = QIntC::to_size(QUtil::tell(f)); fseek(f, 0, SEEK_SET); - file_buf = make_array_pointer_holder(size); + file_buf = QUtil::make_shared_array(size); char* buf_p = file_buf.get(); size_t bytes_read = 0; size_t len = 0; diff --git a/libqpdf/qpdf-c.cc b/libqpdf/qpdf-c.cc index c8d92a75..46c553eb 100644 --- a/libqpdf/qpdf-c.cc +++ b/libqpdf/qpdf-c.cc @@ -18,7 +18,7 @@ struct _qpdf_error { - PointerHolder exc; + std::shared_ptr exc; }; struct _qpdf_data @@ -26,10 +26,10 @@ struct _qpdf_data _qpdf_data(); ~_qpdf_data(); - PointerHolder qpdf; - PointerHolder qpdf_writer; + std::shared_ptr qpdf; + std::shared_ptr qpdf_writer; - PointerHolder error; + std::shared_ptr error; _qpdf_error tmp_error; std::list warnings; std::string tmp_string; @@ -40,12 +40,12 @@ struct _qpdf_data unsigned long long size; char const* password; bool write_memory; - PointerHolder output_buffer; + std::shared_ptr output_buffer; // QPDFObjectHandle support bool silence_errors; bool oh_error_occurred; - std::map> oh_cache; + std::map> oh_cache; qpdf_oh next_oh; std::set cur_iter_dict_keys; std::set::const_iterator dict_iter; @@ -111,13 +111,13 @@ static void call_init_write(qpdf_data qpdf) { qpdf->qpdf_writer = - make_pointer_holder(*(qpdf->qpdf), qpdf->filename); + std::make_shared(*(qpdf->qpdf), qpdf->filename); } static void call_init_write_memory(qpdf_data qpdf) { - qpdf->qpdf_writer = make_pointer_holder(*(qpdf->qpdf)); + qpdf->qpdf_writer = std::make_shared(*(qpdf->qpdf)); qpdf->qpdf_writer->setOutputMemory(); } @@ -144,15 +144,15 @@ trap_errors(qpdf_data qpdf, std::function fn) try { fn(qpdf); } catch (QPDFExc& e) { - qpdf->error = make_pointer_holder(e); + qpdf->error = std::make_shared(e); status |= QPDF_ERRORS; } catch (std::runtime_error& e) { qpdf->error = - make_pointer_holder(qpdf_e_system, "", "", 0, e.what()); + std::make_shared(qpdf_e_system, "", "", 0, e.what()); status |= QPDF_ERRORS; } catch (std::exception& e) { qpdf->error = - make_pointer_holder(qpdf_e_internal, "", "", 0, e.what()); + std::make_shared(qpdf_e_internal, "", "", 0, e.what()); status |= QPDF_ERRORS; } @@ -175,7 +175,7 @@ qpdf_init() { QTC::TC("qpdf", "qpdf-c called qpdf_init"); qpdf_data qpdf = new _qpdf_data(); - qpdf->qpdf = make_pointer_holder(); + qpdf->qpdf = std::make_shared(); return qpdf; } @@ -241,8 +241,7 @@ qpdf_error qpdf_next_warning(qpdf_data qpdf) { if (qpdf_more_warnings(qpdf)) { - qpdf->tmp_error.exc = - make_pointer_holder(qpdf->warnings.front()); + qpdf->tmp_error.exc = std::make_shared(qpdf->warnings.front()); qpdf->warnings.pop_front(); QTC::TC("qpdf", "qpdf-c qpdf_next_warning returned warning"); return &qpdf->tmp_error; @@ -974,7 +973,7 @@ qpdf_register_progress_reporter( { QTC::TC("qpdf", "qpdf-c registered progress reporter"); qpdf->qpdf_writer->registerProgressReporter( - PointerHolder( + std::shared_ptr( new ProgressReporter(report_progress, data))); } @@ -1035,7 +1034,7 @@ static qpdf_oh new_object(qpdf_data qpdf, QPDFObjectHandle const& qoh) { qpdf_oh oh = ++qpdf->next_oh; // never return 0 - qpdf->oh_cache[oh] = make_pointer_holder(qoh); + qpdf->oh_cache[oh] = std::make_shared(qoh); return oh; } diff --git a/libqpdf/qpdf/JSONHandler.hh b/libqpdf/qpdf/JSONHandler.hh index a77d2b53..e44ec161 100644 --- a/libqpdf/qpdf/JSONHandler.hh +++ b/libqpdf/qpdf/JSONHandler.hh @@ -125,7 +125,7 @@ class JSONHandler Handlers h; }; - PointerHolder m; + std::shared_ptr m; }; #endif // JSONHANDLER_HH diff --git a/libqpdf/qpdf/OffsetInputSource.hh b/libqpdf/qpdf/OffsetInputSource.hh index fef23760..0d7266dd 100644 --- a/libqpdf/qpdf/OffsetInputSource.hh +++ b/libqpdf/qpdf/OffsetInputSource.hh @@ -10,7 +10,8 @@ class OffsetInputSource: public InputSource { public: - OffsetInputSource(PointerHolder, qpdf_offset_t global_offset); + OffsetInputSource( + std::shared_ptr, qpdf_offset_t global_offset); virtual ~OffsetInputSource(); virtual qpdf_offset_t findAndSkipNextEOL(); @@ -22,7 +23,7 @@ class OffsetInputSource: public InputSource virtual void unreadCh(char ch); private: - PointerHolder proxied; + std::shared_ptr proxied; qpdf_offset_t global_offset; qpdf_offset_t max_safe_offset; }; diff --git a/libqpdf/qpdf/Pl_PNGFilter.hh b/libqpdf/qpdf/Pl_PNGFilter.hh index 21750842..e34c8631 100644 --- a/libqpdf/qpdf/Pl_PNGFilter.hh +++ b/libqpdf/qpdf/Pl_PNGFilter.hh @@ -46,8 +46,8 @@ class Pl_PNGFilter: public Pipeline unsigned int bytes_per_pixel; unsigned char* cur_row; // points to buf1 or buf2 unsigned char* prev_row; // points to buf1 or buf2 - PointerHolder buf1; - PointerHolder buf2; + std::shared_ptr buf1; + std::shared_ptr buf2; size_t pos; size_t incoming; }; diff --git a/libqpdf/qpdf/Pl_RC4.hh b/libqpdf/qpdf/Pl_RC4.hh index 4154c18c..fe5c3d9e 100644 --- a/libqpdf/qpdf/Pl_RC4.hh +++ b/libqpdf/qpdf/Pl_RC4.hh @@ -27,7 +27,7 @@ class Pl_RC4: public Pipeline virtual void finish(); private: - PointerHolder outbuf; + std::shared_ptr outbuf; size_t out_bufsize; RC4 rc4; }; diff --git a/libqpdf/qpdf/Pl_TIFFPredictor.hh b/libqpdf/qpdf/Pl_TIFFPredictor.hh index 90c9ac05..f14b0f00 100644 --- a/libqpdf/qpdf/Pl_TIFFPredictor.hh +++ b/libqpdf/qpdf/Pl_TIFFPredictor.hh @@ -35,7 +35,7 @@ class Pl_TIFFPredictor: public Pipeline unsigned int bytes_per_row; unsigned int samples_per_pixel; unsigned int bits_per_sample; - PointerHolder cur_row; + std::shared_ptr cur_row; size_t pos; }; diff --git a/libqpdf/qpdf/QPDF_Stream.hh b/libqpdf/qpdf/QPDF_Stream.hh index d9d4e752..4dc92236 100644 --- a/libqpdf/qpdf/QPDF_Stream.hh +++ b/libqpdf/qpdf/QPDF_Stream.hh @@ -37,8 +37,8 @@ class QPDF_Stream: public QPDFObject // Methods to help QPDF copy foreign streams qpdf_offset_t getOffset() const; size_t getLength() const; - PointerHolder getStreamDataBuffer() const; - PointerHolder + std::shared_ptr getStreamDataBuffer() const; + std::shared_ptr getStreamDataProvider() const; // See comments in QPDFObjectHandle.hh for these methods. @@ -49,18 +49,18 @@ class QPDF_Stream: public QPDFObject qpdf_stream_decode_level_e decode_level, bool suppress_warnings, bool will_retry); - PointerHolder getStreamData(qpdf_stream_decode_level_e); - PointerHolder getRawStreamData(); + std::shared_ptr getStreamData(qpdf_stream_decode_level_e); + std::shared_ptr getRawStreamData(); void replaceStreamData( - PointerHolder data, + std::shared_ptr data, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms); void replaceStreamData( - PointerHolder provider, + std::shared_ptr provider, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms); void - addTokenFilter(PointerHolder token_filter); + addTokenFilter(std::shared_ptr token_filter); void replaceDict(QPDFObjectHandle new_dict); @@ -101,9 +101,9 @@ class QPDF_Stream: public QPDFObject QPDFObjectHandle stream_dict; qpdf_offset_t offset; size_t length; - PointerHolder stream_data; - PointerHolder stream_provider; - std::vector> token_filters; + std::shared_ptr stream_data; + std::shared_ptr stream_provider; + std::vector> token_filters; }; #endif // QPDF_STREAM_HH -- cgit v1.2.3-54-g00ecf