Coverage Report

Created: 2026-11-13 07:01

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qpdf/libqpdf/QPDFObjectHandle.cc
Line
Count
Source
1
#include <qpdf/QPDFObjectHandle_private.hh>
2
3
#include <qpdf/JSON_writer.hh>
4
#include <qpdf/Pipeline_private.hh>
5
#include <qpdf/Pl_Buffer.hh>
6
#include <qpdf/Pl_QPDFTokenizer.hh>
7
#include <qpdf/QIntC.hh>
8
#include <qpdf/QPDF.hh>
9
#include <qpdf/QPDFExc.hh>
10
#include <qpdf/QPDFLogger.hh>
11
#include <qpdf/QPDFMatrix.hh>
12
#include <qpdf/QPDFObject_private.hh>
13
#include <qpdf/QPDFPageObjectHelper.hh>
14
#include <qpdf/QPDFParser.hh>
15
#include <qpdf/QTC.hh>
16
#include <qpdf/Util.hh>
17
18
#include <array>
19
#include <cctype>
20
#include <climits>
21
#include <cstdlib>
22
#include <cstring>
23
#include <stdexcept>
24
25
using namespace std::literals;
26
using namespace qpdf;
27
28
using Parser = impl::Parser;
29
30
const Null Null::temp_;
31
32
BaseHandle::
33
operator QPDFObjGen() const
34
1.67M
{
35
1.67M
    return obj ? obj->getObjGen() : QPDFObjGen();
36
1.67M
}
37
38
namespace
39
{
40
    class TerminateParsing
41
    {
42
    };
43
} // namespace
44
45
QPDFObjectHandle::StreamDataProvider::StreamDataProvider(bool supports_retry) :
46
302k
    supports_retry(supports_retry)
47
302k
{
48
302k
}
49
50
QPDFObjectHandle::StreamDataProvider::~StreamDataProvider() // NOLINT (modernize-use-equals-default)
51
302k
{
52
    // Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer
53
302k
}
54
55
void
56
QPDFObjectHandle::StreamDataProvider::provideStreamData(QPDFObjGen const& og, Pipeline* pipeline)
57
0
{
58
0
    return provideStreamData(og.getObj(), og.getGen(), pipeline);
59
0
}
60
61
bool
62
QPDFObjectHandle::StreamDataProvider::provideStreamData(
63
    QPDFObjGen const& og, Pipeline* pipeline, bool suppress_warnings, bool will_retry)
64
0
{
65
0
    return provideStreamData(og.getObj(), og.getGen(), pipeline, suppress_warnings, will_retry);
66
0
}
67
68
void
69
QPDFObjectHandle::StreamDataProvider::provideStreamData(
70
    int objid, int generation, Pipeline* pipeline)
71
0
{
72
0
    throw std::logic_error("you must override provideStreamData -- see QPDFObjectHandle.hh");
73
0
}
74
75
bool
76
QPDFObjectHandle::StreamDataProvider::provideStreamData(
77
    int objid, int generation, Pipeline* pipeline, bool suppress_warnings, bool will_retry)
