Coverage Report

Created: 2025-06-24 07:01

/src/ghostpdl/pdf/pdf_array.c
Line
Count
Source (jump to first uncovered line)
1
/* Copyright (C) 2018-2025 Artifex Software, Inc.
2
   All Rights Reserved.
3
4
   This software is provided AS-IS with no warranty, either express or
5
   implied.
6
7
   This software is distributed under license and may not be copied,
8
   modified or distributed except as expressly authorized under the terms
9
   of the license contained in the file LICENSE in this distribution.
10
11
   Refer to licensing information at http://www.artifex.com or contact
12
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
13
   CA 94129, USA, for further information.
14
*/
15
16
/* array handling for the PDF interpreter */
17
18
#include "ghostpdf.h"
19
#include "pdf_types.h"
20
#include "pdf_stack.h"
21
#include "pdf_deref.h"
22
#include "pdf_array.h"
23
#include "pdf_loop_detect.h"
24
25
/* NOTE: I think this should take a pdf_context param, but it's not available where it's
26
 * called, would require some surgery.
27
 */
28
void pdfi_free_array(pdf_obj *o)
29
14.8M
{
30
14.8M
    pdf_array *a = (pdf_array *)o;
31
14.8M
    int i;
32
33
165M
    for (i=0;i < a->size;i++) {
34
150M
        if (a->values[i] != NULL)
35
150M
            pdfi_countdown(a->values[i]);
36
150M
    }
37
14.8M
    gs_free_object(OBJ_MEMORY(a), a->values, "pdf interpreter free array contents");
38
14.8M
    gs_free_object(OBJ_MEMORY(a), a, "pdf interpreter free array");
39
14.8M
}
40
41
int pdfi_array_alloc(pdf_context *ctx, uint64_t size, pdf_array **a)
42
14.7M
{
43
14.7M
    int code, i;
44
45
14.7M
    *a = NULL;
46
14.7M
    code = pdfi_object_alloc(ctx, PDF_ARRAY, size, (pdf_obj **)a);
47
14.7M
    if (code < 0)
48
0
        return code;
49
50
14.7M
    (*a)->size = size;
51
52
14.7M
    if (size > 0) {
53
        /* Start all the array entries pointing to null.
54
         * array_put will replace tehm. This ensures we always have a valid
55
         * object for every entry. pdfi_array_from_stack() doesn't do this
56
         * initialisation because we know how many obejcts there are in the array
57
         * and we have valid objects for each entry on the stack already created.
58
         */
59
161M
        for (i=0;i<size;i++){
60
147M
            (*a)->values[i] = PDF_NULL_OBJ;
61
147M
        }
62
13.8M
    }
63
14.7M
    return 0;
64
14.7M
}
65
66
/* This was defined in pdf_int.c until we moved the equivalent pdfi_dict_from_stack() into
67
 * pdf_dict.c, because we needed to be able to create dictionaries for images. We don't have
68
 * that need, but its less confusing to have the array_from_stack function defined in
69
 * here, similarly to the dictionary routine.
70
 */
