Revert "Merge pull request #1272 from m-holger/xref_table"

This reverts commit ff2a78f579ebdd06b417e34260a17dba06e71137, reversing changes made to 8f54319f7a6514110f4b05cbbf1cb1c9fc8cb6a0.

Revert "Merge pull request #1272 from m-holger/xref_table"
This reverts commit ff2a78f579ebdd06b417e34260a17dba06e71137, reversing changes made to 8f54319f7a6514110f4b05cbbf1cb1c9fc8cb6a0.
m-holger
1 parent f1800410
Showing 24 changed files with 1171 additions and 1632 deletions
include/qpdf/QPDF.hh
libqpdf/QPDF.cc
libqpdf/QPDFJob.cc
libqpdf/QPDFWriter.cc
libqpdf/QPDF_Stream.cc
libqpdf/QPDF_encryption.cc
libqpdf/QPDF_json.cc
libqpdf/QPDF_linearization.cc
libqpdf/QPDF_optimization.cc
libqpdf/QPDF_pages.cc
libqpdf/qpdf/ObjTable.hh
libqpdf/qpdf/QPDFObject_private.hh
libqpdf/qpdf/QPDF_private.hh
libqpdf/qpdf/qpdf-c_impl.hh
qpdf/qpdf.testcov
qpdf/qtest/qpdf/bad12-recover.out
qpdf/qtest/qpdf/bad12.out
qpdf/qtest/qpdf/fuzz-16214.out
qpdf/qtest/qpdf/issue-147.out
qpdf/qtest/qpdf/issue-335b.out
@@ -725,15 +725,165 @@ class QPDF
     void removePage(QPDFObjectHandle page);
     // End legacy page helpers
  
-    // End of the public API. The following classes and methods are for qpdf internal use only.
+    // Writer class is restricted to QPDFWriter so that only it can call certain methods.
+    class Writer
+    {
+        friend class QPDFWriter;
+
+      private:
+        static void
+        optimize(
+            QPDF& qpdf,
+            QPDFWriter::ObjTable const& obj,
+            std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
+        {
+            return qpdf.optimize(obj, skip_stream_parameters);
+        }
+
+        static void
+        getLinearizedParts(
+            QPDF& qpdf,
+            QPDFWriter::ObjTable const& obj,
+            std::vector<QPDFObjectHandle>& part4,
+            std::vector<QPDFObjectHandle>& part6,
+            std::vector<QPDFObjectHandle>& part7,
+            std::vector<QPDFObjectHandle>& part8,
+            std::vector<QPDFObjectHandle>& part9)
+        {
+            qpdf.getLinearizedParts(obj, part4, part6, part7, part8, part9);
+        }
+
+        static void
+        generateHintStream(
+            QPDF& qpdf,
+            QPDFWriter::NewObjTable const& new_obj,
+            QPDFWriter::ObjTable const& obj,
+            std::shared_ptr<Buffer>& hint_stream,
+            int& S,
+            int& O,
+            bool compressed)
+        {
+            return qpdf.generateHintStream(new_obj, obj, hint_stream, S, O, compressed);
+        }
+
+        static std::vector<QPDFObjGen>
+        getCompressibleObjGens(QPDF& qpdf)
+        {
+            return qpdf.getCompressibleObjVector();
+        }
+
+        static std::vector<bool>
+        getCompressibleObjSet(QPDF& qpdf)
+        {
+            return qpdf.getCompressibleObjSet();
+        }
+
+        static std::map<QPDFObjGen, QPDFXRefEntry> const&
+        getXRefTable(QPDF& qpdf)
+        {
+            return qpdf.getXRefTableInternal();
+        }
+
+        static size_t
+        tableSize(QPDF& qpdf)
+        {
+            return qpdf.tableSize();
+        }
+    };
+
+    // The Resolver class is restricted to QPDFObject so that only it can resolve indirect
+    // references.
+    class Resolver
+    {
+        friend class QPDFObject;
+        friend class QPDF_Unresolved;
+
+      private:
+        static QPDFObject*
+        resolved(QPDF* qpdf, QPDFObjGen og)
+        {
+            return qpdf->resolve(og);
+        }
+    };
+
+    // StreamCopier class is restricted to QPDFObjectHandle so it can copy stream data.
+    class StreamCopier
+    {
+        friend class QPDFObjectHandle;
+
+      private:
+        static void
+        copyStreamData(QPDF* qpdf, QPDFObjectHandle const& dest, QPDFObjectHandle const& src)
+        {
+            qpdf->copyStreamData(dest, src);
+        }
+    };
+
+    // The ParseGuard class allows QPDFParser to detect re-entrant parsing. It also provides
+    // special access to allow the parser to create unresolved objects and dangling references.
+    class ParseGuard
+    {
+        friend class QPDFParser;
+
+      private:
+        ParseGuard(QPDF* qpdf) :
+            qpdf(qpdf)
+        {
+            if (qpdf) {
+                qpdf->inParse(true);
+            }
+        }
+
+        static std::shared_ptr<QPDFObject>
+        getObject(QPDF* qpdf, int id, int gen, bool parse_pdf)
+        {
+            return qpdf->getObjectForParser(id, gen, parse_pdf);
+        }
  
-    class Writer;
-    class Resolver;
-    class StreamCopier;
-    class ParseGuard;
-    class Pipe;
-    class JobSetter;
-    class Xref_table;
+        ~ParseGuard()
+        {
+            if (qpdf) {
+                qpdf->inParse(false);
+            }
+        }
+        QPDF* qpdf;
+    };
+
+    // Pipe class is restricted to QPDF_Stream.
+    class Pipe
+    {
+        friend class QPDF_Stream;
+
+      private:
+        static bool
+        pipeStreamData(
+            QPDF* qpdf,
+            QPDFObjGen const& og,
+            qpdf_offset_t offset,
+            size_t length,
+            QPDFObjectHandle dict,
+            Pipeline* pipeline,
+            bool suppress_warnings,
+            bool will_retry)
+        {
+            return qpdf->pipeStreamData(
+                og, offset, length, dict, pipeline, suppress_warnings, will_retry);
+        }
+    };
+
+    // JobSetter class is restricted to QPDFJob.
+    class JobSetter
+    {
+        friend class QPDFJob;
+
+      private:
+        // Enable enhanced warnings for pdf file checking.
+        static void
+        setCheckMode(QPDF& qpdf, bool val)
+        {
+            qpdf.m->check_mode = val;
+        }
+    };
  
     // For testing only -- do not add to DLL
     static bool test_json_validators();
@@ -748,18 +898,163 @@ class QPDF
  
     static std::string const qpdf_version;
  
-    class ObjCache;
-    class ObjCopier;
-    class EncryptionParameters;
-    class ForeignStreamData;
-    class CopiedStreamDataProvider;
-    class StringDecrypter;
-    class ResolveRecorder;
+    class ObjCache
+    {
+      public:
+        ObjCache() :
+            end_before_space(0),
+            end_after_space(0)
+        {
+        }
+        ObjCache(
+            std::shared_ptr<QPDFObject> object,
+            qpdf_offset_t end_before_space = 0,
+            qpdf_offset_t end_after_space = 0) :
+            object(object),
+            end_before_space(end_before_space),
+            end_after_space(end_after_space)
+        {
+        }
+
+        std::shared_ptr<QPDFObject> object;
+        qpdf_offset_t end_before_space;
+        qpdf_offset_t end_after_space;
+    };
+
+    class ObjCopier
+    {
+      public:
+        std::map<QPDFObjGen, QPDFObjectHandle> object_map;
+        std::vector<QPDFObjectHandle> to_copy;
+        QPDFObjGen::set visiting;
+    };
+
+    class EncryptionParameters
+    {
+        friend class QPDF;
+
+      public:
+        EncryptionParameters();
+
+      private:
+        bool encrypted;
+        bool encryption_initialized;
+        int encryption_V;
+        int encryption_R;
+        bool encrypt_metadata;
+        std::map<std::string, encryption_method_e> crypt_filters;
+        encryption_method_e cf_stream;
+        encryption_method_e cf_string;
+        encryption_method_e cf_file;
+        std::string provided_password;
+        std::string user_password;
+        std::string encryption_key;
+        std::string cached_object_encryption_key;
+        QPDFObjGen cached_key_og;
+        bool user_password_matched;
+        bool owner_password_matched;
+    };
+
+    class ForeignStreamData
+    {
+        friend class QPDF;
+
+      public:
+        ForeignStreamData(
+            std::shared_ptr<EncryptionParameters> encp,
+            std::shared_ptr<InputSource> file,
+            QPDFObjGen const& foreign_og,
+            qpdf_offset_t offset,
+            size_t length,
+            QPDFObjectHandle local_dict);
+
+      private:
+        std::shared_ptr<EncryptionParameters> encp;
+        std::shared_ptr<InputSource> file;
+        QPDFObjGen foreign_og;
+        qpdf_offset_t offset;
+        size_t length;
+        QPDFObjectHandle local_dict;
+    };
+
+    class CopiedStreamDataProvider: public QPDFObjectHandle::StreamDataProvider
+    {
+      public:
+        CopiedStreamDataProvider(QPDF& destination_qpdf);
+        ~CopiedStreamDataProvider() override = default;
+        bool provideStreamData(
+            QPDFObjGen const& og,
+            Pipeline* pipeline,
+            bool suppress_warnings,
+            bool will_retry) override;
+        void registerForeignStream(QPDFObjGen const& local_og, QPDFObjectHandle foreign_stream);
+        void registerForeignStream(QPDFObjGen const& local_og, std::shared_ptr<ForeignStreamData>);
+
+      private:
+        QPDF& destination_qpdf;
+        std::map<QPDFObjGen, QPDFObjectHandle> foreign_streams;
+        std::map<QPDFObjGen, std::shared_ptr<ForeignStreamData>> foreign_stream_data;
+    };
+
+    class StringDecrypter: public QPDFObjectHandle::StringDecrypter
+    {
+        friend class QPDF;
+
+      public:
+        StringDecrypter(QPDF* qpdf, QPDFObjGen const& og);
+        ~StringDecrypter() override = default;
+        void decryptString(std::string& val) override;
+
+      private:
+        QPDF* qpdf;
+        QPDFObjGen og;
+    };
+
+    class ResolveRecorder
+    {
+      public:
+        ResolveRecorder(QPDF* qpdf, QPDFObjGen const& og) :
+            qpdf(qpdf),
+            iter(qpdf->m->resolving.insert(og).first)
+        {
+        }
+        virtual ~ResolveRecorder()
+        {
+            this->qpdf->m->resolving.erase(iter);
+        }
+
+      private:
+        QPDF* qpdf;
+        std::set<QPDFObjGen>::const_iterator iter;
+    };
+
     class JSONReactor;
  
     void parse(char const* password);
     void inParse(bool);
+    void setTrailer(QPDFObjectHandle obj);
+    void read_xref(qpdf_offset_t offset);
+    bool resolveXRefTable();
+    void reconstruct_xref(QPDFExc& e);
+    bool parse_xrefFirst(std::string const& line, int& obj, int& num, int& bytes);
+    bool read_xrefEntry(qpdf_offset_t& f1, int& f2, char& type);
+    bool read_bad_xrefEntry(qpdf_offset_t& f1, int& f2, char& type);
+    qpdf_offset_t read_xrefTable(qpdf_offset_t offset);
+    qpdf_offset_t read_xrefStream(qpdf_offset_t offset);
+    qpdf_offset_t processXRefStream(qpdf_offset_t offset, QPDFObjectHandle& xref_stream);
+    std::pair<int, std::array<int, 3>>
+    processXRefW(QPDFObjectHandle& dict, std::function<QPDFExc(std::string_view)> damaged);
+    int processXRefSize(
+        QPDFObjectHandle& dict, int entry_size, std::function<QPDFExc(std::string_view)> damaged);
+    std::pair<int, std::vector<std::pair<int, int>>> processXRefIndex(
+        QPDFObjectHandle& dict,
+        int max_num_entries,
+        std::function<QPDFExc(std::string_view)> damaged);
+    void insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2);
+    void insertFreeXrefEntry(QPDFObjGen);
+    void insertReconstructedXrefEntry(int obj, qpdf_offset_t f1, int f2);
     void setLastObjectDescription(std::string const& description, QPDFObjGen const& og);
+    QPDFObjectHandle readTrailer();
     QPDFObjectHandle readObject(std::string const& description, QPDFObjGen og);
     void readStream(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset);
     void validateStreamLineEnd(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset);
@@ -786,7 +1081,11 @@ class QPDF
     std::shared_ptr<QPDFObject> getObjectForParser(int id, int gen, bool parse_pdf);
     std::shared_ptr<QPDFObject> getObjectForJSON(int id, int gen);
     void removeObject(QPDFObjGen og);
-    void updateCache(QPDFObjGen const& og, std::shared_ptr<QPDFObject> const& object);
+    void updateCache(
+        QPDFObjGen const& og,
+        std::shared_ptr<QPDFObject> const& object,
+        qpdf_offset_t end_before_space,
+        qpdf_offset_t end_after_space);
     static QPDFExc damagedPDF(
         InputSource& input,
         std::string const& object,
@@ -823,6 +1122,7 @@ class QPDF
  
     // For QPDFWriter:
  
+    std::map<QPDFObjGen, QPDFXRefEntry> const& getXRefTableInternal();
     template <typename T>
     void optimize_internal(
         T const& object_stream_data,
@@ -831,7 +1131,6 @@ class QPDF
     void optimize(
         QPDFWriter::ObjTable const& obj,
         std::function<int(QPDFObjectHandle&)> skip_stream_parameters);
-    void optimize(Xref_table const& obj);
     size_t tableSize();
  
     // Get lists of all objects in order according to the part of a linearized file that they belong
@@ -897,19 +1196,200 @@ class QPDF
     replaceForeignIndirectObjects(QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top);
     void copyStreamData(QPDFObjectHandle dest_stream, QPDFObjectHandle src_stream);
  
-    struct HPageOffsetEntry;
-    struct HPageOffset;
-    struct HSharedObjectEntry;
-    struct HSharedObject;
-    struct HGeneric;
-    struct LinParameters;
-    struct CHPageOffsetEntry;
-    struct CHPageOffset;
-    struct CHSharedObjectEntry;
-    struct CHSharedObject;
-    class ObjUser;
-    struct UpdateObjectMapsFrame;
-    class PatternFinder;
+    // Linearization Hint table structures.
+    // Naming conventions:
+
+    // HSomething is the Something Hint Table or table header
+    // HSomethingEntry is an entry in the Something table
+
+    // delta_something + min_something = something
+    // nbits_something = number of bits required for something
+
+    // something_offset is the pre-adjusted offset in the file.  If >=
+    // H0_offset, H0_length must be added to get an actual file
+    // offset.
+
+    // PDF 1.4: Table F.4
+    struct HPageOffsetEntry
+    {
+        int delta_nobjects{0};              // 1
+        qpdf_offset_t delta_page_length{0}; // 2
+        // vectors' sizes = nshared_objects
+        int nshared_objects{0};                // 3
+        std::vector<int> shared_identifiers;   // 4
+        std::vector<int> shared_numerators;    // 5
+        qpdf_offset_t delta_content_offset{0}; // 6
+        qpdf_offset_t delta_content_length{0}; // 7
+    };
+
+    // PDF 1.4: Table F.3
+    struct HPageOffset
+    {
+        int min_nobjects{0};                // 1
+        qpdf_offset_t first_page_offset{0}; // 2
+        int nbits_delta_nobjects{0};        // 3
+        int min_page_length{0};             // 4
+        int nbits_delta_page_length{0};     // 5
+        int min_content_offset{0};          // 6
+        int nbits_delta_content_offset{0};  // 7
+        int min_content_length{0};          // 8
+        int nbits_delta_content_length{0};  // 9
+        int nbits_nshared_objects{0};       // 10
+        int nbits_shared_identifier{0};     // 11
+        int nbits_shared_numerator{0};      // 12
+        int shared_denominator{0};          // 13
+        // vector size is npages
+        std::vector<HPageOffsetEntry> entries;
+    };
+
+    // PDF 1.4: Table F.6
+    struct HSharedObjectEntry
+    {
+        // Item 3 is a 128-bit signature (unsupported by Acrobat)
+        int delta_group_length{0}; // 1
+        int signature_present{0};  // 2 -- always 0
+        int nobjects_minus_one{0}; // 4 -- always 0
+    };
+
+    // PDF 1.4: Table F.5
+    struct HSharedObject
+    {
+        int first_shared_obj{0};              // 1
+        qpdf_offset_t first_shared_offset{0}; // 2
+        int nshared_first_page{0};            // 3
+        int nshared_total{0};                 // 4
+        int nbits_nobjects{0};                // 5
+        int min_group_length{0};              // 6
+        int nbits_delta_group_length{0};      // 7
+        // vector size is nshared_total
+        std::vector<HSharedObjectEntry> entries;
+    };
+
+    // PDF 1.4: Table F.9
+    struct HGeneric
+    {
+        int first_object{0};                  // 1
+        qpdf_offset_t first_object_offset{0}; // 2
+        int nobjects{0};                      // 3
+        int group_length{0};                  // 4
+    };
+
+    // Other linearization data structures
+
+    // Initialized from Linearization Parameter dictionary
+    struct LinParameters
+    {
+        qpdf_offset_t file_size{0};        // /L
+        int first_page_object{0};          // /O
+        qpdf_offset_t first_page_end{0};   // /E
+        int npages{0};                     // /N
+        qpdf_offset_t xref_zero_offset{0}; // /T
+        int first_page{0};                 // /P
+        qpdf_offset_t H_offset{0};         // offset of primary hint stream
+        qpdf_offset_t H_length{0};         // length of primary hint stream
+    };
+
+    // Computed hint table value data structures.  These tables contain the computed values on which
+    // the hint table values are based.  They exclude things like number of bits and store actual
+    // values instead of mins and deltas.  File offsets are also absolute rather than being offset
+    // by the size of the primary hint table.  We populate the hint table structures from these
+    // during writing and compare the hint table values with these during validation.  We ignore
+    // some values for various reasons described in the code.  Those values are omitted from these
+    // structures.  Note also that object numbers are object numbers from the input file, not the
+    // output file.
+
+    // Naming convention: CHSomething is analogous to HSomething above.  "CH" is computed hint.
+
+    struct CHPageOffsetEntry
+    {
+        int nobjects{0};
+        int nshared_objects{0};
+        // vectors' sizes = nshared_objects
+        std::vector<int> shared_identifiers;
+    };
+
+    struct CHPageOffset
+    {
+        // vector size is npages
+        std::vector<CHPageOffsetEntry> entries;
+    };
+
+    struct CHSharedObjectEntry
+    {
+        CHSharedObjectEntry(int object) :
+            object(object)
+        {
+        }
+
+        int object;
+    };
+
+    // PDF 1.4: Table F.5
+    struct CHSharedObject
+    {
+        int first_shared_obj{0};
+        int nshared_first_page{0};
+        int nshared_total{0};
+        // vector size is nshared_total
+        std::vector<CHSharedObjectEntry> entries;
+    };
+
+    // No need for CHGeneric -- HGeneric is fine as is.
+
+    // Data structures to support optimization -- implemented in QPDF_optimization.cc
+
+    class ObjUser
+    {
+      public:
+        enum user_e { ou_bad, ou_page, ou_thumb, ou_trailer_key, ou_root_key, ou_root };
+
+        // type is set to ou_bad
+        ObjUser();
+
+        // type must be ou_root
+        ObjUser(user_e type);
+
+        // type must be one of ou_page or ou_thumb
+        ObjUser(user_e type, int pageno);
+
+        // type must be one of ou_trailer_key or ou_root_key
+        ObjUser(user_e type, std::string const& key);
+
+        bool operator<(ObjUser const&) const;
+
+        user_e ou_type;
+        int pageno;      // if ou_page;
+        std::string key; // if ou_trailer_key or ou_root_key
+    };
+
+    struct UpdateObjectMapsFrame
+    {
+        UpdateObjectMapsFrame(ObjUser const& ou, QPDFObjectHandle oh, bool top);
+
+        ObjUser const& ou;
+        QPDFObjectHandle oh;
+        bool top;
+    };
+
+    class PatternFinder: public InputSource::Finder
+    {
+      public:
+        PatternFinder(QPDF& qpdf, bool (QPDF::*checker)()) :
+            qpdf(qpdf),
+            checker(checker)
+        {
+        }
+        ~PatternFinder() override = default;
+        bool
+        check() override
+        {
+            return (this->qpdf.*checker)();
+        }
+
+      private:
+        QPDF& qpdf;
+        bool (QPDF::*checker)();
+    };
  
     // Methods to support pattern finding
     static bool validatePDFVersion(char const*&, std::string& version);
@@ -931,7 +1411,6 @@ class QPDF
     QPDFObjectHandle
     getUncompressedObject(QPDFObjectHandle&, std::map<int, int> const& object_stream_data);
     QPDFObjectHandle getUncompressedObject(QPDFObjectHandle&, QPDFWriter::ObjTable const& obj);
-    QPDFObjectHandle getUncompressedObject(QPDFObjectHandle&, Xref_table const& obj);
     int lengthNextN(int first_object, int n);
     void
     checkHPageOffset(std::vector<QPDFObjectHandle> const& pages, std::map<int, int>& idx_to_obj);
@@ -977,7 +1456,6 @@ class QPDF
         std::function<int(QPDFObjectHandle&)> skip_stream_parameters);
     void filterCompressedObjects(std::map<int, int> const& object_stream_data);
     void filterCompressedObjects(QPDFWriter::ObjTable const& object_stream_data);
-    void filterCompressedObjects(Xref_table const& object_stream_data);
  
     // JSON import
     void importJSON(std::shared_ptr<InputSource>, bool must_be_complete);
@@ -1008,7 +1486,90 @@ class QPDF
         return QIntC::to_ulonglong(i);
     }
  
