Merge pull request #1485 from m-holger/modern

Miscellaneous code modernisation

Merge pull request #1485 from m-holger/modern
Miscellaneous code modernisation
m-holger · GitHub
2 parents 2dea7ad7 ebacc77d
Showing 21 changed files with 396 additions and 445 deletions
libqpdf/AES_PDF_native.cc
libqpdf/BufferInputSource.cc
libqpdf/MD5.cc
libqpdf/NNTree.cc
libqpdf/Pl_ASCII85Decoder.cc
libqpdf/Pl_ASCIIHexDecoder.cc
libqpdf/Pl_Base64.cc
libqpdf/Pl_LZWDecoder.cc
libqpdf/Pl_MD5.cc
libqpdf/Pl_SHA2.cc
libqpdf/QPDFCrypto_gnutls.cc
libqpdf/QPDFCrypto_native.cc
libqpdf/QPDFCrypto_openssl.cc
libqpdf/QPDFEmbeddedFileDocumentHelper.cc
libqpdf/QPDFFormFieldObjectHelper.cc
libqpdf/QPDFNameTreeObjectHelper.cc
libqpdf/QPDFObjectHandle.cc
libqpdf/QPDF_objects.cc
libqpdf/RC4.cc
libqpdf/qpdf/Pipeline_private.hh
@@ -11,7 +11,7 @@
 AES_PDF_native::AES_PDF_native(
     bool encrypt,
-    unsigned char const* key,
+    unsigned char const* a_key,
     size_t key_bytes,
     bool cbc_mode,
     unsigned char* cbc_block) :