78
0
{
79
0
    throw std::logic_error("you must override provideStreamData -- see QPDFObjectHandle.hh");
80
0
    return false;
81
0
}
82
83
bool
84
QPDFObjectHandle::StreamDataProvider::supportsRetry()
85
9.11k
{
86
9.11k
    return supports_retry;
87
9.11k
}
88
89
namespace
90
{
91
    class CoalesceProvider: public QPDFObjectHandle::StreamDataProvider
92
    {
93
      public:
94
        CoalesceProvider(QPDFObjectHandle containing_page, QPDFObjectHandle old_contents) :
95
9.11k
            containing_page(containing_page),
96
9.11k
            old_contents(old_contents)
97
9.11k
        {
98
9.11k
        }
99
9.11k
        ~CoalesceProvider() override = default;
100
        void provideStreamData(QPDFObjGen const&, Pipeline* pipeline) override;
101
102
      private:
103
        QPDFObjectHandle containing_page;
104
        QPDFObjectHandle old_contents;
105
    };
106
} // namespace
107
108
void
109
CoalesceProvider::provideStreamData(QPDFObjGen const&, Pipeline* p)
110
9.11k
{
111
9.11k
    QTC::TC("qpdf", "QPDFObjectHandle coalesce provide stream data");
112
9.11k
    std::string description = "page object " + containing_page.getObjGen().unparse(' ');
113
9.11k
    std::string all_description;
114
9.11k
    old_contents.pipeContentStreams(p, description, all_description);
115
9.11k
}
116
117
void
118
QPDFObjectHandle::TokenFilter::handleEOF()
119
28.0k
{
120
28.0k
}
121
122
void
123
QPDFObjectHandle::TokenFilter::setPipeline(Pipeline* p)
124
102k
{
125
102k
    pipeline = p;
126
102k
}
127
128
void
129
QPDFObjectHandle::TokenFilter::write(char const* data, size_t len)
130
8.68M
{
131
8.68M
    if (!pipeline) {
132
0
        return;
133
0
    }
134
8.68M
    if (len) {
135
8.65M
        pipeline->write(data, len);
136
8.65M
    }
137
8.68M
}
138
139
void
140
QPDFObjectHandle::TokenFilter::write(std::string const& str)
141
1.05M
{
142
1.05M
    write(str.c_str(), str.length());
143
1.05M
}
144
145
void
146
QPDFObjectHandle::TokenFilter::writeToken(QPDFTokenizer::Token const& token)
147
4.38M
{
148
4.38M
    std::string const& value = token.getRawValue();
149
4.38M
    write(value.c_str(), value.length());
150
4.38M
}
151
152
void
153
QPDFObjectHandle::ParserCallbacks::handleObject(QPDFObjectHandle)
154
0
{
155
0
    throw std::logic_error("You must override one of the handleObject methods in ParserCallbacks");
156
0
}
157
158
void
159
QPDFObjectHandle::ParserCallbacks::handleObject(QPDFObjectHandle oh, size_t, size_t)
160
0
{
161
    // This version of handleObject was added in qpdf 9. If the developer did not override it, fall
162
    // back to the older interface.
163
0
    handleObject(oh);
164
0
}
165
166
void
167
QPDFObjectHandle::ParserCallbacks::contentSize(size_t)
168
0
{
169
    // Ignore by default; overriding this is optional.
170
0
}
171
172
void
173
QPDFObjectHandle::ParserCallbacks::terminateParsing()
174
0
{
175
0
    throw TerminateParsing();
176
0
}
177
178
std::pair<bool, bool>
179
Name::analyzeJSONEncoding(const std::string& name)
180
700k
{
181
700k
    int tail = 0;       // Number of continuation characters expected.
182
700k
    bool tail2 = false; // Potential overlong 3 octet utf-8.
183
700k
    bool tail3 = false; // potential overlong 4 octet
184
700k
    bool needs_escaping = false;
185
26.5M
    for (auto const& it: name) {
186
26.5M
        auto c = static_cast<unsigned char>(it);
187
26.5M
        if (tail) {
188
17.3k
            if ((c & 0xc0) != 0x80) {
189
10.1k
                return {false, false};
190
10.1k
            }
191
7.21k
            if (tail2) {
192
445
                if ((c & 0xe0) == 0x80) {
193
168
                    return {false, false};
194
168
                }
195
277
                tail2 = false;
196
6.77k
            } else if (tail3) {
197
647
                if ((c & 0xf0) == 0x80) {
198
284
                    return {false, false};
199
284
                }
200
363
                tail3 = false;
201
363
            }
202
6.76k
            tail--;
203
26.5M
        } else if (c < 0x80) {
204
26.5M
            if (!needs_escaping) {
205
4.16M
                needs_escaping = !((c > 34 && c != '\\') || c == ' ' || c == 33);
206
4.16M
            }
207
26.5M
        } else if ((c & 0xe0) == 0xc0) {
208
8.32k
            if ((c & 0xfe) == 0xc0) {
209
675
                return {false, false};
210
675
            }
211
7.64k
            tail = 1;
212
32.0k
        } else if ((c & 0xf0) == 0xe0) {
213
4.15k
            tail2 = (c == 0xe0);
214
4.15k
            tail = 2;
215
27.8k
        } else if ((c & 0xf8) == 0xf0) {
216
3.57k
            tail3 = (c == 0xf0);
217
3.57k
            tail = 3;
218
24.3k
        } else {
219
24.3k
            return {false, false};
220
24.3k
        }
221
26.5M
    }
222
665k
    return {tail == 0, !needs_escaping};
223
700k
}
224
225
std::string
226
Name::normalize(std::string const& name)
227
27.4M
{
228
27.4M
    if (name.empty()) {
229
0
        return name;
230
0
    }
231
27.4M
    std::string result;
232
27.4M
    result += name.at(0);
233
375M
    for (size_t i = 1; i < name.length(); ++i) {
234
348M
        char ch = name.at(i);
235
        // Don't use locale/ctype here; follow PDF spec guidelines.
236
348M
        if (ch == '\0') {
237
            // QPDFTokenizer embeds a null character to encode an invalid #.
238
2.65M
            result += "#";
239
345M
        } else if (
240
345M
            ch < 33 || ch == '#' || ch == '/' || ch == '(' || ch == ')' || ch == '{' || ch == '}' ||
241
261M
            ch == '<' || ch == '>' || ch == '[' || ch == ']' || ch == '%' || ch > 126) {
242
261M
            result += util::hex_encode_char(ch);
243
261M
        } else {
244
83.9M
            result += ch;
245
83.9M
        }
246
348M
    }
247
27.4M
    return result;
248
27.4M
}
249
250
std::shared_ptr<QPDFObject>
251
BaseHandle::copy(bool shallow) const
252
2.47M
{
253
2.47M
    switch (resolved_type_code()) {
254
0
    case ::ot_uninitialized:
255
0
        throw std::logic_error("QPDFObjectHandle: attempting to copy an uninitialized object");
256
0
        return {}; // does not return
257
0
    case ::ot_reserved:
258
0
        return QPDFObject::create<QPDF_Reserved>();
259
226k
    case ::ot_null:
260
226k
        return QPDFObject::create<QPDF_Null>();
261
4.54k
    case ::ot_boolean:
262
4.54k
        return QPDFObject::create<QPDF_Bool>(std::get<QPDF_Bool>(obj->value).val);
263
628k
    case ::ot_integer:
264
628k
        return QPDFObject::create<QPDF_Integer>(std::get<QPDF_Integer>(obj->value).val);
265
105k
    case ::ot_real:
266
105k
        return QPDFObject::create<QPDF_Real>(std::get<QPDF_Real>(obj->value).val);
267
263k
    case ::ot_string:
268
263k
        return QPDFObject::create<QPDF_String>(std::get<QPDF_String>(obj->value).val);
269
591k
    case ::ot_name:
270
591k
        return QPDFObject::create<QPDF_Name>(std::get<QPDF_Name>(obj->value).name);
271
73.3k
    case ::ot_array:
272
73.3k
        {
273
73.3k
            auto const& a = std::get<QPDF_Array>(obj->value);
274
73.3k
            if (shallow) {
275
0
                return QPDFObject::create<QPDF_Array>(a);
276
73.3k
            } else {
277
73.3k
                QTC::TC("qpdf", "QPDF_Array copy", a.sp ? 0 : 1);
278
73.3k
                if (a.sp) {
279
1.17k
                    QPDF_Array result;
280
1.17k
                    result.sp = std::make_unique<QPDF_Array::Sparse>();
281
1.17k
                    result.sp->size = a.sp->size;
282
80.5k
                    for (auto const& [idx, oh]: a.sp->elements) {
283
80.5k
                        result.sp->elements[idx] = oh.indirect() ? oh : oh.copy();
284
80.5k
                    }
285
1.17k
                    return QPDFObject::create<QPDF_Array>(std::move(result));
286
72.2k
                } else {
287
72.2k
                    std::vector<QPDFObjectHandle> result;
288
72.2k
                    result.reserve(a.elements.size());
289
1.48M
                    for (auto const& element: a.elements) {
290
1.48M
                        result.emplace_back(
291
1.48M
                            element ? (element.indirect() ? element : element.copy()) : element);
292
1.48M
                    }
293
72.2k
                    return QPDFObject::create<QPDF_Array>(std::move(result), false);
294
72.2k
                }
295
73.3k
            }
296
73.3k
        }
297
577k
    case ::ot_dictionary:
298
577k
        {
299
577k
            auto const& d = std::get<QPDF_Dictionary>(obj->value);
300
577k
            if (shallow) {
301
494k
                return QPDFObject::create<QPDF_Dictionary>(d.items);
302
494k
            } else {
303
83.1k
                std::map<std::string, QPDFObjectHandle> new_items;
304
464k
                for (auto const& [key, val]: d.items) {
305
464k
                    new_items[key] = val.indirect() ? val : val.copy();
306
464k
                }
307
83.1k
                return QPDFObject::create<QPDF_Dictionary>(new_items);
308
83.1k
            }
309
577k
        }
310
29
    case ::ot_stream:
311
29
        QTC::TC("qpdf", "QPDF_Stream ERR shallow copy stream");
312
29
        throw std::runtime_error("stream objects cannot be cloned");
313
0
        return {}; // does not return
314
0
    case ::ot_operator:
315
0
        return QPDFObject::create<QPDF_Operator>(std::get<QPDF_Operator>(obj->value).val);
316
0
    case ::ot_inlineimage:
317
0
        return QPDFObject::create<QPDF_InlineImage>(std::get<QPDF_InlineImage>(obj->value).val);
318
0
    case ::ot_unresolved:
319
0
        throw std::logic_error("QPDFObjectHandle: attempting to unparse a reserved object");
320
0
        return {}; // does not return
321
0
    case ::ot_destroyed:
322
0
        throw std::logic_error("attempted to shallow copy QPDFObjectHandle from destroyed QPDF");
323
0
        return {}; // does not return
324
0
    case ::ot_reference:
325
0
        return referenced_object().obj_sp();
326
2.47M
    }
327
0
    return {}; // unreachable
328
2.47M
}
329
330
// This method determines structural equivalence up to a given depth.
331
// The default depth is 10.
332
//
333
// Nomenclature note: ISO 32000-2 Annex J uses the term "equal" for this
334
// strict recursive comparison (J.4.1). We use "equivalent_to" here to
335
// implement Annex J's "equality", distinguishing it from C++ shallow
336
// pointer equality.
337
//
338
// Implementation notes:
339
//
340
// (1) We deviate from Annex J by comparing raw streams only, without
341
// decoding.
342
//
343
// (2) Loop detection is expensive and is avoided. If either object has
344
// a cycle in its forward orbit, this implementation will return false.
345
346
bool
347
BaseHandle::equivalent_to(BaseHandle const& other, int depth) const
348
0
{
349
    // A. Identity, size & limit checks
350
0
    if (obj == other.obj) {
351
0
        return true;
352
0
    }
353
0
    if (depth < 0) {
354
0
        return false;
355
0
    }
356
0
    size_t size1 = size();
357
0
    size_t size2 = other.size();
358
0
    if (size1 != size2) {
359
0
        return false;
360
0
    }
361
    // B. Structural comparison
362
0
    qpdf_object_type_e t1 = resolved_type_code();
363
0
    qpdf_object_type_e t2 = other.resolved_type_code();
364
0
    if (t1 == ::ot_reference) {
365
0
        return referenced_object().equivalent_to(other, depth - 1);
366
0
    }
367
0
    if (t2 == ::ot_reference) {
368
0
        return equivalent_to(other.referenced_object(), depth - 1);
369
0
    }
370
0
    if (t1 != t2) {
371
0
        if ((t1 == ::ot_integer || t1 == ::ot_real) && (t2 == ::ot_integer || t2 == ::ot_real)) {
372
            // Numeric equivalence per Annex J
373
0
            return oh().getNumericValue() == other.oh().getNumericValue();
374
0
        }
375
        // normalize uninitialized and null
376
0
        return (t1 == ::ot_uninitialized && t2 == ::ot_null) ||
377
0
            (t2 == ::ot_uninitialized && t1 == ::ot_null);
378
0
    }
379
0
    switch (t1) {
380
0
    case ::ot_uninitialized:
381
0
    case ::ot_null:
382
0
        return true;
383
0
    case ::ot_boolean:
384
0
        return std::get<QPDF_Bool>(obj->value).val == std::get<QPDF_Bool>(other.obj->value).val;
385
0
    case ::ot_string:
386
0
        return std::get<QPDF_String>(obj->value).val == std::get<QPDF_String>(other.obj->value).val;
387
0
    case ::ot_name:
388
0
        return std::get<QPDF_Name>(obj->value).name == std::get<QPDF_Name>(other.obj->value).name;
389
0
    case ::ot_array:
390
0
        {
391
0
            auto const& a1 = std::get<QPDF_Array>(obj->value);
392
0
            auto const& a2 = std::get<QPDF_Array>(other.obj->value);
393
            // sizes size1, size2 were calculated above and checked to be equal
394
0
            if (!a1.sp && !a2.sp) {
395
0
                for (size_t i = 0; i < size1; ++i) {
396
0
                    if (!a1.elements[i].equivalent_to(a2.elements[i], depth - 1)) {
397
0
                        return false;
398
0
                    }
399
0
                }
400
0
                return true;
401
0
            }
402
            // at least one array is sparse
403
0
            auto get_item = [](QPDF_Array const& arr, size_t idx) -> BaseHandle const& {
404
0
                if (arr.sp) {
405
0
                    auto it = arr.sp->elements.find(idx);
406
0
                    if (it == arr.sp->elements.end()) {
407
0
                        static QPDFObjectHandle null_oh = Null();
408
0
                        return null_oh;
409
0
                    }
410
0
                    return it->second;
411
0
                }
412
0
                return arr.elements[idx];
413
0
            };
414
0
            for (size_t i = 0; i < size1; ++i) {
415
0
                if (!get_item(a1, i).equivalent_to(get_item(a2, i), depth - 1)) {
416
0
                    return false;
417
0
                }
418
0
            }
419
0
            return true;
420
0
        }
421
0
    case ::ot_dictionary:
422
0
        {
423
0
            auto const& map1 = std::get<QPDF_Dictionary>(obj->value).items;
424
0
            auto const& map2 = std::get<QPDF_Dictionary>(other.obj->value).items;
425
0
            auto it2 = map2.begin();
426
0
            auto end2 = map2.end();
427
0
            for (auto const& [key1, value1]: map1) {
428
0
                if (value1.null()) {
429
0
                    continue;
430
0
                }
431
0
                while (it2 != end2 && it2->second.null()) {
432
0
                    ++it2;
433
0
                }
434
0
                if (it2 == end2 || key1 != it2->first ||
435
0
                    !value1.equivalent_to(it2->second, depth - 1)) {
436
0
                    return false;
437
0
                }
438
0
                ++it2;
439
0
            }
440
0
            while (it2 != end2 && it2->second.null()) {
441
0
                ++it2;
442
0
            }
443
0
            return it2 == end2;
444
0
        }
445
0
    case ::ot_stream:
446
0
        {
447
0
            auto const& s1 = std::get<QPDF_Stream>(obj->value);
448
0
            auto const& s2 = std::get<QPDF_Stream>(other.obj->value);
449
0
            if (!s1.m->stream_dict.equivalent_to(s2.m->stream_dict, depth - 1)) {
450
0
                return false;
451
0
            }
452
0
            return s1.m->stream_data->view() == s2.m->stream_data->view();
453
0
        }
454
0
    case ::ot_operator:
455
0
        throw std::logic_error("Internal error in BaseHandle::equivalent_to: found ot_operator");
456
0
    case ::ot_inlineimage:
457
0
        throw std::logic_error("Internal error in BaseHandle::equivalent_to: found ot_inlineimage");
458
0
    case ::ot_integer:
459
0
        return std::get<QPDF_Integer>(obj->value).val ==
460
0
            std::get<QPDF_Integer>(other.obj->value).val;
461
0
    case ::ot_real:
462
0
        return oh().getNumericValue() == other.oh().getNumericValue();
463
0
    case ::ot_unresolved: // cannot determine equivalence so return false
464
0
    case ::ot_reference:  // handled above
465
0
    case ::ot_destroyed:  // should not happen
466
0
    case ::ot_reserved:   // should not happen
467
0
        return false;
468
0
    }
469
0
    return false; // unreachable
470
0
}
471
472
std::string
473
BaseHandle::unparse() const
474
30.8M
{
475
30.8M
    switch (resolved_type_code()) {
476
0
    case ::ot_uninitialized:
477
0
        throw std::logic_error("QPDFObjectHandle: attempting to unparse an uninitialized object");
478
0
        return ""; // does not return
479
0
    case ::ot_reserved:
480
0
        throw std::logic_error("QPDFObjectHandle: attempting to unparse a reserved object");
481
0
        return ""; // does not return
482
1.40M
    case ::ot_null:
483
1.40M
        return "null";
484
48.5k
    case ::ot_boolean:
485
48.5k
        return std::get<QPDF_Bool>(obj->value).val ? "true" : "false";
486
4.88M
    case ::ot_integer:
487
4.88M
        return std::to_string(std::get<QPDF_Integer>(obj->value).val);
488
689k
    case ::ot_real:
489
689k
        return std::get<QPDF_Real>(obj->value).val;
490
807k
    case ::ot_string:
491
807k
        return std::get<QPDF_String>(obj->value).unparse(false);
492
23.0M
    case ::ot_name:
493
23.0M
        return Name::normalize(std::get<QPDF_Name>(obj->value).name);
494
0
    case ::ot_array:
495
0
        {
496
0
            auto const& a = std::get<QPDF_Array>(obj->value);
497
0
            std::string result = "[ ";
498
0
            if (a.sp) {
499
0
                size_t next = 0;
500
0
                for (auto& [key, value]: a.sp->elements) {
501
0
                    for (size_t j = next; j < key; ++j) {
502
0
                        result += "null ";
503
0
                    }
504
0
                    result += value.unparse() + " ";
505
0
                    next = key + 1;
506
0
                }
507
0
                for (size_t j = next; j < a.sp->size; ++j) {
508
0
                    result += "null ";
509
0
                }
510
0
            } else {
511
0
                for (auto const& item: a.elements) {
512
0
                    result += item.unparse() + " ";
513
0
                }
514
0
            }
515
0
            result += "]";
516
0
            return result;
517
0
        }
518
0
    case ::ot_dictionary:
519
0
        {
520
0
            auto const& items = std::get<QPDF_Dictionary>(obj->value).items;
521
0
            std::string result = "<< ";
522
0
            for (auto& iter: items) {
523
0
                if (!iter.second.null()) {
524
0
                    result += Name::normalize(iter.first) + " " + iter.second.unparse() + " ";
525
0
                }
526
0
            }
527
0
            result += ">>";
528
0
            return result;
529
0
        }
530
0
    case ::ot_stream:
531
0
        return obj->og.unparse(' ') + " R";
532
0
    case ::ot_operator:
533
0
        return std::get<QPDF_Operator>(obj->value).val;
534
0
    case ::ot_inlineimage:
535
0
        return std::get<QPDF_InlineImage>(obj->value).val;
536
0
    case ::ot_unresolved:
537
0
        throw std::logic_error("QPDFObjectHandle: attempting to unparse a unresolved object");
538
0
        return ""; // does not return
539
0
    case ::ot_destroyed:
540
0
        throw std::logic_error("attempted to unparse a QPDFObjectHandle from a destroyed QPDF");
541
0
        return ""; // does not return
542
0
    case ::ot_reference:
543
0
        return obj->og.unparse(' ') + " R";
544
30.8M
    }
545
0
    return {}; // unreachable
546
30.8M
}
547
548
void
549
BaseHandle::write_json(int json_version, JSON::Writer& p) const
550
1.11M
{
551
1.11M
    switch (resolved_type_code()) {
552
0
    case ::ot_uninitialized:
553
0
        throw std::logic_error(
554
0
            "QPDFObjectHandle: attempting to get JSON from a uninitialized object");
555
0
        break; // unreachable
556
27.5k
    case ::ot_null:
557
27.5k
    case ::ot_operator:
558
27.5k
    case ::ot_inlineimage:
559
27.5k
        p << "null";
560
27.5k
        break;
561
7.10k
    case ::ot_boolean:
562
7.10k
        p << std::get<QPDF_Bool>(obj->value).val;
563
7.10k
        break;
564
359k
    case ::ot_integer:
565
359k
        p << std::to_string(std::get<QPDF_Integer>(obj->value).val);
566
359k
        break;
567
111k
    case ::ot_real:
568
111k
        {
569
111k
            auto const& val = std::get<QPDF_Real>(obj->value).val;
570
111k
            if (val.empty()) {
571
                // Can't really happen...
572
0
                p << "0";
573
111k
            } else if (val.at(0) == '.') {
574
955
                p << "0" << val;
575
110k
            } else if (val.length() >= 2 && val.at(0) == '-' && val.at(1) == '.') {
576
1.59k
                p << "-0." << val.substr(2);
577
108k
            } else if (val.at(0) == '0') {
578
44.3k
                auto i = val.find_first_not_of('0');
579
44.3k
                if (i == std::string::npos) {
580
41.0k
                    p << "0";
581
41.0k
                } else if (val.at(i) == '.') {
582
2.50k
                    p << "0" << val.substr(i);
583
2.50k
                } else {
584
782
                    p << val.substr(i);
585
782
                }
586
64.2k
            } else {
587
64.2k
                p << val;
588
64.2k
            }
589
111k
            if (val.back() == '.') {
590
1.65k
                p << "0";
591
1.65k
            }
592
111k
        }
593
111k
        break;
594
106k
    case ::ot_string:
595
106k
        std::get<QPDF_String>(obj->value).writeJSON(json_version, p);
596
106k
        break;
597
287k
    case ::ot_name:
598
287k
        {
599
287k
            auto const& n = std::get<QPDF_Name>(obj->value);
600
            // For performance reasons this code is duplicated in QPDF_Dictionary::writeJSON. When
601
            // updating this method make sure QPDF_Dictionary is also update.
602
287k
            if (json_version == 1) {
603
0
                p << "\"" << JSON::Writer::encode_string(Name::normalize(n.name)) << "\"";
604
287k
            } else {
605
287k
                if (auto res = Name::analyzeJSONEncoding(n.name); res.first) {
606
271k
                    if (res.second) {
607
259k
                        p << "\"" << n.name << "\"";
608
259k
                    } else {
609
11.5k
                        p << "\"" << JSON::Writer::encode_string(n.name) << "\"";
610
11.5k
                    }
611
271k
                } else {
612
15.8k
                    p << "\"n:" << JSON::Writer::encode_string(Name::normalize(n.name)) << "\"";
613
15.8k
                }
614
287k
            }
615
287k
        }
616
287k
        break;
617
100k
    case ::ot_array:
618
100k
        {
619
100k
            auto const& a = std::get<QPDF_Array>(obj->value);
620
100k
            p.writeStart('[');
621
100k
            if (a.sp) {
622
762
                size_t next = 0;
623
19.0k
                for (auto& [key, value]: a.sp->elements) {
624
87.3k
                    for (size_t j = next; j < key; ++j) {
625
68.3k
                        p.writeNext() << "null";
626
68.3k
                    }
627
19.0k
                    p.writeNext();
628
19.0k
                    auto item_og = value.id_gen();
629
19.0k
                    if (item_og.isIndirect()) {
630
1.45k
                        p << "\"" << item_og.unparse(' ') << " R\"";
631
17.5k
                    } else {
632
17.5k
                        value.write_json(json_version, p);
633
17.5k
                    }
634
19.0k
                    next = key + 1;
635
19.0k
                }
636
18.2k
                for (size_t j = next; j < a.sp->size; ++j) {
637
17.4k
                    p.writeNext() << "null";
638
17.4k
                }
639
99.9k
            } else {
640
888k
                for (auto const& item: a.elements) {
641
888k
                    p.writeNext();
642
888k
                    auto item_og = item.id_gen();
643
888k
                    if (item_og.isIndirect()) {
644
156k
                        p << "\"" << item_og.unparse(' ') << " R\"";
645
732k
                    } else {
646
732k
                        item.write_json(json_version, p);
647
732k
                    }
648
888k
                }
649
99.9k
            }
650
100k
            p.writeEnd(']');
651
100k
        }
652
100k
        break;
653
119k
    case ::ot_dictionary:
654
119k
        {
655
119k
            auto const& d = std::get<QPDF_Dictionary>(obj->value);
656
119k
            p.writeStart('{');
657
495k
            for (auto& iter: d.items) {
658
495k
                if (!iter.second.null()) {
659
413k
                    p.writeNext();
660
413k
                    if (json_version == 1) {
661
0
                        p << "\"" << JSON::Writer::encode_string(Name::normalize(iter.first))
662
0
                          << "\": ";
663
413k
                    } else if (auto res = Name::analyzeJSONEncoding(iter.first); res.first) {
664
392k
                        if (res.second) {
665
384k
                            p << "\"" << iter.first << "\": ";
666
384k
                        } else {
667
7.19k
                            p << "\"" << JSON::Writer::encode_string(iter.first) << "\": ";
668
7.19k
                        }
669
392k
                    } else {
670
21.8k
                        p << "\"n:" << JSON::Writer::encode_string(Name::normalize(iter.first))
671
21.8k
                          << "\": ";
672
21.8k
                    }
673
413k
                    iter.second.writeJSON(json_version, p);
674
413k
                }
675
495k
            }
676
119k
            p.writeEnd('}');
677
119k
        }
678
119k
        break;
679
0
    case ::ot_stream:
680
0
        std::get<QPDF_Stream>(obj->value).m->stream_dict.writeJSON(json_version, p);
681
0
        break;
682
0
    case ::ot_reference:
683
0
        p << "\"" << obj->og.unparse(' ') << " R\"";
684
0
        break;
685
0
    default:
686
0
        throw std::logic_error("attempted to write an unsuitable object as JSON");
687
1.11M
    }
688
1.11M
}
689
690
void
691
BaseHandle::disconnect(bool only_direct)
692
58.6M
{
693
    // QPDF::~QPDF() calls disconnect for indirect objects, so we don't do that here.
694
58.6M
    if (only_direct && indirect()) {
695
3.18M
        return;
696
3.18M
    }
697
698
55.4M
    switch (raw_type_code()) {
699
1.27M
    case ::ot_array:
700
1.27M
        {
701
1.27M
            auto& a = std::get<QPDF_Array>(obj->value);
702
1.27M
            if (a.sp) {
703
20.2M
                for (auto& item: a.sp->elements) {
704
20.2M
                    item.second.disconnect();
705
20.2M
                }
706
1.26M
            } else {
707
22.6M
                for (auto& oh: a.elements) {
708
22.6M
                    oh.disconnect();
709
22.6M
                }
710
1.26M
            }
711
1.27M
        }
712
1.27M
        break;
713
2.16M
    case ::ot_dictionary:
714
8.81M
        for (auto& iter: std::get<QPDF_Dictionary>(obj->value).items) {
715
8.81M
            iter.second.disconnect();
716
8.81M
        }
717
2.16M
        break;
718
466k
    case ::ot_stream:
719
466k
        {
720
466k
            auto& s = std::get<QPDF_Stream>(obj->value);
721
466k
            s.m->stream_provider = nullptr;
722
466k
            s.m->stream_dict.disconnect();
723
466k
        }
724
466k
        break;
725
0
    case ::ot_uninitialized:
726
0
        return;
727
51.5M
    default:
728
51.5M
        break;
729
55.4M
    }
730
55.4M
    obj->qpdf = nullptr;
731
55.4M
    obj->og = QPDFObjGen();
732
55.4M
}
733
734
bool
735
QPDFObjectHandle::isSameObjectAs(QPDFObjectHandle const& rhs) const
736
10.7k
{
737
10.7k
    return obj == rhs.obj;
738
10.7k
}
739
740
qpdf_object_type_e
741
QPDFObjectHandle::getTypeCode() const
742
32.4M
{
743
32.4M
    return type_code();
744
32.4M
}
745
746
char const*
747
BaseHandle::type_name() const
748
101k
{
749
101k
    static constexpr std::array<char const*, 16> tn{
750
101k
        "uninitialized",
751
101k
        "reserved",
752
101k
        "null",
753
101k
        "boolean",
754
101k
        "integer",
755
101k
        "real",
756
101k
        "string",
757
101k
        "name",
758
101k
        "array",
759
101k
        "dictionary",
760
101k
        "stream",
761
101k
        "operator",
762
101k
        "inline-image",
763
101k
        "unresolved",
764
101k
        "destroyed",
765
101k
        "reference"};
766
101k
    return tn[type_code()];
767
101k
}
768
769
char const*
770
QPDFObjectHandle::getTypeName() const
771
0
{
772
0
    return type_name();
773
0
}
774
775
bool
776
QPDFObjectHandle::isDestroyed() const
777
0
{
778
0
    return type_code() == ::ot_destroyed;
779
0
}
780
781
bool
782
QPDFObjectHandle::isBool() const
783
1.07M
{
784
1.07M
    return type_code() == ::ot_boolean;
785
1.07M
}
786
787
bool
788
QPDFObjectHandle::isDirectNull() const
789
0
{
790
    // Don't call dereference() -- this is a const method, and we know
791
    // objid == 0, so there's nothing to resolve.
792
0
    return !indirect() && raw_type_code() == ::ot_null;
793
0
}
794
795
bool
796
QPDFObjectHandle::isNull() const
797
602k
{
798
602k
    return type_code() == ::ot_null;
799
602k
}
800
801
bool
802
QPDFObjectHandle::isInteger() const
803
4.15M
{
804
4.15M
    return type_code() == ::ot_integer;
805
4.15M
}
806
807
bool
808
QPDFObjectHandle::isReal() const
809
1.22M
{
810
1.22M
    return type_code() == ::ot_real;
811
1.22M
}
812
813
bool
814
QPDFObjectHandle::isNumber() const
815
938k
{
816
938k
    return (isInteger() || isReal());
817
938k
}
818
819
double
820
QPDFObjectHandle::getNumericValue() const
821
284k
{
822
284k
    if (isInteger()) {
823
35.1k
        return static_cast<double>(getIntValue());
824
249k
    } else if (isReal()) {
825
249k
        return atof(getRealValue().c_str());
826
249k
    } else {
827
0
        typeWarning("number", "returning 0");
828
0
        QTC::TC("qpdf", "QPDFObjectHandle numeric non-numeric");
829
0
        return 0;
830
0
    }
831
284k
}
832
833
bool
834
QPDFObjectHandle::getValueAsNumber(double& value) const
835
284k
{
836
284k
    if (!isNumber()) {
837
590
        return false;
838
590
    }
839
284k
    value = getNumericValue();
840
284k
    return true;
841
284k
}
842
843
bool
844
QPDFObjectHandle::isName() const
845
1.15M
{
846
1.15M
    return type_code() == ::ot_name;
847
1.15M
}
848
849
bool
850
QPDFObjectHandle::isString() const
851
638k
{
852
638k
    return type_code() == ::ot_string;
853
638k
}
854
855
bool
856
QPDFObjectHandle::isOperator() const
857
29.0M
{
858
29.0M
    return type_code() == ::ot_operator;
859
29.0M
}
860
861
bool
862
QPDFObjectHandle::isInlineImage() const
863
0
{
864
0
    return type_code() == ::ot_inlineimage;
865
0
}
866
867
bool
868
QPDFObjectHandle::isArray() const
869
12.2M
{
870
12.2M
    return type_code() == ::ot_array;
871
12.2M
}
872
873
bool
874
QPDFObjectHandle::isDictionary() const
875
33.8M
{
876
33.8M
    return type_code() == ::ot_dictionary;
877
33.8M
}
878
879
bool
880
QPDFObjectHandle::isStream() const
881
24.1M
{
882
24.1M
    return type_code() == ::ot_stream;
883
24.1M
}
884
885
bool
886
QPDFObjectHandle::isReserved() const
887
0
{
888
0
    return type_code() == ::ot_reserved;
889
0
}
890
891
bool
892
QPDFObjectHandle::isScalar() const
893
678k
{
894
678k
    return isBool() || isInteger() || isName() || isNull() || isReal() || isString();
895
678k
}
896
897
bool
898
QPDFObjectHandle::isNameAndEquals(std::string const& name) const
899
888k
{
900
888k
    return Name(*this) == name;
901
888k
}
902
903
bool
904
QPDFObjectHandle::isDictionaryOfType(std::string const& type, std::string const& subtype) const
905
5.78M
{
906
5.78M
    return isDictionary() && (type.empty() || Name((*this)["/Type"]) == type) &&
907
476k
        (subtype.empty() || Name((*this)["/Subtype"]) == subtype);
908
5.78M
}
909
910
bool
911
QPDFObjectHandle::isStreamOfType(std::string const& type, std::string const& subtype) const
912
2.25M
{
913
2.25M
    if (auto stream = as_stream()) {
914
495k
        return stream && (type.empty() || stream.Type() == type) &&
915
178k
            (subtype.empty() || stream.Subtype() == subtype);
916
495k
    }
917
1.76M
    return false;
918
2.25M
}
919
920
// Bool accessors
921
922
bool
923
QPDFObjectHandle::getBoolValue() const
924
9.90k
{
925
9.90k
    if (auto boolean = as<QPDF_Bool>()) {
926
9.90k
        return boolean->val;
927
9.90k
    } else {
928
0
        typeWarning("boolean", "returning false");
929
0
        QTC::TC("qpdf", "QPDFObjectHandle boolean returning false");
930
0
        return false;
931
0
    }
932
9.90k
}
933
934
bool
935
QPDFObjectHandle::getValueAsBool(bool& value) const
936
0
{
937
0
    if (auto boolean = as<QPDF_Bool>()) {
938
0
        value = boolean->val;
939
0
        return true;
940
0
    }
941
0
    return false;
942
0
}
943
944
// Integer methods
945
946
Integer::Integer(long long value) :
947
92.9k
    BaseHandle(QPDFObject::create<QPDF_Integer>(value))