-    class Members;
+    class Members
+    {
+        friend class QPDF;
+        friend class ResolveRecorder;
+
+      public:
+        QPDF_DLL
+        ~Members() = default;
+
+      private:
+        Members();
+        Members(Members const&) = delete;
+
+        std::shared_ptr<QPDFLogger> log;
+        unsigned long long unique_id{0};
+        QPDFTokenizer tokenizer;
+        std::shared_ptr<InputSource> file;
+        std::string last_object_description;
+        bool provided_password_is_hex_key{false};
+        bool ignore_xref_streams{false};
+        bool suppress_warnings{false};
+        size_t max_warnings{0};
+        bool attempt_recovery{true};
+        bool check_mode{false};
+        std::shared_ptr<EncryptionParameters> encp;
+        std::string pdf_version;
+        std::map<QPDFObjGen, QPDFXRefEntry> xref_table;
+        // Various tables are indexed by object id, with potential size id + 1
+        int xref_table_max_id{std::numeric_limits<int>::max() - 1};
+        qpdf_offset_t xref_table_max_offset{0};
+        std::set<int> deleted_objects;
+        std::map<QPDFObjGen, ObjCache> obj_cache;
+        std::set<QPDFObjGen> resolving;
+        QPDFObjectHandle trailer;
+        std::vector<QPDFObjectHandle> all_pages;
+        bool invalid_page_found{false};
+        std::map<QPDFObjGen, int> pageobj_to_pages_pos;
+        bool pushed_inherited_attributes_to_pages{false};
+        bool ever_pushed_inherited_attributes_to_pages{false};
+        bool ever_called_get_all_pages{false};
+        std::vector<QPDFExc> warnings;
+        std::map<unsigned long long, ObjCopier> object_copiers;
+        std::shared_ptr<QPDFObjectHandle::StreamDataProvider> copied_streams;
+        // copied_stream_data_provider is owned by copied_streams
+        CopiedStreamDataProvider* copied_stream_data_provider{nullptr};
+        bool reconstructed_xref{false};
+        bool fixed_dangling_refs{false};
+        bool immediate_copy_from{false};
+        bool in_parse{false};
+        bool parsed{false};
+        std::set<int> resolved_object_streams;
+
+        // Linearization data
+        qpdf_offset_t first_xref_item_offset{0}; // actual value from file
+        bool uncompressed_after_compressed{false};
+        bool linearization_warnings{false};
+
+        // Linearization parameter dictionary and hint table data: may be read from file or computed
+        // prior to writing a linearized file
+        QPDFObjectHandle lindict;
+        LinParameters linp;
+        HPageOffset page_offset_hints;
+        HSharedObject shared_object_hints;
+        HGeneric outline_hints;
+
+        // Computed linearization data: used to populate above tables during writing and to compare
+        // with them during validation. c_ means computed.
+        LinParameters c_linp;
+        CHPageOffset c_page_offset_data;
+        CHSharedObject c_shared_object_data;
+        HGeneric c_outline_data;
+
+        // Object ordering data for linearized files: initialized by calculateLinearizationData().
+        // Part numbers refer to the PDF 1.4 specification.
+        std::vector<QPDFObjectHandle> part4;
+        std::vector<QPDFObjectHandle> part6;
+        std::vector<QPDFObjectHandle> part7;
+        std::vector<QPDFObjectHandle> part8;
+        std::vector<QPDFObjectHandle> part9;
+
+        // Optimization data
+        std::map<ObjUser, std::set<QPDFObjGen>> obj_user_to_objects;
+        std::map<QPDFObjGen, std::set<ObjUser>> object_to_obj_users;
+    };
  
     // Keep all member variables inside the Members object, which we dynamically allocate. This
     // makes it possible to add new private members without breaking binary compatibility.
 #include <qpdf/qpdf-config.h> // include first for large file support
  
-#include <qpdf/QPDF_private.hh>
+#include <qpdf/QPDF.hh>
  
 #include <array>
 #include <atomic>
@@ -32,51 +32,67 @@
 // being static as well.
 std::string const QPDF::qpdf_version(QPDF_VERSION);
  
+static char const* EMPTY_PDF = (
+    // force line break
+    "%PDF-1.3\n"
+    "1 0 obj\n"
+    "<< /Type /Catalog /Pages 2 0 R >>\n"
+    "endobj\n"
+    "2 0 obj\n"
+    "<< /Type /Pages /Kids [] /Count 0 >>\n"
+    "endobj\n"
+    "xref\n"
+    "0 3\n"
+    "0000000000 65535 f \n"
+    "0000000009 00000 n \n"
+    "0000000058 00000 n \n"
+    "trailer << /Size 3 /Root 1 0 R >>\n"
+    "startxref\n"
+    "110\n"
+    "%%EOF\n");
+
 namespace
 {
-    class InvalidInputSource final: public InputSource
+    class InvalidInputSource: public InputSource
     {
       public:
-        InvalidInputSource(std::string const& name) :
-            name(name)
-        {
-        }
-        ~InvalidInputSource() final = default;
+        ~InvalidInputSource() override = default;
         qpdf_offset_t
-        findAndSkipNextEOL() final
+        findAndSkipNextEOL() override
         {
             throwException();
             return 0;
         }
         std::string const&
-        getName() const final
+        getName() const override
         {
+            static std::string name("closed input source");
             return name;
         }
         qpdf_offset_t
-        tell() final
+        tell() override
         {
             throwException();
             return 0;
         }
         void
-        seek(qpdf_offset_t offset, int whence) final
+        seek(qpdf_offset_t offset, int whence) override
         {
             throwException();
         }
         void
-        rewind() final
+        rewind() override
         {
             throwException();
         }
         size_t
-        read(char* buffer, size_t length) final
+        read(char* buffer, size_t length) override
         {
             throwException();
             return 0;
         }
         void
-        unreadCh(char ch) final
+        unreadCh(char ch) override
         {
             throwException();
         }
@@ -89,8 +105,6 @@ namespace
                                    "source. QPDF operations are invalid before processFile (or "
                                    "another process method) or after closeInputSource");
         }
-
-        std::string const& name;
     };
 } // namespace
  
@@ -182,17 +196,15 @@ QPDF::EncryptionParameters::EncryptionParameters() :
 {
 }
  
-QPDF::Members::Members(QPDF& qpdf) :
+QPDF::Members::Members() :
     log(QPDFLogger::defaultLogger()),
-    file_sp(new InvalidInputSource(no_input_name)),
-    file(file_sp.get()),
-    encp(new EncryptionParameters),
-    xref_table(qpdf, file)
+    file(new InvalidInputSource()),
+    encp(new EncryptionParameters)
 {
 }
  
 QPDF::QPDF() :