@@ -20,38 +20,38 @@ AES_PDF_native::AES_PDF_native(
     cbc_block(cbc_block)
 {
     size_t keybits = 8 * key_bytes;
-    this->key = std::make_unique<unsigned char[]>(key_bytes);
-    this->rk = std::make_unique<uint32_t[]>(RKLENGTH(keybits));
+    key = std::make_unique<unsigned char[]>(key_bytes);
+    rk = std::make_unique<uint32_t[]>(RKLENGTH(keybits));
     size_t rk_bytes = RKLENGTH(keybits) * sizeof(uint32_t);
-    std::memcpy(this->key.get(), key, key_bytes);
-    std::memset(this->rk.get(), 0, rk_bytes);
+    std::memcpy(key.get(), a_key, key_bytes);
+    std::memset(rk.get(), 0, rk_bytes);
     if (encrypt) {
-        this->nrounds = rijndaelSetupEncrypt(this->rk.get(), this->key.get(), keybits);
+        nrounds = rijndaelSetupEncrypt(rk.get(), key.get(), keybits);
     } else {
-        this->nrounds = rijndaelSetupDecrypt(this->rk.get(), this->key.get(), keybits);
+        nrounds = rijndaelSetupDecrypt(rk.get(), key.get(), keybits);
     }
 }
 void
 AES_PDF_native::update(unsigned char* in_data, unsigned char* out_data)
 {
-    if (this->encrypt) {
-        if (this->cbc_mode) {
+    if (encrypt) {
+        if (cbc_mode) {
             for (size_t i = 0; i < QPDFCryptoImpl::rijndael_buf_size; ++i) {
-                in_data[i] ^= this->cbc_block[i];
+                in_data[i] ^= cbc_block[i];
             }
         }
-        rijndaelEncrypt(this->rk.get(), this->nrounds, in_data, out_data);
-        if (this->cbc_mode) {
-            memcpy(this->cbc_block, out_data, QPDFCryptoImpl::rijndael_buf_size);
+        rijndaelEncrypt(rk.get(), nrounds, in_data, out_data);
+        if (cbc_mode) {
+            memcpy(cbc_block, out_data, QPDFCryptoImpl::rijndael_buf_size);
         }
     } else {
-        rijndaelDecrypt(this->rk.get(), this->nrounds, in_data, out_data);
-        if (this->cbc_mode) {
+        rijndaelDecrypt(rk.get(), nrounds, in_data, out_data);
+        if (cbc_mode) {
             for (size_t i = 0; i < QPDFCryptoImpl::rijndael_buf_size; ++i) {
-                out_data[i] ^= this->cbc_block[i];
+                out_data[i] ^= cbc_block[i];
             }
-            memcpy(this->cbc_block, in_data, QPDFCryptoImpl::rijndael_buf_size);
+            memcpy(cbc_block, in_data, QPDFCryptoImpl::rijndael_buf_size);
         }
     }
 }
@@ -26,42 +26,42 @@ BufferInputSource::BufferInputSource(std::string const&amp; description, std::string
 BufferInputSource::~BufferInputSource()
 {
-    if (this->own_memory) {
-        delete this->buf;
+    if (own_memory) {
+        delete buf;
     }
 }
 qpdf_offset_t
 BufferInputSource::findAndSkipNextEOL()
 {
-    if (this->cur_offset < 0) {
+    if (cur_offset < 0) {
         throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
     }
-    qpdf_offset_t end_pos = this->max_offset;
-    if (this->cur_offset >= end_pos) {
-        this->last_offset = end_pos;
-        this->cur_offset = end_pos;
+    qpdf_offset_t end_pos = max_offset;
+    if (cur_offset >= end_pos) {
+        last_offset = end_pos;
+        cur_offset = end_pos;
         return end_pos;
     }
     qpdf_offset_t result = 0;
-    unsigned char const* buffer = this->buf->getBuffer();
+    unsigned char const* buffer = buf->getBuffer();
     unsigned char const* end = buffer + end_pos;
-    unsigned char const* p = buffer + this->cur_offset;
+    unsigned char const* p = buffer + cur_offset;
     while ((p < end) && !((*p == '\r') || (*p == '\n'))) {
         ++p;
     }
     if (p < end) {
         result = p - buffer;
-        this->cur_offset = result + 1;
+        cur_offset = result + 1;
         ++p;
-        while ((this->cur_offset < end_pos) && ((*p == '\r') || (*p == '\n'))) {
+        while ((cur_offset < end_pos) && ((*p == '\r') || (*p == '\n'))) {
             ++p;
-            ++this->cur_offset;
+            ++cur_offset;
         }
     } else {
-        this->cur_offset = end_pos;
+        cur_offset = end_pos;
         result = end_pos;
     }
     return result;
@@ -70,13 +70,13 @@ BufferInputSource::findAndSkipNextEOL()
 std::string const&
 BufferInputSource::getName() const
 {
-    return this->description;
+    return description;
 }
 qpdf_offset_t
 BufferInputSource::tell()
 {
-    return this->cur_offset;
+    return cur_offset;
 }
 void
@@ -84,17 +84,17 @@ BufferInputSource::seek(qpdf_offset_t offset, int whence)
 {
     switch (whence) {
     case SEEK_SET:
-        this->cur_offset = offset;
+        cur_offset = offset;
         break;
     case SEEK_END:
-        QIntC::range_check(this->max_offset, offset);
-        this->cur_offset = this->max_offset + offset;
+        QIntC::range_check(max_offset, offset);
+        cur_offset = max_offset + offset;
         break;
     case SEEK_CUR:
-        QIntC::range_check(this->cur_offset, offset);
-        this->cur_offset += offset;
+        QIntC::range_check(cur_offset, offset);
+        cur_offset += offset;
         break;
     default:
@@ -102,40 +102,40 @@ BufferInputSource::seek(qpdf_offset_t offset, int whence)
         break;
     }
-    if (this->cur_offset < 0) {
-        throw std::runtime_error(this->description + ": seek before beginning of buffer");
+    if (cur_offset < 0) {
+        throw std::runtime_error(description + ": seek before beginning of buffer");
     }
 }
 void
 BufferInputSource::rewind()
 {
-    this->cur_offset = 0;
+    cur_offset = 0;
 }
 size_t
 BufferInputSource::read(char* buffer, size_t length)
 {
-    if (this->cur_offset < 0) {
+    if (cur_offset < 0) {
         throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
     }
-    qpdf_offset_t end_pos = this->max_offset;
-    if (this->cur_offset >= end_pos) {
-        this->last_offset = end_pos;
+    qpdf_offset_t end_pos = max_offset;
+    if (cur_offset >= end_pos) {
+        last_offset = end_pos;
         return 0;
     }
-    this->last_offset = this->cur_offset;
-    size_t len = std::min(QIntC::to_size(end_pos - this->cur_offset), length);
-    memcpy(buffer, this->buf->getBuffer() + this->cur_offset, len);
-    this->cur_offset += QIntC::to_offset(len);
+    last_offset = cur_offset;
+    size_t len = std::min(QIntC::to_size(end_pos - cur_offset), length);
+    memcpy(buffer, buf->getBuffer() + cur_offset, len);
+    cur_offset += QIntC::to_offset(len);
     return len;
 }
 void
 BufferInputSource::unreadCh(char ch)
 {
-    if (this->cur_offset > 0) {
-        --this->cur_offset;
+    if (cur_offset > 0) {
+        --cur_offset;
     }
 }
@@ -14,14 +14,14 @@ MD5::MD5()
 void
 MD5::init()
 {
-    this->crypto = QPDFCryptoProvider::getImpl();
-    this->crypto->MD5_init();
+    crypto = QPDFCryptoProvider::getImpl();
+    crypto->MD5_init();
 }
 void
 MD5::finalize()
 {
-    this->crypto->MD5_finalize();
+    crypto->MD5_finalize();
 }
 void
@@ -48,7 +48,7 @@ MD5::appendString(char const* input_string)
 void
 MD5::encodeDataIncrementally(char const* data, size_t len)
 {
-    this->crypto->MD5_update(QUtil::unsigned_char_pointer(data), len);
+    crypto->MD5_update(QUtil::unsigned_char_pointer(data), len);
 }
 void
@@ -84,14 +84,14 @@ MD5::encodeFile(char const* filename, qpdf_offset_t up_to_offset)
     }
     (void)fclose(file);
-    this->crypto->MD5_finalize();
+    crypto->MD5_finalize();
 }
 void
 MD5::digest(Digest result)
 {
-    this->crypto->MD5_finalize();
-    this->crypto->MD5_digest(result);
+    crypto->MD5_finalize();
+    crypto->MD5_digest(result);
 }
 void
@@ -110,7 +110,7 @@ MD5::print()
 std::string
 MD5::unparse()
 {
-    this->crypto->MD5_finalize();
+    crypto->MD5_finalize();
     Digest digest_val;
     digest(digest_val);
     return QUtil::hex_encode(std::string(reinterpret_cast<char*>(digest_val), 16));
@@ -49,12 +49,12 @@ NNTreeIterator::updateIValue(bool allow_invalid)
     // call updateIValue in operator* and operator->.
     bool okay = false;
-    if ((item_number >= 0) && this->node.isDictionary()) {
-        auto items = this->node.getKey(impl.details.itemsKey());
-        if (this->item_number + 1 < items.getArrayNItems()) {
+    if (item_number >= 0 && node.isDictionary()) {
+        auto items = node.getKey(impl.details.itemsKey());
+        if (item_number + 1 < items.getArrayNItems()) {
             okay = true;
-            this->ivalue.first = items.getArrayItem(this->item_number);
-            this->ivalue.second = items.getArrayItem(1 + this->item_number);
+            ivalue.first = items.getArrayItem(item_number);
+            ivalue.second = items.getArrayItem(1 + item_number);
         } else {
             error(impl.qpdf, node, "update ivalue: items array is too short");
         }
@@ -64,8 +64,8 @@ NNTreeIterator::updateIValue(bool allow_invalid)
             throw std::logic_error(
                 "attempt made to dereference an invalid name/number tree iterator");
         }
-        this->ivalue.first = QPDFObjectHandle();
-        this->ivalue.second = QPDFObjectHandle();
+        ivalue.first = QPDFObjectHandle();
+        ivalue.second = QPDFObjectHandle();
     }
 }
@@ -106,45 +106,45 @@ NNTreeIterator::getNextKid(PathElement&amp; pe, bool backward)
 bool
 NNTreeIterator::valid() const
 {
-    return this->item_number >= 0;
+    return item_number >= 0;
 }
 void
 NNTreeIterator::increment(bool backward)
 {
-    if (this->item_number < 0) {
+    if (item_number < 0) {
         QTC::TC("qpdf", "NNTree increment end()");
         deepen(impl.oh, !backward, true);
         return;
     }
     bool found_valid_key = false;
-    while (valid() && (!found_valid_key)) {
-        this->item_number += backward ? -2 : 2;
-        auto items = this->node.getKey(impl.details.itemsKey());
-        if ((this->item_number < 0) || (this->item_number >= items.getArrayNItems())) {
+    while (valid() && !found_valid_key) {
+        item_number += backward ? -2 : 2;
+        auto items = node.getKey(impl.details.itemsKey());
+        if (item_number < 0 || item_number >= items.getArrayNItems()) {
             bool found = false;
             setItemNumber(QPDFObjectHandle(), -1);
-            while (!(found || this->path.empty())) {
-                auto& element = this->path.back();
+            while (!(found || path.empty())) {
+                auto& element = path.back();
                 auto pe_node = getNextKid(element, backward);
                 if (pe_node.isNull()) {
-                    this->path.pop_back();
+                    path.pop_back();
                 } else {
                     found = deepen(pe_node, !backward, false);
                 }
             }
         }
-        if (this->item_number >= 0) {
-            items = this->node.getKey(impl.details.itemsKey());
-            if (this->item_number + 1 >= items.getArrayNItems()) {
+        if (item_number >= 0) {
+            items = node.getKey(impl.details.itemsKey());
+            if (item_number + 1 >= items.getArrayNItems()) {
                 QTC::TC("qpdf", "NNTree skip item at end of short items");
-                warn(impl.qpdf, this->node, "items array doesn't have enough elements");
-            } else if (!impl.details.keyValid(items.getArrayItem(this->item_number))) {
+                warn(impl.qpdf, node, "items array doesn't have enough elements");
+            } else if (!impl.details.keyValid(items.getArrayItem(item_number))) {
                 QTC::TC("qpdf", "NNTree skip invalid key");
                 warn(
                     impl.qpdf,
-                    this->node,
-                    ("item " + std::to_string(this->item_number) + " has the wrong type"));
+                    node,
+                    ("item " + std::to_string(item_number) + " has the wrong type"));
             } else {
                 found_valid_key = true;
             }
@@ -153,19 +153,19 @@ NNTreeIterator::increment(bool backward)
 }
 void
-NNTreeIterator::resetLimits(QPDFObjectHandle node, std::list<PathElement>::iterator parent)
+NNTreeIterator::resetLimits(QPDFObjectHandle a_node, std::list<PathElement>::iterator parent)
 {
     bool done = false;
     while (!done) {
-        if (parent == this->path.end()) {
+        if (parent == path.end()) {
             QTC::TC("qpdf", "NNTree remove limits from root");
-            node.removeKey("/Limits");
+            a_node.removeKey("/Limits");
             done = true;
             break;
         }
-        auto kids = node.getKey("/Kids");
+        auto kids = a_node.getKey("/Kids");
         int nkids = kids.isArray() ? kids.getArrayNItems() : 0;
-        auto items = node.getKey(impl.details.itemsKey());
+        auto items = a_node.getKey(impl.details.itemsKey());
         int nitems = items.isArray() ? items.getArrayNItems() : 0;
         bool changed = true;
@@ -191,7 +191,7 @@ NNTreeIterator::resetLimits(QPDFObjectHandle node, std::list&lt;PathElement&gt;::itera
             auto limits = QPDFObjectHandle::newArray();
             limits.appendItem(first);
             limits.appendItem(last);
-            auto olimits = node.getKey("/Limits");
+            auto olimits = a_node.getKey("/Limits");
             if (olimits.isArray() && (olimits.getArrayNItems() == 2)) {
                 auto ofirst = olimits.getArrayItem(0);
                 auto olast = olimits.getArrayItem(1);
@@ -202,18 +202,18 @@ NNTreeIterator::resetLimits(QPDFObjectHandle node, std::list&lt;PathElement&gt;::itera
                     changed = false;
                 }
             }
-            if (changed && !node.isSameObjectAs(path.begin()->node)) {
-                node.replaceKey("/Limits", limits);
+            if (changed && !a_node.isSameObjectAs(path.begin()->node)) {
+                a_node.replaceKey("/Limits", limits);
             }
         } else {
             QTC::TC("qpdf", "NNTree unable to determine limits");
-            warn(impl.qpdf, node, "unable to determine limits");
+            warn(impl.qpdf, a_node, "unable to determine limits");
         }
-        if ((!changed) || (parent == this->path.begin())) {
+        if (!changed || parent == path.begin()) {
             done = true;
         } else {
-            node = parent->node;
+            a_node = parent->node;
             --parent;
         }
     }
@@ -283,7 +283,7 @@ NNTreeIterator::split(QPDFObjectHandle to_split, std::list&lt;PathElement&gt;::iterato
         return;
     }
-    bool is_root = (parent == this->path.end());
+    bool is_root = (parent == path.end());
     bool is_leaf = (nitems > 0);
     // CURRENT STATE: tree is in original state; iterator is valid and unchanged.
@@ -312,14 +312,14 @@ NNTreeIterator::split(QPDFObjectHandle to_split, std::list&lt;PathElement&gt;::iterato
         to_split.replaceKey("/Kids", new_kids);
         if (is_leaf) {
             QTC::TC("qpdf", "NNTree split root + leaf");
-            this->node = first_node;
+            node = first_node;
         } else {
             QTC::TC("qpdf", "NNTree split root + !leaf");
-            auto next = this->path.begin();
+            auto next = path.begin();
             next->node = first_node;
         }
         this->path.emplace_front(to_split, 0);
-        parent = this->path.begin();
+        parent = path.begin();
         to_split = first_node;
     }
@@ -353,12 +353,12 @@ NNTreeIterator::split(QPDFObjectHandle to_split, std::list&lt;PathElement&gt;::iterato
     parent_kids.insertItem(parent->kid_number + 1, second_node);
     auto cur_elem = parent;
     ++cur_elem; // points to end() for leaf nodes
-    int old_idx = (is_leaf ? this->item_number : cur_elem->kid_number);
+    int old_idx = (is_leaf ? item_number : cur_elem->kid_number);
     if (old_idx >= start_idx) {
         ++parent->kid_number;
         if (is_leaf) {
             QTC::TC("qpdf", "NNTree split second half item");
-            setItemNumber(second_node, this->item_number - start_idx);
+            setItemNumber(second_node, item_number - start_idx);
         } else {
             QTC::TC("qpdf", "NNTree split second half kid");
             cur_elem->node = second_node;
@@ -377,8 +377,8 @@ NNTreeIterator::split(QPDFObjectHandle to_split, std::list&lt;PathElement&gt;::iterato
 std::list<NNTreeIterator::PathElement>::iterator
 NNTreeIterator::lastPathElement()
 {
-    auto result = this->path.end();
-    if (!this->path.empty()) {
+    auto result = path.end();
+    if (!path.empty()) {
         --result;
     }
     return result;
@@ -394,17 +394,17 @@ NNTreeIterator::insertAfter(QPDFObjectHandle key, QPDFObjectHandle value)
         return;
     }
-    auto items = this->node.getKey(impl.details.itemsKey());
+    auto items = node.getKey(impl.details.itemsKey());
     if (!items.isArray()) {
         error(impl.qpdf, node, "node contains no items array");
     }
-    if (items.getArrayNItems() < this->item_number + 2) {
+    if (items.getArrayNItems() < item_number + 2) {
         error(impl.qpdf, node, "insert: items array is too short");
     }
-    items.insertItem(this->item_number + 2, key);
-    items.insertItem(this->item_number + 3, value);
-    resetLimits(this->node, lastPathElement());
-    split(this->node, lastPathElement());
+    items.insertItem(item_number + 2, key);
+    items.insertItem(item_number + 3, value);
+    resetLimits(node, lastPathElement());
+    split(node, lastPathElement());
     increment(false);
 }
@@ -416,33 +416,33 @@ NNTreeIterator::remove()
     if (!valid()) {
         throw std::logic_error("attempt made to remove an invalid iterator");
     }
-    auto items = this->node.getKey(impl.details.itemsKey());
+    auto items = node.getKey(impl.details.itemsKey());
     int nitems = items.getArrayNItems();
-    if (this->item_number + 2 > nitems) {
-        error(impl.qpdf, this->node, "found short items array while removing an item");
+    if (item_number + 2 > nitems) {
+        error(impl.qpdf, node, "found short items array while removing an item");
     }
-    items.eraseItem(this->item_number);
-    items.eraseItem(this->item_number);
+    items.eraseItem(item_number);
+    items.eraseItem(item_number);
     nitems -= 2;
     if (nitems > 0) {
         // There are still items left
-        if ((this->item_number == 0) || (this->item_number == nitems)) {
+        if (item_number == 0 || item_number == nitems) {
             // We removed either the first or last item of an items array that remains non-empty, so
             // we have to adjust limits.
             QTC::TC("qpdf", "NNTree remove reset limits");
-            resetLimits(this->node, lastPathElement());
+            resetLimits(node, lastPathElement());
         }
-        if (this->item_number == nitems) {
+        if (item_number == nitems) {
             // We removed the last item of a non-empty items array, so advance to the successor of
             // the previous item.
             QTC::TC("qpdf", "NNTree erased last item");
-            this->item_number -= 2;
+            item_number -= 2;
             increment(false);
-        } else if (this->item_number < nitems) {
+        } else if (item_number < nitems) {
             // We don't have to do anything since the removed item's successor now occupies its
             // former location.
             QTC::TC("qpdf", "NNTree erased non-last item");
@@ -454,7 +454,7 @@ NNTreeIterator::remove()
         return;
     }
-    if (this->path.empty()) {
+    if (path.empty()) {
         // Special case: if this is the root node, we can leave it empty.
         QTC::TC("qpdf", "NNTree erased all items on leaf/root");
         setItemNumber(impl.oh, -1);
@@ -498,18 +498,18 @@ NNTreeIterator::remove()
                 deepen(kids.getArrayItem(element->kid_number), true, true);
             }
             done = true;
-        } else if (parent == this->path.end()) {
+        } else if (parent == path.end()) {
             // We erased the very last item. Convert the root to an empty items array.
             QTC::TC("qpdf", "NNTree non-flat tree is empty after remove");
             element->node.removeKey("/Kids");
             element->node.replaceKey(impl.details.itemsKey(), QPDFObjectHandle::newArray());
-            this->path.clear();
+            path.clear();
             setItemNumber(impl.oh, -1);
             done = true;
         } else {
             // Walk up the tree and continue
             QTC::TC("qpdf", "NNTree remove walking up tree");
-            this->path.pop_back();
+            path.pop_back();
         }
     }
 }
@@ -532,99 +532,99 @@ NNTreeIterator::reference
 NNTreeIterator::operator*()
 {
     updateIValue(false);
-    return this->ivalue;
+    return ivalue;
 }
 NNTreeIterator::pointer
 NNTreeIterator::operator->()
 {
     updateIValue(false);
-    return &(this->ivalue);
+    return &ivalue;
 }
 bool
 NNTreeIterator::operator==(NNTreeIterator const& other) const
 {
-    if ((this->item_number == -1) && (other.item_number == -1)) {
+    if (item_number == -1 && other.item_number == -1) {
         return true;
     }
-    if (this->path.size() != other.path.size()) {
+    if (path.size() != other.path.size()) {
         return false;
     }
-    auto tpi = this->path.begin();
+    auto tpi = path.begin();
     auto opi = other.path.begin();
-    while (tpi != this->path.end()) {
+    while (tpi != path.end()) {
         if (tpi->kid_number != opi->kid_number) {
             return false;
         }
         ++tpi;
         ++opi;
     }
-    if (this->item_number != other.item_number) {
+    if (item_number != other.item_number) {
         return false;
     }
     return true;
 }
 void
-NNTreeIterator::setItemNumber(QPDFObjectHandle const& node, int n)
+NNTreeIterator::setItemNumber(QPDFObjectHandle const& a_node, int n)
 {
-    this->node = node;
-    this->item_number = n;
+    node = a_node;
+    item_number = n;
     updateIValue();
 }
 void
-NNTreeIterator::addPathElement(QPDFObjectHandle const& node, int kid_number)
+NNTreeIterator::addPathElement(QPDFObjectHandle const& a_node, int kid_number)
 {
-    this->path.emplace_back(node, kid_number);
+    path.emplace_back(a_node, kid_number);
 }
 bool
-NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
+NNTreeIterator::deepen(QPDFObjectHandle a_node, bool first, bool allow_empty)
 {
     // Starting at this node, descend through the first or last kid until we reach a node with
     // items. If we succeed, return true; otherwise return false and leave path alone.
-    auto opath = this->path;
+    auto opath = path;
     bool failed = false;
     QPDFObjGen::set seen;
-    for (auto const& i: this->path) {
+    for (auto const& i: path) {
         seen.add(i.node);
     }
     while (!failed) {
-        if (!seen.add(node)) {
+        if (!seen.add(a_node)) {
             QTC::TC("qpdf", "NNTree deepen: loop");
-            warn(impl.qpdf, node, "loop detected while traversing name/number tree");
+            warn(impl.qpdf, a_node, "loop detected while traversing name/number tree");
             failed = true;
             break;
         }
-        if (!node.isDictionary()) {
+        if (!a_node.isDictionary()) {
             QTC::TC("qpdf", "NNTree node is not a dictionary");
-            warn(impl.qpdf, node, "non-dictionary node while traversing name/number tree");
+            warn(impl.qpdf, a_node, "non-dictionary node while traversing name/number tree");
             failed = true;
             break;
         }
-        auto kids = node.getKey("/Kids");
+        auto kids = a_node.getKey("/Kids");
         int nkids = kids.isArray() ? kids.getArrayNItems() : 0;
-        auto items = node.getKey(impl.details.itemsKey());
+        auto items = a_node.getKey(impl.details.itemsKey());
         int nitems = items.isArray() ? items.getArrayNItems() : 0;
         if (nitems > 0) {
-            setItemNumber(node, first ? 0 : nitems - 2);
+            setItemNumber(a_node, first ? 0 : nitems - 2);
             break;
         } else if (nkids > 0) {
             int kid_number = first ? 0 : nkids - 1;
-            addPathElement(node, kid_number);
+            addPathElement(a_node, kid_number);
             auto next = kids.getArrayItem(kid_number);
             if (!next.isIndirect()) {
                 if (impl.auto_repair) {
                     QTC::TC("qpdf", "NNTree fix indirect kid");
                     warn(
                         impl.qpdf,
-                        node,
+                        a_node,
                         ("converting kid number " + std::to_string(kid_number) +
                          " to an indirect object"));
                     next = impl.qpdf.makeIndirectObject(next);
@@ -633,21 +633,21 @@ NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
                     QTC::TC("qpdf", "NNTree warn indirect kid");
                     warn(
                         impl.qpdf,
-                        node,
+                        a_node,
                         ("kid number " + std::to_string(kid_number) +
                          " is not an indirect object"));
                 }
             }
-            node = next;
+            a_node = next;
         } else if (allow_empty && items.isArray()) {
             QTC::TC("qpdf", "NNTree deepen found empty");
-            setItemNumber(node, -1);
+            setItemNumber(a_node, -1);
             break;
         } else {
             QTC::TC("qpdf", "NNTree deepen: invalid node");
             warn(
                 impl.qpdf,
-                node,
+                a_node,
                 ("name/number tree node has neither non-empty " + impl.details.itemsKey() +
                  " nor /Kids"));
             failed = true;
@@ -655,7 +655,7 @@ NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
         }
     }
     if (failed) {
-        this->path = opath;
+        path = opath;
         return false;
     }
     return true;
@@ -671,16 +671,16 @@ NNTreeImpl::NNTreeImpl(
 }
 void
-NNTreeImpl::setSplitThreshold(int split_threshold)
+NNTreeImpl::setSplitThreshold(int threshold)
 {
-    this->split_threshold = split_threshold;
+    split_threshold = threshold;
 }
 NNTreeImpl::iterator
 NNTreeImpl::begin()
 {
     iterator result(*this);
-    result.deepen(this->oh, true, true);
+    result.deepen(oh, true, true);
     return result;
 }
@@ -694,7 +694,7 @@ NNTreeImpl::iterator
 NNTreeImpl::last()
 {
     iterator result(*this);
-    result.deepen(this->oh, false, true);
+    result.deepen(oh, false, true);
     return result;
 }
@@ -782,10 +782,7 @@ NNTreeImpl::compareKeyItem(QPDFObjectHandle&amp; key, QPDFObjectHandle&amp; items, int i
     if (!((items.isArray() && (items.getArrayNItems() > (2 * idx)) &&
            details.keyValid(items.getArrayItem(2 * idx))))) {
         QTC::TC("qpdf", "NNTree item is wrong type");
-        error(
-            qpdf,
-            this->oh,
-            ("item at index " + std::to_string(2 * idx) + " is not the right type"));
+        error(qpdf, oh, ("item at index " + std::to_string(2 * idx) + " is not the right type"));
     }
     return details.compareKeys(key, items.getArrayItem(2 * idx));
 }
@@ -796,7 +793,7 @@ NNTreeImpl::compareKeyKid(QPDFObjectHandle&amp; key, QPDFObjectHandle&amp; kids, int idx
     if (!(kids.isArray() && (idx < kids.getArrayNItems()) &&
           kids.getArrayItem(idx).isDictionary())) {
         QTC::TC("qpdf", "NNTree kid is invalid");
-        error(qpdf, this->oh, "invalid kid at index " + std::to_string(idx));
+        error(qpdf, oh, "invalid kid at index " + std::to_string(idx));
     }
     return withinLimits(key, kids.getArrayItem(idx));
 }
@@ -810,8 +807,8 @@ NNTreeImpl::repair()
     for (auto const& i: *this) {
         repl.insert(i.first, i.second);
     }
-    this->oh.replaceKey("/Kids", new_node.getKey("/Kids"));
-    this->oh.replaceKey(details.itemsKey(), new_node.getKey(details.itemsKey()));
+    oh.replaceKey("/Kids", new_node.getKey("/Kids"));
+    oh.replaceKey(details.itemsKey(), new_node.getKey(details.itemsKey()));
 }
 NNTreeImpl::iterator
@@ -820,9 +817,9 @@ NNTreeImpl::find(QPDFObjectHandle key, bool return_prev_if_not_found)
     try {
         return findInternal(key, return_prev_if_not_found);
     } catch (QPDFExc& e) {
-        if (this->auto_repair) {
+        if (auto_repair) {
             QTC::TC("qpdf", "NNTree repair");
-            warn(qpdf, this->oh, std::string("attempting to repair after error: ") + e.what());
+            warn(qpdf, oh, std::string("attempting to repair after error: ") + e.what());
             repair();
             return findInternal(key, return_prev_if_not_found);
         } else {
@@ -856,7 +853,7 @@ NNTreeImpl::findInternal(QPDFObjectHandle key, bool return_prev_if_not_found)
     }
     QPDFObjGen::set seen;
-    auto node = this->oh;
+    auto node = oh;
     iterator result(*this);
     while (true) {
@@ -907,7 +904,7 @@ NNTreeImpl::insertFirst(QPDFObjectHandle key, QPDFObjectHandle value)
     }
     if (!(items.isArray())) {
         QTC::TC("qpdf", "NNTree no valid items node in insertFirst");
-        error(qpdf, this->oh, "unable to find a valid items node");
+        error(qpdf, oh, "unable to find a valid items node");
     }
     items.insertItem(0, key);
     items.insertItem(1, value);
@@ -57,7 +57,7 @@ Pl_ASCII85Decoder::write(unsigned char const* buf, size_t len)
                 break;
             default:
-                if ((buf[i] < 33) || (buf[i] > 117)) {
+                if (buf[i] < 33 || buf[i] > 117) {
                     error = true;
                     throw std::runtime_error("character out of range during base 85 decode");
                 } else {
@@ -17,7 +17,7 @@ Pl_ASCIIHexDecoder::Pl_ASCIIHexDecoder(char const* identifier, Pipeline* next) :
 void
 Pl_ASCIIHexDecoder::write(unsigned char const* buf, size_t len)
 {
-    if (this->eod) {
+    if (eod) {
         return;
     }
     for (size_t i = 0; i < len; ++i) {
@@ -34,14 +34,14 @@ Pl_ASCIIHexDecoder::write(unsigned char const* buf, size_t len)
             break;
         case '>':
-            this->eod = true;
+            eod = true;
             flush();
             break;
         default:
-            if (((ch >= '0') && (ch <= '9')) || ((ch >= 'A') && (ch <= 'F'))) {
-                this->inbuf[this->pos++] = ch;
-                if (this->pos == 2) {
+            if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F')) {
+                inbuf[pos++] = ch;
+                if (pos == 2) {
                     flush();
                 }
             } else {
@@ -52,7 +52,7 @@ Pl_ASCIIHexDecoder::write(unsigned char const* buf, size_t len)
             }
             break;
         }
-        if (this->eod) {
+        if (eod) {
             break;
         }
     }
@@ -61,26 +61,26 @@ Pl_ASCIIHexDecoder::write(unsigned char const* buf, size_t len)
 void
 Pl_ASCIIHexDecoder::flush()
 {
-    if (this->pos == 0) {
+    if (pos == 0) {
         QTC::TC("libtests", "Pl_ASCIIHexDecoder no-op flush");
         return;
     }
     int b[2];
     for (int i = 0; i < 2; ++i) {
-        if (this->inbuf[i] >= 'A') {
-            b[i] = this->inbuf[i] - 'A' + 10;
+        if (inbuf[i] >= 'A') {
+            b[i] = inbuf[i] - 'A' + 10;
         } else {
-            b[i] = this->inbuf[i] - '0';
+            b[i] = inbuf[i] - '0';
         }
     }
     auto ch = static_cast<unsigned char>((b[0] << 4) + b[1]);
-    QTC::TC("libtests", "Pl_ASCIIHexDecoder partial flush", (this->pos == 2) ? 0 : 1);
+    QTC::TC("libtests", "Pl_ASCIIHexDecoder partial flush", (pos == 2) ? 0 : 1);
     // Reset before calling getNext()->write in case that throws an exception.
-    this->pos = 0;
-    this->inbuf[0] = '0';
-    this->inbuf[1] = '0';
-    this->inbuf[2] = '\0';
+    pos = 0;
+    inbuf[0] = '0';
+    inbuf[1] = '0';
+    inbuf[2] = '\0';
     next()->write(&ch, 1);
 }
@@ -102,17 +102,17 @@ Pl_Base64::flush_decode()
     for (size_t i = 0; i < 4; ++i) {
         int v = 0;
         char ch = to_c(buf[i]);
-        if ((ch >= 'A') && (ch <= 'Z')) {
+        if (ch >= 'A' && ch <= 'Z') {
             v = ch - 'A';
-        } else if ((ch >= 'a') && (ch <= 'z')) {
+        } else if (ch >= 'a' && ch <= 'z') {
             v = ch - 'a' + 26;
-        } else if ((ch >= '0') && (ch <= '9')) {
+        } else if (ch >= '0' && ch <= '9') {
             v = ch - '0' + 52;
-        } else if ((ch == '+') || (ch == '-')) {
+        } else if (ch == '+' || ch == '-') {
             v = 62;
-        } else if ((ch == '/') || (ch == '_')) {
+        } else if (ch == '/' || ch == '_') {
             v = 63;
-        } else if ((ch == '=') && ((i == 3) || ((i == 2) && (buf[3] == '=')))) {
+        } else if (ch == '=' && (i == 3 || (i == 2 && buf[3] == '='))) {
             ++pad;
             end_of_data = true;
             v = 0;
@@ -134,7 +134,7 @@ Pl_Base64::flush_decode()
 void
 Pl_Base64::flush_encode()
 {
-    int outval = ((buf[0] << 16) | (buf[1] << 8) | (buf[2]));
+    int outval = ((buf[0] << 16) | (buf[1] << 8) | buf[2]);
     unsigned char out[4] = {
         to_uc(outval >> 18),
         to_uc(0x3f & (outval >> 12)),
@@ -23,8 +23,8 @@ Pl_LZWDecoder::write(unsigned char const* bytes, size_t len)
         if (next_char_ == 3) {
             next_char_ = 0;
         }
-        this->bits_available += 8;
-        if (this->bits_available >= this->code_size) {
+        bits_available += 8;
+        if (bits_available >= code_size) {
             sendNextCode();
         }
     }
@@ -39,12 +39,12 @@ Pl_LZWDecoder::finish()
 void
 Pl_LZWDecoder::sendNextCode()
 {
-    unsigned int high = this->byte_pos;
-    unsigned int med = (this->byte_pos + 1) % 3;
-    unsigned int low = (this->byte_pos + 2) % 3;
+    unsigned int high = byte_pos;
+    unsigned int med = (byte_pos + 1) % 3;
+    unsigned int low = (byte_pos + 2) % 3;
-    unsigned int bits_from_high = 8 - this->bit_pos;
-    unsigned int bits_from_med = this->code_size - bits_from_high;
+    unsigned int bits_from_high = 8 - bit_pos;
+    unsigned int bits_from_med = code_size - bits_from_high;
     unsigned int bits_from_low = 0;
     if (bits_from_med > 8) {
         bits_from_low = bits_from_med - 8;
@@ -54,23 +54,23 @@ Pl_LZWDecoder::sendNextCode()
     unsigned int med_mask = 0xff - ((1U << (8 - bits_from_med)) - 1U);
     unsigned int low_mask = 0xff - ((1U << (8 - bits_from_low)) - 1U);
     unsigned int code = 0;
-    code += (this->buf[high] & high_mask) << bits_from_med;
-    code += ((this->buf[med] & med_mask) >> (8 - bits_from_med));
+    code += (buf[high] & high_mask) << bits_from_med;
+    code += ((buf[med] & med_mask) >> (8 - bits_from_med));
     if (bits_from_low) {
         code <<= bits_from_low;
-        code += ((this->buf[low] & low_mask) >> (8 - bits_from_low));
-        this->byte_pos = low;
-        this->bit_pos = bits_from_low;
+        code += ((buf[low] & low_mask) >> (8 - bits_from_low));
+        byte_pos = low;
+        bit_pos = bits_from_low;
     } else {
-        this->byte_pos = med;
-        this->bit_pos = bits_from_med;
+        byte_pos = med;
+        bit_pos = bits_from_med;
     }
-    if (this->bit_pos == 8) {
-        this->bit_pos = 0;
-        ++this->byte_pos;
-        this->byte_pos %= 3;
+    if (bit_pos == 8) {
+        bit_pos = 0;
+        ++byte_pos;
+        byte_pos %= 3;
     }
-    this->bits_available -= this->code_size;
+    bits_available -= code_size;
     handleCode(code);
 }
@@ -102,12 +102,12 @@ Pl_LZWDecoder::addToTable(unsigned char c)
     unsigned char const* last_data = nullptr;
     unsigned char tmp[1];
-    if (this->last_code < 256) {
-        tmp[0] = static_cast<unsigned char>(this->last_code);
+    if (last_code < 256) {
+        tmp[0] = static_cast<unsigned char>(last_code);
         last_data = tmp;
         last_size = 1;
-    } else if (this->last_code > 257) {
-        unsigned int idx = this->last_code - 258;
+    } else if (last_code > 257) {
+        unsigned int idx = last_code - 258;
         if (idx >= table.size()) {
             throw std::runtime_error("Pl_LZWDecoder::addToTable: table overflow");
         }
@@ -116,34 +116,34 @@ Pl_LZWDecoder::addToTable(unsigned char c)
         last_size = QIntC::to_uint(b.getSize());
     } else {
         throw std::runtime_error(
-            "Pl_LZWDecoder::addToTable called with invalid code (" +
-            std::to_string(this->last_code) + ")");
+            "Pl_LZWDecoder::addToTable called with invalid code (" + std::to_string(last_code) +
+            ")");
     }
     Buffer entry(1 + last_size);
     unsigned char* new_data = entry.getBuffer();
     memcpy(new_data, last_data, last_size);
     new_data[last_size] = c;
-    this->table.push_back(std::move(entry));
+    table.push_back(std::move(entry));
 }
 void
 Pl_LZWDecoder::handleCode(unsigned int code)
 {
-    if (this->eod) {
+    if (eod) {
         return;
     }
     if (code == 256) {
-        if (!this->table.empty()) {
+        if (!table.empty()) {
             QTC::TC("libtests", "Pl_LZWDecoder intermediate reset");
         }
-        this->table.clear();
-        this->code_size = 9;
+        table.clear();
+        code_size = 9;
     } else if (code == 257) {
-        this->eod = true;
+        eod = true;
     } else {
-        if (this->last_code != 256) {
+        if (last_code != 256) {
             // Add to the table from last time.  New table entry would be what we read last plus the
             // first character of what we're reading now.
             unsigned char next_c = '\0';
@@ -159,7 +159,7 @@ Pl_LZWDecoder::handleCode(unsigned int code)
                     // The encoder would have just created this entry, so the first character of
                     // this entry would have been the same as the first character of the last entry.
                     QTC::TC("libtests", "Pl_LZWDecoder last was table size");
-                    next_c = getFirstChar(this->last_code);
+                    next_c = getFirstChar(last_code);
                 } else {
                     next_c = getFirstChar(code);
                 }
@@ -171,7 +171,7 @@ Pl_LZWDecoder::handleCode(unsigned int code)
             addToTable(next_c);
             unsigned int change_idx = new_idx + code_change_delta;
             if ((change_idx == 511) || (change_idx == 1023) || (change_idx == 2047)) {
-                ++this->code_size;
+                ++code_size;
             }
         }
@@ -188,5 +188,5 @@ Pl_LZWDecoder::handleCode(unsigned int code)
         }
     }
-    this->last_code = code;
+    last_code = code;
 }
@@ -13,10 +13,10 @@ Pl_MD5::Pl_MD5(char const* identifier, Pipeline* next) :
 void
 Pl_MD5::write(unsigned char const* buf, size_t len)
 {
-    if (this->enabled) {
-        if (!this->in_progress) {
-            this->md5.reset();
-            this->in_progress = true;
+    if (enabled) {
+        if (!in_progress) {
+            md5.reset();
+            in_progress = true;
         }
         // Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
@@ -25,7 +25,7 @@ Pl_MD5::write(unsigned char const* buf, size_t len)
         unsigned char const* data = buf;
         while (bytes_left > 0) {
             size_t bytes = (bytes_left >= max_bytes ? max_bytes : bytes_left);
-            this->md5.encodeDataIncrementally(reinterpret_cast<char const*>(data), bytes);
+            md5.encodeDataIncrementally(reinterpret_cast<char const*>(data), bytes);
             bytes_left -= bytes;
             data += bytes;
         }
@@ -38,29 +38,29 @@ void
 Pl_MD5::finish()
 {
     next()->finish();
-    if (!this->persist_across_finish) {
-        this->in_progress = false;
+    if (!persist_across_finish) {
+        in_progress = false;
     }
 }
 void
-Pl_MD5::enable(bool enabled)
+Pl_MD5::enable(bool is_enabled)
 {
-    this->enabled = enabled;
+    enabled = is_enabled;
 }
 void
 Pl_MD5::persistAcrossFinish(bool persist)
 {
-    this->persist_across_finish = persist;
+    persist_across_finish = persist;
 }
 std::string
 Pl_MD5::getHexDigest()
 {
-    if (!this->enabled) {
+    if (!enabled) {
         throw std::logic_error("digest requested for a disabled MD5 Pipeline");
     }
-    this->in_progress = false;
-    return this->md5.unparse();
+    in_progress = false;
+    return md5.unparse();
 }
@@ -2,6 +2,7 @@
 #include <qpdf/QPDFCryptoProvider.hh>
 #include <qpdf/QUtil.hh>
+
 #include <stdexcept>
 Pl_SHA2::Pl_SHA2(int bits, Pipeline* next) :
@@ -15,8 +16,8 @@ Pl_SHA2::Pl_SHA2(int bits, Pipeline* next) :
 void
 Pl_SHA2::write(unsigned char const* buf, size_t len)
 {
-    if (!this->in_progress) {
-        this->in_progress = true;
+    if (!in_progress) {
+        in_progress = true;
     }
     // Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
@@ -25,7 +26,7 @@ Pl_SHA2::write(unsigned char const* buf, size_t len)
     unsigned char const* data = buf;
     while (bytes_left > 0) {
         size_t bytes = (bytes_left >= max_bytes ? max_bytes : bytes_left);
-        this->crypto->SHA2_update(data, bytes);
+        crypto->SHA2_update(data, bytes);
         bytes_left -= bytes;
         data += bytes;
     }
@@ -41,33 +42,33 @@ Pl_SHA2::finish()
     if (next()) {
         next()->finish();
     }
-    this->crypto->SHA2_finalize();
-    this->in_progress = false;
+    crypto->SHA2_finalize();
+    in_progress = false;
 }
 void
 Pl_SHA2::resetBits(int bits)
 {
-    if (this->in_progress) {
+    if (in_progress) {
         throw std::logic_error("bit reset requested for in-progress SHA2 Pipeline");
     }
-    this->crypto = QPDFCryptoProvider::getImpl();
-    this->crypto->SHA2_init(bits);
+    crypto = QPDFCryptoProvider::getImpl();
+    crypto->SHA2_init(bits);
 }
 std::string
 Pl_SHA2::getRawDigest()
 {
-    if (this->in_progress) {
+    if (in_progress) {
         throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
     }
-    return this->crypto->SHA2_digest();
+    return crypto->SHA2_digest();
 }
 std::string
 Pl_SHA2::getHexDigest()
 {
-    if (this->in_progress) {
+    if (in_progress) {
         throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
     }
     return QUtil::hex_encode(getRawDigest());
@@ -18,14 +18,14 @@ QPDFCrypto_gnutls::QPDFCrypto_gnutls() :
 QPDFCrypto_gnutls::~QPDFCrypto_gnutls()
 {
-    if (this->hash_ctx) {
-        gnutls_hash_deinit(this->hash_ctx, digest);
+    if (hash_ctx) {
+        gnutls_hash_deinit(hash_ctx, digest);
     }
     if (cipher_ctx) {
-        gnutls_cipher_deinit(this->cipher_ctx);
+        gnutls_cipher_deinit(cipher_ctx);
     }
-    this->aes_key_data = nullptr;
-    this->aes_key_len = 0;
+    aes_key_data = nullptr;
+    aes_key_len = 0;
 }
 void
@@ -43,9 +43,9 @@ void
 QPDFCrypto_gnutls::MD5_init()
 {
     MD5_finalize();
-    int code = gnutls_hash_init(&this->hash_ctx, GNUTLS_DIG_MD5);
+    int code = gnutls_hash_init(&hash_ctx, GNUTLS_DIG_MD5);
     if (code < 0) {
-        this->hash_ctx = nullptr;
+        hash_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: MD5 error: ") + std::string(gnutls_strerror(code)));
     }
@@ -54,22 +54,22 @@ QPDFCrypto_gnutls::MD5_init()
 void
 QPDFCrypto_gnutls::MD5_update(unsigned char const* data, size_t len)
 {
-    gnutls_hash(this->hash_ctx, data, len);
+    gnutls_hash(hash_ctx, data, len);
 }
 void
 QPDFCrypto_gnutls::MD5_finalize()
 {
-    if (this->hash_ctx) {
-        gnutls_hash_deinit(this->hash_ctx, this->digest);
-        this->hash_ctx = nullptr;
+    if (hash_ctx) {
+        gnutls_hash_deinit(hash_ctx, digest);
+        hash_ctx = nullptr;
     }
 }
 void
 QPDFCrypto_gnutls::MD5_digest(MD5_Digest d)
 {
-    memcpy(d, this->digest, sizeof(MD5_Digest));
+    memcpy(d, digest, sizeof(MD5_Digest));
 }
 void
@@ -83,9 +83,9 @@ QPDFCrypto_gnutls::RC4_init(unsigned char const* key_data, int key_len)
     key.data = const_cast<unsigned char*>(key_data);
     key.size = QIntC::to_uint(key_len);
-    int code = gnutls_cipher_init(&this->cipher_ctx, GNUTLS_CIPHER_ARCFOUR_128, &key, nullptr);
+    int code = gnutls_cipher_init(&cipher_ctx, GNUTLS_CIPHER_ARCFOUR_128, &key, nullptr);
     if (code < 0) {
-        this->cipher_ctx = nullptr;
+        cipher_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: RC4 error: ") + std::string(gnutls_strerror(code)));
     }
@@ -94,15 +94,15 @@ QPDFCrypto_gnutls::RC4_init(unsigned char const* key_data, int key_len)
 void
 QPDFCrypto_gnutls::RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data)
 {
-    gnutls_cipher_encrypt2(this->cipher_ctx, in_data, len, out_data, len);
+    gnutls_cipher_encrypt2(cipher_ctx, in_data, len, out_data, len);
 }
 void
 QPDFCrypto_gnutls::RC4_finalize()
 {
-    if (this->cipher_ctx) {
-        gnutls_cipher_deinit(this->cipher_ctx);
-        this->cipher_ctx = nullptr;
+    if (cipher_ctx) {
+        gnutls_cipher_deinit(cipher_ctx);
+        cipher_ctx = nullptr;
     }
 }
@@ -125,10 +125,10 @@ QPDFCrypto_gnutls::SHA2_init(int bits)
         badBits();
         break;
     }
-    this->sha2_bits = bits;
-    int code = gnutls_hash_init(&this->hash_ctx, alg);
+    sha2_bits = bits;
+    int code = gnutls_hash_init(&hash_ctx, alg);
     if (code < 0) {
-        this->hash_ctx = nullptr;
+        hash_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: SHA") + std::to_string(bits) +
             " error: " + std::string(gnutls_strerror(code)));
@@ -138,15 +138,15 @@ QPDFCrypto_gnutls::SHA2_init(int bits)
 void
 QPDFCrypto_gnutls::SHA2_update(unsigned char const* data, size_t len)
 {
-    gnutls_hash(this->hash_ctx, data, len);
+    gnutls_hash(hash_ctx, data, len);
 }
 void
 QPDFCrypto_gnutls::SHA2_finalize()
 {
-    if (this->hash_ctx) {
-        gnutls_hash_deinit(this->hash_ctx, this->digest);
-        this->hash_ctx = nullptr;
+    if (hash_ctx) {
+        gnutls_hash_deinit(hash_ctx, digest);
+        hash_ctx = nullptr;
     }
 }
@@ -154,15 +154,15 @@ std::string
 QPDFCrypto_gnutls::SHA2_digest()
 {
     std::string result;
-    switch (this->sha2_bits) {
+    switch (sha2_bits) {
     case 256:
-        result = std::string(reinterpret_cast<char*>(this->digest), 32);
+        result = std::string(reinterpret_cast<char*>(digest), 32);
         break;
     case 384:
-        result = std::string(reinterpret_cast<char*>(this->digest), 48);
+        result = std::string(reinterpret_cast<char*>(digest), 48);
         break;
     case 512:
-        result = std::string(reinterpret_cast<char*>(this->digest), 64);
+        result = std::string(reinterpret_cast<char*>(digest), 64);
         break;
     default:
         badBits();
@@ -184,8 +184,8 @@ QPDFCrypto_gnutls::rijndael_init(
     this->cbc_mode = cbc_mode;
     if (!cbc_mode) {
         // Save the key so we can re-initialize.
-        this->aes_key_data = key_data;
-        this->aes_key_len = key_len;
+        aes_key_data = key_data;
+        aes_key_len = key_len;
     }
     gnutls_cipher_algorithm_t alg = GNUTLS_CIPHER_UNKNOWN;
@@ -214,9 +214,9 @@ QPDFCrypto_gnutls::rijndael_init(
     iv.data = cbc_block;
     iv.size = rijndael_buf_size;
-    int code = gnutls_cipher_init(&this->cipher_ctx, alg, &cipher_key, &iv);
+    int code = gnutls_cipher_init(&cipher_ctx, alg, &cipher_key, &iv);
     if (code < 0) {
-        this->cipher_ctx = nullptr;
+        cipher_ctx = nullptr;
         throw std::runtime_error(
             std::string("gnutls: AES error: ") + std::string(gnutls_strerror(code)));
     }
@@ -225,29 +225,27 @@ QPDFCrypto_gnutls::rijndael_init(
 void
 QPDFCrypto_gnutls::rijndael_process(unsigned char* in_data, unsigned char* out_data)
 {
-    if (this->encrypt) {
-        gnutls_cipher_encrypt2(
-            this->cipher_ctx, in_data, rijndael_buf_size, out_data, rijndael_buf_size);
+    if (encrypt) {
+        gnutls_cipher_encrypt2(cipher_ctx, in_data, rijndael_buf_size, out_data, rijndael_buf_size);
     } else {
-        gnutls_cipher_decrypt2(
-            this->cipher_ctx, in_data, rijndael_buf_size, out_data, rijndael_buf_size);
+        gnutls_cipher_decrypt2(cipher_ctx, in_data, rijndael_buf_size, out_data, rijndael_buf_size);
     }
     // Gnutls doesn't support AES in ECB (non-CBC) mode, but the result is the same as if you just
     // reset the cbc block to all zeroes each time. We jump through a few hoops here to make this
     // work.
-    if (!this->cbc_mode) {
+    if (!cbc_mode) {
         static unsigned char zeroes[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        rijndael_init(this->encrypt, this->aes_key_data, this->aes_key_len, false, zeroes);
+        rijndael_init(encrypt, aes_key_data, aes_key_len, false, zeroes);
     }
 }
 void
 QPDFCrypto_gnutls::rijndael_finalize()
 {
-    if (this->cipher_ctx) {
-        gnutls_cipher_deinit(this->cipher_ctx);
-        this->cipher_ctx = nullptr;
+    if (cipher_ctx) {
+        gnutls_cipher_deinit(cipher_ctx);
+        cipher_ctx = nullptr;
     }
 }
@@ -40,37 +40,37 @@ QPDFCrypto_native::provideRandomData(unsigned char* data, size_t len)
 void
 QPDFCrypto_native::MD5_init()
 {
-    this->md5 = std::make_shared<MD5_native>();
+    md5 = std::make_shared<MD5_native>();
 }
 void
 QPDFCrypto_native::MD5_update(unsigned char const* data, size_t len)
 {
-    this->md5->update(const_cast<unsigned char*>(data), len);
+    md5->update(const_cast<unsigned char*>(data), len);
 }
 void
 QPDFCrypto_native::MD5_finalize()
 {
-    this->md5->finalize();
+    md5->finalize();
 }
 void
 QPDFCrypto_native::MD5_digest(MD5_Digest d)
 {
-    this->md5->digest(d);
+    md5->digest(d);
 }
 void
 QPDFCrypto_native::RC4_init(unsigned char const* key_data, int key_len)
 {
-    this->rc4 = std::make_shared<RC4_native>(key_data, key_len);
+    rc4 = std::make_shared<RC4_native>(key_data, key_len);
 }
 void
 QPDFCrypto_native::RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data)
 {
-    this->rc4->process(in_data, len, out_data);
+    rc4->process(in_data, len, out_data);
 }
 void
@@ -81,25 +81,25 @@ QPDFCrypto_native::RC4_finalize()
 void
 QPDFCrypto_native::SHA2_init(int bits)
 {
-    this->sha2 = std::make_shared<SHA2_native>(bits);
+    sha2 = std::make_shared<SHA2_native>(bits);
 }
 void
 QPDFCrypto_native::SHA2_update(unsigned char const* data, size_t len)
 {
-    this->sha2->update(data, len);
+    sha2->update(data, len);
 }
 void
 QPDFCrypto_native::SHA2_finalize()
 {
-    this->sha2->finalize();
+    sha2->finalize();
 }
 std::string
 QPDFCrypto_native::SHA2_digest()
 {
-    return this->sha2->getRawDigest();
+    return sha2->getRawDigest();
 }
 void
@@ -111,14 +111,13 @@ QPDFCrypto_native::rijndael_init(
     unsigned char* cbc_block)
 {
-    this->aes_pdf =
-        std::make_shared<AES_PDF_native>(encrypt, key_data, key_len, cbc_mode, cbc_block);
+    aes_pdf = std::make_shared<AES_PDF_native>(encrypt, key_data, key_len, cbc_mode, cbc_block);
 }
 void
 QPDFCrypto_native::rijndael_process(unsigned char* in_data, unsigned char* out_data)
 {
-    this->aes_pdf->update(in_data, out_data);
+    aes_pdf->update(in_data, out_data);
 }
 void
@@ -236,9 +236,7 @@ QPDFCrypto_openssl::rijndael_init(
     }
     check_openssl(EVP_CIPHER_CTX_reset(cipher_ctx));
-    check_openssl(
-        // line-break
-        EVP_CipherInit_ex(cipher_ctx, cipher, nullptr, key_data, cbc_block, encrypt));
+    check_openssl(EVP_CipherInit_ex(cipher_ctx, cipher, nullptr, key_data, cbc_block, encrypt));
     check_openssl(EVP_CIPHER_CTX_set_padding(cipher_ctx, 0));
 }
@@ -63,7 +63,7 @@ QPDFEmbeddedFileDocumentHelper::initEmbeddedFiles()
     }
     auto embedded_files = names.getKey("/EmbeddedFiles");
     if (!embedded_files.isDictionary()) {
-        auto nth = QPDFNameTreeObjectHelper::newEmpty(this->qpdf);
+        auto nth = QPDFNameTreeObjectHelper::newEmpty(qpdf);
         names.replaceKey("/EmbeddedFiles", nth.getObjectHandle());
         m->embedded_files = std::make_shared<QPDFNameTreeObjectHelper>(nth);
     }
@@ -115,7 +115,7 @@ QPDFEmbeddedFileDocumentHelper::removeEmbeddedFile(std::string const&amp; name)
     auto oh = iter->second;
     iter.remove();
     if (oh.isIndirect()) {
-        this->qpdf.replaceObject(oh.getObjGen(), QPDFObjectHandle::newNull());
+        qpdf.replaceObject(oh.getObjGen(), QPDFObjectHandle::newNull());
     }
     return true;
@@ -655,15 +655,76 @@ ValueSetter::writeAppearance()
 namespace
 {
-    class TfFinder: public QPDFObjectHandle::TokenFilter
+    class TfFinder final: public QPDFObjectHandle::TokenFilter
     {
       public:
         TfFinder() = default;
-        ~TfFinder() override = default;
-        void handleToken(QPDFTokenizer::Token const&) override;
-        double getTf();
-        std::string getFontName();
-        std::string getDA();
+        ~TfFinder() final = default;
+
+        void
+        handleToken(QPDFTokenizer::Token const& token) final
+        {
+            auto ttype = token.getType();
+            auto const& value = token.getValue();
+            DA.emplace_back(token.getRawValue());
+            switch (ttype) {
+            case QPDFTokenizer::tt_integer:
+            case QPDFTokenizer::tt_real:
+                last_num = strtod(value.c_str(), nullptr);
+                last_num_idx = QIntC::to_int(DA.size() - 1);
+                break;
+
+            case QPDFTokenizer::tt_name:
+                last_name = value;
+                break;
+
+            case QPDFTokenizer::tt_word:
+                if (token.isWord("Tf")) {
+                    if ((last_num > 1.0) && (last_num < 1000.0)) {
+                        // These ranges are arbitrary but keep us from doing insane things or
+                        // suffering from over/underflow
+                        tf = last_num;
+                    }
+                    tf_idx = last_num_idx;
+                    font_name = last_name;
+                }
+                break;
+
+            default:
+                break;
+            }
+        }
+
+        double
+        getTf() const
+        {
+            return tf;
+        }
+        std::string
+        getFontName() const
+        {
+            return font_name;
+        }
+
+        std::string
+        getDA()
+        {
+            std::string result;
+            int i = -1;
+            for (auto const& cur: DA) {
+                if (++i == tf_idx) {
+                    double delta = strtod(cur.c_str(), nullptr) - tf;
+                    if (delta > 0.001 || delta < -0.001) {
+                        // tf doesn't match the font size passed to Tf, so substitute.
+                        QTC::TC("qpdf", "QPDFFormFieldObjectHelper fallback Tf");
+                        result += QUtil::double_to_string(tf);
+                        continue;
+                    }
+                }
+                result += cur;
+            }
+            return result;
+        }
       private:
         double tf{11.0};
@@ -676,72 +737,6 @@ namespace
     };
 } // namespace
-void
-TfFinder::handleToken(QPDFTokenizer::Token const& token)
-{
-    QPDFTokenizer::token_type_e ttype = token.getType();
-    std::string value = token.getValue();
-    DA.push_back(token.getRawValue());
-    switch (ttype) {
-    case QPDFTokenizer::tt_integer:
-    case QPDFTokenizer::tt_real:
-        last_num = strtod(value.c_str(), nullptr);
-        last_num_idx = QIntC::to_int(DA.size() - 1);
-        break;
-
-    case QPDFTokenizer::tt_name:
-        last_name = value;
-        break;
-
-    case QPDFTokenizer::tt_word:
-        if (token.isWord("Tf")) {
-            if ((last_num > 1.0) && (last_num < 1000.0)) {
-                // These ranges are arbitrary but keep us from doing insane things or suffering from
-                // over/underflow
-                tf = last_num;
-            }
-            tf_idx = last_num_idx;
-            font_name = last_name;
-        }
-        break;
-
-    default:
-        break;
-    }
-}
-
-double
-TfFinder::getTf()
-{
-    return tf;
-}
-
-std::string
-TfFinder::getDA()
-{
-    std::string result;
-    size_t n = DA.size();
-    for (size_t i = 0; i < n; ++i) {
-        std::string cur = DA.at(i);
-        if (QIntC::to_int(i) == tf_idx) {
-            double delta = strtod(cur.c_str(), nullptr) - tf;
-            if ((delta > 0.001) || (delta < -0.001)) {
-                // tf doesn't match the font size passed to Tf, so substitute.
-                QTC::TC("qpdf", "QPDFFormFieldObjectHelper fallback Tf");
-                cur = QUtil::double_to_string(tf);
-            }
-        }
-        result += cur;
-    }
-    return result;
-}
-
-std::string
-TfFinder::getFontName()
-{
-    return font_name;
-}
-
 QPDFObjectHandle
 QPDFFormFieldObjectHelper::getFontFromResource(QPDFObjectHandle resources, std::string const& name)
 {
@@ -89,11 +89,11 @@ QPDFNameTreeObjectHelper::iterator::updateIValue()
 {
     if (impl->valid()) {
         auto p = *impl;
-        this->ivalue.first = p->first.getUTF8Value();
-        this->ivalue.second = p->second;
+        ivalue.first = p->first.getUTF8Value();
+        ivalue.second = p->second;
     } else {
-        this->ivalue.first = "";
-        this->ivalue.second = QPDFObjectHandle();
+        ivalue.first = "";
+        ivalue.second = QPDFObjectHandle();
     }
 }
@@ -101,14 +101,14 @@ QPDFNameTreeObjectHelper::iterator::reference
 QPDFNameTreeObjectHelper::iterator::operator*()
 {
     updateIValue();
-    return this->ivalue;
+    return ivalue;
 }
 QPDFNameTreeObjectHelper::iterator::pointer
 QPDFNameTreeObjectHelper::iterator::operator->()
 {
     updateIValue();
-    return &this->ivalue;
+    return &ivalue;
 }
 bool
+#include <qpdf/assert_debug.h>
+
 #include <qpdf/QPDFObjectHandle_private.hh>
-#include <qpdf/BufferInputSource.hh>
+#include <qpdf/InputSource_private.hh>
 #include <qpdf/JSON_writer.hh>
+#include <qpdf/Pipeline_private.hh>
 #include <qpdf/Pl_Buffer.hh>
 #include <qpdf/Pl_QPDFTokenizer.hh>
+#include <qpdf/QIntC.hh>
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFExc.hh>
 #include <qpdf/QPDFLogger.hh>
@@ -11,13 +15,9 @@
 #include <qpdf/QPDFObject_private.hh>
 #include <qpdf/QPDFPageObjectHelper.hh>
 #include <qpdf/QPDFParser.hh>
-
-#include <qpdf/QIntC.hh>
 #include <qpdf/QTC.hh>
-#include <qpdf/QUtil.hh>
 #include <qpdf/Util.hh>
-#include <algorithm>
 #include <array>
 #include <cctype>
 #include <climits>
@@ -174,48 +174,6 @@ QPDFObjectHandle::ParserCallbacks::terminateParsing()
     throw TerminateParsing();
 }
-namespace
-{
-    class LastChar final: public Pipeline
-    {
-      public:
-        LastChar(Pipeline& next);
-        ~LastChar() final = default;
-        void write(unsigned char const* data, size_t len) final;
-        void finish() final;
-        unsigned char getLastChar();
-
-      private:
-        unsigned char last_char{0};
-    };
-} // namespace
-
-LastChar::LastChar(Pipeline& next) :
-    Pipeline("lastchar", &next)
-{
-}
-
-void
-LastChar::write(unsigned char const* data, size_t len)
-{
-    if (len > 0) {
-        last_char = data[len - 1];
-    }
-    next()->write(data, len);
-}
-
-void
-LastChar::finish()
-{
-    next()->finish();
-}
-
-unsigned char
-LastChar::getLastChar()
-{
-    return last_char;
-}
-
 std::pair<bool, bool>
 Name::analyzeJSONEncoding(const std::string& name)
 {
@@ -1527,16 +1485,14 @@ void
 QPDFObjectHandle::pipeContentStreams(
     Pipeline* p, std::string const& description, std::string& all_description)
 {
-    std::vector<QPDFObjectHandle> streams =
-        arrayOrStreamToStreamArray(description, all_description);
     bool need_newline = false;
-    Pl_Buffer buf("concatenated content stream buffer");
-    for (auto stream: streams) {
+    std::string buffer;
+    pl::String buf(buffer);
+    for (auto stream: arrayOrStreamToStreamArray(description, all_description)) {
         if (need_newline) {
             buf.writeCStr("\n");
         }
-        LastChar lc(buf);
-        if (!stream.pipeStreamData(&lc, 0, qpdf_dl_specialized)) {
+        if (!stream.pipeStreamData(&buf, 0, qpdf_dl_specialized)) {
             QTC::TC("qpdf", "QPDFObjectHandle errors in parsecontent");
             throw QPDFExc(
                 qpdf_e_damaged_pdf,
@@ -1545,11 +1501,11 @@ QPDFObjectHandle::pipeContentStreams(
                 0,
                 "errors while decoding content stream");
         }
-        lc.finish();
-        need_newline = (lc.getLastChar() != static_cast<unsigned char>('\n'));
+        need_newline = buffer.empty() || buffer.back() != '\n';
         QTC::TC("qpdf", "QPDFObjectHandle need_newline", need_newline ? 0 : 1);
+        p->writeString(buffer);
+        buffer.clear();
     }
-    p->writeString(buf.getString());
     p->finish();
 }
@@ -1169,8 +1169,8 @@ QPDFObjectHandle
 QPDF::readTrailer()
 {
     qpdf_offset_t offset = m->file->tell();
-    auto [object, empty] = QPDFParser::parse(
-        *m->file, "trailer", m->tokenizer, nullptr, *this, m->reconstructed_xref);
+    auto [object, empty] =
+        QPDFParser::parse(*m->file, "trailer", m->tokenizer, nullptr, *this, m->reconstructed_xref);
     if (empty) {
         // Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
         // actual PDF files and Adobe Reader appears to ignore them.
@@ -5,11 +5,11 @@
 RC4::RC4(unsigned char const* key_data, int key_len) :
     crypto(QPDFCryptoProvider::getImpl())
 {
-    this->crypto->RC4_init(key_data, key_len);
+    crypto->RC4_init(key_data, key_len);
 }
 void
 RC4::process(unsigned char const* in_data, size_t len, unsigned char* out_data)
 {
-    this->crypto->RC4_process(in_data, len, out_data);
+    crypto->RC4_process(in_data, len, out_data);
 }
@@ -46,6 +46,12 @@ namespace qpdf::pl
         {
         }
+        String(std::string& str) :
+            Pipeline("", nullptr),
+            str(str)
+        {
+        }
+
         ~String() final = default;
         void
@@ -6,6 +6,7 @@
 #include <qpdf/QPDFCryptoImpl.hh>
 #include <qpdf/RC4_native.hh>
 #include <qpdf/SHA2_native.hh>
+
 #include <memory>
 class QPDFCrypto_native final: public QPDFCryptoImpl