948
92.9k
{
949
92.9k
}
950
951
QPDFObjectHandle
952
QPDFObjectHandle::newInteger(long long value)
953
4.08M
{
954
4.08M
    return {QPDFObject::create<QPDF_Integer>(value)};
955
4.08M
}
956
957
int64_t
958
Integer::value() const
959
2.31M
{
960
2.31M
    auto* i = as<QPDF_Integer>();
961
2.31M
    if (!i) {
962
13.0k
        throw invalid_error("Integer");
963
13.0k
    }
964
2.30M
    return i->val;
965
2.31M
}
966
967
long long
968
QPDFObjectHandle::getIntValue() const
969
928k
{
970
928k
    if (auto const integer = Integer(*this)) {
971
928k
        return integer;
972
928k
    } else {
973
0
        typeWarning("integer", "returning 0");
974
0
        return 0;
975
0
    }
976
928k
}
977
978
bool
979
QPDFObjectHandle::getValueAsInt(long long& value) const
980
82.4k
{
981
82.4k
    if (auto const integer = Integer(*this)) {
982
81.4k
        value = integer;
983
81.4k
        return true;
984
81.4k
    }
985
965
    return false;
986
82.4k
}
987
988
int
989
QPDFObjectHandle::getIntValueAsInt() const
990
512k
{
991
512k
    try {
992
512k
        return Integer(*this).value<int>();
993
512k
    } catch (std::invalid_argument&) {
994
311
        typeWarning("integer", "returning 0");
995
311
        return 0;
996
311
    }
997
512k
}
998
999
bool
1000
QPDFObjectHandle::getValueAsInt(int& value) const
1001
21.2k
{
1002
21.2k
    if (!isInteger()) {
1003
605
        return false;
1004
605
    }
1005
20.6k
    value = getIntValueAsInt();
1006
20.6k
    return true;
1007
21.2k
}
1008
1009
unsigned long long
1010
QPDFObjectHandle::getUIntValue() const
1011
366k
{
1012
366k
    try {
1013
366k
        return Integer(*this).value<unsigned long long>();
1014
366k
    } catch (std::invalid_argument&) {
1015
7.48k
        typeWarning("integer", "returning 0");
1016
7.48k
        return 0;
1017
7.48k
    }
1018
366k
}
1019
1020
bool
1021
QPDFObjectHandle::getValueAsUInt(unsigned long long& value) const
1022
0
{
1023
0
    if (!isInteger()) {
1024
0
        return false;
1025
0
    }
1026
0
    value = getUIntValue();
1027
0
    return true;
1028
0
}
1029
1030
unsigned int
1031
QPDFObjectHandle::getUIntValueAsUInt() const
1032
92.2k
{
1033
92.2k
    try {
1034
92.2k
        return Integer(*this).value<unsigned int>();
1035
92.2k
    } catch (std::invalid_argument&) {
1036
5.24k
        typeWarning("integer", "returning 0");
1037
5.24k
        return 0;
1038
5.24k
    }
1039
92.2k
}
1040
1041
bool
1042
QPDFObjectHandle::getValueAsUInt(unsigned int& value) const
1043
25.5k
{
1044
25.5k
    if (!isInteger()) {
1045
4.22k
        return false;
1046
4.22k
    }
1047
21.3k
    value = getUIntValueAsUInt();
1048
21.3k
    return true;
1049
25.5k
}
1050
1051
// Real accessors
1052
1053
std::string
1054
QPDFObjectHandle::getRealValue() const
1055
249k
{
1056
249k
    if (auto* real = as<QPDF_Real>()) {
1057
249k
        return real->val;
1058
249k
    }
1059
0
    typeWarning("real", "returning 0.0");
1060
0
    return "0.0";
1061
249k
}
1062
1063
bool
1064
QPDFObjectHandle::getValueAsReal(std::string& value) const
1065
0
{
1066
0
    if (auto* real = as<QPDF_Real>()) {
1067
0
        value = real->val;
1068
0
        return true;
1069
0
    }
1070
0
    return false;
1071
0
}
1072
1073
// Name methods
1074
1075
QPDFObjectHandle
1076
QPDFObjectHandle::newName(std::string const& name)
1077
41.6k
{
1078
41.6k
    return {QPDFObject::create<QPDF_Name>(name)};
1079
41.6k
}
1080
1081
Name::Name(std::string const& name) :
1082
0
    BaseHandle(QPDFObject::create<QPDF_Name>(name))