-    m(new Members(*this))
+    m(new Members())
 {
     m->tokenizer.allowEOF();
     // Generate a unique ID. It just has to be unique among all QPDF objects allocated throughout
@@ -213,6 +225,9 @@ QPDF::~QPDF()
     // are reachable from this object to release their association with this QPDF. Direct objects
     // are not destroyed since they can be moved to other QPDF objects safely.
  
+    // At this point, obviously no one is still using the QPDF object, but we'll explicitly clear
+    // the xref table anyway just to prevent any possibility of resolve() succeeding.
+    m->xref_table.clear();
     for (auto const& iter: m->obj_cache) {
         iter.second.object->disconnect();
         if (iter.second.object->getTypeCode() != ::ot_null) {
@@ -256,17 +271,14 @@ QPDF::processMemoryFile(
 void
 QPDF::processInputSource(std::shared_ptr<InputSource> source, char const* password)
 {
-    m->file_sp = source;
-    m->file = source.get();
+    m->file = source;
     parse(password);
 }
  
 void
 QPDF::closeInputSource()
 {
-    m->no_input_name = "closed input source";
-    m->file_sp = std::shared_ptr<InputSource>(new InvalidInputSource(m->no_input_name));
-    m->file = m->file_sp.get();
+    m->file = std::shared_ptr<InputSource>(new InvalidInputSource());
 }
  
 void
@@ -278,9 +290,7 @@ QPDF::setPasswordIsHexKey(bool val)
 void
 QPDF::emptyPDF()
 {
-    m->pdf_version = "1.3";
-    m->no_input_name = "empty PDF";
-    m->xref_table.initialize_empty();
+    processMemoryFile("empty PDF", EMPTY_PDF, strlen(EMPTY_PDF));
 }
  
 void
@@ -293,7 +303,7 @@ QPDF::registerStreamFilter(
 void
 QPDF::setIgnoreXRefStreams(bool val)
 {
-    m->xref_table.ignore_streams(val);
+    m->ignore_xref_streams = val;
 }
  
 std::shared_ptr<QPDFLogger>
@@ -331,7 +341,6 @@ void
 QPDF::setAttemptRecovery(bool val)
 {
     m->attempt_recovery = val;
-    m->xref_table.attempt_recovery(val);
 }
  
 void
@@ -401,9 +410,7 @@ QPDF::findHeader()
             // PDF header, all explicit offsets in the file are such that 0 points to the beginning
             // of the header.
             QTC::TC("qpdf", "QPDF global offset");
-            m->file_sp =
-                std::shared_ptr<InputSource>(new OffsetInputSource(m->file_sp, global_offset));
-            m->file = m->file_sp.get();
+            m->file = std::shared_ptr<InputSource>(new OffsetInputSource(m->file, global_offset));
         }
     }
     return valid;
@@ -436,8 +443,46 @@ QPDF::parse(char const* password)
         m->pdf_version = "1.2";
     }
  
-    m->xref_table.initialize();
+    // PDF spec says %%EOF must be found within the last 1024 bytes of/ the file.  We add an extra
+    // 30 characters to leave room for the startxref stuff.
+    m->file->seek(0, SEEK_END);
+    qpdf_offset_t end_offset = m->file->tell();
+    m->xref_table_max_offset = end_offset;
+    // Sanity check on object ids. All objects must appear in xref table / stream. In all realistic
+    // scenarios at least 3 bytes are required.
+    if (m->xref_table_max_id > m->xref_table_max_offset / 3) {
+        m->xref_table_max_id = static_cast<int>(m->xref_table_max_offset / 3);
+    }
+    qpdf_offset_t start_offset = (end_offset > 1054 ? end_offset - 1054 : 0);
+    PatternFinder sf(*this, &QPDF::findStartxref);
+    qpdf_offset_t xref_offset = 0;
+    if (m->file->findLast("startxref", start_offset, 0, sf)) {
+        xref_offset = QUtil::string_to_ll(readToken(*m->file).getValue().c_str());
+    }
+
+    try {
+        if (xref_offset == 0) {
+            QTC::TC("qpdf", "QPDF can't find startxref");
+            throw damagedPDF("", 0, "can't find startxref");
+        }
+        try {
+            read_xref(xref_offset);
+        } catch (QPDFExc&) {
+            throw;
+        } catch (std::exception& e) {
+            throw damagedPDF("", 0, std::string("error reading xref: ") + e.what());
+        }
+    } catch (QPDFExc& e) {
+        if (m->attempt_recovery) {
+            reconstruct_xref(e);
+            QTC::TC("qpdf", "QPDF reconstructed xref table");
+        } else {
+            throw;
+        }
+    }
+
     initializeEncryption();
+    m->parsed = true;
     if (m->xref_table.size() > 0 && !getRoot().getKey("/Pages").isDictionary()) {
         // QPDFs created from JSON have an empty xref table and no root object yet.
         throw damagedPDF("", 0, "unable to find page tree");
@@ -479,77 +524,18 @@ QPDF::warn(
 }
  
 void
-QPDF::Xref_table::initialize_empty()
+QPDF::setTrailer(QPDFObjectHandle obj)
 {
-    initialized_ = true;
-    trailer_ = QPDFObjectHandle::newDictionary();
-    auto rt = qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary());
-    auto pgs = qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary());
-    pgs.replaceKey("/Type", QPDFObjectHandle::newName("/Pages"));
-    pgs.replaceKey("/Kids", QPDFObjectHandle::newArray());
-    pgs.replaceKey("/Count", QPDFObjectHandle::newInteger(0));
-    rt.replaceKey("/Type", QPDFObjectHandle::newName("/Catalog"));
-    rt.replaceKey("/Pages", pgs);
-    trailer_.replaceKey("/Root", rt);
-    trailer_.replaceKey("/Size", QPDFObjectHandle::newInteger(3));
-}
-
-void
-QPDF::Xref_table::initialize_json()
-{
-    initialized_ = true;
-    table.resize(1);
-    trailer_ = QPDFObjectHandle::newDictionary();
-    trailer_.replaceKey("/Size", QPDFObjectHandle::newInteger(1));
-}
-
-void
-QPDF::Xref_table::initialize()
-{
-    // PDF spec says %%EOF must be found within the last 1024 bytes of/ the file.  We add an extra
-    // 30 characters to leave room for the startxref stuff.
-    file->seek(0, SEEK_END);
-    qpdf_offset_t end_offset = file->tell();
-    // Sanity check on object ids. All objects must appear in xref table / stream. In all realistic
-    // scenarios at least 3 bytes are required.
-    if (max_id_ > end_offset / 3) {
-        max_id_ = static_cast<int>(end_offset / 3);
-    }
-    qpdf_offset_t start_offset = (end_offset > 1054 ? end_offset - 1054 : 0);
-    PatternFinder sf(qpdf, &QPDF::findStartxref);
-    qpdf_offset_t xref_offset = 0;
-    if (file->findLast("startxref", start_offset, 0, sf)) {
-        xref_offset = QUtil::string_to_ll(read_token().getValue().c_str());
-    }
-
-    try {
-        if (xref_offset == 0) {
-            QTC::TC("qpdf", "QPDF can't find startxref");
-            throw damaged_pdf("can't find startxref");
-        }
-        try {
-            read(xref_offset);
-        } catch (QPDFExc&) {
-            throw;
-        } catch (std::exception& e) {
-            throw damaged_pdf(std::string("error reading xref: ") + e.what());
-        }
-    } catch (QPDFExc& e) {
-        if (attempt_recovery_) {
-            reconstruct(e);
-            QTC::TC("qpdf", "QPDF reconstructed xref table");
-        } else {
-            throw;
-        }
+    if (m->trailer) {
+        return;
     }
-
-    initialized_ = true;
+    m->trailer = obj;
 }
  
 void
-QPDF::Xref_table::reconstruct(QPDFExc& e)
+QPDF::reconstruct_xref(QPDFExc& e)
 {
-    if (reconstructed_) {
+    if (m->reconstructed_xref) {
         // Avoid xref reconstruction infinite loops. This is getting very hard to reproduce because
         // qpdf is throwing many fewer exceptions while parsing. Most situations are warnings now.
         throw e;
@@ -557,93 +543,78 @@ QPDF::Xref_table::reconstruct(QPDFExc&amp; e)
  
     // If recovery generates more than 1000 warnings, the file is so severely damaged that there
     // probably is no point trying to continue.
-    const auto max_warnings = qpdf.m->warnings.size() + 1000U;
+    const auto max_warnings = m->warnings.size() + 1000U;
     auto check_warnings = [this, max_warnings]() {
-        if (qpdf.m->warnings.size() > max_warnings) {
-            throw damaged_pdf("too many errors while reconstructing cross-reference table");
+        if (m->warnings.size() > max_warnings) {
+            throw damagedPDF("", 0, "too many errors while reconstructing cross-reference table");
         }
     };
  
-    reconstructed_ = true;
+    m->reconstructed_xref = true;
     // We may find more objects, which may contain dangling references.
-    qpdf.m->fixed_dangling_refs = false;
+    m->fixed_dangling_refs = false;
  
-    warn_damaged("file is damaged");
-    qpdf.warn(e);
-    warn_damaged("Attempting to reconstruct cross-reference table");
+    warn(damagedPDF("", 0, "file is damaged"));
+    warn(e);
+    warn(damagedPDF("", 0, "Attempting to reconstruct cross-reference table"));
  
     // Delete all references to type 1 (uncompressed) objects
-    for (auto& iter: table) {
-        if (iter.type() == 1) {
-            iter = {};
+    std::set<QPDFObjGen> to_delete;
+    for (auto const& iter: m->xref_table) {
+        if (iter.second.getType() == 1) {
+            to_delete.insert(iter.first);
         }
     }
+    for (auto const& iter: to_delete) {
+        m->xref_table.erase(iter);
+    }
  
-    std::vector<std::tuple<int, int, qpdf_offset_t>> objects;
-    std::vector<qpdf_offset_t> trailers;
-    int max_found = 0;
-
-    file->seek(0, SEEK_END);
-    qpdf_offset_t eof = file->tell();
-    file->seek(0, SEEK_SET);
+    m->file->seek(0, SEEK_END);
+    qpdf_offset_t eof = m->file->tell();
+    m->file->seek(0, SEEK_SET);
     // Don't allow very long tokens here during recovery. All the interesting tokens are covered.
     static size_t const MAX_LEN = 10;
-    while (file->tell() < eof) {
-        QPDFTokenizer::Token t1 = read_token(MAX_LEN);
-        qpdf_offset_t token_start = file->tell() - toO(t1.getValue().length());
+    while (m->file->tell() < eof) {
+        QPDFTokenizer::Token t1 = readToken(*m->file, MAX_LEN);
+        qpdf_offset_t token_start = m->file->tell() - toO(t1.getValue().length());
         if (t1.isInteger()) {
-            auto pos = file->tell();
-            QPDFTokenizer::Token t2 = read_token(MAX_LEN);
-            if (t2.isInteger() && read_token(MAX_LEN).isWord("obj")) {
+            auto pos = m->file->tell();
+            QPDFTokenizer::Token t2 = readToken(*m->file, MAX_LEN);
+            if ((t2.isInteger()) && (readToken(*m->file, MAX_LEN).isWord("obj"))) {
                 int obj = QUtil::string_to_int(t1.getValue().c_str());
                 int gen = QUtil::string_to_int(t2.getValue().c_str());
-                if (obj <= max_id_) {
-                    objects.emplace_back(obj, gen, token_start);
-                    if (obj > max_found) {
-                        max_found = obj;
-                    }
+                if (obj <= m->xref_table_max_id) {
+                    insertReconstructedXrefEntry(obj, token_start, gen);
                 } else {
-                    warn_damaged("ignoring object with impossibly large id " + std::to_string(obj));
+                    warn(damagedPDF(
+                        "", 0, "ignoring object with impossibly large id " + std::to_string(obj)));
                 }
             }
-            file->seek(pos, SEEK_SET);
-        } else if (!trailer_ && t1.isWord("trailer")) {
-            trailers.emplace_back(file->tell());
-        }
-        file->findAndSkipNextEOL();
-    }
-
-    table.resize(toS(max_found) + 1);
-
-    for (auto tr: trailers) {
-        file->seek(tr, SEEK_SET);
-        auto t = read_trailer();
-        if (!t.isDictionary()) {
-            // Oh well.  It was worth a try.
-        } else {
-            trailer_ = t;
-            break;
+            m->file->seek(pos, SEEK_SET);
+        } else if (!m->trailer && t1.isWord("trailer")) {
+            auto pos = m->file->tell();
+            QPDFObjectHandle t = readTrailer();
+            if (!t.isDictionary()) {
+                // Oh well.  It was worth a try.
+            } else {
+                setTrailer(t);
+            }
+            m->file->seek(pos, SEEK_SET);
         }
         check_warnings();
+        m->file->findAndSkipNextEOL();
     }
+    m->deleted_objects.clear();
  
-    auto rend = objects.rend();
-    for (auto it = objects.rbegin(); it != rend; it++) {
-        auto [obj, gen, token_start] = *it;
-        insert(obj, 1, token_start, gen);
-        check_warnings();
-    }
-
-    if (!trailer_) {
+    if (!m->trailer) {
         qpdf_offset_t max_offset{0};
         // If there are any xref streams, take the last one to appear.
-        int i = -1;
-        for (auto const& item: table) {
-            ++i;
-            if (item.type() != 1) {
+        for (auto const& iter: m->xref_table) {
+            auto entry = iter.second;
+            if (entry.getType() != 1) {
                 continue;
             }
-            auto oh = qpdf.getObject(i, item.gen());
+            auto oh = getObjectByObjGen(iter.first);
             try {
                 if (!oh.isStreamOfType("/XRef")) {
                     continue;
@@ -651,44 +622,44 @@ QPDF::Xref_table::reconstruct(QPDFExc&amp; e)
             } catch (std::exception&) {
                 continue;
             }
-            auto offset = item.offset();
+            auto offset = entry.getOffset();
             if (offset > max_offset) {
                 max_offset = offset;
-                trailer_ = oh.getDict();
+                setTrailer(oh.getDict());
             }
             check_warnings();
         }
         if (max_offset > 0) {
             try {
-                read(max_offset);
+                read_xref(max_offset);
             } catch (std::exception&) {
-                throw damaged_pdf(
-                    "error decoding candidate xref stream while recovering damaged file");
+                throw damagedPDF(
+                    "", 0, "error decoding candidate xref stream while recovering damaged file");
             }
             QTC::TC("qpdf", "QPDF recover xref stream");
         }
     }
  
-    if (!trailer_) {
+    if (!m->trailer) {
         // We could check the last encountered object to see if it was an xref stream.  If so, we
         // could try to get the trailer from there.  This may make it possible to recover files with
         // bad startxref pointers even when they have object streams.
  
-        throw damaged_pdf("unable to find trailer dictionary while recovering damaged file");
+        throw damagedPDF("", 0, "unable to find trailer dictionary while recovering damaged file");
     }
-    if (table.empty()) {
+    if (m->xref_table.empty()) {
         // We cannot check for an empty xref table in parse because empty tables are valid when
         // creating QPDF objects from JSON.
-        throw damaged_pdf("unable to find objects while recovering damaged file");
+        throw damagedPDF("", 0, "unable to find objects while recovering damaged file");
     }
     check_warnings();
-    if (!initialized_) {
-        initialized_ = true;
-        qpdf.getAllPages();
+    if (!m->parsed) {
+        m->parsed = true;
+        getAllPages();
         check_warnings();
-        if (qpdf.m->all_pages.empty()) {
-            initialized_ = false;
-            throw damaged_pdf("unable to find any pages while recovering damaged file");
+        if (m->all_pages.empty()) {
+            m->parsed = false;
+            throw damagedPDF("", 0, "unable to find any pages while recovering damaged file");
         }
     }
     // We could iterate through the objects looking for streams and try to find objects inside of
@@ -699,7 +670,7 @@ QPDF::Xref_table::reconstruct(QPDFExc&amp; e)
 }
  
 void
-QPDF::Xref_table::read(qpdf_offset_t xref_offset)
+QPDF::read_xref(qpdf_offset_t xref_offset)
 {
     std::map<int, int> free_table;
     std::set<qpdf_offset_t> visited;
@@ -707,7 +678,7 @@ QPDF::Xref_table::read(qpdf_offset_t xref_offset)
         visited.insert(xref_offset);
         char buf[7];
         memset(buf, 0, sizeof(buf));
-        file->seek(xref_offset, SEEK_SET);
+        m->file->seek(xref_offset, SEEK_SET);
         // Some files miss the mark a little with startxref. We could do a better job of searching
         // in the neighborhood for something that looks like either an xref table or stream, but the
         // simple heuristic of skipping whitespace can help with the xref table case and is harmless
@@ -716,11 +687,11 @@ QPDF::Xref_table::read(qpdf_offset_t xref_offset)
         bool skipped_space = false;
         while (!done) {
             char ch;
-            if (1 == file->read(&ch, 1)) {
+            if (1 == m->file->read(&ch, 1)) {
                 if (QUtil::is_space(ch)) {
                     skipped_space = true;
                 } else {
-                    file->unreadCh(ch);
+                    m->file->unreadCh(ch);
                     done = true;
                 }
             } else {
@@ -729,13 +700,13 @@ QPDF::Xref_table::read(qpdf_offset_t xref_offset)
             }
         }
  
-        file->read(buf, sizeof(buf) - 1);
+        m->file->read(buf, sizeof(buf) - 1);
         // The PDF spec says xref must be followed by a line terminator, but files exist in the wild
         // where it is terminated by arbitrary whitespace.
         if ((strncmp(buf, "xref", 4) == 0) && QUtil::is_space(buf[4])) {
             if (skipped_space) {
                 QTC::TC("qpdf", "QPDF xref skipped space");
-                warn_damaged("extraneous whitespace seen before xref");
+                warn(damagedPDF("", 0, "extraneous whitespace seen before xref"));
             }
             QTC::TC(
                 "qpdf",
@@ -749,38 +720,54 @@ QPDF::Xref_table::read(qpdf_offset_t xref_offset)
             while (QUtil::is_space(buf[skip])) {
                 ++skip;
             }
-            xref_offset = process_section(xref_offset + skip);
+            xref_offset = read_xrefTable(xref_offset + skip);
         } else {
-            xref_offset = read_stream(xref_offset);
+            xref_offset = read_xrefStream(xref_offset);
         }
         if (visited.count(xref_offset) != 0) {
             QTC::TC("qpdf", "QPDF xref loop");
-            throw damaged_pdf("loop detected following xref tables");
+            throw damagedPDF("", 0, "loop detected following xref tables");
         }
     }
  
-    if (!trailer_) {
-        throw damaged_pdf("unable to find trailer while reading xref");
+    if (!m->trailer) {
+        throw damagedPDF("", 0, "unable to find trailer while reading xref");
     }
-    int size = trailer_.getKey("/Size").getIntValueAsInt();
-
-    if (size < 3) {
-        throw damaged_pdf("too few objects - file can't have a page tree");
+    int size = m->trailer.getKey("/Size").getIntValueAsInt();
+    int max_obj = 0;
+    if (!m->xref_table.empty()) {
+        max_obj = m->xref_table.rbegin()->first.getObj();
+    }
+    if (!m->deleted_objects.empty()) {
+        max_obj = std::max(max_obj, *(m->deleted_objects.rbegin()));
+    }
+    if ((size < 1) || (size - 1 != max_obj)) {
+        QTC::TC("qpdf", "QPDF xref size mismatch");
+        warn(damagedPDF(
+            "",
+            0,
+            ("reported number of objects (" + std::to_string(size) +
+             ") is not one plus the highest object number (" + std::to_string(max_obj) + ")")));
     }
  
-    // We are no longer reporting what the highest id in the xref table is. I don't think it adds
-    // anything. If we want to report more detail, we should report the total number of missing
-    // entries, including missing entries before the last actual entry.
+    // We no longer need the deleted_objects table, so go ahead and clear it out to make sure we
+    // never depend on its being set.
+    m->deleted_objects.clear();
+
+    // Make sure we keep only the highest generation for any object.
+    QPDFObjGen last_og{-1, 0};
+    for (auto const& item: m->xref_table) {
+        auto id = item.first.getObj();
+        if (id == last_og.getObj() && id > 0) {
+            removeObject(last_og);
+        }
+        last_og = item.first;
+    }
 }
  
-QPDF::Xref_table::Subsection
-QPDF::Xref_table::subsection(std::string const& line)
+bool
+QPDF::parse_xrefFirst(std::string const& line, int& obj, int& num, int& bytes)
 {
-    auto terminate = [this]() -> void {
-        QTC::TC("qpdf", "QPDF invalid xref");
-        throw damaged_table("xref syntax invalid");
-    };
-
     // is_space and is_digit both return false on '\0', so this will not overrun the null-terminated
     // buffer.
     char const* p = line.c_str();
@@ -792,7 +779,7 @@ QPDF::Xref_table::subsection(std::string const&amp; line)
     }
     // Require digit
     if (!QUtil::is_digit(*p)) {
-        terminate();
+        return false;
     }
     // Gather digits
     std::string obj_str;
@@ -801,7 +788,7 @@ QPDF::Xref_table::subsection(std::string const&amp; line)
     }
     // Require space
     if (!QUtil::is_space(*p)) {
-        terminate();
+        return false;
     }
     // Skip spaces
     while (QUtil::is_space(*p)) {
@@ -809,7 +796,7 @@ QPDF::Xref_table::subsection(std::string const&amp; line)
     }
     // Require digit
     if (!QUtil::is_digit(*p)) {
-        terminate();
+        return false;
     }
     // Gather digits
     std::string num_str;
@@ -820,82 +807,18 @@ QPDF::Xref_table::subsection(std::string const&amp; line)
     while (QUtil::is_space(*p)) {
         ++p;
     }
-    auto obj = QUtil::string_to_int(obj_str.c_str());
-    auto count = QUtil::string_to_int(num_str.c_str());
-    if (obj > max_id() || count > max_id() || (obj + count) > max_id()) {
-        throw damaged_table("xref table subsection header contains impossibly large entry");
-    }
-    return {obj, count, file->getLastOffset() + toI(p - start)};
-}
-
-std::vector<QPDF::Xref_table::Subsection>
-QPDF::Xref_table::bad_subsections(std::string& line, qpdf_offset_t start)
-{
-    std::vector<QPDF::Xref_table::Subsection> result;
-    qpdf_offset_t f1 = 0;
-    int f2 = 0;
-    char type = '\0';
-
-    file->seek(start, SEEK_SET);
-
-    while (true) {
-        line.assign(50, '\0');
-        file->read(line.data(), line.size());
-        auto [obj, num, offset] = result.emplace_back(subsection(line));
-        file->seek(offset, SEEK_SET);
-        for (qpdf_offset_t i = obj; i - num < obj; ++i) {
-            if (!read_entry(f1, f2, type)) {
-                QTC::TC("qpdf", "QPDF invalid xref entry");
-                throw damaged_table("invalid xref entry (obj=" + std::to_string(i) + ")");
-            }
-        }
-        qpdf_offset_t pos = file->tell();
-        if (read_token().isWord("trailer")) {
-            return result;
-        } else {
-            file->seek(pos, SEEK_SET);
-        }
-    }
-}
-
-// Optimistically read and parse all subsection headers. If an error is encountered return the
-// result of bad_subsections.
-std::vector<QPDF::Xref_table::Subsection>
-QPDF::Xref_table::subsections(std::string& line)
-{
-    auto recovery_offset = file->tell();
-    try {
-        std::vector<QPDF::Xref_table::Subsection> result;
-
-        while (true) {
-            line.assign(50, '\0');
-            file->read(line.data(), line.size());
-            auto& sub = result.emplace_back(subsection(line));
-            auto count = std::get<1>(sub);
-            auto offset = std::get<2>(sub);
-            file->seek(offset + 20 * toO(count) - 1, SEEK_SET);
-            file->read(line.data(), 1);
-            if (!(line[0] == '\n' || line[0] == '\n')) {
-                return bad_subsections(line, recovery_offset);
-            }
-            qpdf_offset_t pos = file->tell();
-            if (read_token().isWord("trailer")) {
-                return result;
-            } else {
-                file->seek(pos, SEEK_SET);
-            }
-        }
-    } catch (...) {
-        return bad_subsections(line, recovery_offset);
-    }
+    bytes = toI(p - start);
+    obj = QUtil::string_to_int(obj_str.c_str());
+    num = QUtil::string_to_int(num_str.c_str());
+    return true;
 }
  
 bool
-QPDF::Xref_table::read_bad_entry(qpdf_offset_t& f1, int& f2, char& type)
+QPDF::read_bad_xrefEntry(qpdf_offset_t& f1, int& f2, char& type)
 {
     // Reposition after initial read attempt and reread.
-    file->seek(file->getLastOffset(), SEEK_SET);
-    auto line = file->readLine(30);
+    m->file->seek(m->file->getLastOffset(), SEEK_SET);
+    auto line = m->file->readLine(30);
  
     // is_space and is_digit both return false on '\0', so this will not overrun the null-terminated
     // buffer.
@@ -961,7 +884,7 @@ QPDF::Xref_table::read_bad_entry(qpdf_offset_t&amp; f1, int&amp; f2, char&amp; type)
     }
  
     if (invalid) {
-        qpdf.warn(damaged_table("accepting invalid xref table entry"));
+        warn(damagedPDF("xref table", "accepting invalid xref table entry"));
     }
  
     f1 = QUtil::string_to_ll(f1_str.c_str());
@@ -973,10 +896,10 @@ QPDF::Xref_table::read_bad_entry(qpdf_offset_t&amp; f1, int&amp; f2, char&amp; type)
 // Optimistically read and parse xref entry. If entry is bad, call read_bad_xrefEntry and return
 // result.
 bool
-QPDF::Xref_table::read_entry(qpdf_offset_t& f1, int& f2, char& type)
+QPDF::read_xrefEntry(qpdf_offset_t& f1, int& f2, char& type)
 {
     std::array<char, 21> line;
-    if (file->read(line.data(), 20) != 20) {
+    if (m->file->read(line.data(), 20) != 20) {
         // C++20: [[unlikely]]
         return false;
     }
@@ -1022,78 +945,84 @@ QPDF::Xref_table::read_entry(qpdf_offset_t&amp; f1, int&amp; f2, char&amp; type)
             return true;
         }
     }
-    return read_bad_entry(f1, f2, type);
+    return read_bad_xrefEntry(f1, f2, type);
 }
  
 // Read a single cross-reference table section and associated trailer.
 qpdf_offset_t
-QPDF::Xref_table::process_section(qpdf_offset_t xref_offset)
+QPDF::read_xrefTable(qpdf_offset_t xref_offset)
 {
-    file->seek(xref_offset, SEEK_SET);
+    m->file->seek(xref_offset, SEEK_SET);
     std::string line;
-    auto subs = subsections(line);
-
-    auto cur_trailer_offset = file->tell();
-    auto cur_trailer = read_trailer();
-    if (!cur_trailer.isDictionary()) {
-        QTC::TC("qpdf", "QPDF missing trailer");
-        throw qpdf.damagedPDF("", "expected trailer dictionary");
-    }
-
-    if (!trailer_) {
-        unsigned int sz;
-        trailer_ = cur_trailer;
-
-        if (!trailer_.hasKey("/Size")) {
-            QTC::TC("qpdf", "QPDF trailer lacks size");
-            throw qpdf.damagedPDF("trailer", "trailer dictionary lacks /Size key");
-        }
-        if (!trailer_.getKey("/Size").getValueAsUInt(sz)) {
-            QTC::TC("qpdf", "QPDF trailer size not integer");
-            throw qpdf.damagedPDF("trailer", "/Size key in trailer dictionary is not an integer");
-        }
-
-        table.resize(sz);
-    }
-
-    for (auto [obj, num, offset]: subs) {
-        file->seek(offset, SEEK_SET);
+    while (true) {
+        line.assign(50, '\0');
+        m->file->read(line.data(), line.size());
+        int obj = 0;
+        int num = 0;
+        int bytes = 0;
+        if (!parse_xrefFirst(line, obj, num, bytes)) {
+            QTC::TC("qpdf", "QPDF invalid xref");
+            throw damagedPDF("xref table", "xref syntax invalid");
+        }
+        m->file->seek(m->file->getLastOffset() + bytes, SEEK_SET);
         for (qpdf_offset_t i = obj; i - num < obj; ++i) {
             if (i == 0) {
                 // This is needed by checkLinearization()
-                first_item_offset_ = file->tell();
+                m->first_xref_item_offset = m->file->tell();
             }
             // For xref_table, these will always be small enough to be ints
             qpdf_offset_t f1 = 0;
             int f2 = 0;
             char type = '\0';
-            if (!read_entry(f1, f2, type)) {
-                throw damaged_table("invalid xref entry (obj=" + std::to_string(i) + ")");
+            if (!read_xrefEntry(f1, f2, type)) {
+                QTC::TC("qpdf", "QPDF invalid xref entry");
+                throw damagedPDF(
+                    "xref table", "invalid xref entry (obj=" + std::to_string(i) + ")");
             }
             if (type == 'f') {
-                insert_free(QPDFObjGen(toI(i), f2));
+                insertFreeXrefEntry(QPDFObjGen(toI(i), f2));
             } else {
-                insert(toI(i), 1, f1, f2);
+                insertXrefEntry(toI(i), 1, f1, f2);
             }
         }
-        qpdf_offset_t pos = file->tell();
-        if (read_token().isWord("trailer")) {
+        qpdf_offset_t pos = m->file->tell();
+        if (readToken(*m->file).isWord("trailer")) {
             break;
         } else {
-            file->seek(pos, SEEK_SET);
+            m->file->seek(pos, SEEK_SET);
+        }
+    }
+
+    // Set offset to previous xref table if any
+    QPDFObjectHandle cur_trailer = readTrailer();
+    if (!cur_trailer.isDictionary()) {
+        QTC::TC("qpdf", "QPDF missing trailer");
+        throw damagedPDF("", "expected trailer dictionary");
+    }
+
+    if (!m->trailer) {
+        setTrailer(cur_trailer);
+
+        if (!m->trailer.hasKey("/Size")) {
+            QTC::TC("qpdf", "QPDF trailer lacks size");
+            throw damagedPDF("trailer", "trailer dictionary lacks /Size key");
+        }
+        if (!m->trailer.getKey("/Size").isInteger()) {
+            QTC::TC("qpdf", "QPDF trailer size not integer");
+            throw damagedPDF("trailer", "/Size key in trailer dictionary is not an integer");
         }
     }
  
     if (cur_trailer.hasKey("/XRefStm")) {
-        if (ignore_streams_) {
+        if (m->ignore_xref_streams) {
             QTC::TC("qpdf", "QPDF ignoring XRefStm in trailer");
         } else {
             if (cur_trailer.getKey("/XRefStm").isInteger()) {
                 // Read the xref stream but disregard any return value -- we'll use our trailer's
                 // /Prev key instead of the xref stream's.
-                (void)read_stream(cur_trailer.getKey("/XRefStm").getIntValue());
+                (void)read_xrefStream(cur_trailer.getKey("/XRefStm").getIntValue());
             } else {
-                throw qpdf.damagedPDF("xref stream", cur_trailer_offset, "invalid /XRefStm");
+                throw damagedPDF("xref stream", xref_offset, "invalid /XRefStm");
             }
         }
     }
@@ -1101,8 +1030,7 @@ QPDF::Xref_table::process_section(qpdf_offset_t xref_offset)
     if (cur_trailer.hasKey("/Prev")) {
         if (!cur_trailer.getKey("/Prev").isInteger()) {
             QTC::TC("qpdf", "QPDF trailer prev not integer");
-            throw qpdf.damagedPDF(
-                "trailer", cur_trailer_offset, "/Prev key in trailer dictionary is not an integer");
+            throw damagedPDF("trailer", "/Prev key in trailer dictionary is not an integer");
         }
         QTC::TC("qpdf", "QPDF prev key in trailer dictionary");
         return cur_trailer.getKey("/Prev").getIntValue();
@@ -1113,35 +1041,34 @@ QPDF::Xref_table::process_section(qpdf_offset_t xref_offset)
  
 // Read a single cross-reference stream.
 qpdf_offset_t
-QPDF::Xref_table::read_stream(qpdf_offset_t xref_offset)
+QPDF::read_xrefStream(qpdf_offset_t xref_offset)
 {
-    if (!ignore_streams_) {
+    if (!m->ignore_xref_streams) {
         QPDFObjGen x_og;
         QPDFObjectHandle xref_obj;
         try {
-            xref_obj = qpdf.readObjectAtOffset(
-                false, xref_offset, "xref stream", QPDFObjGen(0, 0), x_og, true);
+            xref_obj =
+                readObjectAtOffset(false, xref_offset, "xref stream", QPDFObjGen(0, 0), x_og, true);
         } catch (QPDFExc&) {
             // ignore -- report error below
         }
         if (xref_obj.isStreamOfType("/XRef")) {
             QTC::TC("qpdf", "QPDF found xref stream");
-            return process_stream(xref_offset, xref_obj);
+            return processXRefStream(xref_offset, xref_obj);
         }
     }
  
     QTC::TC("qpdf", "QPDF can't find xref");
-    throw qpdf.damagedPDF("", xref_offset, "xref not found");
+    throw damagedPDF("", xref_offset, "xref not found");
     return 0; // unreachable
 }
  
 // Return the entry size of the xref stream and the processed W array.
 std::pair<int, std::array<int, 3>>
-QPDF::Xref_table::process_W(
-    QPDFObjectHandle& dict, std::function<QPDFExc(std::string_view)> damaged)
+QPDF::processXRefW(QPDFObjectHandle& dict, std::function<QPDFExc(std::string_view)> damaged)
 {
     auto W_obj = dict.getKey("/W");
-    if (!(W_obj.isArray() && W_obj.getArrayNItems() >= 3 && W_obj.getArrayItem(0).isInteger() &&
+    if (!(W_obj.isArray() && (W_obj.getArrayNItems() >= 3) && W_obj.getArrayItem(0).isInteger() &&
           W_obj.getArrayItem(1).isInteger() && W_obj.getArrayItem(2).isInteger())) {
         throw damaged("Cross-reference stream does not have a proper /W key");
     }
@@ -1166,10 +1093,9 @@ QPDF::Xref_table::process_W(
     return {entry_size, W};
 }
  
-// Validate Size entry and return the maximum number of entries that the xref stream can contain and
-// the value of the Size entry.
-std::pair<int, size_t>
-QPDF::Xref_table::process_Size(
+// Validate Size key and return the maximum number of entries that the xref stream can contain.
+int
+QPDF::processXRefSize(
     QPDFObjectHandle& dict, int entry_size, std::function<QPDFExc(std::string_view)> damaged)
 {
     // Number of entries is limited by the highest possible object id and stream size.
@@ -1188,12 +1114,12 @@ QPDF::Xref_table::process_Size(
         throw damaged("Cross-reference stream has an impossibly large /Size key");
     }
     // We are not validating that Size <= (Size key of parent xref / trailer).
-    return {max_num_entries, toS(size)};
+    return max_num_entries;
 }
  
 // Return the number of entries of the xref stream and the processed Index array.
 std::pair<int, std::vector<std::pair<int, int>>>
-QPDF::Xref_table::process_Index(
+QPDF::processXRefIndex(
     QPDFObjectHandle& dict, int max_num_entries, std::function<QPDFExc(std::string_view)> damaged)
 {
     auto size = dict.getKey("/Size").getIntValueAsInt();
@@ -1260,17 +1186,17 @@ QPDF::Xref_table::process_Index(
 }
  
 qpdf_offset_t
-QPDF::Xref_table::process_stream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
+QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
 {
     auto damaged = [this, xref_offset](std::string_view msg) -> QPDFExc {
-        return qpdf.damagedPDF("xref stream", xref_offset, msg.data());
+        return damagedPDF("xref stream", xref_offset, msg.data());
     };
  
     auto dict = xref_obj.getDict();
  
-    auto [entry_size, W] = process_W(dict, damaged);
-    auto [max_num_entries, size] = process_Size(dict, entry_size, damaged);
-    auto [num_entries, indx] = process_Index(dict, max_num_entries, damaged);
+    auto [entry_size, W] = processXRefW(dict, damaged);
+    int max_num_entries = processXRefSize(dict, entry_size, damaged);
+    auto [num_entries, indx] = processXRefIndex(dict, max_num_entries, damaged);
  
     std::shared_ptr<Buffer> bp = xref_obj.getStreamData(qpdf_dl_specialized);
     size_t actual_size = bp->getSize();
@@ -1283,16 +1209,8 @@ QPDF::Xref_table::process_stream(qpdf_offset_t xref_offset, QPDFObjectHandle&amp; xr
         if (expected_size > actual_size) {
             throw x;
         } else {
-            qpdf.warn(x);
-        }
-    }
-
-    if (!trailer_) {
-        trailer_ = dict;
-        if (size > toS(max_id_)) {
-            throw damaged("Cross-reference stream /Size entry is impossibly large");
+            warn(x);
         }
-        table.resize(size);
     }
  
     bool saw_first_compressed_object = false;
@@ -1320,29 +1238,33 @@ QPDF::Xref_table::process_stream(qpdf_offset_t xref_offset, QPDFObjectHandle&amp; xr
             // object record, in which case the generation number appears as the third field.
             if (saw_first_compressed_object) {
                 if (fields[0] != 2) {
-                    uncompressed_after_compressed_ = true;
+                    m->uncompressed_after_compressed = true;
                 }
             } else if (fields[0] == 2) {
                 saw_first_compressed_object = true;
             }
             if (obj == 0) {
                 // This is needed by checkLinearization()
-                first_item_offset_ = xref_offset;
+                m->first_xref_item_offset = xref_offset;
             } else if (fields[0] == 0) {
                 // Ignore fields[2], which we don't care about in this case. This works around the
                 // issue of some PDF files that put invalid values, like -1, here for deleted
                 // objects.
-                insert_free(QPDFObjGen(obj, 0));
+                insertFreeXrefEntry(QPDFObjGen(obj, 0));
             } else {
-                insert(obj, toI(fields[0]), fields[1], toI(fields[2]));
+                insertXrefEntry(obj, toI(fields[0]), fields[1], toI(fields[2]));
             }
             ++obj;
         }
     }
  
+    if (!m->trailer) {
+        setTrailer(dict);
+    }
+
     if (dict.hasKey("/Prev")) {
         if (!dict.getKey("/Prev").isInteger()) {
-            throw qpdf.damagedPDF(
+            throw damagedPDF(
                 "xref stream", "/Prev key in xref stream dictionary is not an integer");
         }
         QTC::TC("qpdf", "QPDF prev key in xref stream dictionary");
@@ -1353,7 +1275,7 @@ QPDF::Xref_table::process_stream(qpdf_offset_t xref_offset, QPDFObjectHandle&amp; xr
 }
  
 void
-QPDF::Xref_table::insert(int obj, int f0, qpdf_offset_t f1, int f2)
+QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2)
 {
     // Populate the xref table in such a way that the first reference to an object that we see,
     // which is the one in the latest xref table in which it appears, is the one that gets stored.
@@ -1362,35 +1284,23 @@ QPDF::Xref_table::insert(int obj, int f0, qpdf_offset_t f1, int f2)
     // If there is already an entry for this object and generation in the table, it means that a
     // later xref table has registered this object.  Disregard this one.
  
-    int new_gen = f0 == 2 ? 0 : f2;
-
-    if (!(obj > 0 && static_cast<size_t>(obj) < table.size() && 0 <= f2 && new_gen < 65535)) {
-        // We are ignoring invalid objgens. Most will arrive here from xref reconstruction. There
-        // is probably no point having another warning but we could count invalid items in order to
-        // decide when to give up.
-        QTC::TC("qpdf", "QPDF xref overwrite invalid objgen");
+    if (obj > m->xref_table_max_id) {
+        // ignore impossibly large object ids or object ids > Size.
         return;
     }
  
-    auto& entry = table[static_cast<size_t>(obj)];
-    auto old_type = entry.type();
-
-    if (!old_type && entry.gen() > 0) {
-        // At the moment we are processing the updates last to first and therefore the gen doesn't
-        // matter as long as it > 0 to distinguish it from an uninitialized entry. This will need
-        // to be revisited when we want to support incremental updates or more comprhensive
-        // checking.
+    if (m->deleted_objects.count(obj)) {
         QTC::TC("qpdf", "QPDF xref deleted object");
         return;
     }
  
     if (f0 == 2 && static_cast<int>(f1) == obj) {
-        qpdf.warn(qpdf.damagedPDF(
-            "xref stream", "self-referential object stream " + std::to_string(obj)));
+        warn(damagedPDF("xref stream", "self-referential object stream " + std::to_string(obj)));
         return;
     }
  
-    if (old_type && entry.gen() >= new_gen) {
+    auto [iter, created] = m->xref_table.try_emplace(QPDFObjGen(obj, (f0 == 2 ? 0 : f2)));
+    if (!created) {
         QTC::TC("qpdf", "QPDF xref reused object");
         return;
     }
@@ -1398,129 +1308,85 @@ QPDF::Xref_table::insert(int obj, int f0, qpdf_offset_t f1, int f2)
     switch (f0) {
     case 1:
         // f2 is generation
-        QTC::TC("qpdf", "QPDF xref gen > 0", (f2 > 0) ? 1 : 0);
-        entry = {f2, Uncompressed(f1)};
+        QTC::TC("qpdf", "QPDF xref gen > 0", ((f2 > 0) ? 1 : 0));
+        iter->second = QPDFXRefEntry(f1);
         break;
  
     case 2:
-        entry = {0, Compressed(toI(f1), f2)};
-        object_streams_ = true;
+        iter->second = QPDFXRefEntry(toI(f1), f2);
         break;
  
     default:
-        throw qpdf.damagedPDF(
-            "xref stream", "unknown xref stream entry type " + std::to_string(f0));
+        throw damagedPDF("xref stream", "unknown xref stream entry type " + std::to_string(f0));
         break;
     }
 }
  
 void
-QPDF::Xref_table::insert_free(QPDFObjGen og)
+QPDF::insertFreeXrefEntry(QPDFObjGen og)
 {
-    // At the moment we are processing the updates last to first and therefore the gen doesn't
-    // matter as long as it > 0 to distinguish it from an uninitialized entry. This will need to be
-    // revisited when we want to support incremental updates or more comprhensive checking.
-    if (og.getObj() < 1) {
-        return;
-    }
-    size_t id = static_cast<size_t>(og.getObj());
-    if (id < table.size() && !type(id)) {
-        table[id] = {1, {}};
+    if (!m->xref_table.count(og)) {
+        m->deleted_objects.insert(og.getObj());
     }
 }
  
-QPDFObjGen
-QPDF::Xref_table::at_offset(qpdf_offset_t offset) const noexcept
+// Replace uncompressed object. This is used in xref recovery mode, which reads the file from
+// beginning to end.
+void
+QPDF::insertReconstructedXrefEntry(int obj, qpdf_offset_t f1, int f2)
 {
-    int id = 0;
-    int gen = 0;
-    qpdf_offset_t start = 0;
-
-    int i = 0;
-    for (auto const& item: table) {
-        auto o = item.offset();
-        if (start < o && o <= offset) {
-            start = o;
-            id = i;
-            gen = item.gen();
-        }
-        ++i;
+    if (!(obj > 0 && obj <= m->xref_table_max_id && 0 <= f2 && f2 < 65535)) {
+        QTC::TC("qpdf", "QPDF xref overwrite invalid objgen");
+        return;
     }
-    return QPDFObjGen(id, gen);
-}
  
-std::map<QPDFObjGen, QPDFXRefEntry>
-QPDF::Xref_table::as_map() const
-{
-    std::map<QPDFObjGen, QPDFXRefEntry> result;
-    int i{0};
-    for (auto const& item: table) {
-        switch (item.type()) {
-        case 0:
-            break;
-        case 1:
-            result.emplace(QPDFObjGen(i, item.gen()), item.offset());
-            break;
-        case 2:
-            result.emplace(
-                QPDFObjGen(i, 0), QPDFXRefEntry(item.stream_number(), item.stream_index()));
-            break;
-        default:
-            throw std::logic_error("Xref_table: invalid entry type");
-        }
-        ++i;
+    QPDFObjGen og(obj, f2);
+    if (!m->deleted_objects.count(obj)) {
+        // deleted_objects stores the uncompressed objects removed from the xref table at the start
+        // of recovery.
+        QTC::TC("qpdf", "QPDF xref overwrite object");
+        m->xref_table[QPDFObjGen(obj, f2)] = QPDFXRefEntry(f1);
     }
-    return result;
 }
  
 void
 QPDF::showXRefTable()
 {
-    m->xref_table.show();
-}
-
-void
-QPDF::Xref_table::show()
-{
-    auto& cout = *qpdf.m->log->getInfo();
-    int i = -1;
-    for (auto const& item: table) {
-        ++i;
-        if (item.type()) {
-            cout << std::to_string(i) << "/" << std::to_string(item.gen()) << ": ";
-            switch (item.type()) {
-            case 1:
-                cout << "uncompressed; offset = " << item.offset() << "\n";
-                break;
+    auto& cout = *m->log->getInfo();
+    for (auto const& iter: m->xref_table) {
+        QPDFObjGen const& og = iter.first;
+        QPDFXRefEntry const& entry = iter.second;
+        cout << og.unparse('/') << ": ";
+        switch (entry.getType()) {
+        case 1:
+            cout << "uncompressed; offset = " << entry.getOffset();
+            break;
  
-            case 2:
-                cout << "compressed; stream = " << item.stream_number()
-                     << ", index = " << item.stream_index() << "\n";
-                break;
+        case 2:
+            *m->log->getInfo() << "compressed; stream = " << entry.getObjStreamNumber()
+                               << ", index = " << entry.getObjStreamIndex();
+            break;
  
-            default:
-                throw std::logic_error(
-                    "unknown cross-reference table type while showing xref_table");
-            }
+        default:
+            throw std::logic_error("unknown cross-reference table type while"
+                                   " showing xref_table");
+            break;
         }
+        m->log->info("\n");
     }
 }
  
 // Resolve all objects in the xref table. If this triggers a xref table reconstruction abort and
 // return false. Otherwise return true.
 bool
-QPDF::Xref_table::resolve()
-{
-    bool may_change = !reconstructed_;
-    int i = -1;
-    for (auto& item: table) {
-        ++i;
-        if (item.type()) {
-            if (qpdf.isUnresolved(QPDFObjGen(i, item.gen()))) {
-                qpdf.resolve(QPDFObjGen(i, item.gen()));
-                if (may_change && reconstructed_) {
-                    return false;
-                }
+QPDF::resolveXRefTable()
+{
+    bool may_change = !m->reconstructed_xref;
+    for (auto& iter: m->xref_table) {
+        if (isUnresolved(iter.first)) {
+            resolve(iter.first);
+            if (may_change && m->reconstructed_xref) {
+                return false;
             }
         }
     }
@@ -1535,9 +1401,9 @@ QPDF::fixDanglingReferences(bool force)
     if (m->fixed_dangling_refs) {
         return;
     }
-    if (!m->xref_table.resolve()) {
+    if (!resolveXRefTable()) {
         QTC::TC("qpdf", "QPDF fix dangling triggered xref reconstruction");
-        m->xref_table.resolve();
+        resolveXRefTable();
     }
     m->fixed_dangling_refs = true;
 }
@@ -1584,21 +1450,21 @@ QPDF::setLastObjectDescription(std::string const&amp; description, QPDFObjGen const&amp;
 }
  
 QPDFObjectHandle
-QPDF::Xref_table::read_trailer()
+QPDF::readTrailer()
 {
-    qpdf_offset_t offset = file->tell();
+    qpdf_offset_t offset = m->file->tell();
     bool empty = false;
     auto object =
-        QPDFParser(*file, "trailer", tokenizer, nullptr, &qpdf, true).parse(empty, false);
+        QPDFParser(*m->file, "trailer", m->tokenizer, nullptr, this, true).parse(empty, false);
     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.
-        qpdf.warn(qpdf.damagedPDF("trailer", "empty object treated as null"));
-    } else if (object.isDictionary() && read_token().isWord("stream")) {
-        qpdf.warn(qpdf.damagedPDF("trailer", file->tell(), "stream keyword found in trailer"));
+        warn(damagedPDF("trailer", "empty object treated as null"));
+    } else if (object.isDictionary() && readToken(*m->file).isWord("stream")) {
+        warn(damagedPDF("trailer", m->file->tell(), "stream keyword found in trailer"));
     }
     // Override last_offset so that it points to the beginning of the object we just read
-    file->setLastOffset(offset);
+    m->file->setLastOffset(offset);
     return object;
 }
  
@@ -1666,7 +1532,7 @@ QPDF::readStream(QPDFObjectHandle&amp; object, QPDFObjGen og, qpdf_offset_t offset)
     } catch (QPDFExc& e) {
         if (m->attempt_recovery) {
             warn(e);
-            length = recoverStreamLength(m->file_sp, og, stream_offset);
+            length = recoverStreamLength(m->file, og, stream_offset);
         } else {
             throw;
         }
@@ -1773,9 +1639,21 @@ QPDF::recoverStreamLength(
     }
  
     if (length) {
+        auto end = stream_offset + toO(length);
+        qpdf_offset_t found_offset = 0;
+        QPDFObjGen found_og;
+
         // Make sure this is inside this object
-        auto found = m->xref_table.at_offset(stream_offset + toO(length));
-        if (found == QPDFObjGen() || found == og) {
+        for (auto const& [current_og, entry]: m->xref_table) {
+            if (entry.getType() == 1) {
+                qpdf_offset_t obj_offset = entry.getOffset();
+                if (found_offset < obj_offset && obj_offset < end) {
+                    found_offset = obj_offset;
+                    found_og = current_og;
+                }
+            }
+        }
+        if (!found_offset || found_og == og) {
             // If we are trying to recover an XRef stream the xref table will not contain and
             // won't contain any entries, therefore we cannot check the found length. Otherwise we
             // found endstream\nendobj within the space allowed for this object, so we're probably
@@ -1884,18 +1762,21 @@ QPDF::readObjectAtOffset(
     } catch (QPDFExc& e) {
         if (try_recovery) {
             // Try again after reconstructing xref table
-            m->xref_table.reconstruct(e);
-            if (m->xref_table.type(exp_og) == 1) {
+            reconstruct_xref(e);
+            if (m->xref_table.count(exp_og) && (m->xref_table[exp_og].getType() == 1)) {
+                qpdf_offset_t new_offset = m->xref_table[exp_og].getOffset();
+                QPDFObjectHandle result =
+                    readObjectAtOffset(false, new_offset, description, exp_og, og, false);
                 QTC::TC("qpdf", "QPDF recovered in readObjectAtOffset");
-                return readObjectAtOffset(
-                    false, m->xref_table.offset(exp_og), description, exp_og, og, false);
+                return result;
             } else {
                 QTC::TC("qpdf", "QPDF object gone after xref reconstruction");
                 warn(damagedPDF(
                     "",
                     0,
                     ("object " + exp_og.unparse(' ') +
-                     " not found in file after regenerating cross reference table")));
+                     " not found in file after regenerating cross reference "
+                     "table")));
                 return QPDFObjectHandle::newNull();
             }
         } else {
@@ -1928,7 +1809,7 @@ QPDF::readObjectAtOffset(
             }
         }
         qpdf_offset_t end_after_space = m->file->tell();
-        if (skip_cache_if_in_xref && m->xref_table.type(og)) {
+        if (skip_cache_if_in_xref && m->xref_table.count(og)) {
             // Ordinarily, an object gets read here when resolved through xref table or stream. In
             // the special case of the xref stream and linearization hint tables, the offset comes
             // from another source. For the specific case of xref streams, the xref stream is read
@@ -1956,9 +1837,7 @@ QPDF::readObjectAtOffset(
             // could use !check_og in place of skip_cache_if_in_xref.
             QTC::TC("qpdf", "QPDF skipping cache for known unchecked object");
         } else {
-            m->xref_table.linearization_offsets(
-                toS(og.getObj()), end_before_space, end_after_space);
-            updateCache(og, oh.getObj());
+            updateCache(og, oh.getObj(), end_before_space, end_after_space);
         }
     }
  
@@ -1977,43 +1856,44 @@ QPDF::resolve(QPDFObjGen og)
         // has to be resolved during object parsing, such as stream length.
         QTC::TC("qpdf", "QPDF recursion loop in resolve");
         warn(damagedPDF("", "loop detected resolving object " + og.unparse(' ')));
-        updateCache(og, QPDF_Null::create());
+        updateCache(og, QPDF_Null::create(), -1, -1);
         return m->obj_cache[og].object.get();
     }
     ResolveRecorder rr(this, og);
  
-    try {
-        switch (m->xref_table.type(og)) {
-        case 0:
-            break;
-        case 1:
-            {
-                // Object stored in cache by readObjectAtOffset
-                QPDFObjGen a_og;
-                QPDFObjectHandle oh =
-                    readObjectAtOffset(true, m->xref_table.offset(og), "", og, a_og, false);
-            }
-            break;
+    if (m->xref_table.count(og) != 0) {
+        QPDFXRefEntry const& entry = m->xref_table[og];
+        try {
+            switch (entry.getType()) {
+            case 1:
+                {
+                    qpdf_offset_t offset = entry.getOffset();
+                    // Object stored in cache by readObjectAtOffset
+                    QPDFObjGen a_og;
+                    QPDFObjectHandle oh = readObjectAtOffset(true, offset, "", og, a_og, false);
+                }
+                break;
  
-        case 2:
-            resolveObjectsInStream(m->xref_table.stream_number(og.getObj()));
-            break;
+            case 2:
+                resolveObjectsInStream(entry.getObjStreamNumber());
+                break;
  
-        default:
-            throw damagedPDF(
-                "", 0, ("object " + og.unparse('/') + " has unexpected xref entry type"));
+            default:
+                throw damagedPDF(
+                    "", 0, ("object " + og.unparse('/') + " has unexpected xref entry type"));
+            }
+        } catch (QPDFExc& e) {
+            warn(e);
+        } catch (std::exception& e) {
+            warn(damagedPDF(
+                "", 0, ("object " + og.unparse('/') + ": error reading object: " + e.what())));
         }
-    } catch (QPDFExc& e) {
-        warn(e);
-    } catch (std::exception& e) {
-        warn(damagedPDF(
-            "", 0, ("object " + og.unparse('/') + ": error reading object: " + e.what())));
     }
  
     if (isUnresolved(og)) {
         // PDF spec says unknown objects resolve to the null object.
         QTC::TC("qpdf", "QPDF resolve failure to null");
-        updateCache(og, QPDF_Null::create());
+        updateCache(og, QPDF_Null::create(), -1, -1);
     }
  
     auto result(m->obj_cache[og].object);
@@ -2035,6 +1915,12 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
             "supposed object stream " + std::to_string(obj_stream_number) + " is not a stream");
     }
  
+    // For linearization data in the object, use the data from the object stream for the objects in
+    // the stream.
+    QPDFObjGen stream_og(obj_stream_number, 0);
+    qpdf_offset_t end_before_space = m->obj_cache[stream_og].end_before_space;
+    qpdf_offset_t end_after_space = m->obj_cache[stream_og].end_after_space;
+
     QPDFObjectHandle dict = obj_stream.getDict();
     if (!dict.isDictionaryOfType("/ObjStm")) {
         QTC::TC("qpdf", "QPDF ERR object stream with wrong type");
@@ -2059,7 +1945,6 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
             (m->file->getName() + " object stream " + std::to_string(obj_stream_number)),
             bp.get()));
  
-    qpdf_offset_t last_offset = -1;
     for (int i = 0; i < n; ++i) {
         QPDFTokenizer::Token tnum = readToken(*input);
         QPDFTokenizer::Token toffset = readToken(*input);
@@ -2073,7 +1958,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
  
         int num = QUtil::string_to_int(tnum.getValue().c_str());
         long long offset = QUtil::string_to_int(toffset.getValue().c_str());
-        if (num > m->xref_table.max_id()) {
+        if (num > m->xref_table_max_id) {
             continue;
         }
         if (num == obj_stream_number) {
@@ -2085,15 +1970,6 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
                 "object stream claims to contain itself"));
             continue;
         }
-        if (offset <= last_offset) {
-            throw damagedPDF(
-                *input,
-                m->last_object_description,
-                input->getLastOffset(),
-                "expected offsets in object stream to be increasing");
-        }
-        last_offset = offset;
-
         offsets[num] = toI(offset + first);
     }
  
@@ -2105,12 +1981,13 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
     m->last_object_description += "object ";
     for (auto const& iter: offsets) {
         QPDFObjGen og(iter.first, 0);
-        if (m->xref_table.type(og) == 2 &&
-            m->xref_table.stream_number(og.getObj()) == obj_stream_number) {
+        auto entry = m->xref_table.find(og);
+        if (entry != m->xref_table.end() && entry->second.getType() == 2 &&
+            entry->second.getObjStreamNumber() == obj_stream_number) {
             int offset = iter.second;
             input->seek(offset, SEEK_SET);
             QPDFObjectHandle oh = readObjectInStream(input, iter.first);
-            updateCache(og, oh.getObj());
+            updateCache(og, oh.getObj(), end_before_space, end_after_space);
         } else {
             QTC::TC("qpdf", "QPDF not caching overridden objstm object");
         }
@@ -2125,14 +2002,20 @@ QPDF::newIndirect(QPDFObjGen const&amp; og, std::shared_ptr&lt;QPDFObject&gt; const&amp; obj)
 }
  
 void
-QPDF::updateCache(QPDFObjGen const& og, std::shared_ptr<QPDFObject> const& object)
+QPDF::updateCache(
+    QPDFObjGen const& og,
+    std::shared_ptr<QPDFObject> const& object,
+    qpdf_offset_t end_before_space,
+    qpdf_offset_t end_after_space)
 {
     object->setObjGen(this, og);
     if (isCached(og)) {
         auto& cache = m->obj_cache[og];
         cache.object->assign(object);
+        cache.end_before_space = end_before_space;
+        cache.end_after_space = end_after_space;
     } else {
-        m->obj_cache[og] = ObjCache(object);
+        m->obj_cache[og] = ObjCache(object, end_before_space, end_after_space);
     }
 }
  
@@ -2162,7 +2045,7 @@ QPDFObjectHandle
 QPDF::makeIndirectFromQPDFObject(std::shared_ptr<QPDFObject> const& obj)
 {
     QPDFObjGen next{nextObjGen()};
-    m->obj_cache[next] = ObjCache(obj);
+    m->obj_cache[next] = ObjCache(obj, -1, -1);
     return newIndirect(next, m->obj_cache[next].object);
 }
  
@@ -2218,7 +2101,7 @@ QPDF::getObjectForParser(int id, int gen, bool parse_pdf)
     if (auto iter = m->obj_cache.find(og); iter != m->obj_cache.end()) {
         return iter->second.object;
     }
-    if (m->xref_table.type(og) || !m->xref_table.initialized()) {
+    if (m->xref_table.count(og) || !m->parsed) {
         return m->obj_cache.insert({og, QPDF_Unresolved::create(this, og)}).first->second.object;
     }
     if (parse_pdf) {
@@ -2234,9 +2117,8 @@ QPDF::getObjectForJSON(int id, int gen)
     auto [it, inserted] = m->obj_cache.try_emplace(og);
     auto& obj = it->second.object;
     if (inserted) {
-        obj = (m->xref_table.initialized() && !m->xref_table.type(og))
-            ? QPDF_Null::create(this, og)
-            : QPDF_Unresolved::create(this, og);
+        obj = (m->parsed && !m->xref_table.count(og)) ? QPDF_Null::create(this, og)
+                                                      : QPDF_Unresolved::create(this, og);
     }
     return obj;
 }
@@ -2246,10 +2128,10 @@ QPDF::getObject(QPDFObjGen const&amp; og)
 {
     if (auto it = m->obj_cache.find(og); it != m->obj_cache.end()) {
         return {it->second.object};
-    } else if (m->xref_table.initialized() && !m->xref_table.type(og)) {
+    } else if (m->parsed && !m->xref_table.count(og)) {
         return QPDF_Null::create();
     } else {
-        auto result = m->obj_cache.try_emplace(og, QPDF_Unresolved::create(this, og));
+        auto result = m->obj_cache.try_emplace(og, QPDF_Unresolved::create(this, og), -1, -1);
         return {result.first->second.object};
     }
 }
@@ -2285,12 +2167,13 @@ QPDF::replaceObject(QPDFObjGen const&amp; og, QPDFObjectHandle oh)
         QTC::TC("qpdf", "QPDF replaceObject called with indirect object");
         throw std::logic_error("QPDF::replaceObject called with indirect object handle");
     }
-    updateCache(og, oh.getObj());
+    updateCache(og, oh.getObj(), -1, -1);
 }
  
 void
 QPDF::removeObject(QPDFObjGen og)
 {
+    m->xref_table.erase(og);
     if (auto cached = m->obj_cache.find(og); cached != m->obj_cache.end()) {
         // Take care of any object handles that may be floating around.
         cached->second.object->assign(QPDF_Null::create());
@@ -2559,7 +2442,7 @@ QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign)
     } else {
         auto foreign_stream_data = std::make_shared<ForeignStreamData>(
             foreign_stream_qpdf.m->encp,
-            foreign_stream_qpdf.m->file_sp,
+            foreign_stream_qpdf.m->file,
             foreign.getObjGen(),
             stream->getParsedOffset(),
             stream->getLength(),
@@ -2643,13 +2526,13 @@ QPDF::getExtensionLevel()
 QPDFObjectHandle
 QPDF::getTrailer()
 {
-    return m->xref_table.trailer();
+    return m->trailer;
 }
  
 QPDFObjectHandle
 QPDF::getRoot()
 {
-    QPDFObjectHandle root = m->xref_table.trailer().getKey("/Root");
+    QPDFObjectHandle root = m->trailer.getKey("/Root");
     if (!root.isDictionary()) {
         throw damagedPDF("", 0, "unable to find /Root dictionary");
     } else if (
@@ -2665,10 +2548,17 @@ QPDF::getRoot()
 std::map<QPDFObjGen, QPDFXRefEntry>
 QPDF::getXRefTable()
 {
-    if (!m->xref_table.initialized()) {
+    return getXRefTableInternal();
+}
+
+std::map<QPDFObjGen, QPDFXRefEntry> const&
+QPDF::getXRefTableInternal()
+{
+    if (!m->parsed) {
         throw std::logic_error("QPDF::getXRefTable called before parsing.");
     }
-    return m->xref_table.as_map();
+
+    return m->xref_table;
 }
  
 size_t
@@ -2676,10 +2566,7 @@ QPDF::tableSize()
 {
     // If obj_cache is dense, accommodate all object in tables,else accommodate only original
     // objects.
-    auto max_xref = toI(m->xref_table.size());
-    if (max_xref > 0) {
-        --max_xref;
-    }
+    auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
     auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
     auto max_id = std::numeric_limits<int>::max() - 1;
     if (max_obj >= max_id || max_xref >= max_id) {
@@ -2717,14 +2604,14 @@ QPDF::getCompressibleObjGens()
     // iterating through the xref table since it avoids preserving orphaned items.
  
     // Exclude encryption dictionary, if any
-    QPDFObjectHandle encryption_dict = m->xref_table.trailer().getKey("/Encrypt");
+    QPDFObjectHandle encryption_dict = m->trailer.getKey("/Encrypt");
     QPDFObjGen encryption_dict_og = encryption_dict.getObjGen();
  
     const size_t max_obj = getObjectCount();
     std::vector<bool> visited(max_obj, false);
     std::vector<QPDFObjectHandle> queue;
     queue.reserve(512);
-    queue.push_back(m->xref_table.trailer());
+    queue.push_back(m->trailer);
     std::vector<T> result;
     if constexpr (std::is_same_v<T, QPDFObjGen>) {
         result.reserve(m->obj_cache.size());
@@ -2879,7 +2766,7 @@ QPDF::pipeStreamData(
 {
     return pipeStreamData(
         m->encp,
-        m->file_sp,
+        m->file,
         *this,
         og,
         offset,
@@ -13,6 +13,7 @@
 #include <qpdf/Pl_StdioFile.hh>
 #include <qpdf/Pl_String.hh>
 #include <qpdf/QIntC.hh>
+#include <qpdf/QPDF.hh>
 #include <qpdf/QPDFAcroFormDocumentHelper.hh>
 #include <qpdf/QPDFCryptoProvider.hh>
 #include <qpdf/QPDFEmbeddedFileDocumentHelper.hh>
@@ -25,7 +26,6 @@
 #include <qpdf/QPDFSystemError.hh>
 #include <qpdf/QPDFUsage.hh>
 #include <qpdf/QPDFWriter.hh>
-#include <qpdf/QPDF_private.hh>
 #include <qpdf/QTC.hh>
 #include <qpdf/QUtil.hh>
  
@@ -14,10 +14,10 @@
 #include <qpdf/Pl_RC4.hh>
 #include <qpdf/Pl_StdioFile.hh>
 #include <qpdf/QIntC.hh>
+#include <qpdf/QPDF.hh>
 #include <qpdf/QPDFObjectHandle.hh>
 #include <qpdf/QPDF_Name.hh>
 #include <qpdf/QPDF_String.hh>
-#include <qpdf/QPDF_private.hh>
 #include <qpdf/QTC.hh>
 #include <qpdf/QUtil.hh>
 #include <qpdf/RC4.hh>
@@ -1698,6 +1698,7 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object)
             if (obj_to_write.isStream()) {
                 // This condition occurred in a fuzz input. Ideally we should block it at parse
                 // time, but it's not clear to me how to construct a case for this.
+                QTC::TC("qpdf", "QPDFWriter stream in ostream");
                 obj_to_write.warnIfPossible("stream found inside object stream; treating as null");
                 obj_to_write = QPDFObjectHandle::newNull();
             }
@@ -1936,26 +1937,47 @@ void
 QPDFWriter::preserveObjectStreams()
 {
     auto const& xref = QPDF::Writer::getXRefTable(m->pdf);
-    m->obj.streams_empty = !xref.object_streams();
-    if (m->obj.streams_empty) {
-        return;
-    }
-    // This code filters out objects that are not allowed to be in object streams. In addition to
-    // removing objects that were erroneously included in object streams in the source PDF, it also
-    // prevents unreferenced objects from being included.
+    // Our object_to_object_stream map has to map ObjGen -> ObjGen since we may be generating object
+    // streams out of old objects that have generation numbers greater than zero. However in an
+    // existing PDF, all object stream objects and all objects in them must have generation 0
+    // because the PDF spec does not provide any way to do otherwise. This code filters out objects
+    // that are not allowed to be in object streams. In addition to removing objects that were
+    // erroneously included in object streams in the source PDF, it also prevents unreferenced
+    // objects from being included.
+    auto end = xref.cend();
+    m->obj.streams_empty = true;
     if (m->preserve_unreferenced_objects) {
-        QTC::TC("qpdf", "QPDFWriter preserve object streams preserve unreferenced");
-        for (auto [id, stream]: xref.compressed_objects()) {
-            m->obj[id].object_stream = stream;
+        for (auto iter = xref.cbegin(); iter != end; ++iter) {
+            if (iter->second.getType() == 2) {
+                // Pdf contains object streams.
+                QTC::TC("qpdf", "QPDFWriter preserve object streams preserve unreferenced");
+                m->obj.streams_empty = false;
+                m->obj[iter->first].object_stream = iter->second.getObjStreamNumber();
+            }
         }
     } else {
-        QTC::TC("qpdf", "QPDFWriter preserve object streams");
-        auto eligible = QPDF::Writer::getCompressibleObjSet(m->pdf);
-        for (auto [id, stream]: xref.compressed_objects()) {
-            if (eligible[id]) {
-                m->obj[id].object_stream = stream;
-            } else {
-                QTC::TC("qpdf", "QPDFWriter exclude from object stream");
+        // Start by scanning for first compressed object in case we don't have any object streams to
+        // process.
+        for (auto iter = xref.cbegin(); iter != end; ++iter) {
+            if (iter->second.getType() == 2) {
+                // Pdf contains object streams.
+                QTC::TC("qpdf", "QPDFWriter preserve object streams");
+                m->obj.streams_empty = false;
+                auto eligible = QPDF::Writer::getCompressibleObjSet(m->pdf);
+                // The object pointed to by iter may be a previous generation, in which case it is
+                // removed by getCompressibleObjSet. We need to restart the loop (while the object
+                // table may contain multiple generations of an object).
+                for (iter = xref.cbegin(); iter != end; ++iter) {
+                    if (iter->second.getType() == 2) {
+                        auto id = static_cast<size_t>(iter->first.getObj());
+                        if (id < eligible.size() && eligible[id]) {
+                            m->obj[iter->first].object_stream = iter->second.getObjStreamNumber();
+                        } else {
+                            QTC::TC("qpdf", "QPDFWriter exclude from object stream");
+                        }
+                    }
+                }
+                return;
             }
         }
     }
@@ -10,8 +10,8 @@
 #include <qpdf/Pl_Flate.hh>
 #include <qpdf/Pl_QPDFTokenizer.hh>
 #include <qpdf/QIntC.hh>
+#include <qpdf/QPDF.hh>
 #include <qpdf/QPDFExc.hh>
-#include <qpdf/QPDF_private.hh>
 #include <qpdf/QTC.hh>
 #include <qpdf/QUtil.hh>
 #include <qpdf/SF_ASCII85Decode.hh>
@@ -3,7 +3,7 @@
  
 #include <qpdf/assert_debug.h>
  
-#include <qpdf/QPDF_private.hh>
+#include <qpdf/QPDF.hh>
  
 #include <qpdf/QPDFExc.hh>
  
@@ -727,7 +727,7 @@ QPDF::initializeEncryption()
     // at /Encrypt again.  Otherwise, things could go wrong if someone mutates the encryption
     // dictionary.
  
-    if (!m->xref_table.trailer().hasKey("/Encrypt")) {
+    if (!m->trailer.hasKey("/Encrypt")) {
         return;
     }
  
@@ -736,7 +736,7 @@ QPDF::initializeEncryption()
     m->encp->encrypted = true;
  
     std::string id1;
-    QPDFObjectHandle id_obj = m->xref_table.trailer().getKey("/ID");
+    QPDFObjectHandle id_obj = m->trailer.getKey("/ID");
     if ((id_obj.isArray() && (id_obj.getArrayNItems() == 2) && id_obj.getArrayItem(0).isString())) {
         id1 = id_obj.getArrayItem(0).getStringValue();
     } else {
@@ -745,7 +745,7 @@ QPDF::initializeEncryption()
         warn(damagedPDF("trailer", "invalid /ID in trailer dictionary"));
     }
  
-    QPDFObjectHandle encryption_dict = m->xref_table.trailer().getKey("/Encrypt");
+    QPDFObjectHandle encryption_dict = m->trailer.getKey("/Encrypt");
     if (!encryption_dict.isDictionary()) {
         throw damagedPDF("/Encrypt in trailer dictionary is not a dictionary");
     }
@@ -51,6 +51,17 @@
 //   ]                            |   <- st_top
 // }                              |
  
+static char const* JSON_PDF = (
+    // force line break
+    "%PDF-1.3\n"
+    "xref\n"
+    "0 1\n"
+    "0000000000 65535 f \n"
+    "trailer << /Size 1 >>\n"
+    "startxref\n"
+    "9\n"
+    "%%EOF\n");
+
 // Validator methods -- these are much more performant than std::regex.
 static bool
 is_indirect_object(std::string const& v, int& obj, int& gen)
@@ -256,10 +267,10 @@ class QPDF::JSONReactor: public JSON::Reactor
     struct StackFrame
     {
         StackFrame(state_e state) :
-            state(state){};
+            state(state) {};
         StackFrame(state_e state, QPDFObjectHandle&& object) :
             state(state),
-            object(object){};
+            object(object) {};
         state_e state;
         QPDFObjectHandle object;
     };
@@ -582,7 +593,8 @@ QPDF::JSONReactor::dictionaryItem(std::string const&amp; key, JSON const&amp; value)
             this->saw_value = true;
             // The trailer must be a dictionary, so we can use setNextStateIfDictionary.
             if (setNextStateIfDictionary("trailer.value", value, st_object)) {
-                pdf.m->xref_table.trailer(makeObject(value));
+                this->pdf.m->trailer = makeObject(value);
+                setObjectDescription(this->pdf.m->trailer, value);
             }
         } else if (key == "stream") {
             // Don't need to set saw_stream here since there's already an error.
@@ -774,9 +786,7 @@ QPDF::createFromJSON(std::string const&amp; json_file)
 void
 QPDF::createFromJSON(std::shared_ptr<InputSource> is)
 {
-    m->pdf_version = "1.3";
-    m->no_input_name = is->getName();
-    m->xref_table.initialize_json();
+    processMemoryFile(is->getName().c_str(), JSON_PDF, strlen(JSON_PDF));
     importJSON(is, true);
 }
  
 // See doc/linearization.
  
-#include <qpdf/QPDF_private.hh>
+#include <qpdf/QPDF.hh>
  
 #include <qpdf/BitStream.hh>
 #include <qpdf/BitWriter.hh>
@@ -288,8 +288,9 @@ QPDF::readHintStream(Pipeline&amp; pl, qpdf_offset_t offset, size_t length)
     QPDFObjGen og;
     QPDFObjectHandle H =
         readObjectAtOffset(false, offset, "linearization hint stream", QPDFObjGen(0, 0), og, false);
-    qpdf_offset_t min_end_offset = m->xref_table.end_before_space(og);
-    qpdf_offset_t max_end_offset = m->xref_table.end_after_space(og);
+    ObjCache& oc = m->obj_cache[og];
+    qpdf_offset_t min_end_offset = oc.end_before_space;
+    qpdf_offset_t max_end_offset = oc.end_after_space;
     if (!H.isStream()) {
         throw damagedPDF("linearization dictionary", "hint table is not a stream");
     }
@@ -300,11 +301,14 @@ QPDF::readHintStream(Pipeline&amp; pl, qpdf_offset_t offset, size_t length)
     // increasing length to cover it, even though the specification says all objects in the
     // linearization parameter dictionary must be direct.  We have to get the file position of the
     // end of length in this case.
-    auto length_og = Hdict.getKey("/Length").getObjGen();
-    if (length_og.isIndirect()) {
+    QPDFObjectHandle length_obj = Hdict.getKey("/Length");
+    if (length_obj.isIndirect()) {
         QTC::TC("qpdf", "QPDF hint table length indirect");
-        min_end_offset = m->xref_table.end_before_space(length_og);
-        max_end_offset = m->xref_table.end_after_space(length_og);
+        // Force resolution
+        (void)length_obj.getIntValue();
+        ObjCache& oc2 = m->obj_cache[length_obj.getObjGen()];
+        min_end_offset = oc2.end_before_space;
+        max_end_offset = oc2.end_after_space;
     } else {
         QTC::TC("qpdf", "QPDF hint table length direct");
     }
@@ -441,7 +445,7 @@ QPDF::checkLinearizationInternal()
     for (size_t i = 0; i < toS(npages); ++i) {
         QPDFObjectHandle const& page = pages.at(i);
         QPDFObjGen og(page.getObjGen());
-        if (m->xref_table.type(og) == 2) {
+        if (m->xref_table[og].getType() == 2) {
             linearizationWarning(
                 "page dictionary for page " + std::to_string(i) + " is compressed");
         }
@@ -457,11 +461,12 @@ QPDF::checkLinearizationInternal()
             break;
         }
     }
-    if (m->file->tell() != m->xref_table.first_item_offset()) {
+    if (m->file->tell() != m->first_xref_item_offset) {
         QTC::TC("qpdf", "QPDF err /T mismatch");
         linearizationWarning(
-            "space before first xref item (/T) mismatch (computed = " +
-            std::to_string(m->xref_table.first_item_offset()) +
+            "space before first xref item (/T) mismatch "
+            "(computed = " +
+            std::to_string(m->first_xref_item_offset) +
             "; file = " + std::to_string(m->file->tell()));
     }
  
@@ -472,7 +477,7 @@ QPDF::checkLinearizationInternal()
     // compressed objects are supposed to be at the end of the containing xref section if any object
     // streams are in use.
  
-    if (m->xref_table.uncompressed_after_compressed()) {
+    if (m->uncompressed_after_compressed) {
         linearizationWarning("linearized file contains an uncompressed object after a compressed "
                              "one in a cross-reference stream");
     }
@@ -480,9 +485,18 @@ QPDF::checkLinearizationInternal()
     // Further checking requires optimization and order calculation. Don't allow optimization to
     // make changes.  If it has to, then the file is not properly linearized.  We use the xref table
     // to figure out which objects are compressed and which are uncompressed.
-
-    optimize(m->xref_table);
-    calculateLinearizationData(m->xref_table);
+    { // local scope
+        std::map<int, int> object_stream_data;
+        for (auto const& iter: m->xref_table) {
+            QPDFObjGen const& og = iter.first;
+            QPDFXRefEntry const& entry = iter.second;
+            if (entry.getType() == 2) {
+                object_stream_data[og.getObj()] = entry.getObjStreamNumber();
+            }
+        }
+        optimize(object_stream_data, false);
+        calculateLinearizationData(object_stream_data);
+    }
  
     // E: offset of end of first page -- Implementation note 123 says Acrobat includes on extra
     // object here by mistake.  pdlin fails to place thumbnail images in section 9, so when
@@ -499,14 +513,13 @@ QPDF::checkLinearizationInternal()
     qpdf_offset_t max_E = -1;
     for (auto const& oh: m->part6) {
         QPDFObjGen og(oh.getObjGen());
-        auto before = m->xref_table.end_before_space(og);
-        auto after = m->xref_table.end_after_space(og);
-        if (before <= 0) {
+        if (m->obj_cache.count(og) == 0) {
             // All objects have to have been dereferenced to be classified.
             throw std::logic_error("linearization part6 object not in cache");
         }
-        min_E = std::max(min_E, before);
-        max_E = std::max(max_E, after);
+        ObjCache const& oc = m->obj_cache[og];
+        min_E = std::max(min_E, oc.end_before_space);
+        max_E = std::max(max_E, oc.end_after_space);
     }
     if ((p.first_page_end < min_E) || (p.first_page_end > max_E)) {
         QTC::TC("qpdf", "QPDF warn /E mismatch");
@@ -533,11 +546,10 @@ QPDF::maxEnd(ObjUser const&amp; ou)
     }
     qpdf_offset_t end = 0;
     for (auto const& og: m->obj_user_to_objects[ou]) {
-        auto e = m->xref_table.end_after_space(og);
-        if (e <= 0) {
+        if (m->obj_cache.count(og) == 0) {
             stopOnError("unknown object referenced in object user table");
         }
-        end = std::max(end, e);
+        end = std::max(end, m->obj_cache[og].end_after_space);
     }
     return end;
 }
@@ -545,18 +557,23 @@ QPDF::maxEnd(ObjUser const&amp; ou)
 qpdf_offset_t
 QPDF::getLinearizationOffset(QPDFObjGen const& og)
 {
-    switch (m->xref_table.type(og)) {
+    QPDFXRefEntry entry = m->xref_table[og];
+    qpdf_offset_t result = 0;
+    switch (entry.getType()) {
     case 1:
-        return m->xref_table.offset(og);
+        result = entry.getOffset();
+        break;
  
     case 2:
         // For compressed objects, return the offset of the object stream that contains them.
-        return getLinearizationOffset(QPDFObjGen(m->xref_table.stream_number(og.getObj()), 0));
+        result = getLinearizationOffset(QPDFObjGen(entry.getObjStreamNumber(), 0));
+        break;
  
     default:
         stopOnError("getLinearizationOffset called for xref entry not of type 1 or 2");
-        return 0; // unreachable
+        break;
     }
+    return result;
 }
  
 QPDFObjectHandle
@@ -571,16 +588,6 @@ QPDF::getUncompressedObject(QPDFObjectHandle&amp; obj, std::map&lt;int, int&gt; const&amp; obj
 }
  
 QPDFObjectHandle
-QPDF::getUncompressedObject(QPDFObjectHandle& obj, Xref_table const& xref)
-{
-    auto og = obj.getObjGen();
-    if (obj.isNull() || xref.type(og) != 2) {
-        return obj;
-    }
-    return getObject(xref.stream_number(og.getObj()), 0);
-}
-
-QPDFObjectHandle
 QPDF::getUncompressedObject(QPDFObjectHandle& oh, QPDFWriter::ObjTable const& obj)
 {
     if (obj.contains(oh)) {
@@ -597,13 +604,15 @@ QPDF::lengthNextN(int first_object, int n)
     int length = 0;
     for (int i = 0; i < n; ++i) {
         QPDFObjGen og(first_object + i, 0);
-        auto end = m->xref_table.end_after_space(og);
-        if (end <= 0) {
+        if (m->xref_table.count(og) == 0) {
             linearizationWarning(
                 "no xref table entry for " + std::to_string(first_object + i) + " 0");
-            continue;
+        } else {
+            if (m->obj_cache.count(og) == 0) {
+                stopOnError("found unknown object while calculating length for linearization data");
+            }
+            length += toI(m->obj_cache[og].end_after_space - getLinearizationOffset(og));
         }
-        length += toI(end - getLinearizationOffset(og));
     }
     return length;
 }
@@ -627,7 +636,7 @@ QPDF::checkHPageOffset(
     int npages = toI(pages.size());
     qpdf_offset_t table_offset = adjusted_offset(m->page_offset_hints.first_page_offset);
     QPDFObjGen first_page_og(pages.at(0).getObjGen());
-    if (m->xref_table.type(first_page_og) == 0) {
+    if (m->xref_table.count(first_page_og) == 0) {
         stopOnError("supposed first page object is not known");
     }
     qpdf_offset_t offset = getLinearizationOffset(first_page_og);
@@ -638,7 +647,7 @@ QPDF::checkHPageOffset(
     for (int pageno = 0; pageno < npages; ++pageno) {
         QPDFObjGen page_og(pages.at(toS(pageno)).getObjGen());
         int first_object = page_og.getObj();
-        if (m->xref_table.type(page_og) == 0) {
+        if (m->xref_table.count(page_og) == 0) {
             stopOnError("unknown object in page offset hint table");
         }
         offset = getLinearizationOffset(page_og);
@@ -760,7 +769,7 @@ QPDF::checkHSharedObject(std::vector&lt;QPDFObjectHandle&gt; const&amp; pages, std::map&lt;in
                 cur_object = so.first_shared_obj;
  
                 QPDFObjGen og(cur_object, 0);
-                if (m->xref_table.type(og) == 0) {
+                if (m->xref_table.count(og) == 0) {
                     stopOnError("unknown object in shared object hint table");
                 }
                 qpdf_offset_t offset = getLinearizationOffset(og);
@@ -811,7 +820,7 @@ QPDF::checkHOutlines()
                 return;
             }
             QPDFObjGen og(outlines.getObjGen());
-            if (m->xref_table.type(og) == 0) {
+            if (m->xref_table.count(og) == 0) {
                 stopOnError("unknown object in outlines hint table");
             }
             qpdf_offset_t offset = getLinearizationOffset(og);
@@ -830,7 +839,8 @@ QPDF::checkHOutlines()
                     std::to_string(table_length) + "; computed = " + std::to_string(length));
             }
         } else {
-            linearizationWarning("incorrect first object number in outline hints table.");
+            linearizationWarning("incorrect first object number in outline "
+                                 "hints table.");
         }
     } else {
         linearizationWarning("incorrect object count in outline hint table");
@@ -2,7 +2,7 @@
  
 #include <qpdf/assert_debug.h>
  
-#include <qpdf/QPDF_private.hh>
+#include <qpdf/QPDF.hh>
  
 #include <qpdf/QPDFExc.hh>
 #include <qpdf/QPDFWriter_private.hh>
@@ -78,12 +78,6 @@ QPDF::optimize(
     optimize_internal(obj, true, skip_stream_parameters);
 }
  
-void
-QPDF::optimize(QPDF::Xref_table const& xref)
-{
-    optimize_internal(xref, false, nullptr);
-}
-
 template <typename T>
 void
 QPDF::optimize_internal(
@@ -121,13 +115,13 @@ QPDF::optimize_internal(
     }
  
     // Traverse document-level items
-    for (auto const& key: m->xref_table.trailer().getKeys()) {
+    for (auto const& key: m->trailer.getKeys()) {
         if (key == "/Root") {
             // handled separately
         } else {
             updateObjectMaps(
                 ObjUser(ObjUser::ou_trailer_key, key),
-                m->xref_table.trailer().getKey(key),
+                m->trailer.getKey(key),
                 skip_stream_parameters);
         }
     }
@@ -175,13 +169,13 @@ QPDF::pushInheritedAttributesToPage(bool allow_changes, bool warn_skipped_keys)
     // values for them.
     std::map<std::string, std::vector<QPDFObjectHandle>> key_ancestors;
     pushInheritedAttributesToPageInternal(
-        m->xref_table.trailer().getKey("/Root").getKey("/Pages"),
+        m->trailer.getKey("/Root").getKey("/Pages"),
         key_ancestors,
         allow_changes,
         warn_skipped_keys);
     if (!key_ancestors.empty()) {
-        throw std::logic_error(
-            "key_ancestors not empty after pushing inherited attributes to pages");
+        throw std::logic_error("key_ancestors not empty after"
+                               " pushing inherited attributes to pages");
     }
     m->pushed_inherited_attributes_to_pages = true;
     m->ever_pushed_inherited_attributes_to_pages = true;
@@ -448,45 +442,3 @@ QPDF::filterCompressedObjects(QPDFWriter::ObjTable const&amp; obj)
     m->obj_user_to_objects = t_obj_user_to_objects;
     m->object_to_obj_users = t_object_to_obj_users;
 }
-
-void
-QPDF::filterCompressedObjects(QPDF::Xref_table const& xref)
-{
-    if (!xref.object_streams()) {
-        return;
-    }
-
-    // Transform object_to_obj_users and obj_user_to_objects so that they refer only to uncompressed
-    // objects.  If something is a user of a compressed object, then it is really a user of the
-    // object stream that contains it.
-
-    std::map<ObjUser, std::set<QPDFObjGen>> t_obj_user_to_objects;
-    std::map<QPDFObjGen, std::set<ObjUser>> t_object_to_obj_users;
-
-    for (auto const& i1: m->obj_user_to_objects) {
-        ObjUser const& ou = i1.first;
-        // Loop over objects.
-        for (auto const& og: i1.second) {
-            if (auto stream = xref.stream_number(og.getObj())) {
-                t_obj_user_to_objects[ou].insert(QPDFObjGen(stream, 0));
-            } else {
-                t_obj_user_to_objects[ou].insert(og);
-            }
-        }
-    }
-
-    for (auto const& i1: m->object_to_obj_users) {
-        QPDFObjGen const& og = i1.first;
-        // Loop over obj_users.
-        for (auto const& ou: i1.second) {
-            if (auto stream = xref.stream_number(og.getObj())) {
-                t_object_to_obj_users[QPDFObjGen(stream, 0)].insert(ou);
-            } else {
-                t_object_to_obj_users[og].insert(ou);
-            }
-        }
-    }
-
-    m->obj_user_to_objects = t_obj_user_to_objects;
-    m->object_to_obj_users = t_object_to_obj_users;
-}
-#include <qpdf/QPDF_private.hh>
+#include <qpdf/QPDF.hh>
  
 #include <qpdf/QPDFExc.hh>
 #include <qpdf/QTC.hh>
@@ -46,12 +46,6 @@ class ObjTable: public std::vector&lt;T&gt;
     }
  
     inline T const&
-    operator[](unsigned int idx) const
-    {
-        return element(idx);
-    }
-
-    inline T const&
     operator[](QPDFObjGen og) const
     {
         return element(static_cast<size_t>(og.getObj()));
@@ -6,13 +6,14 @@
  
 #include <qpdf/Constants.h>
 #include <qpdf/JSON.hh>
+#include <qpdf/QPDF.hh>
 #include <qpdf/QPDFValue.hh>
-#include <qpdf/QPDF_private.hh>
 #include <qpdf/Types.h>
  
 #include <string>
 #include <string_view>
  
+class QPDF;
 class QPDFObjectHandle;
  
 class QPDFObject
-#ifndef QPDF_PRIVATE_HH
-#define QPDF_PRIVATE_HH
-
-#include <qpdf/QPDF.hh>
-
-#include <variant>
-
-// Xref_table encapsulates the pdf's xref table and trailer.
-class QPDF::Xref_table
-{
-  public:
-    Xref_table(QPDF& qpdf, InputSource* const& file) :
-        qpdf(qpdf),
-        file(file)
-    {
-        tokenizer.allowEOF();
-    }
-
-    void initialize();
-    void initialize_empty();
-    void initialize_json();
-    void reconstruct(QPDFExc& e);
-    void show();
-    bool resolve();
-
-    QPDFObjectHandle
-    trailer() const
-    {
-        return trailer_;
-    }
-
-    void
-    trailer(QPDFObjectHandle&& oh)
-    {
-        trailer_ = std::move(oh);
-    }
-
-    // Returns 0 if og is not in table.
-    size_t
-    type(QPDFObjGen og) const
-    {
-        int id = og.getObj();
-        if (id < 1 || static_cast<size_t>(id) >= table.size()) {
-            return 0;
-        }
-        auto& e = table[static_cast<size_t>(id)];
-        return e.gen() == og.getGen() ? e.type() : 0;
-    }
-
-    // Returns 0 if og is not in table.
-    size_t
-    type(size_t id) const noexcept
-    {
-        if (id >= table.size()) {
-            return 0;
-        }
-        return table[id].type();
-    }
-
-    // Returns 0 if og is not in table.
-    qpdf_offset_t
-    offset(QPDFObjGen og) const noexcept
-    {
-        int id = og.getObj();
-        if (id < 1 || static_cast<size_t>(id) >= table.size()) {
-            return 0;
-        }
-        return table[static_cast<size_t>(id)].offset();
-    }
-
-    // Returns 0 if id is not in table.
-    int
-    stream_number(int id) const noexcept
-    {
-        if (id < 1 || static_cast<size_t>(id) >= table.size()) {
-            return 0;
-        }
-        return table[static_cast<size_t>(id)].stream_number();
-    }
-
-    int
-    stream_index(int id) const noexcept
-    {
-        if (id < 1 || static_cast<size_t>(id) >= table.size()) {
-            return 0;
-        }
-        return table[static_cast<size_t>(id)].stream_index();
-    }
-
-    QPDFObjGen at_offset(qpdf_offset_t offset) const noexcept;
-
-    std::map<QPDFObjGen, QPDFXRefEntry> as_map() const;
-
-    bool
-    object_streams() const noexcept
-    {
-        return object_streams_;
-    }
-
-    // Return a vector of object id and stream number for each compressed object.
-    std::vector<std::pair<unsigned int, int>>
-    compressed_objects() const
-    {
-        if (!initialized()) {
-            throw std::logic_error("Xref_table::compressed_objects called before parsing.");
-        }
-
-        std::vector<std::pair<unsigned int, int>> result;
-        result.reserve(table.size());
-
-        unsigned int i{0};
-        for (auto const& item: table) {
-            if (item.type() == 2) {
-                result.emplace_back(i, item.stream_number());
-            }
-            ++i;
-        }
-        return result;
-    }
-
-    // Temporary access to underlying table size
-    size_t
-    size() const noexcept
-    {
-        return table.size();
-    }
-
-    void
-    ignore_streams(bool val) noexcept
-    {
-        ignore_streams_ = val;
-    }
-
-    bool
-    initialized() const noexcept
-    {
-        return initialized_;
-    }
-
-    void
-    attempt_recovery(bool val) noexcept
-    {
-        attempt_recovery_ = val;
-    }
-
-    int
-    max_id() const noexcept
-    {
-        return max_id_;
-    }
-
-    // For Linearization
-
-    qpdf_offset_t
-    end_after_space(QPDFObjGen og)
-    {
-        auto& e = entry(toS(og.getObj()));
-        switch (e.type()) {
-        case 1:
-            return e.end_after_space_;
-        case 2:
-            {
-                auto es = entry(toS(e.stream_number()));
-                return es.type() == 1 ? es.end_after_space_ : 0;
-            }
-        default:
-            return 0;
-        }
-    }
-
-    qpdf_offset_t
-    end_before_space(QPDFObjGen og)
-    {
-        auto& e = entry(toS(og.getObj()));
-        switch (e.type()) {
-        case 1:
-            return e.end_before_space_;
-        case 2:
-            {
-                auto es = entry(toS(e.stream_number()));
-                return es.type() == 1 ? es.end_before_space_ : 0;
-            }
-        default:
-            return 0;
-        }
-    }
-
-    void
-    linearization_offsets(size_t id, qpdf_offset_t before, qpdf_offset_t after)
-    {
-        if (type(id)) {
-            table[id].end_before_space_ = before;
-            table[id].end_after_space_ = after;
-        }
-    }
-
-    bool
-    uncompressed_after_compressed() const noexcept
-    {
-        return uncompressed_after_compressed_;
-    }
-
-    // Actual value from file
-    qpdf_offset_t
-    first_item_offset() const noexcept
-    {
-        return first_item_offset_;
-    }
-
-  private:
-    // Object, count, offset of first entry
-    typedef std::tuple<int, int, qpdf_offset_t> Subsection;
-
-    struct Uncompressed
-    {
-        Uncompressed(qpdf_offset_t offset) :
-            offset(offset)
-        {
-        }
-        qpdf_offset_t offset;
-    };
-
-    struct Compressed
-    {
-        Compressed(int stream_number, int stream_index) :
-            stream_number(stream_number),
-            stream_index(stream_index)
-        {
-        }
-        int stream_number{0};
-        int stream_index{0};
-    };
-
-    typedef std::variant<std::monostate, Uncompressed, Compressed> Xref;
-
-    struct Entry
-    {
-        Entry() = default;
-
-        Entry(int gen, Xref entry) :
-            gen_(gen),
-            entry(entry)
-        {
-        }
-
-        int
-        gen() const noexcept
-        {
-            return gen_;
-        }
-
-        size_t
-        type() const noexcept
-        {
-            return entry.index();
-        }
-
-        qpdf_offset_t
-        offset() const noexcept
-        {
-            return type() == 1 ? std::get<1>(entry).offset : 0;
-        }
-
-        int
-        stream_number() const noexcept
-        {
-            return type() == 2 ? std::get<2>(entry).stream_number : 0;
-        }
-
-        int
-        stream_index() const noexcept
-        {
-            return type() == 2 ? std::get<2>(entry).stream_index : 0;
-        }
-
-        int gen_{0};
-        Xref entry;
-        qpdf_offset_t end_before_space_{0};
-        qpdf_offset_t end_after_space_{0};
-    };
-
-    Entry&
-    entry(size_t id)
-    {
-        return id < table.size() ? table[id] : table[0];
-    }
-
-    void read(qpdf_offset_t offset);
-
-    // Methods to parse tables
-    qpdf_offset_t process_section(qpdf_offset_t offset);
-    std::vector<Subsection> subsections(std::string& line);
-    std::vector<Subsection> bad_subsections(std::string& line, qpdf_offset_t offset);
-    Subsection subsection(std::string const& line);
-    bool read_entry(qpdf_offset_t& f1, int& f2, char& type);
-    bool read_bad_entry(qpdf_offset_t& f1, int& f2, char& type);
-
-    // Methods to parse streams
-    qpdf_offset_t read_stream(qpdf_offset_t offset);
-    qpdf_offset_t process_stream(qpdf_offset_t offset, QPDFObjectHandle& xref_stream);
-    std::pair<int, std::array<int, 3>>
-    process_W(QPDFObjectHandle& dict, std::function<QPDFExc(std::string_view)> damaged);
-    std::pair<int, size_t> process_Size(
-        QPDFObjectHandle& dict, int entry_size, std::function<QPDFExc(std::string_view)> damaged);
-    std::pair<int, std::vector<std::pair<int, int>>> process_Index(
-        QPDFObjectHandle& dict,
-        int max_num_entries,
-        std::function<QPDFExc(std::string_view)> damaged);
-
-    QPDFObjectHandle read_trailer();
-
-    QPDFTokenizer::Token
-    read_token(size_t max_len = 0)
-    {
-        return tokenizer.readToken(*file, "", true, max_len);
-    }
-
-    // Methods to insert table entries
-    void insert(int obj, int f0, qpdf_offset_t f1, int f2);
-    void insert_free(QPDFObjGen);
-
-    QPDFExc
-    damaged_pdf(std::string const& msg)
-    {
-        return qpdf.damagedPDF("", 0, msg);
-    }
-
-    QPDFExc
-    damaged_table(std::string const& msg)
-    {
-        return qpdf.damagedPDF("xref table", msg);
-    }
-
-    void
-    warn_damaged(std::string const& msg)
-    {
-        qpdf.warn(damaged_pdf(msg));
-    }
-
-    QPDF& qpdf;
-    InputSource* const& file;
-    QPDFTokenizer tokenizer;
-
-    std::vector<Entry> table;
-    QPDFObjectHandle trailer_;
-
-    bool attempt_recovery_{true};
-    bool initialized_{false};
-    bool ignore_streams_{false};
-    bool reconstructed_{false};
-    bool object_streams_{false};
-    // Before the xref table is initialized, max_id_ is an upper bound on the possible object ids
-    // that could be present in the PDF file. Once the trailer has been read, max_id_ is set to the
-    // value of /Size. If the file is damaged, max_id_ becomes the maximum object id in the xref
-    // table after reconstruction.
-    int max_id_{std::numeric_limits<int>::max() - 1};
-
-    // Linearization data
-    bool uncompressed_after_compressed_{false};
-    qpdf_offset_t first_item_offset_{0}; // actual value from file
-};
-
-// The Resolver class is restricted to QPDFObject so that only it can resolve indirect
-// references.
-class QPDF::Resolver
-{
-    friend class QPDFObject;
-    friend class QPDF_Unresolved;
-
-  private:
-    static QPDFObject*
-    resolved(QPDF* qpdf, QPDFObjGen og)
-    {
-        return qpdf->resolve(og);
-    }
-};
-
-// StreamCopier class is restricted to QPDFObjectHandle so it can copy stream data.
-class QPDF::StreamCopier
-{
-    friend class QPDFObjectHandle;
-
-  private:
-    static void
-    copyStreamData(QPDF* qpdf, QPDFObjectHandle const& dest, QPDFObjectHandle const& src)
-    {
-        qpdf->copyStreamData(dest, src);
-    }
-};
-
-// The ParseGuard class allows QPDFParser to detect re-entrant parsing. It also provides
-// special access to allow the parser to create unresolved objects and dangling references.
-class QPDF::ParseGuard
-{
-    friend class QPDFParser;
-
-  private:
-    ParseGuard(QPDF* qpdf) :
-        qpdf(qpdf)
-    {
-        if (qpdf) {
-            qpdf->inParse(true);
-        }
-    }
-
-    static std::shared_ptr<QPDFObject>
-    getObject(QPDF* qpdf, int id, int gen, bool parse_pdf)
-    {
-        return qpdf->getObjectForParser(id, gen, parse_pdf);
-    }
-
-    ~ParseGuard()
-    {
-        if (qpdf) {
-            qpdf->inParse(false);
-        }
-    }
-    QPDF* qpdf;
-};
-
-// Pipe class is restricted to QPDF_Stream.
-class QPDF::Pipe
-{
-    friend class QPDF_Stream;
-
-  private:
-    static bool
-    pipeStreamData(
-        QPDF* qpdf,
-        QPDFObjGen const& og,
-        qpdf_offset_t offset,
-        size_t length,
-        QPDFObjectHandle dict,
-        Pipeline* pipeline,
-        bool suppress_warnings,
-        bool will_retry)
-    {
-        return qpdf->pipeStreamData(
-            og, offset, length, dict, pipeline, suppress_warnings, will_retry);
-    }
-};
-
-class QPDF::ObjCache
-{
-  public:
-    ObjCache() = default;
-
-    ObjCache(std::shared_ptr<QPDFObject> object) :
-        object(object)
-    {
-    }
-
-    std::shared_ptr<QPDFObject> object;
-};
-
-class QPDF::ObjCopier
-{
-  public:
-    std::map<QPDFObjGen, QPDFObjectHandle> object_map;
-    std::vector<QPDFObjectHandle> to_copy;
-    QPDFObjGen::set visiting;
-};
-
-class QPDF::EncryptionParameters
-{
-    friend class QPDF;
-
-  public:
-    EncryptionParameters();
-
-  private:
-    bool encrypted;
-    bool encryption_initialized;
-    int encryption_V;
-    int encryption_R;
-    bool encrypt_metadata;
-    std::map<std::string, encryption_method_e> crypt_filters;
-    encryption_method_e cf_stream;
-    encryption_method_e cf_string;
-    encryption_method_e cf_file;
-    std::string provided_password;
-    std::string user_password;
-    std::string encryption_key;
-    std::string cached_object_encryption_key;
-    QPDFObjGen cached_key_og;
-    bool user_password_matched;
-    bool owner_password_matched;
-};
-
-class QPDF::ForeignStreamData
-{
-    friend class QPDF;
-
-  public:
-    ForeignStreamData(
-        std::shared_ptr<EncryptionParameters> encp,
-        std::shared_ptr<InputSource> file,
-        QPDFObjGen const& foreign_og,
-        qpdf_offset_t offset,
-        size_t length,
-        QPDFObjectHandle local_dict);
-
-  private:
-    std::shared_ptr<EncryptionParameters> encp;
-    std::shared_ptr<InputSource> file;
-    QPDFObjGen foreign_og;
-    qpdf_offset_t offset;
-    size_t length;
-    QPDFObjectHandle local_dict;
-};
-
-class QPDF::CopiedStreamDataProvider: public QPDFObjectHandle::StreamDataProvider
-{
-  public:
-    CopiedStreamDataProvider(QPDF& destination_qpdf);
-    ~CopiedStreamDataProvider() override = default;
-    bool provideStreamData(
-        QPDFObjGen const& og, Pipeline* pipeline, bool suppress_warnings, bool will_retry) override;
-    void registerForeignStream(QPDFObjGen const& local_og, QPDFObjectHandle foreign_stream);
-    void registerForeignStream(QPDFObjGen const& local_og, std::shared_ptr<ForeignStreamData>);
-
-  private:
-    QPDF& destination_qpdf;
-    std::map<QPDFObjGen, QPDFObjectHandle> foreign_streams;
-    std::map<QPDFObjGen, std::shared_ptr<ForeignStreamData>> foreign_stream_data;
-};
-
-class QPDF::StringDecrypter: public QPDFObjectHandle::StringDecrypter
-{
-    friend class QPDF;
-
-  public:
-    StringDecrypter(QPDF* qpdf, QPDFObjGen const& og);
-    ~StringDecrypter() override = default;
-    void decryptString(std::string& val) override;
-
-  private:
-    QPDF* qpdf;
-    QPDFObjGen og;
-};
-
-// PDF 1.4: Table F.4
-struct QPDF::HPageOffsetEntry
-{
-    int delta_nobjects{0};              // 1
-    qpdf_offset_t delta_page_length{0}; // 2
-    // vectors' sizes = nshared_objects
-    int nshared_objects{0};                // 3
-    std::vector<int> shared_identifiers;   // 4
-    std::vector<int> shared_numerators;    // 5
-    qpdf_offset_t delta_content_offset{0}; // 6
-    qpdf_offset_t delta_content_length{0}; // 7
-};
-
-// PDF 1.4: Table F.3
-struct QPDF::HPageOffset
-{
-    int min_nobjects{0};                // 1
-    qpdf_offset_t first_page_offset{0}; // 2
-    int nbits_delta_nobjects{0};        // 3
-    int min_page_length{0};             // 4
-    int nbits_delta_page_length{0};     // 5
-    int min_content_offset{0};          // 6
-    int nbits_delta_content_offset{0};  // 7
-    int min_content_length{0};          // 8
-    int nbits_delta_content_length{0};  // 9
-    int nbits_nshared_objects{0};       // 10
-    int nbits_shared_identifier{0};     // 11
-    int nbits_shared_numerator{0};      // 12
-    int shared_denominator{0};          // 13
-    // vector size is npages
-    std::vector<HPageOffsetEntry> entries;
-};
-
-// PDF 1.4: Table F.6
-struct QPDF::HSharedObjectEntry
-{
-    // Item 3 is a 128-bit signature (unsupported by Acrobat)
-    int delta_group_length{0}; // 1
-    int signature_present{0};  // 2 -- always 0
-    int nobjects_minus_one{0}; // 4 -- always 0
-};
-
-// PDF 1.4: Table F.5
-struct QPDF::HSharedObject
-{
-    int first_shared_obj{0};              // 1
-    qpdf_offset_t first_shared_offset{0}; // 2
-    int nshared_first_page{0};            // 3
-    int nshared_total{0};                 // 4
-    int nbits_nobjects{0};                // 5
-    int min_group_length{0};              // 6
-    int nbits_delta_group_length{0};      // 7
-    // vector size is nshared_total
-    std::vector<HSharedObjectEntry> entries;
-};
-
-// PDF 1.4: Table F.9
-struct QPDF::HGeneric
-{
-    int first_object{0};                  // 1
-    qpdf_offset_t first_object_offset{0}; // 2
-    int nobjects{0};                      // 3
-    int group_length{0};                  // 4
-};
-
-// Other linearization data structures
-
-// Initialized from Linearization Parameter dictionary
-struct QPDF::LinParameters
-{
-    qpdf_offset_t file_size{0};        // /L
-    int first_page_object{0};          // /O
-    qpdf_offset_t first_page_end{0};   // /E
-    int npages{0};                     // /N
-    qpdf_offset_t xref_zero_offset{0}; // /T
-    int first_page{0};                 // /P
-    qpdf_offset_t H_offset{0};         // offset of primary hint stream
-    qpdf_offset_t H_length{0};         // length of primary hint stream
-};
-
-// Computed hint table value data structures.  These tables contain the computed values on which
-// the hint table values are based.  They exclude things like number of bits and store actual
-// values instead of mins and deltas.  File offsets are also absolute rather than being offset
-// by the size of the primary hint table.  We populate the hint table structures from these
-// during writing and compare the hint table values with these during validation.  We ignore
-// some values for various reasons described in the code.  Those values are omitted from these
-// structures.  Note also that object numbers are object numbers from the input file, not the
-// output file.
-
-// Naming convention: CHSomething is analogous to HSomething above.  "CH" is computed hint.
-
-struct QPDF::CHPageOffsetEntry
-{
-    int nobjects{0};
-    int nshared_objects{0};
-    // vectors' sizes = nshared_objects
-    std::vector<int> shared_identifiers;
-};
-
-struct QPDF::CHPageOffset
-{
-    // vector size is npages
-    std::vector<CHPageOffsetEntry> entries;
-};
-
-struct QPDF::CHSharedObjectEntry
-{
-    CHSharedObjectEntry(int object) :
-        object(object)
-    {
-    }
-
-    int object;
-};
-
-// PDF 1.4: Table F.5
-struct QPDF::CHSharedObject
-{
-    int first_shared_obj{0};
-    int nshared_first_page{0};
-    int nshared_total{0};
-    // vector size is nshared_total
-    std::vector<CHSharedObjectEntry> entries;
-};
-
-// No need for CHGeneric -- HGeneric is fine as is.
-
-// Data structures to support optimization -- implemented in QPDF_optimization.cc
-
-class QPDF::ObjUser
-{
-  public:
-    enum user_e { ou_bad, ou_page, ou_thumb, ou_trailer_key, ou_root_key, ou_root };
-
-    // type is set to ou_bad
-    ObjUser();
-
-    // type must be ou_root
-    ObjUser(user_e type);
-
-    // type must be one of ou_page or ou_thumb
-    ObjUser(user_e type, int pageno);
-
-    // type must be one of ou_trailer_key or ou_root_key
-    ObjUser(user_e type, std::string const& key);
-
-    bool operator<(ObjUser const&) const;
-
-    user_e ou_type;
-    int pageno;      // if ou_page;
-    std::string key; // if ou_trailer_key or ou_root_key
-};
-
-struct QPDF::UpdateObjectMapsFrame
-{
-    UpdateObjectMapsFrame(ObjUser const& ou, QPDFObjectHandle oh, bool top);
-
-    ObjUser const& ou;
-    QPDFObjectHandle oh;
-    bool top;
-};
-
-class QPDF::PatternFinder: public InputSource::Finder
-{
-  public:
-    PatternFinder(QPDF& qpdf, bool (QPDF::*checker)()) :
-        qpdf(qpdf),
-        checker(checker)
-    {
-    }
-    ~PatternFinder() override = default;
-    bool
-    check() override
-    {
-        return (this->qpdf.*checker)();
-    }
-
-  private:
-    QPDF& qpdf;
-    bool (QPDF::*checker)();
-};
-
-class QPDF::Members
-{
-    friend class QPDF;
-    friend class ResolveRecorder;
-
-  public:
-    QPDF_DLL
-    ~Members() = default;
-
-  private:
-    Members(QPDF& qpdf);
-    Members(Members const&) = delete;
-
-    std::shared_ptr<QPDFLogger> log;
-    unsigned long long unique_id{0};
-    QPDFTokenizer tokenizer;
-    // Filename to use if there is no input PDF
-    std::string no_input_name{"closed input source"};
-    // If file_sp is updated, file must also be updated.
-    std::shared_ptr<InputSource> file_sp;
-    InputSource* file;
-    std::string last_object_description;
-    bool provided_password_is_hex_key{false};
-    bool suppress_warnings{false};
-    size_t max_warnings{0};
-    bool attempt_recovery{true};
-    bool check_mode{false};
-    std::shared_ptr<EncryptionParameters> encp;
-    std::string pdf_version;
-    Xref_table xref_table;
-    std::map<QPDFObjGen, ObjCache> obj_cache;
-    std::set<QPDFObjGen> resolving;
-    std::vector<QPDFObjectHandle> all_pages;
-    bool invalid_page_found{false};
-    std::map<QPDFObjGen, int> pageobj_to_pages_pos;
-    bool pushed_inherited_attributes_to_pages{false};
-    bool ever_pushed_inherited_attributes_to_pages{false};
-    bool ever_called_get_all_pages{false};
-    std::vector<QPDFExc> warnings;
-    std::map<unsigned long long, ObjCopier> object_copiers;
-    std::shared_ptr<QPDFObjectHandle::StreamDataProvider> copied_streams;
-    // copied_stream_data_provider is owned by copied_streams
-    CopiedStreamDataProvider* copied_stream_data_provider{nullptr};
-    bool fixed_dangling_refs{false};
-    bool immediate_copy_from{false};
-    bool in_parse{false};
-    std::set<int> resolved_object_streams;
-
-    // Linearization data
-    bool linearization_warnings{false};
-
-    // Linearization parameter dictionary and hint table data: may be read from file or computed
-    // prior to writing a linearized file
-    QPDFObjectHandle lindict;
-    LinParameters linp;
-    HPageOffset page_offset_hints;
-    HSharedObject shared_object_hints;
-    HGeneric outline_hints;
-
-    // Computed linearization data: used to populate above tables during writing and to compare
-    // with them during validation. c_ means computed.
-    LinParameters c_linp;
-    CHPageOffset c_page_offset_data;
-    CHSharedObject c_shared_object_data;
-    HGeneric c_outline_data;
-
-    // Object ordering data for linearized files: initialized by calculateLinearizationData().
-    // Part numbers refer to the PDF 1.4 specification.
-    std::vector<QPDFObjectHandle> part4;
-    std::vector<QPDFObjectHandle> part6;
-    std::vector<QPDFObjectHandle> part7;
-    std::vector<QPDFObjectHandle> part8;
-    std::vector<QPDFObjectHandle> part9;
-
-    // Optimization data
-    std::map<ObjUser, std::set<QPDFObjGen>> obj_user_to_objects;
-    std::map<QPDFObjGen, std::set<ObjUser>> object_to_obj_users;
-};
-
-// JobSetter class is restricted to QPDFJob.
-class QPDF::JobSetter
-{
-    friend class QPDFJob;
-
-  private:
-    // Enable enhanced warnings for pdf file checking.
-    static void
-    setCheckMode(QPDF& qpdf, bool val)
-    {
-        qpdf.m->check_mode = val;
-    }
-};
-
-class QPDF::ResolveRecorder
-{
-  public:
-    ResolveRecorder(QPDF* qpdf, QPDFObjGen const& og) :
-        qpdf(qpdf),
-        iter(qpdf->m->resolving.insert(og).first)
-    {
-    }
-    virtual ~ResolveRecorder()
-    {
-        this->qpdf->m->resolving.erase(iter);
-    }
-
-  private:
-    QPDF* qpdf;
-    std::set<QPDFObjGen>::const_iterator iter;
-};
-
-// Writer class is restricted to QPDFWriter so that only it can call certain methods.
-class QPDF::Writer
-{
-    friend class QPDFWriter;
-
-  private:
-    static void
-    optimize(
-        QPDF& qpdf,
-        QPDFWriter::ObjTable const& obj,
-        std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
-    {
-        return qpdf.optimize(obj, skip_stream_parameters);
-    }
-
-    static void
-    getLinearizedParts(
-        QPDF& qpdf,
-        QPDFWriter::ObjTable const& obj,
-        std::vector<QPDFObjectHandle>& part4,
-        std::vector<QPDFObjectHandle>& part6,
-        std::vector<QPDFObjectHandle>& part7,
-        std::vector<QPDFObjectHandle>& part8,
-        std::vector<QPDFObjectHandle>& part9)
-    {
-        qpdf.getLinearizedParts(obj, part4, part6, part7, part8, part9);
-    }
-
-    static void
-    generateHintStream(
-        QPDF& qpdf,
-        QPDFWriter::NewObjTable const& new_obj,
-        QPDFWriter::ObjTable const& obj,
-        std::shared_ptr<Buffer>& hint_stream,
-        int& S,
-        int& O,
-        bool compressed)
-    {
-        return qpdf.generateHintStream(new_obj, obj, hint_stream, S, O, compressed);
-    }
-
-    static std::vector<QPDFObjGen>
-    getCompressibleObjGens(QPDF& qpdf)
-    {
-        return qpdf.getCompressibleObjVector();
-    }
-
-    static std::vector<bool>
-    getCompressibleObjSet(QPDF& qpdf)
-    {
-        return qpdf.getCompressibleObjSet();
-    }
-
-    static Xref_table const&
-    getXRefTable(QPDF& qpdf)
-    {
-        return qpdf.m->xref_table;
-    }
-
-    static size_t
-    tableSize(QPDF& qpdf)
-    {
-        return qpdf.tableSize();
-    }
-};
-
-#endif // QPDF_PRIVATE_HH
@@ -16,7 +16,7 @@ struct _qpdf_data
     _qpdf_data() = default;
  
     _qpdf_data(std::unique_ptr<QPDF>&& qpdf) :
-        qpdf(std::move(qpdf)){};
+        qpdf(std::move(qpdf)) {};
  
     ~_qpdf_data() = default;
  
@@ -48,6 +48,7 @@ QPDFWriter encrypted hint stream 0
 QPDF opt inherited scalar 0
 QPDF xref reused object 0
 QPDF xref gen > 0 1
+QPDF xref size mismatch 0
 QPDF not a pdf file 0
 QPDF can't find startxref 0
 QPDF invalid xref 0
@@ -104,6 +105,7 @@ QPDFWriter not recompressing /FlateDecode 0
 QPDF_encryption xref stream from encrypted file 0
 QPDFJob unable to filter 0
 QUtil non-trivial UTF-16 0
+QPDF xref overwrite object 0
 QPDF xref overwrite invalid objgen 0
 QPDF decoding error warning 0
 qpdf-c called qpdf_init 0
@@ -435,6 +437,7 @@ QPDF xref skipped space 0
 QPDF eof skipping spaces before xref 1
 QPDF_encryption user matches owner V < 5 0
 QPDF_encryption same password 1
+QPDFWriter stream in ostream 0
 QPDFParser duplicate dict key 0
 QPDFWriter no encryption sig contents 0
 QPDFPageObjectHelper colorspace lookup 0
+WARNING: bad12.pdf: reported number of objects (9) is not one plus the highest object number (7)
 WARNING: bad12.pdf (object 2 0, offset 128): expected endobj
 /QTest is implicit
 /QTest is direct and has type null (2)
+WARNING: bad12.pdf: reported number of objects (9) is not one plus the highest object number (7)
 WARNING: bad12.pdf (object 2 0, offset 128): expected endobj
 /QTest is implicit
 /QTest is direct and has type null (2)
@@ -11,9 +11,11 @@ WARNING: fuzz-16214.pdf (object 1 0, offset 7189): expected n n obj
 WARNING: fuzz-16214.pdf: Attempting to reconstruct cross-reference table
 WARNING: fuzz-16214.pdf (offset 7207): error decoding stream data for object 2 0: stream inflate: inflate: data: invalid code lengths set
 WARNING: fuzz-16214.pdf (offset 7207): getStreamData called on unfilterable stream
-WARNING: fuzz-16214.pdf (object 7 0, offset 7207): supposed object stream 5 has wrong type
-WARNING: fuzz-16214.pdf (object 7 0, offset 7207): object stream 5 has incorrect keys
+WARNING: fuzz-16214.pdf (object 8 0, offset 7207): supposed object stream 5 has wrong type
+WARNING: fuzz-16214.pdf (object 8 0, offset 7207): object stream 5 has incorrect keys
 WARNING: fuzz-16214.pdf (object 21 0, offset 3639): expected endstream
 WARNING: fuzz-16214.pdf (object 21 0, offset 3112): attempting to recover stream length
 WARNING: fuzz-16214.pdf (object 21 0, offset 3112): recovered stream length: 340
+WARNING: fuzz-16214.pdf, stream object 8 0: stream found inside object stream; treating as null
+WARNING: fuzz-16214.pdf, stream object 8 0: stream found inside object stream; treating as null
 qpdf: operation succeeded with warnings; resulting file may have some problems
@@ -2,6 +2,6 @@ WARNING: issue-147.pdf: can&#39;t find PDF header
 WARNING: issue-147.pdf: file is damaged
 WARNING: issue-147.pdf: can't find startxref
 WARNING: issue-147.pdf: Attempting to reconstruct cross-reference table
-WARNING: issue-147.pdf: ignoring object with impossibly large id 62
 WARNING: issue-147.pdf (trailer, offset 9): expected dictionary key but found non-name object; inserting key /QPDFFake1
-qpdf: issue-147.pdf: unable to find /Root dictionary
+WARNING: issue-147.pdf: ignoring object with impossibly large id 62
+qpdf: issue-147.pdf: unable to find objects while recovering damaged file
 WARNING: issue-335b.pdf: can't find PDF header
 WARNING: issue-335b.pdf: file is damaged
-WARNING: issue-335b.pdf (xref table, offset 11): xref table subsection header contains impossibly large entry
+WARNING: issue-335b.pdf (xref table, offset 23): invalid xref entry (obj=6)
 WARNING: issue-335b.pdf: Attempting to reconstruct cross-reference table
 qpdf: issue-335b.pdf: unable to find trailer dictionary while recovering damaged file
 WARNING: recover-xref-stream.pdf: file is damaged
 WARNING: recover-xref-stream.pdf: can't find startxref
 WARNING: recover-xref-stream.pdf: Attempting to reconstruct cross-reference table
+WARNING: recover-xref-stream.pdf: reported number of objects (14) is not one plus the highest object number (15)
 qpdf: operation succeeded with warnings; resulting file may have some problems
@@ -3,11 +3,6 @@ WARNING: xref-errors.pdf (xref table, offset 606): accepting invalid xref table 
 WARNING: xref-errors.pdf (xref table, offset 627): accepting invalid xref table entry
 WARNING: xref-errors.pdf (xref table, offset 648): accepting invalid xref table entry
 WARNING: xref-errors.pdf (xref table, offset 667): accepting invalid xref table entry
-WARNING: xref-errors.pdf (xref table, offset 585): accepting invalid xref table entry
-WARNING: xref-errors.pdf (xref table, offset 606): accepting invalid xref table entry
-WARNING: xref-errors.pdf (xref table, offset 627): accepting invalid xref table entry
-WARNING: xref-errors.pdf (xref table, offset 648): accepting invalid xref table entry
-WARNING: xref-errors.pdf (xref table, offset 667): accepting invalid xref table entry
 checking xref-errors.pdf
 PDF Version: 1.3
 File is not encrypted
@@ -16,7 +16,7 @@ my $td = new TestDriver(&#39;specific-bugs&#39;);
  
 # The number is the github issue number in which the bug was reported.
 my @bug_tests = (
-#    ["51", "resolve loop", 2],
+    ["51", "resolve loop", 2],
     ["99", "object 0", 2],
     ["99b", "object 0", 2],
     ["100", "xref reconstruction loop", 2],
@@ -28,7 +28,7 @@ my @bug_tests = (
     ["106", "zlib data error", 3],
     ["141a", "/W entry size 0", 2],
     ["141b", "/W entry size 0", 2],
-#    ["143", "self-referential ostream", 2, "--preserve-unreferenced"],
+    ["143", "self-referential ostream", 2, "--preserve-unreferenced"],
     ["146", "very deeply nested array", 2],
     ["147", "previously caused memory error", 2],
     ["148", "free memory on bad flate", 2],
@@ -38,7 +38,7 @@ my @bug_tests = (
     ["263", "empty xref stream", 2],
     ["335a", "ozz-fuzz-12152", 2],
     ["335b", "ozz-fuzz-14845", 2],
-#    ["fuzz-16214", "stream in object stream", 3, "--preserve-unreferenced"],
+    ["fuzz-16214", "stream in object stream", 3, "--preserve-unreferenced"],
     # When adding to this list, consider adding to CORPUS_FROM_TEST in
     # fuzz/CMakeLists.txt and updating the count in
     # fuzz/qtest/fuzz.test.