71
int pdfi_array_from_stack(pdf_context *ctx, uint32_t indirect_num, uint32_t indirect_gen)
72
14.8M
{
73
14.8M
    uint64_t index = 0;
74
14.8M
    pdf_array *a = NULL;
75
14.8M
    pdf_obj *o;
76
14.8M
    int code;
77
78
14.8M
    code = pdfi_count_to_mark(ctx, &index);
79
14.8M
    if (code < 0)
80
242k
        return code;
81
82
14.5M
    code = pdfi_array_alloc(ctx, index, &a);
83
14.5M
    if (code < 0)
84
0
        return code;
85
86
122M
    while (index) {
87
107M
        o = ctx->stack_top[-1];
88
107M
        code = pdfi_array_put(ctx, a, --index, o);
89
107M
        if (code < 0) {
90
0
            (void)pdfi_clear_to_mark(ctx);
91
0
            return code;
92
0
        }
93
107M
        pdfi_pop(ctx, 1);
94
107M
    }
95
96
14.5M
    code = pdfi_clear_to_mark(ctx);
97
14.5M
    if (code < 0)
98
0
        return code;
99
100
14.5M
    if (ctx->args.pdfdebug)
101
0
        outprintf (ctx->memory, " ]\n");
102
103
14.5M
    a->indirect_num = indirect_num;
104
14.5M
    a->indirect_gen = indirect_gen;
105
106
14.5M
    code = pdfi_push(ctx, (pdf_obj *)a);
107
14.5M
    if (code < 0)
108
0
        pdfi_free_array((pdf_obj *)a);
109
110
14.5M
    return code;
111
14.5M
}
112
113
int pdfi_array_fetch_recursing(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o, bool setref, bool cache)
114
709k
{
115
709k
    int code;
116
709k
    pdf_obj *obj;
117
118
709k
    *o = NULL;
119
120
709k
    if (pdfi_type_of(a) != PDF_ARRAY)
121
0
        return_error(gs_error_typecheck);
122
123
709k
    if (index >= a->size)
124
0
        return_error(gs_error_rangecheck);
125
709k
    obj = a->values[index];
126
127
709k
    if (pdfi_type_of(obj) == PDF_INDIRECT) {
128
1.62k
        pdf_obj *o1 = NULL;
129
1.62k
        pdf_indirect_ref *r = (pdf_indirect_ref *)obj;
130
131
1.62k
        if (r->ref_object_num == a->object_num)
132
9
            return_error(gs_error_circular_reference);
133
134
1.62k
        if (cache)
135
1.62k
            code = pdfi_deref_loop_detect(ctx, r->ref_object_num, r->ref_generation_num, &o1);
136
0
        else
137
0
            code = pdfi_deref_loop_detect_nocache(ctx, r->ref_object_num, r->ref_generation_num, &o1);
138
1.62k
        if (code < 0)
139
295
            return code;
140
141
1.32k
        if (setref)
142
1.32k
            (void)pdfi_array_put(ctx, a, index, o1);
143
1.32k
        obj = o1;
144
707k
    } else {
145
707k
        if (ctx->loop_detection != NULL && (uintptr_t)obj > TOKEN__LAST_KEY && obj->object_num != 0)
146
742
            if (pdfi_loop_detector_check_object(ctx, obj->object_num))
147
0
                return gs_note_error(gs_error_circular_reference);
148
707k
        pdfi_countup(obj);
149
707k
    }
150
151
709k
    *o = obj;
152
709k
    return 0;
153
709k
}
154
155
/* Fetch object from array, resolving indirect reference if needed
156
 * setref -- indicates whether to replace indirect ref with the object
157
 */
158
int pdfi_array_fetch(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o, bool setref, bool cache)
159
346M
{
160
346M
    int code;
161
346M
    pdf_obj *obj;
162
163
346M
    *o = NULL;
164
165
346M
    if (pdfi_type_of(a) != PDF_ARRAY)
166
20
        return_error(gs_error_typecheck);
167
168
346M
    if (index >= a->size)
169
7.62k
        return_error(gs_error_rangecheck);
170
346M
    obj = a->values[index];
171
172
346M
    if (pdfi_type_of(obj) == PDF_INDIRECT) {
173
1.00M
        pdf_obj *o1 = NULL;
174
1.00M
        pdf_indirect_ref *r = (pdf_indirect_ref *)obj;
175
176
1.00M
        if (r->ref_object_num == a->object_num)
177
153
            return_error(gs_error_circular_reference);
178
179
1.00M
        if (cache)
180
964k
            code = pdfi_deref_loop_detect(ctx, r->ref_object_num, r->ref_generation_num, &o1);
181
41.9k
        else
182
41.9k
            code = pdfi_deref_loop_detect_nocache(ctx, r->ref_object_num, r->ref_generation_num, &o1);
183
1.00M
        if (code < 0)
184
437k
            return code;
185
186
568k
        if (setref)
187
563k
            (void)pdfi_array_put(ctx, a, index, o1);
188
568k
        obj = o1;
189
345M
    } else {
190
345M
        pdfi_countup(obj);
191
345M
    }
192
193
345M
    *o = obj;
194
345M
    return 0;
195
346M
}
196
197
/* Get element from array without resolving PDF_INDIRECT dereferences.
198
 * It looks to me like some usages need to do the checking themselves to
199
 * avoid circular references?  Can remove this if not really needed.
200
 */