1083
0
{
1084
0
}
1085
1086
Name::Name(std::string&& name) :
1087
267k
    BaseHandle(QPDFObject::create<QPDF_Name>(std::move(name)))
1088
267k
{
1089
267k
}
1090
1091
std::string const&
1092
Name::value() const
1093
3.16M
{
1094
3.16M
    auto* n = as<QPDF_Name>();
1095
3.16M
    if (!n) {
1096
0
        throw invalid_error("Name");
1097
0
    }
1098
3.16M
    return n->name;
1099
3.16M
}
1100
1101
std::string
1102
QPDFObjectHandle::getName() const
1103
227k
{
1104
227k
    if (auto* name = as<QPDF_Name>()) {
1105
219k
        return name->name;
1106
219k
    }
1107
7.20k
    typeWarning("name", "returning dummy name");
1108
7.20k
    return "/QPDFFakeName";
1109
227k
}
1110
1111
bool
1112
QPDFObjectHandle::getValueAsName(std::string& value) const
1113
0
{
1114
0
    if (auto* name = as<QPDF_Name>()) {
1115
0
        value = name->name;
1116
0
        return true;
1117
0
    }
1118
0
    return false;
1119
0
}
1120
1121
// String methods
1122
1123
QPDFObjectHandle
1124
QPDFObjectHandle::newString(std::string const& str)
1125
172k
{
1126
172k
    return {QPDFObject::create<QPDF_String>(str)};
1127
172k
}
1128
1129
QPDFObjectHandle
1130
QPDFObjectHandle::newUnicodeString(std::string const& utf8_str)
1131
17.9k
{
1132
17.9k
    return {String::utf16(utf8_str).obj_sp()};
1133
17.9k
}
1134
1135
String::String(std::string const& str) :
1136
8.02k
    BaseHandle(QPDFObject::create<QPDF_String>(str))
1137
8.02k
{
1138
8.02k
}
1139
1140
String::String(std::string&& str) :
1141
9.89k
    BaseHandle(QPDFObject::create<QPDF_String>(std::move(str)))
1142
9.89k
{
1143
9.89k
}
1144
1145
String
1146
String::utf16(std::string const& utf8_str)
1147
17.9k
{
1148
17.9k
    std::string result;
1149
17.9k
    if (QUtil::utf8_to_pdf_doc(utf8_str, result, '?')) {
1150
8.02k
        return String(result);
1151
8.02k
    }
1152
9.89k
    return String(QUtil::utf8_to_utf16(utf8_str));
1153
17.9k
}
1154
1155
std::string const&
1156
String::value() const
1157
166k
{
1158
166k
    auto* s = as<QPDF_String>();
1159
166k
    if (!s) {
1160
0
        throw invalid_error("String");
1161
0
    }
1162
166k
    return s->val;
1163
166k
}
1164
1165
std::string
1166
String::utf8_value() const
1167
1.91M
{
1168
1.91M
    auto* s = as<QPDF_String>();
1169
1.91M
    if (!s) {
1170
0
        throw invalid_error("String");
1171
0
    }
1172
1.91M
    if (util::is_utf16(s->val)) {
1173
112k
        return QUtil::utf16_to_utf8(s->val);
1174
112k
    }
1175
1.80M
    if (util::is_explicit_utf8(s->val)) {
1176
        // PDF 2.0 allows UTF-8 strings when explicitly prefixed with the three-byte representation
1177
        // of U+FEFF.
1178
19.9k
        return s->val.substr(3);
1179
19.9k
    }
1180
1.78M
    return QUtil::pdf_doc_to_utf8(s->val);
1181
1.80M
}
1182
1183
std::string
1184
QPDFObjectHandle::getStringValue() const
1185
157k
{
1186
157k
    try {
1187
157k
        return String(obj).value();
1188
157k
    } catch (std::invalid_argument&) {
1189
0
        typeWarning("string", "returning empty string");
1190
0
        return {};
1191
0
    }
1192
157k
}
1193
1194
bool
1195
QPDFObjectHandle::getValueAsString(std::string& value) const
1196
0
{
1197
0
    try {
1198
0
        value = String(obj).value();
1199
0
        return true;
1200
0
    } catch (std::invalid_argument&) {
1201
0
        return false;
1202
0
    }
1203
0
}
1204
1205
std::string
1206
QPDFObjectHandle::getUTF8Value() const
1207
1.83M
{
1208
1.83M
    try {
1209
1.83M
        return String(obj).utf8_value();
1210
1.83M
    } catch (std::invalid_argument&) {
1211
0
        typeWarning("string", "returning empty string");
1212
0
        return {};
1213
0
    }
1214
1.83M
}
1215
1216
bool
1217
QPDFObjectHandle::getValueAsUTF8(std::string& value) const
1218
0
{
1219
0
    try {
1220
0
        value = String(obj).utf8_value();
1221
0
        return true;
1222
0
    } catch (std::invalid_argument&) {
1223
0
        return false;
1224
0
    }
1225
0
}
1226
1227
// Operator and Inline Image accessors
1228
1229
std::string
1230
QPDFObjectHandle::getOperatorValue() const
1231
27.0M
{
1232
27.0M
    if (auto* op = as<QPDF_Operator>()) {
1233
27.0M
        return op->val;
1234
27.0M
    }
1235
0
    typeWarning("operator", "returning fake value");
1236
0
    return "QPDFFAKE";
1237
27.0M
}
1238
1239
bool
1240
QPDFObjectHandle::getValueAsOperator(std::string& value) const
1241
0
{
1242
0
    if (auto* op = as<QPDF_Operator>()) {
1243
0
        value = op->val;
1244
0
        return true;
1245
0
    }
1246
0
    return false;
1247
0
}
1248
1249
std::string
1250
QPDFObjectHandle::getInlineImageValue() const
1251
0
{
1252
0
    if (auto* ii = as<QPDF_InlineImage>()) {
1253
0
        return ii->val;
1254
0
    }
1255
0
    typeWarning("inlineimage", "returning empty data");
1256
0
    return {};
1257
0
}
1258
1259
bool
1260
QPDFObjectHandle::getValueAsInlineImage(std::string& value) const
1261
0
{
1262
0
    if (auto* ii = as<QPDF_InlineImage>()) {
1263
0
        value = ii->val;
1264
0
        return true;
1265
0
    }
1266
0
    return false;
1267
0
}
1268
1269
// Array accessors and mutators are in QPDF_Array.cc
1270
1271
QPDFObjectHandle::QPDFArrayItems
1272
QPDFObjectHandle::aitems()
1273
9.08k
{
1274
9.08k
    return *this;
1275
9.08k
}
1276
1277
// Dictionary accessors are in QPDF_Dictionary.cc
1278
1279
QPDFObjectHandle::QPDFDictItems
1280
QPDFObjectHandle::ditems()
1281
0
{
1282
0
    return {*this};
1283
0
}
1284
1285
// Array and Name accessors
1286
1287
bool
1288
QPDFObjectHandle::isOrHasName(std::string const& value) const
1289
207k
{
1290
207k
    if (isNameAndEquals(value)) {
1291
4.03k
        return true;
1292
203k
    } else if (isArray()) {
1293
486k
        for (auto& item: getArrayAsVector()) {
1294
486k
            if (item.isNameAndEquals(value)) {
1295
3.60k
                return true;
1296
3.60k
            }
1297
486k
        }
1298
95.7k
    }
1299
199k
    return false;
1300
207k
}
1301
1302
void
1303
QPDFObjectHandle::makeResourcesIndirect(QPDF& owning_qpdf)
1304
0
{
1305
0
    for (auto const& i1: as_dictionary()) {
1306
0
        for (auto& i2: i1.second.as_dictionary()) {
1307
0
            if (!i2.second.null() && !i2.second.isIndirect()) {
1308
0
                i2.second = owning_qpdf.makeIndirectObject(i2.second);
1309
0
            }
1310
0
        }
1311
0
    }
1312
0
}
1313
1314
void
1315
QPDFObjectHandle::mergeResources(
1316
    QPDFObjectHandle other, std::map<std::string, std::map<std::string, std::string>>* conflicts)
1317
55.7k
{
1318
55.7k
    if (!(isDictionary() && other.isDictionary())) {
1319
15.8k
        QTC::TC("qpdf", "QPDFObjectHandle merge top type mismatch");
1320
15.8k
        return;
1321
15.8k
    }
1322
1323
39.8k
    auto make_og_to_name = [](QPDFObjectHandle& dict,
1324
39.8k
                              std::map<QPDFObjGen, std::string>& og_to_name) {
1325
0
        for (auto const& [key, value]: dict.as_dictionary()) {
1326
0
            if (!value.null() && value.isIndirect()) {
1327
0
                og_to_name.insert_or_assign(value.getObjGen(), key);
1328
0
            }
1329
0
        }
1330
0
    };
1331
1332
    // This algorithm is described in comments in QPDFObjectHandle.hh
1333
    // above the declaration of mergeResources.
1334
69.5k
    for (auto const& [rtype, value1]: other.as_dictionary()) {
1335
69.5k
        auto other_val = value1;
1336
69.5k
        if (hasKey(rtype)) {
1337
38.9k
            QPDFObjectHandle this_val = getKey(rtype);
1338
38.9k
            if (this_val.isDictionary() && other_val.isDictionary()) {
1339
28.0k
                if (this_val.isIndirect()) {
1340
                    // Do this even if there are no keys. Various places in the code call
1341
                    // mergeResources with resource dictionaries that contain empty subdictionaries
1342
                    // just to get this shallow copy functionality.
1343
3.64k
                    QTC::TC("qpdf", "QPDFObjectHandle replace with copy");
1344
3.64k
                    this_val = replaceKeyAndGetNew(rtype, this_val.shallowCopy());
1345
3.64k
                }
1346
28.0k
                std::map<QPDFObjGen, std::string> og_to_name;
1347
28.0k
                std::set<std::string> rnames;
1348
28.0k
                int min_suffix = 1;
1349
28.0k
                bool initialized_maps = false;
1350
138k
                for (auto const& [key, value2]: other_val.as_dictionary()) {
1351
138k
                    QPDFObjectHandle rval = value2;
1352
138k
                    if (!this_val.hasKey(key)) {
1353
45.7k
                        if (!rval.isIndirect()) {
1354
13.5k
                            QTC::TC("qpdf", "QPDFObjectHandle merge shallow copy");
1355
13.5k
                            rval = rval.shallowCopy();
1356
13.5k
                        }
1357
45.7k
                        this_val.replaceKey(key, rval);
1358
92.6k
                    } else if (conflicts) {
1359
0
                        if (!initialized_maps) {
1360
0
                            make_og_to_name(this_val, og_to_name);
1361
0
                            rnames = this_val.getResourceNames();
1362
0
                            initialized_maps = true;
1363
0
                        }
1364
0
                        auto rval_og = rval.getObjGen();
1365
0
                        if (rval.isIndirect() && og_to_name.contains(rval_og)) {
1366
0
                            QTC::TC("qpdf", "QPDFObjectHandle merge reuse");
1367
0
                            auto new_key = og_to_name[rval_og];
1368
0
                            if (new_key != key) {
1369
0
                                (*conflicts)[rtype][key] = new_key;
1370
0
                            }
1371
0
                        } else {
1372
0
                            QTC::TC("qpdf", "QPDFObjectHandle merge generate");
1373
0
                            std::string new_key =
1374
0
                                getUniqueResourceName(key + "_", min_suffix, &rnames);
1375
0
                            (*conflicts)[rtype][key] = new_key;
1376
0
                            this_val.replaceKey(new_key, rval);
1377
0
                        }
1378
0
                    }
1379
138k
                }
1380
28.0k
            } else if (this_val.isArray() && other_val.isArray()) {
1381
4.54k
                std::set<std::string> scalars;
1382
238k
                for (auto this_item: this_val.aitems()) {
1383
238k
                    if (this_item.isScalar()) {
1384
236k
                        scalars.insert(this_item.unparse());
1385
236k
                    }
1386
238k
                }
1387
415k
                for (auto other_item: other_val.aitems()) {
1388
415k
                    if (other_item.isScalar()) {
1389
412k
                        if (!scalars.contains(other_item.unparse())) {
1390
231k
                            QTC::TC("qpdf", "QPDFObjectHandle merge array");
1391
231k
                            this_val.appendItem(other_item);
1392
231k
                        } else {
1393
180k
                            QTC::TC("qpdf", "QPDFObjectHandle merge array dup");
1394
180k
                        }
1395
412k
                    }
1396
415k
                }
1397
4.54k
            }
1398
38.9k
        } else {
1399
30.6k
            QTC::TC("qpdf", "QPDFObjectHandle merge copy from other");
1400
30.6k
            replaceKey(rtype, other_val.shallowCopy());
1401
30.6k
        }
1402
69.5k
    }
1403
39.8k
}
1404
1405
std::set<std::string>
1406
QPDFObjectHandle::getResourceNames() const
1407
28.6k
{
1408
    // Return second-level dictionary keys
1409
28.6k
    std::set<std::string> result;
1410
68.6k
    for (auto const& item: as_dictionary(strict)) {
1411
543k
        for (auto const& [key2, val2]: item.second.as_dictionary(strict)) {
1412
543k
            if (!val2.null()) {
1413
446k
                result.insert(key2);
1414
446k
            }
1415
543k
        }
1416
68.6k
    }
1417
28.6k
    return result;
1418
28.6k
}
1419
1420
std::string
1421
QPDFObjectHandle::getUniqueResourceName(
1422
    std::string const& prefix, int& min_suffix, std::set<std::string>* namesp) const
1423
28.6k
{
1424
28.6k
    std::set<std::string> names = (namesp ? *namesp : getResourceNames());
1425
28.6k
    int max_suffix = min_suffix + QIntC::to_int(names.size());
1426
28.6k
    while (min_suffix <= max_suffix) {
1427
28.6k
        std::string candidate = prefix + std::to_string(min_suffix);
1428
28.6k
        if (!names.contains(candidate)) {
1429
28.6k
            return candidate;
1430
28.6k
        }
1431
        // Increment after return; min_suffix should be the value
1432
        // used, not the next value.
1433
20
        ++min_suffix;
1434
20
    }
1435
    // This could only happen if there is a coding error.
1436
    // The number of candidates we test is more than the
1437
    // number of keys we're checking against.
1438
0
    throw std::logic_error(
1439
0
        "unable to find unconflicting name in QPDFObjectHandle::getUniqueResourceName");
1440
28.6k
}
1441
1442
// Dictionary mutators are in QPDF_Dictionary.cc
1443
1444
// Stream accessors are in QPDF_Stream.cc
1445
1446
std::map<std::string, QPDFObjectHandle>
1447
QPDFObjectHandle::getPageImages()
1448
0
{
1449
0
    return QPDFPageObjectHelper(*this).getImages();
1450
0
}
1451
1452
std::vector<QPDFObjectHandle>
1453
QPDFObjectHandle::arrayOrStreamToStreamArray(
1454
    std::string const& description, std::string& all_description)
1455
63.3k
{
1456
63.3k
    all_description = description;
1457
63.3k
    std::vector<QPDFObjectHandle> result;
1458
63.3k
    if (auto array = as_array(strict)) {
1459
17.1k
        int n_items = static_cast<int>(array.size());
1460
268k
        for (int i = 0; i < n_items; ++i) {
1461
251k
            QPDFObjectHandle item = array[i];
1462
251k
            if (item.isStream()) {
1463
65.1k
                result.emplace_back(item);
1464
186k
            } else {
1465
186k
                item.warn(
1466
186k
                    {qpdf_e_damaged_pdf,
1467
186k
                     "",
1468
186k
                     description + ": item index " + std::to_string(i) + " (from 0)",
1469
186k
                     0,
1470
186k
                     "ignoring non-stream in an array of streams"});
1471
186k
            }
1472
251k
        }
1473
46.2k
    } else if (isStream()) {
1474
16.8k
        result.emplace_back(*this);
1475
29.3k
    } else if (!null()) {
1476
1.06k
        warn(
1477
1.06k
            {qpdf_e_damaged_pdf,
1478
1.06k
             "",
1479
1.06k
             description,
1480
1.06k
             0,
1481
1.06k
             " object is supposed to be a stream or an array of streams but is neither"});
1482
1.06k
    }
1483
1484
63.3k
    bool first = true;
1485
82.0k
    for (auto const& item: result) {
1486
82.0k
        if (first) {
1487
32.8k
            first = false;
1488
49.1k
        } else {
1489
49.1k
            all_description += ",";
1490
49.1k
        }
1491
82.0k
        all_description += " stream " + item.getObjGen().unparse(' ');
1492
82.0k
    }
1493
1494
63.3k
    return result;
1495
63.3k
}
1496
1497
std::vector<QPDFObjectHandle>
1498
QPDFObjectHandle::getPageContents()
1499
15.1k
{
1500
15.1k
    std::string description = "page object " + getObjGen().unparse(' ');
1501
15.1k
    std::string all_description;
1502
15.1k
    return getKey("/Contents").arrayOrStreamToStreamArray(description, all_description);
1503
15.1k
}
1504
1505
void
1506
QPDFObjectHandle::addPageContents(QPDFObjectHandle new_contents, bool first)
1507
15.1k
{
1508
15.1k
    new_contents.assertStream();
1509
1510
15.1k
    std::vector<QPDFObjectHandle> content_streams;
1511
15.1k
    if (first) {
1512
7.64k
        QTC::TC("qpdf", "QPDFObjectHandle prepend page contents");
1513
7.64k
        content_streams.push_back(new_contents);
1514
7.64k
    }
1515
15.1k
    for (auto const& iter: getPageContents()) {
1516
9.30k
        QTC::TC("qpdf", "QPDFObjectHandle append page contents");
1517
9.30k
        content_streams.push_back(iter);
1518
9.30k
    }
1519
15.1k
    if (!first) {
1520
7.51k
        content_streams.push_back(new_contents);
1521
7.51k
    }
1522
1523
15.1k
    replaceKey("/Contents", newArray(content_streams));
1524
15.1k
}
1525
1526
void
1527
QPDFObjectHandle::rotatePage(int angle, bool relative)
1528
0
{
1529
0
    if ((angle % 90) != 0) {
1530
0
        throw std::runtime_error(
1531
0
            "QPDF::rotatePage called with an angle that is not a multiple of 90");
1532
0
    }
1533
0
    int new_angle = angle;
1534
0
    if (relative) {
1535
0
        int old_angle = 0;
1536
0
        QPDFObjectHandle cur_obj = *this;
1537
0
        QPDFObjGen::set visited;
1538
0
        while (visited.add(cur_obj)) {
1539
            // Don't get stuck in an infinite loop
1540
0
            if (cur_obj.getKey("/Rotate").getValueAsInt(old_angle)) {
1541
0
                break;
1542
0
            } else if (cur_obj.getKey("/Parent").isDictionary()) {
1543
0
                cur_obj = cur_obj.getKey("/Parent");
1544
0
            } else {
1545
0
                break;
1546
0
            }
1547
0
        }
1548
0
        QTC::TC("qpdf", "QPDFObjectHandle found old angle", visited.size() > 1 ? 0 : 1);
1549
0
        if ((old_angle % 90) != 0) {
1550
0
            old_angle = 0;
1551
0
        }
1552
0
        new_angle += old_angle;
1553
0
    }
1554
0
    new_angle = (new_angle + 360) % 360;
1555
    // Make this explicit even with new_angle == 0 since /Rotate can be inherited.
1556
0
    replaceKey("/Rotate", Integer(new_angle));
1557
0
}
1558
1559
void
1560
QPDFObjectHandle::coalesceContentStreams()
1561
39.0k
{
1562
39.0k
    QPDFObjectHandle contents = getKey("/Contents");
1563
39.0k
    if (contents.isStream()) {
1564
7.65k
        QTC::TC("qpdf", "QPDFObjectHandle coalesce called on stream");
1565
7.65k
        return;
1566
31.4k
    } else if (!contents.isArray()) {
1567
        // /Contents is optional for pages, and some very damaged files may have pages that are
1568
        // invalid in other ways.
1569
22.3k
        return;
1570
22.3k
    }
1571
    // Should not be possible for a page object to not have an owning PDF unless it was manually
1572
    // constructed in some incorrect way. However, it can happen in a PDF file whose page structure
1573
    // is direct, which is against spec but still possible to hand construct, as in fuzz issue
1574
    // 27393.
1575
9.11k
    QPDF& qpdf = getQPDF("coalesceContentStreams called on object  with no associated PDF file");
1576
1577
9.11k
    QPDFObjectHandle new_contents = newStream(&qpdf);
1578
9.11k
    replaceKey("/Contents", new_contents);
1579
1580
9.11k
    auto provider = std::shared_ptr<StreamDataProvider>(new CoalesceProvider(*this, contents));
1581
9.11k
    new_contents.replaceStreamData(provider, newNull(), newNull());
1582
9.11k
}
1583
1584
std::string
1585
QPDFObjectHandle::unparse() const
1586
818k
{
1587
818k
    if (isIndirect()) {
1588
6.25k
        return getObjGen().unparse(' ') + " R";
1589
812k
    } else {
1590
812k
        return unparseResolved();
1591
812k
    }
1592
818k
}
1593
1594
std::string
1595
QPDFObjectHandle::unparseResolved() const
1596
30.8M
{
1597
30.8M
    if (!obj) {
1598
0
        throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHandle");
1599
0
    }
1600
30.8M
    return BaseHandle::unparse();
1601
30.8M
}
1602
1603
std::string
1604
QPDFObjectHandle::unparseBinary() const
1605
0
{
1606
0
    if (auto str = as<QPDF_String>()) {
1607
0
        return str->unparse(true);
1608
0
    } else {
1609
0
        return unparse();
1610
0
    }
1611
0
}
1612
1613
JSON
1614
QPDFObjectHandle::getJSON(int json_version, bool dereference_indirect) const
1615
34.2k
{
1616
34.2k
    if ((!dereference_indirect) && isIndirect()) {
1617
0
        return JSON::makeString(unparse());
1618
34.2k
    } else if (!obj) {
1619
0
        throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHandle");
1620
34.2k
    } else {
1621
34.2k
        Pl_Buffer p{"json"};
1622
34.2k
        JSON::Writer jw{&p, 0};
1623
34.2k
        writeJSON(json_version, jw, dereference_indirect);
1624
34.2k
        p.finish();
1625
34.2k
        return JSON::parse(p.getString());
1626
34.2k
    }
1627
34.2k
}
1628
1629
void
1630
QPDFObjectHandle::writeJSON(int json_version, JSON::Writer& p, bool dereference_indirect) const
1631
448k
{
1632
448k
    if (!dereference_indirect && isIndirect()) {
1633
78.8k
        p << "\"" << getObjGen().unparse(' ') << " R\"";
1634
369k
    } else if (!obj) {
1635
0
        throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHandle");
1636
369k
    } else {
1637
369k
        write_json(json_version, p);
1638
369k
    }
1639
448k
}
1640
1641
void
1642
QPDFObjectHandle::writeJSON(
1643
    int json_version, Pipeline* p, bool dereference_indirect, size_t depth) const