201
int pdfi_array_get_no_deref(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o)
202
776k
{
203
776k
    if (pdfi_type_of(a) != PDF_ARRAY)
204
0
        return_error(gs_error_typecheck);
205
206
776k
    if (index >= a->size)
207
0
        return_error(gs_error_rangecheck);
208
209
776k
    *o = a->values[index];
210
776k
    pdfi_countup(*o);
211
776k
    return 0;
212
776k
}
213
214
/* Same as pdfi_array_get() but doesn't replace indirect ref with a new object.
215
 */
216
int pdfi_array_get_no_store_R(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o)
217
677k
{
218
677k
    int code;
219
220
677k
    code = pdfi_array_fetch(ctx, a, index, o, false, false);
221
677k
    if (code < 0) return code;
222
223
674k
    return 0;
224
677k
}
225
226
/* Get value from pdfi_array.
227
 * Handles type-checking and resolving indirect references.
228
 */
229
int pdfi_array_get_type(pdf_context *ctx, pdf_array *a, uint64_t index,
230
                    pdf_obj_type type, pdf_obj **o)
231
96.0M
{
232
96.0M
    int code;
233
234
96.0M
    code = pdfi_array_get(ctx, a, index, o);
235
96.0M
    if (code < 0)
236
218k
        return code;
237
238
95.7M
    if (pdfi_type_of(*o) != type) {
239
21.3k
        pdfi_countdown(*o);
240
21.3k
        *o = NULL;
241
21.3k
        return_error(gs_error_typecheck);
242
21.3k
    }
243
95.7M
    return 0;
244
95.7M
}
245
246
int pdfi_array_get_int(pdf_context *ctx, pdf_array *a, uint64_t index, int64_t *i)
247
77.0k
{
248
77.0k
    int code;
249
77.0k
    pdf_obj *n;
250
251
77.0k
    code = pdfi_array_get(ctx, a, index, &n);
252
77.0k
    if (code < 0)
253
64
        return code;
254
77.0k
    code = pdfi_obj_to_int(ctx, n, i);
255
77.0k
    pdfi_countdown(n);
256
77.0k
    return code;
257
77.0k
}
258
259
int pdfi_array_get_number(pdf_context *ctx, pdf_array *a, uint64_t index, double *d)
260
19.7M
{
261
19.7M
    int code;
262
19.7M
    pdf_obj *n;
263
264
19.7M
    code = pdfi_array_get(ctx, a, index, &n);
265
19.7M
    if (code < 0)
266
63
        return code;
267
268
19.7M
    code = pdfi_obj_to_real(ctx, n, d);
269
19.7M
    pdfi_countdown(n);
270
271
19.7M
    return code;
272
19.7M
}
273
274
/* Check whether a particular object is in an array.
275
 * If index is not NULL, fill it in with the index of the object.
276
 * Note that this will resolve indirect references if needed.
277
 */