1644
0
{
1645
0
    JSON::Writer jw{p, depth};
1646
0
    writeJSON(json_version, jw, dereference_indirect);
1647
0
}
1648
1649
QPDFObjectHandle
1650
QPDFObjectHandle::wrapInArray()
1651
0
{
1652
0
    if (isArray()) {
1653
0
        return *this;
1654
0
    }
1655
0
    QPDFObjectHandle result = QPDFObjectHandle::newArray();
1656
0
    result.appendItem(*this);
1657
0
    return result;
1658
0
}
1659
1660
QPDFObjectHandle
1661
QPDFObjectHandle::parse(std::string const& object_str, std::string const& object_description)
1662
49.7k
{
1663
49.7k
    return parse(nullptr, object_str, object_description);
1664
49.7k
}
1665
1666
QPDFObjectHandle
1667
QPDFObjectHandle::parse(
1668
    QPDF* context, std::string const& object_str, std::string const& object_description)
1669
49.7k
{
1670
49.7k
    auto input = is::OffsetBuffer("parsed object", object_str);
1671
49.7k
    auto result = Parser::parse(input, object_description, context);
1672
49.7k
    size_t offset = QIntC::to_size(input.tell());
1673
664k
    while (offset < object_str.length()) {
1674
614k
        if (!isspace(object_str.at(offset))) {
1675
136
            QTC::TC("qpdf", "QPDFObjectHandle trailing data in parse");
1676
136
            throw QPDFExc(
1677
136
                qpdf_e_damaged_pdf,
1678
136
                "parsed object",
1679
136
                object_description,
1680
136
                input.getLastOffset(),
1681
136
                "trailing data found parsing object from string");
1682
136
        }
1683
614k
        ++offset;
1684
614k
    }
1685
49.5k
    return result;
1686
49.7k
}
1687
1688
void
1689
QPDFObjectHandle::pipePageContents(Pipeline* p)
1690
0
{
1691
0
    std::string description = "page object " + getObjGen().unparse(' ');
1692
0
    std::string all_description;
1693
0
    getKey("/Contents").pipeContentStreams(p, description, all_description);
1694
0
}
1695
1696
void
1697
QPDFObjectHandle::pipeContentStreams(
1698
    Pipeline* p, std::string const& description, std::string& all_description)
1699
48.1k
{
1700
48.1k
    bool need_newline = false;
1701
48.1k
    std::string buffer;
1702
48.1k
    pl::String buf(buffer);
1703
68.5k
    for (auto stream: arrayOrStreamToStreamArray(description, all_description)) {
1704
68.5k
        if (need_newline) {
1705
23.0k
            buf.writeCStr("\n");
1706
23.0k
        }
1707
68.5k
        if (!stream.pipeStreamData(&buf, 0, qpdf_dl_specialized)) {
1708
2.19k
            QTC::TC("qpdf", "QPDFObjectHandle errors in parsecontent");
1709
2.19k
            throw QPDFExc(
1710
2.19k
                qpdf_e_damaged_pdf,
1711
2.19k
                "content stream",
1712
2.19k
                "content stream object " + stream.getObjGen().unparse(' '),
1713
2.19k
                0,
1714
2.19k
                "errors while decoding content stream");
1715
2.19k
        }
1716
66.3k
        need_newline = buffer.empty() || buffer.back() != '\n';
1717
66.3k
        QTC::TC("qpdf", "QPDFObjectHandle need_newline", need_newline ? 0 : 1);
1718
66.3k
        p->writeString(buffer);
1719
66.3k
        buffer.clear();
1720
66.3k
    }
1721
45.9k
    p->finish();
1722
45.9k
}
1723
1724
void
1725
QPDFObjectHandle::parsePageContents(ParserCallbacks* callbacks)
1726
39.0k
{
1727
39.0k
    std::string description = "page object " + getObjGen().unparse(' ');
1728
39.0k
    getKey("/Contents").parseContentStream_internal(description, callbacks);
1729
39.0k
}
1730
1731
void
1732
QPDFObjectHandle::parseAsContents(ParserCallbacks* callbacks)
1733
0
{
1734
0
    std::string description = "object " + getObjGen().unparse(' ');
1735
0
    parseContentStream_internal(description, callbacks);
1736
0
}
1737
1738
void
1739
QPDFObjectHandle::filterPageContents(TokenFilter* filter, Pipeline* next)
1740
0
{
1741
0
    auto description = "token filter for page object " + getObjGen().unparse(' ');
1742
0
    Pl_QPDFTokenizer token_pipeline(description.c_str(), filter, next);
1743
0
    pipePageContents(&token_pipeline);
1744
0
}
1745
1746
void
1747
QPDFObjectHandle::filterAsContents(TokenFilter* filter, Pipeline* next)
1748
0
{
1749
0
    auto description = "token filter for object " + getObjGen().unparse(' ');
1750
0
    Pl_QPDFTokenizer token_pipeline(description.c_str(), filter, next);
1751
0
    pipeStreamData(&token_pipeline, 0, qpdf_dl_specialized);
1752
0
}
1753
1754
void
1755
QPDFObjectHandle::parseContentStream(QPDFObjectHandle stream_or_array, ParserCallbacks* callbacks)
1756
0
{
1757
0
    stream_or_array.parseContentStream_internal("content stream objects", callbacks);
1758
0
}
1759
1760
void
1761
QPDFObjectHandle::parseContentStream_internal(
1762
    std::string const& description, ParserCallbacks* callbacks)
1763
39.0k
{
1764
39.0k
    std::string stream_data;
1765
39.0k
    pl::String buf(stream_data);
1766
39.0k
    std::string all_description;
1767
39.0k
    pipeContentStreams(&buf, description, all_description);
1768
39.0k
    if (callbacks) {
1769
0
        callbacks->contentSize(stream_data.size());
1770
0
    }
1771
39.0k
    try {
1772
39.0k
        parseContentStream_data(stream_data, all_description, callbacks, getOwningQPDF());
1773
39.0k
    } catch (TerminateParsing&) {
1774
0
        return;
1775
0
    }
1776
36.4k
    if (callbacks) {
1777
0
        callbacks->handleEOF();
1778
0
    }
1779
36.4k
}
1780
1781
void
1782
QPDFObjectHandle::parseContentStream_data(
1783
    std::string_view stream_data,
1784
    std::string const& description,
1785
    ParserCallbacks* callbacks,
1786
    QPDF* context)
1787
36.4k
{
1788
36.4k
    size_t stream_length = stream_data.size();
1789
36.4k
    auto input = is::OffsetBuffer(description, stream_data);
1790
36.4k
    Tokenizer tokenizer;
1791
36.4k
    tokenizer.allowEOF();
1792
36.4k
    auto max_bad_count = Limits::parser_max_errors();
1793
36.4k
    auto sp_description = Parser::make_description(description, "content");
1794
29.0M
    while (QIntC::to_size(input.tell()) < stream_length) {
1795
        // Read a token and seek to the beginning. The offset we get from this process is the
1796
        // beginning of the next non-ignorable (space, comment) token. This way, the offset and
1797
        // don't including ignorable content.
1798
29.0M
        tokenizer.nextToken(input, "content", true);
1799
29.0M
        qpdf_offset_t offset = input.getLastOffset();
1800
29.0M
        input.seek(offset, SEEK_SET);
1801
29.0M
        auto [obj, empty] = Parser::parse_content(input, sp_description, tokenizer, context);
1802
29.0M
        if (empty) {
1803
            // EOF
1804
11.1k
            return;
1805
11.1k
        }
1806
29.0M
        if (!obj) {
1807
13.1k
            if (max_bad_count && --max_bad_count == 0) {
1808
476
                Limits::error();
1809
476
                warn(
1810
476
                    context,
1811
476
                    {qpdf_e_damaged_pdf,
1812
476
                     description,
1813
476
                     "stream data",
1814
476
                     input.tell(),
1815
476
                     "limits error(parser-max-errors): too many errors during content stream "
1816
476
                     "parsing"});
1817
476
                return;
1818
476
            }
1819
12.6k
            obj = newNull();
1820
12.6k
        }
1821
29.0M
        size_t length = QIntC::to_size(input.tell() - offset);
1822
29.0M
        if (callbacks) {
1823
0
            callbacks->handleObject(obj, QIntC::to_size(offset), length);
1824
0
        }
1825
29.0M
        if (obj.isOperator() && obj.getOperatorValue() == "ID") {
1826
            // Discard next character; it is the space after ID that terminated the token.  Read
1827
            // until end of inline image.
1828
3.20k
            char ch;
1829
3.20k
            input.read(&ch, 1);
1830
3.20k
            tokenizer.expectInlineImage(input);
1831
3.20k
            tokenizer.nextToken(input, description);
1832
3.20k
            offset = input.getLastOffset();
1833
3.20k
            length = QIntC::to_size(input.tell() - offset);
1834
3.20k
            if (tokenizer.getType() == QPDFTokenizer::tt_bad) {
1835
169
                QTC::TC("qpdf", "QPDFObjectHandle EOF in inline image");
1836
169
                warn(
1837
169
                    context,
1838
169
                    {qpdf_e_damaged_pdf,
1839
169
                     description,
1840
169
                     "stream data",
1841
169
                     input.tell(),
1842
169
                     "EOF found while reading inline image"});
1843
3.03k
            } else {
1844
3.03k
                QTC::TC("qpdf", "QPDFObjectHandle inline image token");
1845
3.03k
                if (callbacks) {
1846
0
                    callbacks->handleObject(
1847
0
                        QPDFObjectHandle::newInlineImage(tokenizer.getValue()),
1848
0
                        QIntC::to_size(offset),
1849
0
                        length);
1850
0
                }
1851
3.03k
            }
1852
3.20k
        }
1853
29.0M
    }
1854
36.4k
}
1855
1856
void
1857
QPDFObjectHandle::addContentTokenFilter(std::shared_ptr<TokenFilter> filter)
1858
0
{
1859
0
    coalesceContentStreams();
1860
0
    getKey("/Contents").addTokenFilter(filter);
1861
0
}
1862
1863
void
1864
QPDFObjectHandle::addTokenFilter(std::shared_ptr<TokenFilter> filter)
1865
0
{
1866
0
    return as_stream(error).addTokenFilter(filter);
1867
0
}
1868
1869
QPDFObjectHandle
1870
QPDFObjectHandle::parse(
1871
    std::shared_ptr<InputSource> input,
1872
    std::string const& object_description,
1873
    QPDFTokenizer& tokenizer,
1874
    bool& empty,
1875
    StringDecrypter* decrypter,
1876
    QPDF* context)
1877
0
{
1878
0
    return Parser::parse(*input, object_description, tokenizer, empty, decrypter, context);
1879
0
}
1880
1881
qpdf_offset_t
1882
QPDFObjectHandle::getParsedOffset() const
1883
0
{
1884
0
    return offset();
1885
0
}
1886
1887
QPDFObjectHandle
1888
QPDFObjectHandle::newBool(bool value)
1889
5.39k
{
1890
5.39k
    return {QPDFObject::create<QPDF_Bool>(value)};
1891
5.39k
}
1892
1893
QPDFObjectHandle
1894
QPDFObjectHandle::newNull()
1895
286k
{
1896
286k
    return {QPDFObject::create<QPDF_Null>()};
1897
286k
}
1898
1899
QPDFObjectHandle
1900
QPDFObjectHandle::newReal(std::string const& value)
1901
12.6k
{
1902
12.6k
    return {QPDFObject::create<QPDF_Real>(value)};
1903
12.6k
}
1904
1905
QPDFObjectHandle
1906
QPDFObjectHandle::newReal(double value, int decimal_places, bool trim_trailing_zeroes)
1907
394k
{
1908
394k
    return {QPDFObject::create<QPDF_Real>(value, decimal_places, trim_trailing_zeroes)};
1909
394k
}
1910
1911
QPDFObjectHandle
1912
QPDFObjectHandle::newOperator(std::string const& value)
1913
0
{
1914
0
    return {QPDFObject::create<QPDF_Operator>(value)};
1915
0
}
1916
1917
QPDFObjectHandle
1918
QPDFObjectHandle::newInlineImage(std::string const& value)
1919
0
{
1920
0
    return {QPDFObject::create<QPDF_InlineImage>(value)};
1921
0
}
1922
1923
QPDFObjectHandle
1924
QPDFObjectHandle::newArray()
1925
24.8k
{
1926
24.8k
    return newArray(std::vector<QPDFObjectHandle>());
1927
24.8k
}
1928
1929
QPDFObjectHandle
1930
QPDFObjectHandle::newArray(std::vector<QPDFObjectHandle> const& items)
1931
140k
{
1932
140k
    return {QPDFObject::create<QPDF_Array>(items)};
1933
140k
}
1934
1935
QPDFObjectHandle
1936
QPDFObjectHandle::newArray(Rectangle const& rect)
1937
98.7k
{
1938
98.7k
    return newArray({newReal(rect.llx), newReal(rect.lly), newReal(rect.urx), newReal(rect.ury)});
1939
98.7k
}
1940
1941
QPDFObjectHandle
1942
QPDFObjectHandle::newArray(Matrix const& matrix)
1943
0
{
1944
0
    return newArray(
1945
0
        {newReal(matrix.a),
1946
0
         newReal(matrix.b),
1947
0
         newReal(matrix.c),
1948
0
         newReal(matrix.d),
1949
0
         newReal(matrix.e),
1950
0
         newReal(matrix.f)});
1951
0
}
1952
1953
QPDFObjectHandle
1954
QPDFObjectHandle::newArray(QPDFMatrix const& matrix)
1955
0
{
1956
0
    return newArray(
1957
0
        {newReal(matrix.a),
1958
0
         newReal(matrix.b),
1959
0
         newReal(matrix.c),
1960
0
         newReal(matrix.d),
1961
0
         newReal(matrix.e),
1962
0
         newReal(matrix.f)});
1963
0
}
1964
1965
QPDFObjectHandle
1966
QPDFObjectHandle::newFromRectangle(Rectangle const& rect)
1967
11.5k
{
1968
11.5k
    return newArray(rect);
1969
11.5k
}
1970
1971
QPDFObjectHandle
1972
QPDFObjectHandle::newFromMatrix(Matrix const& m)
1973
0
{
1974
0
    return newArray(m);
1975
0
}
1976
1977
QPDFObjectHandle
1978
QPDFObjectHandle::newFromMatrix(QPDFMatrix const& m)
1979
0
{
1980
0
    return newArray(m);
1981
0
}
1982
1983
QPDFObjectHandle
1984
QPDFObjectHandle::newDictionary()
1985
265k
{
1986
265k
    return newDictionary(std::map<std::string, QPDFObjectHandle>());
1987
265k
}
1988
1989
QPDFObjectHandle
1990
QPDFObjectHandle::newDictionary(std::map<std::string, QPDFObjectHandle> const& items)
1991
265k
{
1992
265k
    return {QPDFObject::create<QPDF_Dictionary>(items)};
1993
265k
}
1994
1995
QPDFObjectHandle
1996
QPDFObjectHandle::newStream(QPDF* qpdf)
1997
9.11k
{
1998
9.11k
    if (qpdf == nullptr) {
1999
0
        throw std::runtime_error("attempt to create stream in null qpdf object");
2000
0
    }
2001
9.11k
    QTC::TC("qpdf", "QPDFObjectHandle newStream");
2002
9.11k
    return qpdf->newStream();
2003
9.11k
}
2004
2005
QPDFObjectHandle
2006
QPDFObjectHandle::newStream(QPDF* qpdf, std::shared_ptr<Buffer> data)
2007
0
{
2008
0
    if (qpdf == nullptr) {
2009
0
        throw std::runtime_error("attempt to create stream in null qpdf object");
2010
0
    }
2011
0
    QTC::TC("qpdf", "QPDFObjectHandle newStream with data");
2012
0
    return qpdf->newStream(data);
2013
0
}
2014
2015
QPDFObjectHandle
2016
QPDFObjectHandle::newStream(QPDF* qpdf, std::string const& data)
2017
0
{
2018
0
    if (qpdf == nullptr) {
2019
0
        throw std::runtime_error("attempt to create stream in null qpdf object");
2020
0
    }
2021
0
    QTC::TC("qpdf", "QPDFObjectHandle newStream with string");
2022
0
    return qpdf->newStream(data);
2023
0
}
2024
2025
QPDFObjectHandle
2026
QPDFObjectHandle::newReserved(QPDF* qpdf)
2027
0
{
2028
0
    if (qpdf == nullptr) {
2029
0
        throw std::runtime_error("attempt to create reserved object in null qpdf object");
2030
0
    }
2031
0
    return qpdf->newReserved();
2032
0
}
2033
2034
std::string
2035
BaseHandle::description() const
2036
1.05M
{
2037
1.05M
    return obj ? obj->getDescription() : ""s;
2038
1.05M
}
2039
2040
void
2041
QPDFObjectHandle::setObjectDescription(QPDF* owning_qpdf, std::string const& object_description)
2042
56.1k
{
2043
56.1k
    if (obj) {
2044
56.1k
        auto descr = std::make_shared<QPDFObject::Description>(object_description);
2045
56.1k
        obj->setDescription(owning_qpdf, descr);
2046
56.1k
    }
2047
56.1k
}
2048
2049
bool
2050
QPDFObjectHandle::hasObjectDescription() const
2051
6.04M
{
2052
6.04M
    return obj && obj->hasDescription();
2053
6.04M
}
2054
2055
QPDFObjectHandle
2056
QPDFObjectHandle::shallowCopy()
2057
68.0k
{
2058
68.0k
    if (!obj) {
2059
0
        throw std::logic_error("operation attempted on uninitialized QPDFObjectHandle");
2060
0
    }
2061
68.0k
    return {copy()};
2062
68.0k
}
2063
2064
QPDFObjectHandle
2065
QPDFObjectHandle::unsafeShallowCopy()
2066
494k
{
2067
494k
    if (!obj) {
2068
0
        throw std::logic_error("operation attempted on uninitialized QPDFObjectHandle");
2069
0
    }
2070
494k
    return {copy(true)};
2071
494k
}
2072
2073
void
2074
QPDFObjectHandle::makeDirect(uint32_t level, QPDFObjGen::set& visited, bool stop_at_streams)
2075
354k
{
2076
354k
    static uint32_t constexpr max_nesting = 500;
2077
354k
    if (++level > max_nesting + 1) {
2078
0
        throw std::runtime_error("QPDFObjectHandle::makeDirect exceeded maximum nesting level");
2079
0
    }
2080
354k
    assertInitialized();
2081
2082
354k
    auto cur_og = getObjGen();
2083
354k
    if (!visited.add(cur_og)) {
2084
256
        throw std::runtime_error("loop detected while converting object from indirect to direct");
2085
256
    }
2086
2087
354k
    if (isBool() || isInteger() || isName() || isNull() || isReal() || isString()) {
2088
275k
        obj = copy(true);
2089
275k
    } else if (auto a = as_array(strict)) {
2090
34.6k
        std::vector<QPDFObjectHandle> items;
2091
243k
        for (auto const& item: a) {
2092
243k
            items.emplace_back(item);
2093
243k
            items.back().makeDirect(level, visited, stop_at_streams);
2094
243k
        }
2095
34.6k
        obj = QPDFObject::create<QPDF_Array>(items);
2096
43.4k
    } else if (isDictionary()) {
2097
43.4k
        std::map<std::string, QPDFObjectHandle> items;
2098
139k
        for (auto const& [key, value]: as_dictionary(strict)) {
2099
139k
            if (!value.null()) {
2100
109k
                items.insert({key, value});
2101
109k
                items[key].makeDirect(level, visited, stop_at_streams);
2102
109k
            }
2103
139k
        }
2104
43.4k
        obj = QPDFObject::create<QPDF_Dictionary>(items);
2105
43.4k
    } else if (isStream()) {
2106
14
        QTC::TC("qpdf", "QPDFObjectHandle copy stream", stop_at_streams ? 0 : 1);
2107
14
        if (!stop_at_streams) {
2108
14
            throw std::runtime_error("attempt to make a stream into a direct object");
2109
14
        }
2110
14
    } else if (isReserved()) {
2111
0
        throw std::logic_error(
2112
0
            "QPDFObjectHandle: attempting to make a reserved object handle direct");
2113
0
    } else {
2114
0
        throw std::logic_error("QPDFObjectHandle::makeDirectInternal: unknown object type");
2115
0
    }
2116
2117
354k
    visited.erase(cur_og);
2118
354k
}
2119
2120
void
2121
QPDFObjectHandle::makeDirect(bool allow_streams)
2122
1.51k
{
2123
1.51k
    QPDFObjGen::set visited;
2124
1.51k
    makeDirect(0, visited, allow_streams);
2125
1.51k
}
2126
2127
void
2128
QPDFObjectHandle::assertInitialized() const
2129
354k
{
2130
354k
    if (!obj) {
2131
0
        throw std::logic_error("operation attempted on uninitialized QPDFObjectHandle");
2132
0
    }
2133
354k
}
2134
2135
std::invalid_argument
2136
BaseHandle::invalid_error(std::string const& method) const
2137
13.0k
{
2138
13.0k
    return std::invalid_argument(method + " operation attempted on invalid object");
2139
13.0k
}
2140
std::runtime_error
2141
BaseHandle::type_error(char const* expected_type) const
2142
322
{
2143
322
    return std::runtime_error(
2144
322
        "operation for "s + expected_type + " attempted on object of type " + type_name());
2145
322
}
2146
2147
QPDFExc
2148
BaseHandle::type_error(char const* expected_type, std::string const& message) const
2149
101k
{
2150
101k
    return {
2151
101k
        qpdf_e_object,
2152
101k
        "",
2153
101k
        description(),
2154
101k
        0,
2155
101k
        "operation for "s + expected_type + " attempted on object of type " + type_name() + ": " +
2156
101k
            message};
2157
101k
}
2158
2159
void
2160
QPDFObjectHandle::typeWarning(char const* expected_type, std::string const& message) const
2161
101k
{
2162
101k
    if (!obj) {
2163
0
        throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHandle");
2164
0
    }
2165
101k
    warn(type_error(expected_type, message));
2166
101k
}
2167
2168
void
2169
QPDFObjectHandle::warnIfPossible(std::string const& warning) const
2170
0
{
2171
0
    warn(warning);
2172
0
}
2173
2174
void
2175
QPDFObjectHandle::objectWarning(std::string const& warning) const
2176
227
{
2177
227
    warn({qpdf_e_object, "", description(), 0, warning});
2178
227
}
2179
2180
void
2181
QPDFObjectHandle::assertType(char const* type_name, bool istype) const
2182
15.4k
{
2183
15.4k
    if (!istype) {
2184
322
        throw type_error(type_name);
2185
322
    }
2186
15.4k
}
2187
2188
void
2189
QPDFObjectHandle::assertNull() const
2190
0
{
2191
0
    assertType("null", isNull());
2192
0
}
2193
2194
void
2195
QPDFObjectHandle::assertBool() const
2196
0
{
2197
0
    assertType("boolean", isBool());
2198
0
}
2199
2200
void
2201
QPDFObjectHandle::assertInteger() const
2202
0
{
2203
0
    assertType("integer", isInteger());
2204
0
}
2205
2206
void
2207
QPDFObjectHandle::assertReal() const
2208
0
{
2209
0
    assertType("real", isReal());
2210
0
}
2211
2212
void
2213
QPDFObjectHandle::assertName() const
2214
0
{
2215
0
    assertType("name", isName());
2216
0
}
2217
2218
void
2219
QPDFObjectHandle::assertString() const
2220
0
{
2221
0
    assertType("string", isString());
2222
0
}
2223
2224
void
2225
QPDFObjectHandle::assertOperator() const
2226
0
{
2227
0
    assertType("operator", isOperator());
2228
0
}
2229
2230
void
2231
QPDFObjectHandle::assertInlineImage() const
2232
0
{
2233
0
    assertType("inlineimage", isInlineImage());
2234
0
}
2235
2236
void
2237
QPDFObjectHandle::assertArray() const
2238
0
{
2239
0
    assertType("array", isArray());
2240
0
}
2241
2242
void
2243
QPDFObjectHandle::assertDictionary() const
2244
0
{
2245
0
    assertType("dictionary", isDictionary());
2246
0
}
2247
2248
void
2249
QPDFObjectHandle::assertStream() const
2250
15.1k
{
2251
15.1k
    assertType("stream", isStream());
2252
15.1k
}
2253
2254
void
2255
QPDFObjectHandle::assertReserved() const
2256
0
{
2257
0
    assertType("reserved", isReserved());
2258
0
}
2259
2260
void
2261
QPDFObjectHandle::assertIndirect() const
2262
0
{
2263
0
    if (!isIndirect()) {
2264
0
        throw std::logic_error("operation for indirect object attempted on direct object");
2265
0
    }
2266
0
}
2267
2268
void
2269
QPDFObjectHandle::assertScalar() const
2270
0
{
2271
0
    assertType("scalar", isScalar());
2272
0
}
2273
2274
void
2275
QPDFObjectHandle::assertNumber() const
2276
0
{
2277
0
    assertType("number", isNumber());
2278
0
}
2279
2280
bool
2281
QPDFObjectHandle::isPageObject() const
2282
0
{
2283
    // See comments in QPDFObjectHandle.hh.
2284
0
    if (!qpdf()) {
2285
0
        return false;
2286
0
    }
2287
    // getAllPages repairs /Type when traversing the page tree.
2288
0
    (void)qpdf()->doc().pages().all();
2289
0
    return isDictionaryOfType("/Page");
2290
0
}
2291
2292
bool
2293
QPDFObjectHandle::isPagesObject() const
2294
0
{
2295
0
    if (!qpdf()) {
2296
0
        return false;
2297
0
    }
2298
    // getAllPages repairs /Type when traversing the page tree.
2299
0
    (void)qpdf()->doc().pages().all();
2300
0
    return isDictionaryOfType("/Pages");
2301
0
}
2302
2303
bool
2304
QPDFObjectHandle::isFormXObject() const
2305
151k
{
2306
151k
    return isStreamOfType("", "/Form");
2307
151k
}
2308
2309
bool
2310
QPDFObjectHandle::isImage(bool exclude_imagemask) const
2311
26.6k
{
2312
26.6k
    return (
2313
26.6k
        isStreamOfType("", "/Image") &&
2314
1.26k
        ((!exclude_imagemask) ||
2315
1.26k
         (!(getDict().getKey("/ImageMask").isBool() &&
2316
335
            getDict().getKey("/ImageMask").getBoolValue()))));
2317
26.6k
}
2318
2319
void
2320
QPDFObjectHandle::assertPageObject() const
2321
0
{
2322
0
    if (!isPageObject()) {
2323
0
        throw std::runtime_error("page operation called on non-Page object");
2324
0
    }
2325
0
}
2326
2327
void
2328
BaseHandle::warn(QPDF* qpdf, QPDFExc&& e)
2329
645
{
2330
645
    if (!qpdf) {
2331
0
        throw std::move(e);
2332
0
    }
2333
645
    qpdf->warn(std::move(e));
2334
645
}
2335
2336
void
2337
BaseHandle::warn(QPDFExc&& e) const
2338
1.24M
{
2339
1.24M
    if (!qpdf()) {
2340
4.43k
        throw std::move(e);
2341
4.43k
    }
2342
1.23M
    qpdf()->warn(std::move(e));
2343
1.23M
}
2344
2345
void
2346
BaseHandle::warn(std::string const& warning) const
2347
1.09M
{
2348
1.09M
    if (qpdf()) {
2349
953k
        warn({qpdf_e_damaged_pdf, "", description(), 0, warning});
2350
953k
    } else {
2351
145k
        *QPDFLogger::defaultLogger()->getError() << warning << "\n";
2352
145k
    }
2353
1.09M
}
2354
2355
QPDFObjectHandle::QPDFDictItems::QPDFDictItems(QPDFObjectHandle const& oh) :
2356
0
    oh(oh)