278
bool pdfi_array_known(pdf_context *ctx, pdf_array *a, pdf_obj *o, int *index)
279
64.0k
{
280
64.0k
    int i;
281
282
64.0k
    if (pdfi_type_of(a) != PDF_ARRAY)
283
0
        return_error(gs_error_typecheck);
284
285
28.5M
    for (i=0; i < a->size; i++) {
286
28.5M
        pdf_obj *val;
287
28.5M
        int code;
288
289
28.5M
        code = pdfi_array_fetch(ctx, a, i, &val, true, true);
290
28.5M
        if (code < 0)
291
195k
            continue;
292
28.3M
        if (pdf_object_num(val) == pdf_object_num(o)) {
293
61.9k
            if (index != NULL) *index = i;
294
61.9k
            pdfi_countdown(val);
295
61.9k
            return true;
296
61.9k
        }
297
28.2M
        pdfi_countdown(val);
298
28.2M
    }
299
2.14k
    return false;
300
64.0k
}
301
302
int pdfi_array_put(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj *o)
303
152M
{
304
152M
    if (pdfi_type_of(a) != PDF_ARRAY)
305
0
        return_error(gs_error_typecheck);
306
307
152M
    if (index >= a->size)
308
0
        return_error(gs_error_rangecheck);
309
310
152M
    pdfi_countdown(a->values[index]);
311
152M
    a->values[index] = o;
312
152M
    pdfi_countup(o);
313
152M
    return 0;
314
152M
}
315
316
int pdfi_array_put_int(pdf_context *ctx, pdf_array *a, uint64_t index, int64_t val)
317
9
{
318
9
    int code;
319
9
    pdf_num *obj;
320
321
9
    if (pdfi_type_of(a) != PDF_ARRAY)
322
0
        return_error(gs_error_typecheck);
323
324
9
    code = pdfi_object_alloc(ctx, PDF_INT, 0, (pdf_obj **)&obj);
325
9
    if (code < 0)
326
0
        return code;
327
9
    obj->value.i = val;
328
329
9
    return pdfi_array_put(ctx, a, index, (pdf_obj *)obj);
330
9
}
331
332
int pdfi_array_put_real(pdf_context *ctx, pdf_array *a, uint64_t index, double val)
333
3.93k
{
334
3.93k
    int code;
335
3.93k
    pdf_num *obj;
336
337
3.93k
    if (pdfi_type_of(a) != PDF_ARRAY)
338
0
        return_error(gs_error_typecheck);
339
340
3.93k
    code = pdfi_object_alloc(ctx, PDF_REAL, 0, (pdf_obj **)&obj);
341
3.93k
    if (code < 0)
342
0
        return code;
343
3.93k
    obj->value.d = val;
344
345
3.93k
    return pdfi_array_put(ctx, a, index, (pdf_obj *)obj);
346
3.93k
}
347
348
/* Strictly speaking the normalize_rect isn't really part of the PDF array
349
 * processing, but its very likely that any time we want to use it, the
350
 * rectangle will have come from a PDF array in a PDF file so it makes
351
 * sense to have it here.
352
 */
353
354
/* Normalize rectangle */
355
void pdfi_normalize_rect(pdf_context *ctx, gs_rect *rect)
356
256k
{
357
256k
    double temp;
358
359
    /* Normalize the rectangle */
360
256k
    if (rect->p.x > rect->q.x) {
361
1.77k
        temp = rect->p.x;
362
1.77k
        rect->p.x = rect->q.x;
363
1.77k
        rect->q.x = temp;
364
1.77k
    }
365
256k
    if (rect->p.y > rect->q.y) {
366
243
        temp = rect->p.y;
367
243
        rect->p.y = rect->q.y;
368
243
        rect->q.y = temp;
369
243
    }
370
256k
}
371
372
/*
373
 * Turn an Array into a gs_rect.  If Array is NULL, makes a tiny rect
374
 */