2357
0
{
2358
0
}
2359
2360
QPDFObjectHandle::QPDFDictItems::iterator&
2361
QPDFObjectHandle::QPDFDictItems::iterator::operator++()
2362
0
{
2363
0
    ++m->iter;
2364
0
    updateIValue();
2365
0
    return *this;
2366
0
}
2367
2368
QPDFObjectHandle::QPDFDictItems::iterator&
2369
QPDFObjectHandle::QPDFDictItems::iterator::operator--()
2370
0
{
2371
0
    --m->iter;
2372
0
    updateIValue();
2373
0
    return *this;
2374
0
}
2375
2376
QPDFObjectHandle::QPDFDictItems::iterator::reference
2377
QPDFObjectHandle::QPDFDictItems::iterator::operator*()
2378
0
{
2379
0
    updateIValue();
2380
0
    return ivalue;
2381
0
}
2382
2383
QPDFObjectHandle::QPDFDictItems::iterator::pointer
2384
QPDFObjectHandle::QPDFDictItems::iterator::operator->()
2385
0
{
2386
0
    updateIValue();
2387
0
    return &ivalue;
2388
0
}
2389
2390
bool
2391
QPDFObjectHandle::QPDFDictItems::iterator::operator==(iterator const& other) const
2392
0
{
2393
0
    if (m->is_end && other.m->is_end) {
2394
0
        return true;
2395
0
    }
2396
0
    if (m->is_end || other.m->is_end) {
2397
0
        return false;
2398
0
    }
2399
0
    return (ivalue.first == other.ivalue.first);
2400
0
}
2401
2402
QPDFObjectHandle::QPDFDictItems::iterator::iterator(QPDFObjectHandle& oh, bool for_begin) :
2403
0
    m(new Members(oh, for_begin))
2404
0
{
2405
0
    updateIValue();
2406
0
}
2407
2408
void
2409
QPDFObjectHandle::QPDFDictItems::iterator::updateIValue()
2410
0
{
2411
0
    m->is_end = (m->iter == m->keys.end());
2412
0
    if (m->is_end) {
2413
0
        ivalue.first = "";
2414
0
        ivalue.second = QPDFObjectHandle();
2415
0
    } else {
2416
0
        ivalue.first = *(m->iter);
2417
0
        ivalue.second = m->oh.getKey(ivalue.first);
2418
0
    }
2419
0
}
2420
2421
QPDFObjectHandle::QPDFDictItems::iterator::Members::Members(QPDFObjectHandle& oh, bool for_begin) :
2422
0
    oh(oh)
2423
0
{
2424
0
    keys = oh.getKeys();
2425
0
    iter = for_begin ? keys.begin() : keys.end();
2426
0
}
2427
2428
QPDFObjectHandle::QPDFDictItems::iterator
2429
QPDFObjectHandle::QPDFDictItems::begin()
2430
0
{
2431
0
    return {oh, true};
2432
0
}
2433
2434
QPDFObjectHandle::QPDFDictItems::iterator
2435
QPDFObjectHandle::QPDFDictItems::end()
2436
0
{
2437
0
    return {oh, false};
2438
0
}
2439
2440
QPDFObjectHandle::QPDFArrayItems::QPDFArrayItems(QPDFObjectHandle const& oh) :
2441
9.08k
    oh(oh)
2442
9.08k
{
2443
9.08k
}
2444
2445
QPDFObjectHandle::QPDFArrayItems::iterator&
2446
QPDFObjectHandle::QPDFArrayItems::iterator::operator++()
2447
653k
{
2448
653k
    if (!m->is_end) {
2449
653k
        ++m->item_number;
2450
653k
        updateIValue();
2451
653k
    }
2452
653k
    return *this;
2453
653k
}
2454
2455
QPDFObjectHandle::QPDFArrayItems::iterator&
2456
QPDFObjectHandle::QPDFArrayItems::iterator::operator--()
2457
0
{
2458
0
    if (m->item_number > 0) {
2459
0
        --m->item_number;
2460
0
        updateIValue();
2461
0
    }
2462
0
    return *this;
2463
0
}
2464
2465
QPDFObjectHandle::QPDFArrayItems::iterator::reference
2466
QPDFObjectHandle::QPDFArrayItems::iterator::operator*()
2467
653k
{
2468
653k
    updateIValue();
2469
653k
    return ivalue;
2470
653k
}
2471
2472
QPDFObjectHandle::QPDFArrayItems::iterator::pointer
2473
QPDFObjectHandle::QPDFArrayItems::iterator::operator->()
2474
0
{
2475
0
    updateIValue();
2476
0
    return &ivalue;
2477
0
}
2478
2479
bool
2480
QPDFObjectHandle::QPDFArrayItems::iterator::operator==(iterator const& other) const
2481
662k
{
2482
662k
    return (m->item_number == other.m->item_number);
2483
662k
}
2484
2485
QPDFObjectHandle::QPDFArrayItems::iterator::iterator(QPDFObjectHandle& oh, bool for_begin) :
2486
18.1k
    m(new Members(oh, for_begin))
2487
18.1k
{
2488
18.1k
    updateIValue();
2489
18.1k
}
2490
2491
void
2492
QPDFObjectHandle::QPDFArrayItems::iterator::updateIValue()
2493
1.32M
{
2494
1.32M
    m->is_end = (m->item_number >= m->oh.getArrayNItems());
2495
1.32M
    if (m->is_end) {
2496
18.1k
        ivalue = QPDFObjectHandle();
2497
1.30M
    } else {
2498
1.30M
        ivalue = m->oh.getArrayItem(m->item_number);
2499
1.30M
    }
2500
1.32M
}
2501
2502
QPDFObjectHandle::QPDFArrayItems::iterator::Members::Members(QPDFObjectHandle& oh, bool for_begin) :
2503
18.1k
    oh(oh)
2504
18.1k
{
2505
18.1k
    item_number = for_begin ? 0 : oh.getArrayNItems();
2506
18.1k
}
2507
2508
QPDFObjectHandle::QPDFArrayItems::iterator
2509
QPDFObjectHandle::QPDFArrayItems::begin()
2510
9.08k
{
2511
9.08k
    return {oh, true};
2512
9.08k
}
2513
2514
QPDFObjectHandle::QPDFArrayItems::iterator
2515
QPDFObjectHandle::QPDFArrayItems::end()
2516
9.08k
{
2517
9.08k
    return {oh, false};
2518
9.08k
}
2519
2520
QPDFObjGen
2521
QPDFObjectHandle::getObjGen() const
2522
67.1M
{
2523
67.1M
    return obj ? obj->getObjGen() : QPDFObjGen();
2524
67.1M
}
2525
2526
int
2527
QPDFObjectHandle::getObjectID() const
2528
27.6M
{
2529
27.6M
    return getObjGen().getObj();
2530
27.6M
}
2531
2532
int
2533
QPDFObjectHandle::getGeneration() const
2534
0
{
2535
0
    return getObjGen().getGen();
2536
0
}
2537
2538
bool
2539
QPDFObjectHandle::isIndirect() const
2540
1.75M
{
2541
1.75M
    return getObjectID() != 0;
2542
1.75M
}
2543
2544
// Indirect object accessors
2545
QPDF*
2546
QPDFObjectHandle::getOwningQPDF() const
2547
2.45M
{
2548
2.45M
    return obj ? obj->getQPDF() : nullptr;
2549
2.45M
}
2550
2551
QPDF&
2552
QPDFObjectHandle::getQPDF(std::string const& error_msg) const
2553
9.11k
{
2554
9.11k
    if (auto result = obj ? obj->getQPDF() : nullptr) {
2555
9.11k
        return *result;
2556
9.11k
    }
2557
0
    throw std::runtime_error(error_msg.empty() ? "attempt to use a null qpdf object" : error_msg);
2558
9.11k
}
2559
2560
void
2561
QPDFObjectHandle::setParsedOffset(qpdf_offset_t offset)
2562
487
{
2563
487
    if (obj) {
2564
487
        obj->setParsedOffset(offset);
2565
487
    }
2566
487
}
2567
2568
QPDFObjectHandle
2569
operator""_qpdf(char const* v, size_t len)
2570
0
{
2571
0
    return QPDFObjectHandle::parse(std::string(v, len), "QPDFObjectHandle literal");
2572
0
}