375
int pdfi_array_to_gs_rect(pdf_context *ctx, pdf_array *array, gs_rect *rect)
376
614k
{
377
614k
    double number;
378
614k
    int code = 0;
379
380
    /* Init to tiny rect to allow sane continuation on errors */
381
614k
    rect->p.x = 0.0;
382
614k
    rect->p.y = 0.0;
383
614k
    rect->q.x = 1.0;
384
614k
    rect->q.y = 1.0;
385
386
    /* Identity matrix if no array */
387
614k
    if (array == NULL || pdfi_type_of(array) != PDF_ARRAY) {
388
3.67k
        return 0;
389
3.67k
    }
390
611k
    if (pdfi_array_size(array) != 4) {
391
458
        return_error(gs_error_rangecheck);
392
458
    }
393
610k
    code = pdfi_array_get_number(ctx, array, 0, &number);
394
610k
    if (code < 0) goto errorExit;
395
610k
    rect->p.x = (float)number;
396
610k
    code = pdfi_array_get_number(ctx, array, 1, &number);
397
610k
    if (code < 0) goto errorExit;
398
610k
    rect->p.y = (float)number;
399
610k
    code = pdfi_array_get_number(ctx, array, 2, &number);
400
610k
    if (code < 0) goto errorExit;
401
610k
    rect->q.x = (float)number;
402
610k
    code = pdfi_array_get_number(ctx, array, 3, &number);
403
610k
    if (code < 0) goto errorExit;
404
610k
    rect->q.y = (float)number;
405
406
610k
    return 0;
407
408
86
 errorExit:
409
86
    return code;
410
610k
}
411
412
/* Create a new PDF array object with 4 entires, and store the values from a
413
 * gs_rect to it.
414
 */
415
int pdfi_gs_rect_to_array(pdf_context *ctx, gs_rect *rect, pdf_array **new_array)
416
2.24k
{
417
2.24k
    pdf_num *num = NULL;
418
2.24k
    int code = 0;
419
420
2.24k
    code = pdfi_array_alloc(ctx, 4, new_array);
421
2.24k
    if (code < 0)
422
0
        return code;
423
424
2.24k
    pdfi_countup(*new_array);
425
426
2.24k
    code = pdfi_num_alloc(ctx, rect->p.x, &num);
427
2.24k
    if (code < 0)
428
0
        goto error;
429
430
2.24k
    code = pdfi_array_put(ctx, *new_array, 0, (pdf_obj *)num);
431
2.24k
    if (code < 0)
432
0
        goto error;
433
434
2.24k
    code = pdfi_num_alloc(ctx, rect->p.y, &num);
435
2.24k
    if (code < 0)
436
0
        goto error;
437
438
2.24k
    code = pdfi_array_put(ctx, *new_array, 1, (pdf_obj *)num);
439
2.24k
    if (code < 0)
440
0
        goto error;
441
442
2.24k
    code = pdfi_num_alloc(ctx, rect->q.x, &num);
443
2.24k
    if (code < 0)
444
0
        goto error;
445
446
2.24k
    code = pdfi_array_put(ctx, *new_array, 2, (pdf_obj *)num);
447
2.24k
    if (code < 0)
448
0
        goto error;
449
450
2.24k
    code = pdfi_num_alloc(ctx, rect->q.y, &num);
451
2.24k
    if (code < 0)
452
0
        goto error;
453
454
2.24k
    code = pdfi_array_put(ctx, *new_array, 3, (pdf_obj *)num);
455
2.24k
    if (code < 0)
456
0
        goto error;
457
458
2.24k
    return 0;
459
460
0
error:
461
0
    pdfi_countdown(new_array);
462
0
    return code;
463
2.24k
}
464
465
/* Turn a /Matrix Array into a gs_matrix.  If Array is NULL, makes an identity matrix */
466
int pdfi_array_to_gs_matrix(pdf_context *ctx, pdf_array *array, gs_matrix *mat)
467
376k
{
468
376k
    double number;
469
376k
    int code = 0;
470
471
    /* Init to identity matrix to allow sane continuation on errors */
472
376k
    mat->xx = 1.0;
473
376k
    mat->xy = 0.0;
474
376k
    mat->yx = 0.0;
475
376k
    mat->yy = 1.0;
476
376k
    mat->tx = 0.0;
477
376k
    mat->ty = 0.0;
478
479
    /* Identity matrix if no array */
480
376k
    if (array == NULL || pdfi_type_of(array) != PDF_ARRAY) {
481
224k
        return 0;
482
224k
    }
483
151k
    if (pdfi_array_size(array) != 6) {
484
190
        return_error(gs_error_rangecheck);
485
190
    }
486
151k
    code = pdfi_array_get_number(ctx, array, 0, &number);
487
151k
    if (code < 0) goto errorExit;
488
151k
    mat->xx = (float)number;
489
151k
    code = pdfi_array_get_number(ctx, array, 1, &number);
490
151k
    if (code < 0) goto errorExit;
491
151k
    mat->xy = (float)number;
492
151k
    code = pdfi_array_get_number(ctx, array, 2, &number);
493
151k
    if (code < 0) goto errorExit;
494
151k
    mat->yx = (float)number;
495
151k
    code = pdfi_array_get_number(ctx, array, 3, &number);
496
151k
    if (code < 0) goto errorExit;
497
151k
    mat->yy = (float)number;
498
151k
    code = pdfi_array_get_number(ctx, array, 4, &number);
499
151k
    if (code < 0) goto errorExit;
500
151k
    mat->tx = (float)number;
501
151k
    code = pdfi_array_get_number(ctx, array, 5, &number);
502
151k
    if (code < 0) goto errorExit;
503
151k
    mat->ty = (float)number;
504
151k
    return 0;
505
506
33
 errorExit:
507
33
    return code;
508
151k
}
509
510
/* Turn a pdf_array into a double array of specified size */
511
int pdfi_array_to_num_array(pdf_context *ctx, pdf_array *array, double *out, int offset, int size)
512
19.6k
{
513
19.6k
    int i;
514
19.6k
    int code;
515
19.6k
    double num;
516
517
142k
    for (i=0; i<size; i++) {
518
122k
        code = pdfi_array_get_number(ctx, array, offset+i, &num);
519
122k
        if (code < 0)
520
101
            return code;
521
122k
        out[i] = num;
522
122k
    }
523
19.5k
    return 0;
524
19.6k
}
525
526
/* Transform a BBox by a matrix (from zmatrix.c/zbbox_transform())*/
527
void
528
pdfi_bbox_transform(pdf_context *ctx, gs_rect *bbox, gs_matrix *matrix)
529
131k
{
530
131k
    gs_point aa, az, za, zz;
531
131k
    double temp;
532
533
131k
    gs_point_transform(bbox->p.x, bbox->p.y, matrix, &aa);
534
131k
    gs_point_transform(bbox->p.x, bbox->q.y, matrix, &az);
535
131k
    gs_point_transform(bbox->q.x, bbox->p.y, matrix, &za);
536
131k
    gs_point_transform(bbox->q.x, bbox->q.y, matrix, &zz);
537
538
131k
    if ( aa.x > az.x)
539
1.52k
        temp = aa.x, aa.x = az.x, az.x = temp;
540
131k
    if ( za.x > zz.x)
541
1.52k
        temp = za.x, za.x = zz.x, zz.x = temp;
542
131k
    if ( za.x < aa.x)
543
69
        aa.x = za.x;  /* min */
544
131k
    if ( az.x > zz.x)
545
69
        zz.x = az.x;  /* max */
546
547
131k
    if ( aa.y > az.y)
548
3.25k
        temp = aa.y, aa.y = az.y, az.y = temp;
549
131k
    if ( za.y > zz.y)
550
3.25k
        temp = za.y, za.y = zz.y, zz.y = temp;
551
131k
    if ( za.y < aa.y)
552
73
        aa.y = za.y;  /* min */
553
131k
    if ( az.y > zz.y)
554
73
        zz.y = az.y;  /* max */
555
556
131k
    bbox->p.x = aa.x;
557
131k
    bbox->p.y = aa.y;
558
131k
    bbox->q.x = zz.x;
559
131k
    bbox->q.y = zz.y;
560
131k
}