API2/Basic/PDF/File.pm

filter: Statementstmt 75.9% 553 / 728 Branchbran 60.3% 222 / 368 Conditioncond 45.5% 41 / 90 MC/DCmcdc 23.6% 13 / 55 Subroutinesub 93.7% 45 / 48 Podpod 100% 27 / 27 totaltotal 68.4% 901 / 1316 SCAR 75.3
CC
232
Cov
69%
copy
210.0
out_trailer
117.6
readval
112.1
CRAP 1866.3
« API2/Resource/Font/SynFont.pm ↑ Summary API2/Resource/Font/BdFont.pm »
1 # Code in the PDF::API2::Basic::PDF namespace was originally copied from the
2 # Text::PDF distribution.
3 #
4 # Copyright Martin Hosken <Martin_Hosken@sil.org>
5 #
6 # Martin Hosken's code may be used under the terms of the MIT license.
7 # Subsequent versions of the code have the same license as PDF::API2.
8  
9 package PDF::API2::Basic::PDF::File;
10  
11 39 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
12  
13 39 our $VERSION = '2.044'; # VERSION
14  
15 =head1 NAME
16  
17 PDF::API2::Basic::PDF::File - Low-level PDF file access
18  
19 =head1 SYNOPSIS
20  
21 $p = PDF::API2::Basic::PDF::File->open("filename.pdf", 1);
22 $p->new_obj($obj_ref);
23 $p->free_obj($obj_ref);
24 $p->append_file;
25 $p->close_file;
26 $p->release; # IMPORTANT!
27  
28 =head1 DESCRIPTION
29  
30 This class keeps track of the directory aspects of a PDF file. There are two
31 parts to the directory: the main directory object which is the parent to all
32 other objects and a chain of cross-reference tables and corresponding trailer
33 dictionaries starting with the main directory object.
34  
35 =head1 INSTANCE VARIABLES
36  
37 Within this class hierarchy, rather than making everything visible via methods,
38 which would be a lot of work, there are various instance variables which are
39 accessible via associative array referencing. To distinguish instance variables
40 from content variables (which may come from the PDF content itself), each such
41 variable will start with a space.
42  
43 Variables which do not start with a space directly reflect elements in a PDF
44 dictionary. In the case of a PDF::API2::Basic::PDF::File, the elements reflect those in the
45 trailer dictionary.
46  
47 Since some variables are not designed for class users to access, variables are
48 marked in the documentation with (R) to indicate that such an entry should only
49 be used as read-only information. (P) indicates that the information is private
50 and not designed for user use at all, but is included in the documentation for
51 completeness and to ensure that nobody else tries to use it.
52  
53 =over
54  
55 =item newroot
56  
57 This variable allows the user to create a new root entry to occur in the trailer
58 dictionary which is output when the file is written or appended. If you wish to
59 over-ride the root element in the dictionary you have, use this entry to indicate
60 that without losing the current Root entry. Notice that newroot should point to
61 a PDF level object and not just to a dictionary which does not have object status.
62  
63 =item INFILE (R)
64  
65 Contains the filehandle used to read this information into this PDF directory. Is
66 an IO object.
67  
68 =item fname (R)
69  
70 This is the filename which is reflected by INFILE, or the original IO object passed
71 in.
72  
73 =item update (R)
74  
75 This indicates that the read file has been opened for update and that at some
76 point, $p->appendfile() can be called to update the file with the changes that
77 have been made to the memory representation.
78  
79 =item maxobj (R)
80  
81 Contains the first usable object number above any that have already appeared
82 in the file so far.
83  
84 =item outlist (P)
85  
86 This is a list of Objind which are to be output when the next appendfile or outfile
87 occurs.
88  
89 =item firstfree (P)
90  
91 Contains the first free object in the free object list. Free objects are removed
92 from the front of the list and added to the end.
93  
94 =item lastfree (P)
95  
96 Contains the last free object in the free list. It may be the same as the firstfree
97 if there is only one free object.
98  
99 =item objcache (P)
100  
101 All objects are held in the cache to ensure that a system only has one occurrence of
102 each object. In effect, the objind class acts as a container type class to hold the
103 PDF object structure and it would be unfortunate if there were two identical
104 place-holders floating around a system.
105  
106 =item epos (P)
107  
108 The end location of the read-file.
109  
110 =back
111  
112 Each trailer dictionary contains a number of private instance variables which
113 hold the chain together.
114  
115 =over
116  
117 =item loc (P)
118  
119 Contains the location of the start of the cross-reference table preceding the
120 trailer.
121  
122 =item xref (P)
123  
124 Contains an anonymous array of each cross-reference table entry.
125  
126 =item prev (P)
127  
128 A reference to the previous table. Note this differs from the Prev entry which
129 is in PDF which contains the location of the previous cross-reference table.
130  
131 =back
132  
133 =head1 METHODS
134  
135 =cut
136  
137 39 ▶use Scalar::Util qw(blessed weaken);
Subroutine BEGIN: called CC=1 SCAR=0.0
138  
139 39 ▶use vars qw($cr $irreg_char $reg_char $ws_char $delim_char %types);
Subroutine BEGIN: called CC=1 SCAR=0.0
140  
141 39 $ws_char = '[ \t\r\n\f\0]';
142 39 $delim_char = '[][<>{}()/%]';
143 39 $reg_char = '[^][<>{}()/% \t\r\n\f\0]';
144 39 $irreg_char = '[][<>{}()/% \t\r\n\f\0]';
145 39 $cr = '\s*(?:\015|\012|(?:\015\012))';
146  
147 39 my $re_comment = qr/(?:\%[^\r\n]*)/;
148 39 my $re_whitespace = qr/(?:[ \t\r\n\f\0]|$re_comment)/;
149  
150 39 %types = (
151 'Page' => 'PDF::API2::Basic::PDF::Page',
152 'Pages' => 'PDF::API2::Basic::PDF::Pages',
153 );
154  
155 39 my $readDebug = 0;
156  
157 39 ▶use Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
158 39 ▶use IO::File;
Subroutine BEGIN: called CC=1 SCAR=0.0
159  
160 # Now for the basic PDF types
161 39 ▶use PDF::API2::Basic::PDF::Utils;
Subroutine BEGIN: called CC=1 SCAR=0.0
162  
163 39 ▶use PDF::API2::Basic::PDF::Array;
Subroutine BEGIN: called CC=1 SCAR=0.0
164 39 ▶use PDF::API2::Basic::PDF::Bool;
Subroutine BEGIN: called CC=1 SCAR=0.0
165 39 ▶use PDF::API2::Basic::PDF::Dict;
Subroutine BEGIN: called CC=1 SCAR=0.0
166 39 ▶use PDF::API2::Basic::PDF::Name;
Subroutine BEGIN: called CC=1 SCAR=0.0
167 39 ▶use PDF::API2::Basic::PDF::Number;
Subroutine BEGIN: called CC=1 SCAR=0.0
168 39 ▶use PDF::API2::Basic::PDF::Objind;
Subroutine BEGIN: called CC=1 SCAR=0.0
169 39 ▶use PDF::API2::Basic::PDF::String;
Subroutine BEGIN: called CC=1 SCAR=0.0
170 39 ▶use PDF::API2::Basic::PDF::Page;
Subroutine BEGIN: called CC=1 SCAR=0.0
171 39 ▶use PDF::API2::Basic::PDF::Pages;
Subroutine BEGIN: called CC=1 SCAR=0.0
172 39 ▶use PDF::API2::Basic::PDF::Null;
Subroutine BEGIN: called CC=1 SCAR=0.0
173 39 ▶use POSIX qw(ceil floor);
Subroutine BEGIN: called CC=1 SCAR=0.0
174  
175 39 ▶no warnings qw[ deprecated recursion uninitialized ];
Subroutine BEGIN: called CC=1 SCAR=0.0
176  
177  
178 =head2 PDF::API2::Basic::PDF::File->new
179  
180 Creates a new, empty file object which can act as the host to other PDF objects.
181 Since there is no file associated with this object, it is assumed that the
182 object is created in readiness for creating a new PDF file.
183  
184 =cut
185  
186 sub new {
187 164 ▶ my ($class, $root) = @_;
Subroutine new: called CC=2 SCAR=7.0
Pod documented
188 164 my $self = $class->_new();
189  
190 164 ▶ unless ($root) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($root) 164 0 164
191 164 $root = PDFDict();
192 164 $root->{'Type'} = PDFName('Catalog');
193 }
194 164 $self->new_obj($root);
195 164 $self->{'Root'} = $root;
196 164 return $self;
197 }
198  
199  
200 =head2 $p = PDF::API2::Basic::PDF::File->open($filename, $update)
201  
202 Opens the file and reads all the trailers and cross reference tables to build
203 a complete directory of objects.
204  
205 $update specifies whether this file is being opened for updating and editing,
206 or simply to be read.
207  
208 $filename may be an IO object
209  
210 =cut
211  
212 sub open {
213 16 ▶ my ($class, $filename, $update) = @_;
Subroutine open: called CC=15 SCAR=28.0
Pod documented
214 16 my ($fh, $buffer);
215  
216 16 my $self = $class->_new();
217 16 ▶ if (ref $filename) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $filename) { } 8 8 16
218 8 $self->{' INFILE'} = $filename;
219 8 ▶ if ($update) {
Branch: 1 branch
BranchTrueFalseTotal
if ($update) 8 0 8
220 8 $self->{' update'} = 1;
221 8 $self->{' OUTFILE'} = $filename;
222 }
223 8 $fh = $filename;
224 }
225 else {
226 8 ▶ die "File '$filename' does not exist" unless -f $filename;
Branch: 1 branch
BranchTrueFalseTotal
unless -f $filename 0 8 8
227 8 ▶ die "File '$filename' is not readable" unless -r $filename;
Branch: 1 branch
BranchTrueFalseTotal
unless -r $filename 0 8 8
228 8 ▶ if ($update) {
Branch: 1 branch
BranchTrueFalseTotal
if ($update) 8 0 8
229 8 ▶ die "File '$filename' is not writable" unless -w $filename;
Branch: 1 branch
BranchTrueFalseTotal
unless -w $filename 0 8 8
230 }
231 8 ▶ $fh = IO::File->new(($update ? '+' : '') . "<$filename")
Branch: 1 branch
BranchTrueFalseTotal
$update ? : 8 0 8
Condition50%1/2
'IO::File'->new(($update ? '+' : '') . "<$filename") || die("Error opening '${filename}': $!")
l!l
80
MC/DC0%0/1
'IO::File'->new(($update ? '+' : '') . "<$filename") || die("Error opening '${filename}': $!")
'IO::File'->new(($update ? '+' : '') . "<$filename")
Truth table50%1/2
A
A= 'IO::File'->new(($update ? '+' : '') . "<$filename")
Aresult
11
00
232 || die "Error opening '$filename': $!";
233 8 $self->{' INFILE'} = $fh;
234 8 ▶ if ($update) {
Branch: 1 branch
BranchTrueFalseTotal
if ($update) 8 0 8
235 8 $self->{' update'} = 1;
236 8 $self->{' OUTFILE'} = $fh;
237 8 $self->{' fname'} = $filename;
238 }
239 }
240 16 binmode $fh, ':raw';
241 16 $fh->seek(0, 0); # go to start of file
242 16 $fh->read($buffer, 255);
243 16 ▶ unless ($buffer =~ /^\%PDF\-([12]\.\d+)\s*$cr/m) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($buffer =~ /^\%PDF\-([12]\.\d+)\s*$PDF::API2::Basic::PDF::File::cr/m) 0 16 16
244 0 croak "$filename does not appear to be a valid PDF";
245 }
246 16 $self->{' version'} = $1;
247  
248 16 $fh->seek(0, 2); # go to end of file
249 16 my $end = $fh->tell();
250 16 $self->{' epos'} = $end;
251 16 foreach my $offset (1..64) {
252 32 $fh->seek($end - 16 * $offset, 0);
253 32 $fh->read($buffer, 16 * $offset);
254 32 ▶ last if $buffer =~ m/startxref($cr|\s*)\d+($cr|\s*)\%\%eof.*?/i;
Branch: 1 branch
BranchTrueFalseTotal
if $buffer =~ /startxref($PDF::API2::Basic::PDF::File::cr|\s*)\d+($PDF::API2::Basic::PDF::File::cr|\s*)\%\%eof.*?/i 16 16 32
255 }
256 16 ▶ unless ($buffer =~ m/startxref[^\d]+([0-9]+)($cr|\s*)\%\%eof.*?/i) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($buffer =~ /startxref[^\d]+([0-9]+)($PDF::API2::Basic::PDF::File::cr|\s*)\%\%eof.*?/i) 0 16 16
257 0 die "Malformed PDF file $filename";
258 }
259 16 my $xpos = $1;
260 16 $self->{' xref_position'} = $xpos;
261  
262 16 my $tdict = $self->readxrtr($xpos, $self);
263 16 foreach my $key (keys %$tdict) {
264 121 $self->{$key} = $tdict->{$key};
265 }
266 16 return $self;
267 }
268  
269 =head2 $p->version($version)
270  
271 Gets/sets the PDF version (e.g. 1.4)
272  
273 =cut
274  
275 sub version {
276 9 ▶ my $self = shift();
Subroutine version: called CC=5 SCAR=16.4
Pod documented
277  
278 9 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 2 7 9
279 2 my $version = shift();
280 2 ▶ croak "Invalid version $version" unless $version =~ /^([12]\.[0-9]+)$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $version =~ /^([12]\.[0-9]+)$/ 0 2 2
281 2 $self->header_version($version);
282 2 ▶ if ($version >= 1.4) {
Branch: 1 branch
BranchTrueFalseTotal
if ($version >= 1.4) { } 2 0 2
283 2 $self->trailer_version($version);
284 }
285 else {
286 0 delete $self->{'Root'}->{'Version'};
287 0 $self->out_obj($self->{'Root'});
288 }
289 2 return $version;
290 }
291  
292 7 my $header_version = $self->header_version();
293 7 my $trailer_version = $self->trailer_version();
294 7 ▶ return $trailer_version if $trailer_version > $header_version;
Branch: 1 branch
BranchTrueFalseTotal
if $trailer_version > $header_version 4 3 7
295 3 return $header_version;
296 }
297  
298 =head2 $version = $p->header_version($version)
299  
300 Gets/sets the PDF version stored in the file header.
301  
302 =cut
303  
304 sub header_version {
305 14 ▶ my $self = shift();
Subroutine header_version: called CC=3 SCAR=11.0
Pod documented
306  
307 14 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 5 9 14
308 5 my $version = shift();
309 5 ▶ croak "Invalid version $version" unless $version =~ /^([12]\.[0-9]+)$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $version =~ /^([12]\.[0-9]+)$/ 0 5 5
310 5 $self->{' version'} = $version;
311 }
312  
313 14 return $self->{' version'};
314 }
315  
316 =head2 $version = $p->trailer_version($version)
317  
318 Gets/sets the PDF version stored in the document catalog.
319  
320 =cut
321  
322 sub trailer_version {
323 12 ▶ my $self = shift();
Subroutine trailer_version: called CC=4 SCAR=13.9
Pod documented
324  
325 12 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 4 8 12
326 4 my $version = shift();
327 4 ▶ croak "Invalid version $version" unless $version =~ /^([12]\.[0-9]+)$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $version =~ /^([12]\.[0-9]+)$/ 0 4 4
328 4 $self->{'Root'}->{'Version'} = PDFName($version);
329 4 $self->out_obj($self->{'Root'});
330 4 return $version;
331 }
332  
333 8 ▶ return unless $self->{'Root'}->{'Version'};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"Root"}{"Version"} 0 8 8
334 8 $self->{'Root'}->{'Version'}->realise();
335 8 return $self->{'Root'}->{'Version'}->val();
336 }
337  
338 =head2 $prev_version = $p->require_version($version)
339  
340 Ensures that the PDF version is at least C<$version>.
341  
342 =cut
343  
344 sub require_version {
345 3 ▶ my ($self, $min_version) = @_;
Subroutine require_version: called CC=2 SCAR=6.9
Pod documented
346 3 my $current_version = $self->version();
347 3 ▶ $self->version($min_version) if $current_version < $min_version;
Branch: 1 branch
BranchTrueFalseTotal
if $current_version < $min_version 1 2 3
348 3 return $current_version;
349 }
350  
351 =head2 $p->release()
352  
353 Releases ALL of the memory used by the PDF document and all of its
354 component objects. After calling this method, do B<NOT> expect to
355 have anything left in the C<PDF::API2::Basic::PDF::File> object (so if
356 you need to save, be sure to do it before calling this method).
357  
358 B<NOTE>, that it is important that you call this method on any
359 C<PDF::API2::Basic::PDF::File> object when you wish to destruct it and
360 free up its memory. Internally, PDF files have an enormous number of
361 cross-references and this causes circular references within the
362 internal data structures. Calling 'C<release()>' forces a brute-force
363 cleanup of the data structures, freeing up all of the memory. Once
364 you've called this method, though, don't expect to be able to do
365 anything else with the C<PDF::API2::Basic::PDF::File> object; it'll
366 have B<no> internal state whatsoever.
367  
368 =cut
369  
370 # Maintainer's Question: Couldn't this be handled by a DESTROY method
371 # instead of requiring an explicit call to release()?
372 sub release {
373 612 ▶ my $self = shift();
Subroutine release: called CC=9 SCAR=22.0
Pod documented
374  
375 612 ▶ return $self unless ref($self);
Branch: 1 branch
BranchTrueFalseTotal
unless ref $self 0 612 612
376 612 my @tofree = values %$self;
377  
378 612 foreach my $key (keys %$self) {
379 2271 $self->{$key} = undef;
380 2271 delete $self->{$key};
381 }
382  
383 # PDFs with highly-interconnected page trees or outlines can hit Perl's
384 # recursion limit pretty easily, so disable the warning for this specific
385 # loop.
386 39 ▶ no warnings 'recursion';
Subroutine BEGIN: called CC=1 SCAR=0.0
387  
388 612 ▶ while (my $item = shift @tofree) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $item = shift @tofree) 7111 612 7723
389 7111 ▶ if (blessed($item) and $item->can('release')) {
Branch: 3 branches
BranchTrueFalseTotal
if (builtin::blessed($item) and $item->can('release')) { } 2117 4994 7111
elsif (ref $item eq 'ARRAY') { } 1554 3440 4994
elsif (ref $item eq 'HASH') { } 880 2560 3440
Condition100%3/3
builtin::blessed($item) and $item->can("release")
!ll&&!rl&&r
47002942117
MC/DC100%2/2
builtin::blessed($item) and $item->can("release")
builtin::blessed($item) $item->can("release")
Truth table100%3/3
A and B
A= builtin::blessed($item)B= $item->can("release")
ABresult
0X0
100
111
390 2117 $item->release(1);
391 }
392 elsif (ref($item) eq 'ARRAY') {
393 1554 push @tofree, @$item;
394 }
395 elsif (ref($item) eq 'HASH') {
396 880 push @tofree, values %$item;
397 880 foreach my $key (keys %$item) {
398 3831 $item->{$key} = undef;
399 3831 delete $item->{$key};
400 }
401 }
402 else {
403 2560 $item = undef;
404 }
405 }
406 }
407  
408 =head2 $p->append_file()
409  
410 Appends the objects for output to the read file and then appends the appropriate table.
411  
412 =cut
413  
414 sub append_file {
415 3 ▶ my $self = shift();
Subroutine append_file: called CC=5 SCAR=16.4
Pod documented
416 3 ▶ return unless $self->{' update'};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{" update"} 0 3 3
417  
418 3 my $fh = $self->{' INFILE'};
419  
420 3 my $tdict = PDFDict();
421 3 $tdict->{'Prev'} = PDFNum($self->{' loc'});
422 3 $tdict->{'Info'} = $self->{'Info'};
423 3 ▶ if (defined $self->{' newroot'}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $self->{' newroot'}) { } 0 3 3
424 0 $tdict->{'Root'} = $self->{' newroot'};
425 }
426 else {
427 3 $tdict->{'Root'} = $self->{'Root'};
428 }
429 3 $tdict->{'Size'} = $self->{'Size'};
430  
431 3 foreach my $key (grep { $_ !~ m/^\s/ } keys %$self) {
432 9 ▶ $tdict->{$key} = $self->{$key} unless defined $tdict->{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $tdict->{$key} 0 9 9
433 }
434  
435 3 $fh->seek($self->{' epos'}, 0);
436 3 $self->out_trailer($tdict, $self->{' update'});
437 3 close $self->{' OUTFILE'};
438 }
439  
440  
441 =head2 $p->out_file($fname)
442  
443 Writes a PDF file to a file of the given filename based on the current list of
444 objects to be output. It creates the trailer dictionary based on information
445 in $self.
446  
447 $fname may be an IO object;
448  
449 =cut
450  
451 sub out_file {
452 140 ▶ my ($self, $fname) = @_;
Subroutine out_file: called CC=1 SCAR=0.0
Pod documented
453  
454 140 $self->create_file($fname);
455 140 $self->close_file();
456 140 return $self;
457 }
458  
459  
460 =head2 $p->create_file($fname)
461  
462 Creates a new output file (no check is made of an existing open file) of
463 the given filename or IO object. Note, make sure that $p->{' version'} is set
464 correctly before calling this function.
465  
466 =cut
467  
468 sub create_file {
469 140 ▶ my ($self, $filename) = @_;
Subroutine create_file: called CC=4 SCAR=15.5
Pod documented
470 140 my $fh;
471  
472 140 $self->{' fname'} = $filename;
473 140 ▶ if (ref $filename) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $filename) { } 140 0 140
474 140 $fh = $filename;
475 }
476 else {
477 0 ▶ $fh = IO::File->new(">$filename") || die "Unable to open $filename for writing";
Condition0%0/2
'IO::File'->new(">$filename") || die("Unable to open $filename for writing")
l!l
00
MC/DC0%0/1
'IO::File'->new(">$filename") || die("Unable to open $filename for writing")
'IO::File'->new(">$filename")
Truth table0%0/2
A
A= 'IO::File'->new(">$filename")
Aresult
11
00
478 0 binmode($fh,':raw');
479 }
480  
481 140 $self->{' OUTFILE'} = $fh;
482 140 ▶ $fh->print('%PDF-' . ($self->{' version'} // '1.4') . "\n");
Condition50%1/2
$self->{" version"} // "1.4"
l!l
1400
MC/DC0%0/1
$self->{" version"} // "1.4"
$self->{" version"}
Truth table50%1/2
A
A= $self->{" version"}
Aresult
11
00
483 140 $fh->print("%\xC6\xCD\xCD\xB5\n"); # and some binary stuff in a comment
484 140 return $self;
485 }
486  
487  
488 =head2 $p->clone_file($fname)
489  
490 Creates a copy of the input file at the specified filename and sets it as the
491 output file for future writes. A file handle may be passed instead of a
492 filename.
493  
494 =cut
495  
496 sub clone_file {
497 4 ▶ my ($self, $filename) = @_;
Subroutine clone_file: called CC=4 SCAR=14.4
Pod documented
498 4 my $fh;
499  
500 4 $self->{' fname'} = $filename;
501 4 ▶ if (ref $filename) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $filename) { } 4 0 4
502 4 $fh = $filename;
503 }
504 else {
505 0 ▶ $fh = IO::File->new(">$filename") || die "Unable to open $filename for writing";
Condition0%0/2
'IO::File'->new(">$filename") || die("Unable to open $filename for writing")
l!l
00
MC/DC0%0/1
'IO::File'->new(">$filename") || die("Unable to open $filename for writing")
'IO::File'->new(">$filename")
Truth table0%0/2
A
A= 'IO::File'->new(">$filename")
Aresult
11
00
506 0 binmode($fh,':raw');
507 }
508  
509 4 $self->{' OUTFILE'} = $fh;
510  
511 4 my $in = $self->{' INFILE'};
512 4 $in->seek(0, 0);
513 4 my $data;
514 4 ▶ while (not $in->eof()) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($in->eof) 4 4 8
515 4 $in->read($data, 1024 * 1024);
516 4 $fh->print($data);
517 }
518 4 return $self;
519 }
520  
521 =head2 $p->close_file
522  
523 Closes up the open file for output by outputting the trailer etc.
524  
525 =cut
526  
527 sub close_file {
528 145 ▶ my $self = shift();
Subroutine close_file: called CC=11 SCAR=25.8
Pod documented
529  
530 145 my $tdict = PDFDict();
531 145 ▶ $tdict->{'Info'} = $self->{'Info'} if defined $self->{'Info'};
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->{"Info"} 145 0 145
532 145 ▶ $tdict->{'Root'} = (defined $self->{' newroot'} and $self->{' newroot'} ne '') ? $self->{' newroot'} : $self->{'Root'};
Branch: 1 branch
BranchTrueFalseTotal
defined $self->{' newroot'} && $self->{' newroot'} ne '' ? : 0 145 145
Condition33%1/3
defined $self->{" newroot"} and $self->{" newroot"} ne ""
!ll&&!rl&&r
14500
MC/DC0%0/2
defined $self->{" newroot"} and $self->{" newroot"} ne ""
defined $self->{" newroot"} $self->{" newroot"} ne ""
Truth table33%1/3
A and B
A= defined $self->{" newroot"}B= $self->{" newroot"} ne ""
ABresult
0X0
100
111
533  
534 # remove all freed objects from the outlist, AND the outlist_cache if not updating
535 # NO! Don't do that thing! In fact, let out_trailer do the opposite!
536  
537 145 ▶ $tdict->{'Size'} = $self->{'Size'} || PDFNum(1);
Condition66%2/3
$self->{'Size'} || PDFNum(1)
l!l&&r!l&&!r
51400
MC/DC0%0/2
$self->{'Size'} || PDFNum(1)
$self->{'Size'} PDFNum(1)
Truth table66%2/3
A || B
A= $self->{'Size'}B= PDFNum(1)
ABresult
1X1
011
000
538 145 ▶ $tdict->{'Prev'} = PDFNum($self->{' loc'}) if $self->{' loc'};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{" loc"} 5 140 145
539 145 ▶ if ($self->{' update'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{" update"}) 5 140 145
540 5 foreach my $key (grep { $_ !~ m/^[\s\-]/ } keys %$self) {
541 16 ▶ $tdict->{$key} = $self->{$key} unless defined $tdict->{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $tdict->{$key} 0 16 16
542 }
543  
544 5 my $fh = $self->{' INFILE'};
545 5 $fh->seek($self->{' epos'}, 0);
546 }
547  
548 145 $self->out_trailer($tdict, $self->{' update'});
549 145 close($self->{' OUTFILE'});
550 145 ▶ if ($^O eq 'MacOS' and not ref($self->{' fname'})) {
Branch: 1 branch
BranchTrueFalseTotal
if ($^O eq "MacOS" and not ref $self->{" fname"}) 0 145 145
Condition33%1/3
$^O eq "MacOS" and not ref $self->{" fname"}
!ll&&!rl&&r
14500
MC/DC0%0/2
$^O eq "MacOS" and not ref $self->{" fname"}
$^O eq "MacOS" not ref $self->{" fname"}
Truth table33%1/3
A and not(B)
A= $^O eq "MacOS"B= not ref $self->{" fname"}
ABresult
0X0
100
111
551 0 MacPerl::SetFileInfo('CARO', 'TEXT', $self->{' fname'});
552 }
553  
554 145 return $self;
555 }
556  
557 =head2 ($value, $str) = $p->readval($str, %opts)
558  
559 Reads a PDF value from the current position in the file. If $str is too short
560 then read some more from the current location in the file until the whole object
561 is read. This is a recursive call which may slurp in a whole big stream (unprocessed).
562  
563 Returns the recursive data structure read and also the current $str that has been
564 read from the file.
565  
566 =cut
567  
568 sub readval {
569 842 ▶ my ($self, $str, %opts) = @_;
Subroutine readval: called CC=51 SCAR=47.2
Pod documented
570 842 my $fh = $self->{' INFILE'};
571 842 my ($result, $value);
572  
573 842 ▶ my $update = defined($opts{update}) ? $opts{update} : 1;
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{'update'} ? : 10 832 842
574 842 ▶ $str = update($fh, $str) if $update;
Branch: 1 branch
BranchTrueFalseTotal
if $update 832 10 842
575  
576 842 $str =~ s/^$ws_char+//; # Ignore initial white space
577 842 $str =~ s/^\%[^\015\012]*$ws_char+//; # Ignore comments
578  
579 # Dictionary
580 842 ▶ if ($str =~ m/^<</s) {
Branch: 10 branches
BranchTrueFalseTotal
if ($str =~ /^<</s) { } 146 696 842
elsif ($str =~ /^([0-9]+)(?:$PDF::API2::Basic::PDF::File::ws_char|$re_comment)+([0-9]+)(?:$PDF::API2::Basic::PDF::File::ws_char|$re_comment)+R/s) { } 152 544 696
elsif ($str =~ /^([0-9]+)(?:$PDF::API2::Basic::PDF::File::ws_char|$re_comment)+([0-9]+)(?:$PDF::API2::Basic::PDF::File::ws_char|$re_comment)+obj/s) { } 95 449 544
elsif ($str =~ m[^/($PDF::API2::Basic::PDF::File::reg_char*)]s) { } 287 162 449
elsif ($str =~ /^\(/) { } 2 160 162
elsif ($str =~ /^</) { } 0 160 160
elsif ($str =~ /^\[/) { } 74 86 160
elsif ($str =~ /^(true|false)($PDF::API2::Basic::PDF::File::irreg_char|$)/) { } 0 86 86
elsif ($str =~ /^([+-.0-9]+)($PDF::API2::Basic::PDF::File::irreg_char|$)/) { } 86 0 86
elsif ($str =~ /^null($PDF::API2::Basic::PDF::File::irreg_char|$)/) { } 0 0 0
581 146 $str = substr ($str, 2);
582 146 ▶ $str = update($fh, $str) if $update;
Branch: 1 branch
BranchTrueFalseTotal
if $update 144 2 146
583 146 $result = PDFDict();
584  
585 146 ▶ while ($str !~ m/^>>/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($str =~ /^>>/) 398 146 544
586 398 $str =~ s/^$ws_char+//; # Ignore initial white space
587 398 $str =~ s/^\%[^\015\012]*$ws_char+//; # Ignore comments
588  
589 398 ▶ if ($str =~ s|^/($reg_char+)||) {
Branch: 3 branches
BranchTrueFalseTotal
if ($str =~ s[^/($PDF::API2::Basic::PDF::File::reg_char+)][]) { } 398 0 398
elsif ($str =~ s[^/$PDF::API2::Basic::PDF::File::ws_char+][]) { } 0 0 0
elsif ($str =~ s[^//][/]) { } 0 0 0
590 398 my $key = PDF::API2::Basic::PDF::Name::name_to_string($1, $self);
591 398 ($value, $str) = $self->readval($str, %opts);
592 398 ▶ unless ((ref($value) // '') eq 'PDF::API2::Basic::PDF::Null') {
Branch: 1 branch
BranchTrueFalseTotal
unless ((ref $value // "") eq "PDF::API2::Basic::PDF::Null") 398 0 398
Condition50%1/2
ref $value // ""
l!l
3980
MC/DC0%0/1
ref $value // ""
ref $value
Truth table50%1/2
A
A= ref $value
Aresult
11
00
593 398 $result->{$key} = $value;
594 }
595 }
596 elsif ($str =~ s|^/$ws_char+||) {
597 # fixes a broken key problem of acrobat. -- fredo
598 0 ($value, $str) = $self->readval($str, %opts);
599 0 ▶ unless ((ref($value) // '') eq 'PDF::API2::Basic::PDF::Null') {
Branch: 1 branch
BranchTrueFalseTotal
unless ((ref $value // "") eq "PDF::API2::Basic::PDF::Null") 0 0 0
Condition0%0/2
ref $value // ""
l!l
00
MC/DC0%0/1
ref $value // ""
ref $value
Truth table0%0/2
A
A= ref $value
Aresult
11
00
600 0 $result->{'null'} = $value;
601 }
602 }
603 elsif ($str =~ s|^//|/|) {
604 # fixes again a broken key problem of illustrator/enfocus. -- fredo
605 0 ($value, $str) = $self->readval($str, %opts);
606 0 ▶ unless ((ref($value) // '') eq 'PDF::API2::Basic::PDF::Null') {
Branch: 1 branch
BranchTrueFalseTotal
unless ((ref $value // "") eq "PDF::API2::Basic::PDF::Null") 0 0 0
Condition0%0/2
ref $value // ""
l!l
00
MC/DC0%0/1
ref $value // ""
ref $value
Truth table0%0/2
A
A= ref $value
Aresult
11
00
607 0 $result->{'null'} = $value;
608 }
609 }
610 else {
611 0 die "Invalid dictionary key";
612 }
613 398 ▶ $str = update($fh, $str) if $update; # thanks gareth.jones@stud.man.ac.uk
Branch: 1 branch
BranchTrueFalseTotal
if $update 396 2 398
614 }
615 146 $str =~ s/^>>//;
616 146 ▶ $str = update($fh, $str) if $update;
Branch: 1 branch
BranchTrueFalseTotal
if $update 144 2 146
617 # streams can't be followed by a lone carriage-return.
618 # fredo: yes they can !!! -- use the MacOS Luke.
619 146 ▶ if (($str =~ s/^stream(?:(?:\015\012)|\012|\015)//) and ($result->{'Length'}->val != 0)) { # stream
Branch: 1 branch
BranchTrueFalseTotal
if ($str =~ s/^stream(?:(?:\015\012)|\012|\015)// and $result->{"Length"}->val != 0) 10 136 146
Condition66%2/3
$str =~ s/^stream(?:(?:\015\012)|\012|\015)// and $result->{"Length"}->val != 0
!ll&&!rl&&r
136010
MC/DC50%1/2
$str =~ s/^stream(?:(?:\015\012)|\012|\015)// and $result->{"Length"}->val != 0
$str =~ s/^stream(?:(?:\015\012)|\012|\015)// $result->{"Length"}->val != 0
Truth table66%2/3
A and B
A= $str =~ s/^stream(?:(?:\015\012)|\012|\015)//B= $result->{"Length"}->val != 0
ABresult
0X0
100
111
620 10 my $length = $result->{'Length'}->val;
621 10 $result->{' streamsrc'} = $fh;
622 10 $result->{' streamloc'} = $fh->tell - length($str);
623  
624 10 ▶ unless ($opts{'nostreams'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($opts{"nostreams"}) 10 0 10
625 10 ▶ if ($length > length($str)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($length > length $str) { } 0 10 10
626 0 $value = $str;
627 0 $length -= length($str);
628 0 read $fh, $str, $length + 11; # slurp the whole stream!
629 }
630 else {
631 10 $value = '';
632 }
633 10 $value .= substr($str, 0, $length);
634 10 $result->{' stream'} = $value;
635 10 $result->{' nofilt'} = 1;
636 10 ▶ $str = update($fh, $str, 1) if $update; # tell update we are in-stream and only need an endstream
Branch: 1 branch
BranchTrueFalseTotal
if $update 10 0 10
637 10 $str = substr($str, index($str, 'endstream') + 9);
638 }
639 }
640  
641 146 ▶ if (defined $result->{'Type'} and defined $types{$result->{'Type'}->val}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $result->{"Type"} and defined $PDF::API2::Basic::PDF::File::types{$result->{"Type"}->val}) 34 112 146
Condition100%3/3
defined $result->{"Type"} and defined $PDF::API2::Basic::PDF::File::types{$result->{"Type"}->val}
!ll&&!rl&&r
872534
MC/DC100%2/2
defined $result->{"Type"} and defined $PDF::API2::Basic::PDF::File::types{$result->{"Type"}->val}
defined $result->{"Type"} defined $PDF::API2::Basic::PDF::File::types{$result->{"Type"}->val}
Truth table100%3/3
A and B
A= defined $result->{"Type"}B= defined $PDF::API2::Basic::PDF::File::types{$result->{"Type"}->val}
ABresult
0X0
100
111
642 34 bless $result, $types{$result->{'Type'}->val};
643 }
644 # gdj: FIXME: if any of the ws chars were crs, then the whole
645 # string might not have been read.
646 }
647  
648 # Indirect Object
649 elsif ($str =~ m/^([0-9]+)(?:$ws_char|$re_comment)+([0-9]+)(?:$ws_char|$re_comment)+R/s) {
650 152 my $num = $1;
651 152 $value = $2;
652 152 $str =~ s/^([0-9]+)(?:$ws_char|$re_comment)+([0-9]+)(?:$ws_char|$re_comment)+R//s;
653 152 ▶ unless ($result = $self->test_obj($num, $value)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($result = $self->test_obj($num, $value)) 119 33 152
654 119 $result = PDF::API2::Basic::PDF::Objind->new();
655 119 $result->{' objnum'} = $num;
656 119 $result->{' objgen'} = $value;
657 119 $self->add_obj($result, $num, $value);
658 }
659 152 $result->{' parent'} = $self;
660 152 weaken $result->{' parent'};
661  
662 # Removed to address changes being lost when an indirect object is realised twice
663 # $result->{' realised'} = 0;
664  
665 # gdj: FIXME: if any of the ws chars were crs, then the whole
666 # string might not have been read.
667 }
668  
669 # Object
670 elsif ($str =~ m/^([0-9]+)(?:$ws_char|$re_comment)+([0-9]+)(?:$ws_char|$re_comment)+obj/s) {
671 95 my $obj;
672 95 my $num = $1;
673 95 $value = $2;
674 95 $str =~ s/^([0-9]+)(?:$ws_char|$re_comment)+([0-9]+)(?:$ws_char|$re_comment)+obj//s;
675 95 ($obj, $str) = $self->readval($str, %opts);
676 95 ▶ if ($result = $self->test_obj($num, $value)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result = $self->test_obj($num, $value)) { } 81 14 95
677 81 $result->merge($obj);
678 }
679 else {
680 14 $result = $obj;
681 14 $self->add_obj($result, $num, $value);
682 14 $result->{' realised'} = 1;
683 }
684 95 ▶ $str = update($fh, $str) if $update; # thanks to kundrat@kundrat.sk
Branch: 1 branch
BranchTrueFalseTotal
if $update 91 4 95
685 95 $str =~ s/^endobj//;
686 }
687  
688 # Name
689 elsif ($str =~ m|^/($reg_char*)|s) {
690 287 $value = $1;
691 287 $str =~ s|^/($reg_char*)||s;
692 287 $result = PDF::API2::Basic::PDF::Name->from_pdf($value, $self);
693 }
694  
695 # Literal String
696 elsif ($str =~ m/^\(/) {
697 # We now need to find an unbalanced, unescaped right-paren.
698 # This can't be done with a regex.
699 2 my $value = '(';
700 2 $str = substr($str, 1);
701  
702 2 my $nested_level = 1;
703 2 while (1) {
704 # Ignore everything up to the first escaped or parenthesis character
705 2 ▶ if ($str =~ /^([^\\()]+)(.*)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($str =~ /^([^\\()]+)(.*)/s) 2 0 2
706 2 $value .= $1;
707 2 $str = $2;
708 }
709  
710 # Ignore escaped parentheses
711 2 ▶ if ($str =~ /^(\\[()])/) {
Branch: 4 branches
BranchTrueFalseTotal
if ($str =~ /^(\\[()])/) { } 0 2 2
elsif ($str =~ /^\(/) { } 0 2 2
elsif ($str =~ /^\)/) { } 2 0 2
elsif ($str =~ /^(\\[^()])/) { } 0 0 0
712 0 $value .= $1;
713 0 $str = substr($str, 2);
714 }
715  
716 # Left parenthesis: increase nesting
717 elsif ($str =~ /^\(/) {
718 0 $value .= '(';
719 0 $str = substr($str, 1);
720 0 $nested_level++;
721 }
722  
723 # Right parenthesis: decrease nesting
724 elsif ($str =~ /^\)/) {
725 2 $value .= ')';
726 2 $str = substr($str, 1);
727 2 $nested_level--;
728 2 ▶ last unless $nested_level;
Branch: 1 branch
BranchTrueFalseTotal
unless $nested_level 2 0 2
729 }
730  
731 # Other escaped character
732 elsif ($str =~ /^(\\[^()])/) {
733 0 $value .= $1;
734 0 $str = substr($str, 2);
735 }
736  
737 # If there wasn't an escaped or parenthesis character,
738 # read some more.
739 else {
740 # We don't use update because we don't want to remove
741 # whitespace or comments.
742 0 ▶ $fh->read($str, 255, length($str)) or die 'Unterminated string.';
Branch: 1 branch
BranchTrueFalseTotal
$fh->read($str, 255, length $str) or die "Unterminated string." 0 0 0
743 }
744 }
745  
746 2 $result = PDF::API2::Basic::PDF::String->from_pdf($value);
747 }
748  
749 # Hex String
750 elsif ($str =~ m/^</) {
751 0 $str =~ s/^<//;
752 0 ▶ $fh->read($str, 255, length($str)) while (0 > index($str, '>'));
Branch: 1 branch
BranchTrueFalseTotal
(index($str, ">") == -1) and do { $fh->read($str, 255, length $str) } 0 0 0
753 0 ($value, $str) = ($str =~ /^(.*?)>(.*)/s);
754 0 $result = PDF::API2::Basic::PDF::String->from_pdf('<' . $value . '>');
755 }
756  
757 # Array
758 elsif ($str =~ m/^\[/) {
759 74 $str =~ s/^\[//;
760 74 ▶ $str = update($fh, $str) if $update;
Branch: 1 branch
BranchTrueFalseTotal
if $update 74 0 74
761 74 $result = PDFArray();
762 74 ▶ while ($str !~ m/^\]/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($str =~ /^\]/) 224 74 298
763 224 $str =~ s/^$ws_char+//; # Ignore initial white space
764 224 $str =~ s/^\%[^\015\012]*$ws_char+//; # Ignore comments
765  
766 224 ($value, $str) = $self->readval($str, %opts);
767 224 $result->add_elements($value);
768 224 ▶ $str = update($fh, $str) if $update; # str might just be exhausted!
Branch: 1 branch
BranchTrueFalseTotal
if $update 224 0 224
769 }
770 74 $str =~ s/^\]//;
771 }
772  
773 # Boolean
774 elsif ($str =~ m/^(true|false)($irreg_char|$)/) {
775 0 $value = $1;
776 0 $str =~ s/^(?:true|false)//;
777 0 $result = PDF::API2::Basic::PDF::Bool->from_pdf($value);
778 }
779  
780 # Number
781 elsif ($str =~ m/^([+-.0-9]+)($irreg_char|$)/) {
782 86 $value = $1;
783 86 $str =~ s/^([+-.0-9]+)//;
784  
785 # If $str only consists of whitespace (or is empty), call update to
786 # see if this is the beginning of an indirect object or reference
787 86 ▶ if ($update and ($str =~ /^$re_whitespace*$/s or $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($update and $str =~ /^$re_whitespace*$/s || $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s) 6 80 86
Condition100%6/6
$update and $str =~ /^$re_whitespace*$/s || $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s
!ll&&!rl&&r
2804
$str =~ /^$re_whitespace*$/s or $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s
l!l&&r!l&&!r
4278
MC/DC66%2/3
$update and $str =~ /^$re_whitespace*$/s || $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s
$update $str =~ /^$re_whitespace*$/s $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s
Truth table75%3/4
A and B or C
A= $updateB= $str =~ /^$re_whitespace*$/sC= $str =~ /^$re_whitespace+[0-9]+$re_whitespace*$/s
ABCresult
0XX0
1000
11X1
1011
788 6 $str =~ s/^$re_whitespace+/ /s;
789 6 $str =~ s/$re_whitespace+$/ /s;
790 6 $str = update($fh, $str);
791 6 ▶ if ($str =~ m/^$re_whitespace*([0-9]+)$re_whitespace+(?:R|obj)/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($str =~ /^$re_whitespace*([0-9]+)$re_whitespace+(?:R|obj)/s) 4 2 6
792 4 return $self->readval("$value $str", %opts);
793 }
794 }
795  
796 82 $result = PDF::API2::Basic::PDF::Number->from_pdf($value);
797 }
798  
799 # Null
800 elsif ($str =~ m/^null($irreg_char|$)/) {
801 0 $str =~ s/^null//;
802 0 $result = PDF::API2::Basic::PDF::Null->new;
803 }
804  
805 else {
806 0 die "Can't parse `$str' near " . ($fh->tell()) . " length " . length($str) . ".";
807 }
808  
809 838 $str =~ s/^$ws_char+//s;
810 838 return ($result, $str);
811 }
812  
813  
814 =head2 $ref = $p->read_obj($objind, %opts)
815  
816 Given an indirect object reference, locate it and read the object returning
817 the read in object.
818  
819 =cut
820  
821 sub read_obj {
822 77 ▶ my ($self, $objind, %opts) = @_;
Subroutine read_obj: called CC=3 SCAR=11.4
Pod documented
823  
824 77 ▶ my $res = $self->read_objnum($objind->{' objnum'}, $objind->{' objgen'}, %opts) || return;
Condition50%1/2
$self->read_objnum($objind->{' objnum'}, $objind->{' objgen'}, %opts) || (return)
l!l
770
MC/DC0%0/1
$self->read_objnum($objind->{' objnum'}, $objind->{' objgen'}, %opts) || (return)
$self->read_objnum($objind->{' objnum'}, $objind->{' objgen'}, %opts)
Truth table50%1/2
A
A= $self->read_objnum($objind->{' objnum'}, $objind->{' objgen'}, %opts)
Aresult
11
00
825 77 ▶ $objind->merge($res) unless $objind eq $res;
Branch: 1 branch
BranchTrueFalseTotal
unless $objind eq $res 0 77 77
826 77 return $objind;
827 }
828  
829  
830 =head2 $ref = $p->read_objnum($num, $gen, %opts)
831  
832 Returns a fully read object of given number and generation in this file
833  
834 =cut
835  
836 sub read_objnum {
837 85 ▶ my ($self, $num, $gen, %opts) = @_;
Subroutine read_objnum: called CC=14 SCAR=28.3
Pod documented
838 85 ▶ croak 'Undefined object number in call to read_objnum($num, $gen)' unless defined $num;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $num 0 85 85
839 85 ▶ croak 'Undefined object generation in call to read_objnum($num, $gen)' unless defined $gen;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $gen 0 85 85
840 85 ▶ croak "Invalid object number '$num' in call to read_objnum" unless $num =~ /^[0-9]+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $num =~ /^[0-9]+$/ 0 85 85
841 85 ▶ croak "Invalid object generation '$gen' in call to read_objnum" unless $gen =~ /^[0-9]+$/;
Branch: 1 branch
BranchTrueFalseTotal
unless $gen =~ /^[0-9]+$/ 0 85 85
842  
843 85 ▶ my $object_location = $self->locate_obj($num, $gen) || return;
Condition50%1/2
$self->locate_obj($num, $gen) || (return)
l!l
850
MC/DC0%0/1
$self->locate_obj($num, $gen) || (return)
$self->locate_obj($num, $gen)
Truth table50%1/2
A
A= $self->locate_obj($num, $gen)
Aresult
11
00
844 85 my $object;
845  
846 # Compressed object
847 85 ▶ if (ref($object_location)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $object_location) 4 81 85
848 4 my ($object_stream_num, $object_stream_pos) = @{$object_location};
849  
850 4 my $object_stream = $self->read_objnum($object_stream_num, 0, %opts);
851 4 ▶ die 'Cannot find the compressed object stream' unless $object_stream;
Branch: 1 branch
BranchTrueFalseTotal
unless $object_stream 0 4 4
852  
853 4 ▶ $object_stream->read_stream() if $object_stream->{' nofilt'};
Branch: 1 branch
BranchTrueFalseTotal
if $object_stream->{" nofilt"} 4 0 4
854  
855 # An object stream starts with pairs of integers containing object numbers and
856 # stream offsets relative to the First key
857 4 my $fh;
858 my $pairs;
859 4 ▶ unless ($object_stream->{' streamfile'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($object_stream->{' streamfile'}) { } 0 4 4
860 4 $pairs = substr($object_stream->{' stream'}, 0, $object_stream->{'First'}->val);
861 }
862 else {
863 0 CORE::open($fh, '<', $object_stream->{' streamfile'});
864 0 read($fh, $pairs, $object_stream->{'First'}->val());
865 }
866 4 my @map = split /\s+/, $pairs;
867  
868 # Find the offset of the object in the stream
869 4 my $index = $object_stream_pos * 2;
870 4 ▶ die "Objind $num does not exist at index $index" unless $map[$index] == $num;
Branch: 1 branch
BranchTrueFalseTotal
unless $map[$index] == $num 0 4 4
871 4 my $start = $map[$index + 1];
872  
873 # Unless this is the last object in the stream, its length is determined by the
874 # offset of the next object
875 4 my $last_object_in_stream = $map[-2];
876 4 my $length;
877 4 ▶ if ($last_object_in_stream == $num) {
Branch: 1 branch
BranchTrueFalseTotal
if ($last_object_in_stream == $num) { } 2 2 4
878 2 ▶ if ($object_stream->{' stream'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($object_stream->{' stream'}) { } 2 0 2
879 2 $length = length($object_stream->{' stream'}) - $object_stream->{'First'}->val() - $start;
880 }
881 else {
882 0 $length = (-s $object_stream->{' streamfile'}) - $object_stream->{'First'}->val() - $start;
883 }
884 }
885 else {
886 2 my $next_start = $map[$index + 3];
887 2 $length = $next_start - $start;
888 }
889  
890 # Read the object from the stream
891 4 my $stream = "$num 0 obj ";
892 4 ▶ unless ($object_stream->{' streamfile'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($object_stream->{' streamfile'}) { } 0 4 4
893 4 $stream .= substr($object_stream->{' stream'}, $object_stream->{'First'}->val() + $start, $length);
894 }
895 else {
896 0 seek($fh, $object_stream->{'First'}->val() + $start, 0);
897 0 read($fh, $stream, $length, length($stream));
898 0 close $fh;
899 }
900  
901 4 ($object) = $self->readval($stream, %opts, update => 0);
902 4 return $object;
903 }
904  
905 81 my $current_location = $self->{' INFILE'}->tell;
906 81 $self->{' INFILE'}->seek($object_location, 0);
907 81 ($object) = $self->readval('', %opts);
908 81 $self->{' INFILE'}->seek($current_location, 0);
909 81 return $object;
910 }
911  
912  
913 =head2 $objind = $p->new_obj($obj)
914  
915 Creates a new, free object reference based on free space in the cross reference chain.
916 If nothing free then thinks up a new number. If $obj then turns that object into this
917 new object rather than returning a new object.
918  
919 =cut
920  
921 sub new_obj {
922 1072 ▶ my ($self, $base) = @_;
Subroutine new_obj: called CC=12 SCAR=38.3
Pod documented
923 1072 my $res;
924  
925 1072 ▶ if (defined $self->{' free'} and scalar @{$self->{' free'}} > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $self->{" free"} and scalar @{$self->{" free"};} > 0) 0 1072 1072
Condition66%2/3
defined $self->{" free"} and scalar @{$self->{" free"};} > 0
!ll&&!rl&&r
1057150
MC/DC0%0/2
defined $self->{" free"} and scalar @{$self->{" free"};} > 0
defined $self->{" free"} scalar @{$self->{" free"};} > 0
Truth table66%2/3
A and B
A= defined $self->{" free"}B= scalar @{$self->{" free"};} > 0
ABresult
0X0
100
111
926 0 $res = shift(@{$self->{' free'}});
927 0 ▶ if (defined $base) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $base) { } 0 0 0
928 0 my ($num, $gen) = @{$self->{' objects'}{$res->uid}};
929 0 $self->remove_obj($res);
930 0 $self->add_obj($base, $num, $gen);
931 0 return $self->out_obj($base);
932 }
933 else {
934 0 $self->{' objects'}{$res->uid}[2] = 0;
935 0 return $res;
936 }
937 }
938  
939 1072 my $tdict = $self;
940 1072 my $i;
941 1072 ▶ while (defined $tdict) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $tdict) 1073 1072 2145
942 1073 ▶ $i = $tdict->{' xref'}{defined($i) ? $i : ''}[0];
Branch: 1 branch
BranchTrueFalseTotal
defined $i ? : 0 1073 1073
943 1073 ▶ while (defined $i and $i != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $i and $i != 0) 0 1073 1073
Condition33%1/3
defined $i and $i != 0
!ll&&!rl&&r
107300
MC/DC0%0/2
defined $i and $i != 0
defined $i $i != 0
Truth table33%1/3
A and B
A= defined $iB= $i != 0
ABresult
0X0
100
111
944 0 my ($ni, $ng) = @{$tdict->{' xref'}{$i}};
945 0 ▶ unless (defined $self->locate_obj($i, $ng)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $self->locate_obj($i, $ng)) 0 0 0
946 0 ▶ if (defined $base) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $base) { } 0 0 0
947 0 $self->add_obj($base, $i, $ng);
948 0 return $base;
949 }
950 else {
951 0 ▶ $res = $self->test_obj($i, $ng) || $self->add_obj(PDF::API2::Basic::PDF::Objind->new(), $i, $ng);
Condition0%0/3
$self->test_obj($i, $ng) || $self->add_obj('PDF::API2::Basic::PDF::Objind'->new, $i, $ng)
l!l&&r!l&&!r
000
MC/DC0%0/2
$self->test_obj($i, $ng) || $self->add_obj('PDF::API2::Basic::PDF::Objind'->new, $i, $ng)
$self->test_obj($i, $ng) $self->add_obj('PDF::API2::Basic::PDF::Objind'->new, $i, $ng)
Truth table0%0/3
A || B
A= $self->test_obj($i, $ng)B= $self->add_obj('PDF::API2::Basic::PDF::Objind'->new, $i, $ng)
ABresult
1X1
011
000
952 0 $self->out_obj($res);
953 0 return $res;
954 }
955 }
956 0 $i = $ni;
957 }
958 1073 $tdict = $tdict->{' prev'};
959 }
960  
961 1072 $i = $self->{' maxobj'}++;
962 1072 ▶ if (defined $base) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $base) { } 1072 0 1072
963 1072 $self->add_obj($base, $i, 0);
964 1072 $self->out_obj($base);
965 1072 return $base;
966 }
967 else {
968 0 $res = $self->add_obj(PDF::API2::Basic::PDF::Objind->new(), $i, 0);
969 0 $self->out_obj($res);
970 0 return $res;
971 }
972 }
973  
974  
975 =head2 $p->out_obj($objind)
976  
977 Indicates that the given object reference should appear in the output xref
978 table whether with data or freed.
979  
980 =cut
981  
982 sub out_obj {
983 2676 ▶ my ($self, $obj) = @_;
Subroutine out_obj: called CC=2 SCAR=6.9
Pod documented
984  
985 # This is why we've been keeping the outlist CACHE around; to speed
986 # up this method by orders of magnitude (it saves up from having to
987 # grep the full outlist each time through as we'll just do a lookup
988 # in the hash) (which is super-fast).
989 2676 ▶ unless (exists $self->{' outlist_cache'}{$obj}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $self->{" outlist_cache"}{$obj}) 1087 1589 2676
990 1087 push @{$self->{' outlist'}}, $obj;
991 # weaken $self->{' outlist'}->[-1];
992 1087 $self->{' outlist_cache'}{$obj} = 1;
993 }
994 2676 return $obj;
995 }
996  
997  
998 =head2 $p->free_obj($objind)
999  
1000 Marks an object reference for output as being freed.
1001  
1002 =cut
1003  
1004 sub free_obj {
1005 0 ▶ my ($self, $obj) = @_;
Subroutine free_obj: not called CC=1 SCAR=6.9
Pod documented
1006  
1007 0 push @{$self->{' free'}}, $obj;
1008 0 $self->{' objects'}{$obj->uid()}[2] = 1;
1009 0 $self->out_obj($obj);
1010 }
1011  
1012  
1013 =head2 $p->remove_obj($objind)
1014  
1015 Removes the object from all places where we might remember it
1016  
1017 =cut
1018  
1019 sub remove_obj {
1020 0 ▶ my ($self, $objind) = @_;
Subroutine remove_obj: not called CC=2 SCAR=17.9
Pod documented
1021  
1022 # who says it has to be fast
1023 0 delete $self->{' objects'}{$objind->uid()};
1024 0 delete $self->{' outlist_cache'}{$objind};
1025 0 delete $self->{' printed_cache'}{$objind};
1026 0 @{$self->{' outlist'}} = grep { $_ ne $objind } @{$self->{' outlist'}};
1027 0 @{$self->{' printed'}} = grep { $_ ne $objind } @{$self->{' printed'}};
1028 $self->{' objcache'}{$objind->{' objnum'}, $objind->{' objgen'}} = undef
1029 0 ▶ if $self->{' objcache'}{$objind->{' objnum'}, $objind->{' objgen'}} eq $objind;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{" objcache"}{join $;, $objind->{" objnum"}, $objind->{" objgen"}} eq $objind 0 0 0
1030 0 return $self;
1031 }
1032  
1033  
1034 =head2 $p->ship_out(@objects)
1035  
1036 Ships the given objects (or all objects for output if @objects is empty) to
1037 the currently open output file (assuming there is one). Freed objects are not
1038 shipped, and once an object is shipped it is switched such that this file
1039 becomes its source and it will not be shipped again unless out_obj is called
1040 again. Notice that a shipped out object can be re-output or even freed, but
1041 that it will not cause the data already output to be changed.
1042  
1043 =cut
1044  
1045 sub ship_out {
1046 154 ▶ my ($self, @objs) = @_;
Subroutine ship_out: called CC=11 SCAR=25.0
Pod documented
1047  
1048 154 ▶ die "No output file specified" unless defined $self->{' OUTFILE'};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $self->{" OUTFILE"} 0 154 154
1049 154 my $fh = $self->{' OUTFILE'};
1050 154 seek($fh, 0, 2); # go to the end of the file
1051  
1052 154 ▶ @objs = @{$self->{' outlist'}} unless scalar @objs > 0;
Branch: 1 branch
BranchTrueFalseTotal
unless scalar @objs > 0 154 0 154
1053 154 foreach my $objind (@objs) {
1054 890 ▶ next unless $objind->is_obj($self);
Branch: 1 branch
BranchTrueFalseTotal
unless $objind->is_obj($self) 0 890 890
1055 890 my $j = -1;
1056 890 ▶ for (my $i = 0; $i < scalar @{$self->{' outlist'}}; $i++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < scalar @{$self->{" outlist"};}) 890 0 890
1057 890 ▶ if ($self->{' outlist'}[$i] eq $objind) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{" outlist"}[$i] eq $objind) 890 0 890
1058 890 $j = $i;
1059 890 last;
1060 }
1061 }
1062 890 ▶ next if $j < 0;
Branch: 1 branch
BranchTrueFalseTotal
if $j < 0 0 890 890
1063 890 splice(@{$self->{' outlist'}}, $j, 1);
1064 890 delete $self->{' outlist_cache'}{$objind};
1065 890 ▶ next if grep { $_ eq $objind } @{$self->{' free'}};
Branch: 1 branch
BranchTrueFalseTotal
if grep {$_ eq $objind;} @{$$self{" free"};} 0 890 890
1066  
1067 890 ▶ map { $fh->print("\% $_ \n") } split(/$cr/, $objind->{' comments'}) if $objind->{' comments'};
Branch: 1 branch
BranchTrueFalseTotal
if $objind->{" comments"} 0 890 890
1068 890 $self->{' locs'}{$objind->uid()} = $fh->tell();
1069 890 my ($objnum, $objgen) = @{$self->{' objects'}{$objind->uid()}}[0..1];
1070 890 $fh->printf('%d %d obj ', $objnum, $objgen);
1071 890 $objind->outobjdeep($fh, $self);
1072 890 $fh->print(" endobj\n");
1073  
1074 # Note that we've output this obj, not forgetting to update
1075 # the cache of whats printed.
1076 890 ▶ unless (exists $self->{' printed_cache'}{$objind}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $self->{" printed_cache"}{$objind}) 890 0 890
1077 890 push @{$self->{' printed'}}, $objind;
1078 890 $self->{' printed_cache'}{$objind}++;
1079 }
1080 }
1081 154 return $self;
1082 }
1083  
1084 =head2 $p->copy($outpdf, \&filter)
1085  
1086 Iterates over every object in the file reading the object, calling filter with the object
1087 and outputting the result. if filter is not defined, then just copies input to output.
1088  
1089 =cut
1090  
1091 sub copy {
1092 0 ▶ my ($self, $out, $filter) = @_;
Subroutine copy: not called CC=14 SCAR=53.5
Pod documented
1093 0 my ($obj, $minl, $mini, $ming);
1094  
1095 0 foreach my $key (grep { not m/^[\s\-]/ } keys %$self) {
1096 0 ▶ $out->{$key} = $self->{$key} unless defined $out->{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $out->{$key} 0 0 0
1097 }
1098  
1099 0 my $tdict = $self;
1100 0 ▶ while (defined $tdict) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $tdict) 0 0 0
1101 0 foreach my $i (sort {$a <=> $b} keys %{$tdict->{' xref'}}) {
1102 0 my ($nl, $ng, $nt) = @{$tdict->{' xref'}{$i}};
1103 0 ▶ next unless $nt eq 'n';
Branch: 1 branch
BranchTrueFalseTotal
unless $nt eq "n" 0 0 0
1104  
1105 0 ▶ if ($nl < $minl or $mini == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($nl < $minl or $mini == 0) 0 0 0
Condition0%0/3
$nl < $minl or $mini == 0
l!l&&r!l&&!r
000
MC/DC0%0/2
$nl < $minl or $mini == 0
$nl < $minl $mini == 0
Truth table0%0/3
A or B
A= $nl < $minlB= $mini == 0
ABresult
1X1
011
000
1106 0 $mini = $i;
1107 0 $ming = $ng;
1108 0 $minl = $nl;
1109 }
1110 0 ▶ unless ($obj = $self->test_obj($i, $ng)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($obj = $self->test_obj($i, $ng)) 0 0 0
1111 0 $obj = PDF::API2::Basic::PDF::Objind->new();
1112 0 $obj->{' objnum'} = $i;
1113 0 $obj->{' objgen'} = $ng;
1114 0 $self->add_obj($obj, $i, $ng);
1115 0 $obj->{' parent'} = $self;
1116 0 weaken $obj->{' parent'};
1117 0 $obj->{' realised'} = 0;
1118 }
1119 0 $obj->realise;
1120 0 ▶ my $res = defined $filter ? &{$filter}($obj) : $obj;
Branch: 1 branch
BranchTrueFalseTotal
defined $filter ? : 0 0 0
1121 0 ▶ $out->new_obj($res) unless (!$res || $res->is_obj($out));
Branch: 1 branch
BranchTrueFalseTotal
unless not $res or $res->is_obj($out) 0 0 0
Condition0%0/3
not $res or $res->is_obj($out)
l!l&&r!l&&!r
000
MC/DC0%0/2
not $res or $res->is_obj($out)
not $res $res->is_obj($out)
Truth table0%0/3
not(A) or B
A= not $resB= $res->is_obj($out)
ABresult
1X1
011
000
1122 }
1123 0 $tdict = $tdict->{' prev'};
1124 }
1125  
1126 # test for linearized and remove it from output
1127 0 $obj = $self->test_obj($mini, $ming);
1128 0 ▶ if ($obj->isa('PDF::API2::Basic::PDF::Dict') && $obj->{'Linearized'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($obj->isa("PDF::API2::Basic::PDF::Dict") and $obj->{"Linearized"}) 0 0 0
Condition0%0/3
$obj->isa("PDF::API2::Basic::PDF::Dict") and $obj->{"Linearized"}
!ll&&!rl&&r
000
MC/DC0%0/2
$obj->isa("PDF::API2::Basic::PDF::Dict") and $obj->{"Linearized"}
$obj->isa("PDF::API2::Basic::PDF::Dict") $obj->{"Linearized"}
Truth table0%0/3
A and B
A= $obj->isa("PDF::API2::Basic::PDF::Dict")B= $obj->{"Linearized"}
ABresult
0X0
100
111
1129 0 $out->free_obj($obj);
1130 }
1131  
1132 0 return $self;
1133 }
1134  
1135  
1136 =head1 PRIVATE METHODS & FUNCTIONS
1137  
1138 The following methods and functions are considered private to this class. This
1139 does not mean you cannot use them if you have a need, just that they aren't really
1140 designed for users of this class.
1141  
1142 =head2 $offset = $p->locate_obj($num, $gen)
1143  
1144 Returns a file offset to the object asked for by following the chain of cross
1145 reference tables until it finds the one you want.
1146  
1147 =cut
1148  
1149 sub locate_obj {
1150 85 ▶ my ($self, $num, $gen) = @_;
Subroutine locate_obj: called CC=6 SCAR=18.7
Pod documented
1151  
1152 85 my $tdict = $self;
1153 85 ▶ while (defined $tdict) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $tdict) 94 0 94
1154 94 ▶ if (ref $tdict->{' xref'}{$num}) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $tdict->{" xref"}{$num}) 85 9 94
1155 85 my $ref = $tdict->{' xref'}{$num};
1156 85 ▶ return $ref unless scalar(@$ref) == 3;
Branch: 1 branch
BranchTrueFalseTotal
unless scalar @$ref == 3 4 81 85
1157  
1158 81 ▶ if ($ref->[1] == $gen) {
Branch: 1 branch
BranchTrueFalseTotal
if ($ref->[1] == $gen) 81 0 81
1159 81 ▶ return $ref->[0] if $ref->[2] eq 'n';
Branch: 1 branch
BranchTrueFalseTotal
if $ref->[2] eq "n" 81 0 81
1160 0 return; # if $ref->[2] eq 'f';
1161 }
1162 }
1163 9 $tdict = $tdict->{' prev'};
1164 }
1165 0 return;
1166 }
1167  
1168  
1169 =head2 update($fh, $str, $instream)
1170  
1171 Keeps reading $fh for more data to ensure that $str has at least a line full
1172 for C<readval> to work on. At this point we also take the opportunity to ignore
1173 comments.
1174  
1175 =cut
1176  
1177 sub update {
1178 1940 ▶ my ($fh, $str, $instream) = @_;
Subroutine update: called CC=13 SCAR=28.7
Pod documented
1179 1940 ▶ print STDERR 'fpos=' . tell($fh) . ' strlen=' . length($str) . "\n" if $readDebug;
Branch: 1 branch
BranchTrueFalseTotal
if $readDebug 0 1940 1940
1180 1940 ▶ if ($instream) {
Branch: 1 branch
BranchTrueFalseTotal
if ($instream) { } 10 1930 1940
1181 # we are inside a (possible binary) stream
1182 # so we fetch data till we see an 'endstream'
1183 # -- fredo/2004-09-03
1184 10 ▶ while ($str !~ m/endstream/ and not $fh->eof()) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($str =~ /endstream/ or $fh->eof) 0 10 10
Condition33%1/3
$str =~ /endstream/ or $fh->eof
l!l&&r!l&&!r
1000
MC/DC0%0/2
$str =~ /endstream/ or $fh->eof
$str =~ /endstream/ $fh->eof
Truth table33%1/3
A or B
A= $str =~ /endstream/B= $fh->eof
ABresult
1X1
011
000
1185 0 ▶ print STDERR 'fpos=' . tell($fh) . ' strlen=' . length($str) . "\n" if $readDebug;
Branch: 1 branch
BranchTrueFalseTotal
if $readDebug 0 0 0
1186 0 $fh->read($str, 314, length($str));
1187 }
1188 }
1189 else {
1190 1930 $str =~ s/^$ws_char*//;
1191 1930 ▶ while ($str !~ m/$cr/ and not $fh->eof()) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($str =~ /$PDF::API2::Basic::PDF::File::cr/ or $fh->eof) 107 1930 2037
Condition100%3/3
$str =~ /$PDF::API2::Basic::PDF::File::cr/ or $fh->eof
l!l&&r!l&&!r
188842107
MC/DC100%2/2
$str =~ /$PDF::API2::Basic::PDF::File::cr/ or $fh->eof
$str =~ /$PDF::API2::Basic::PDF::File::cr/ $fh->eof
Truth table100%3/3
A or B
A= $str =~ /$PDF::API2::Basic::PDF::File::cr/B= $fh->eof
ABresult
1X1
011
000
1192 107 ▶ print STDERR 'fpos=' . tell($fh) . ' strlen=' . length($str) . "\n" if $readDebug;
Branch: 1 branch
BranchTrueFalseTotal
if $readDebug 0 107 107
1193 107 $fh->read($str, 314, length($str));
1194 107 $str =~ s/^$ws_char*//so;
1195 }
1196 1930 ▶ while ($str =~ m/^\%/) { # restructured by fredo/2003-03-23
Branch: 1 branch
BranchTrueFalseTotal
if ($str =~ /^\%/) 1 1930 1931
1197 1 ▶ print STDERR 'fpos=' . tell($fh) . ' strlen=' . length($str) . "\n" if $readDebug;
Branch: 1 branch
BranchTrueFalseTotal
if $readDebug 0 1 1
1198 1 ▶ $fh->read($str, 314, length($str)) while ($str !~ m/$cr/ and not $fh->eof());
Branch: 1 branch
BranchTrueFalseTotal
$str =~ /$PDF::API2::Basic::PDF::File::cr/ or $fh->eof or do { $fh->read($str, 314, length $str) } 0 1 1
Condition33%1/3
$str =~ /$PDF::API2::Basic::PDF::File::cr/ or $fh->eof
l!l&&r!l&&!r
100
MC/DC0%0/2
$str =~ /$PDF::API2::Basic::PDF::File::cr/ or $fh->eof
$str =~ /$PDF::API2::Basic::PDF::File::cr/ $fh->eof
Truth table33%1/3
A or B
A= $str =~ /$PDF::API2::Basic::PDF::File::cr/B= $fh->eof
ABresult
1X1
011
000
1199 1 $str =~ s/^\%[^\015\012]*$ws_char*//so; # fixed for reportlab -- fredo
1200 }
1201 }
1202  
1203 1940 return $str;
1204 }
1205  
1206 =head2 $objind = $p->test_obj($num, $gen)
1207  
1208 Tests the cache to see whether an object reference (which may or may not have
1209 been getobj()ed) has been cached. Returns it if it has.
1210  
1211 =cut
1212  
1213 sub test_obj {
1214 247 ▶ my ($self, $num, $gen) = @_;
Subroutine test_obj: called CC=1 SCAR=0.0
Pod documented
1215 247 return $self->{' objcache'}{$num, $gen};
1216 }
1217  
1218  
1219 =head2 $p->add_obj($objind)
1220  
1221 Adds the given object to the internal object cache.
1222  
1223 =cut
1224  
1225 sub add_obj {
1226 1205 ▶ my ($self, $obj, $num, $gen) = @_;
Subroutine add_obj: called CC=1 SCAR=0.0
Pod documented
1227  
1228 1205 $self->{' objcache'}{$num, $gen} = $obj;
1229 1205 $self->{' objects'}{$obj->uid()} = [$num, $gen];
1230 # weaken $self->{' objcache'}{$num, $gen};
1231 1205 return $obj;
1232 }
1233  
1234  
1235 =head2 $tdict = $p->readxrtr($xpos)
1236  
1237 Recursive function which reads each of the cross-reference and trailer tables
1238 in turn until there are no more.
1239  
1240 Returns a dictionary corresponding to the trailer chain. Each trailer also
1241 includes the corresponding cross-reference table.
1242  
1243 The structure of the xref private element in a trailer dictionary is of an
1244 anonymous hash of cross reference elements by object number. Each element
1245 consists of an array of 3 elements corresponding to the three elements read
1246 in [location, generation number, free or used]. See the PDF specification
1247 for details.
1248  
1249 =cut
1250  
1251 sub _unpack_xref_stream {
1252 78 ▶ my ($self, $width, $data) = @_;
Subroutine _unpack_xref_stream: called CC=6 SCAR=27.6
1253  
1254 78 ▶ return unpack('C', $data) if $width == 1;
Branch: 1 branch
BranchTrueFalseTotal
if $width == 1 26 52 78
1255 52 ▶ return unpack('n', $data) if $width == 2;
Branch: 1 branch
BranchTrueFalseTotal
if $width == 2 52 0 52
1256 0 ▶ return unpack('N', "\x00$data") if $width == 3;
Branch: 1 branch
BranchTrueFalseTotal
if $width == 3 0 0 0
1257 0 ▶ return unpack('N', $data) if $width == 4;
Branch: 1 branch
BranchTrueFalseTotal
if $width == 4 0 0 0
1258 0 ▶ return unpack('Q>', $data) if $width == 8;
Branch: 1 branch
BranchTrueFalseTotal
if $width == 8 0 0 0
1259  
1260 0 die "Unsupported xref stream entry width: $width";
1261 }
1262  
1263 sub readxrtr {
1264 19 ▶ my ($self, $xpos) = @_;
Subroutine readxrtr: called CC=26 SCAR=33.3
Pod documented
1265 19 my ($tdict, $buf, $xmin, $xnum, $xdiff);
1266  
1267 19 my $fh = $self->{' INFILE'};
1268 19 $fh->seek($xpos, 0);
1269 19 $fh->read($buf, 22);
1270 19 $buf = update($fh, $buf); # fix for broken JAWS xref calculation.
1271  
1272 19 my $xlist = {};
1273  
1274 ## seams that some products calculate wrong prev entries (short)
1275 ## so we seek ahead to find one -- fredo; save for now
1276 #while($buf !~ m/^xref$cr/i && !eof($fh))
1277 #{
1278 # $buf =~ s/^(\s+|\S+|.)//i;
1279 # $buf=update($fh,$buf);
1280 #}
1281  
1282 19 ▶ if ($buf =~ s/^xref$cr//i) {
Branch: 2 branches
BranchTrueFalseTotal
if ($buf =~ s/^xref$PDF::API2::Basic::PDF::File::cr//i) { } 16 3 19
elsif ($buf =~ /^(\d+)\s+(\d+)\s+obj/i) { } 3 0 3
1283 # Plain XRef tables.
1284 16 ▶ while ($buf =~ m/^$ws_char*([0-9]+)$ws_char+([0-9]+)$ws_char*$cr(.*?)$/s) {
Branch: 1 branch
BranchTrueFalseTotal
if ($buf =~ /^$PDF::API2::Basic::PDF::File::ws_char*([0-9]+)$PDF::API2::Basic::PDF::File::ws_char+([0-9]+)$PDF::API2::Basic::PDF::File::ws_char*$PDF::API2::Basic::PDF::File::cr(.*?)$/s) 21 16 37
1285 21 my $old_buf = $buf;
1286 21 $xmin = $1;
1287 21 $xnum = $2;
1288 21 $buf = $3;
1289 21 ▶ unless ($old_buf =~ /^[0-9]+ [0-9]+$cr/) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($old_buf =~ /^[0-9]+ [0-9]+$PDF::API2::Basic::PDF::File::cr/) 0 21 21
1290 # See PDF 1.7 section 7.5.4: Cross-Reference Table
1291 0 warn q{Malformed xref in PDF file: subsection shall begin with a line containing two numbers separated by a SPACE (20h)};
1292 }
1293 21 $xdiff = length($buf);
1294  
1295 21 $fh->read($buf, 20 * $xnum - $xdiff + 15, $xdiff);
1296 21 ▶ while ($xnum-- > 0 and $buf =~ s/^0*([0-9]*)$ws_char+0*([0-9]+)$ws_char+([nf])$cr//) {
Branch: 1 branch
BranchTrueFalseTotal
if ($xnum-- > 0 and $buf =~ s/^0*([0-9]*)$PDF::API2::Basic::PDF::File::ws_char+0*([0-9]+)$PDF::API2::Basic::PDF::File::ws_char+([nf])$PDF::API2::Basic::PDF::File::cr//) 118 21 139
Condition66%2/3
$xnum-- > 0 and $buf =~ s/^0*([0-9]*)$PDF::API2::Basic::PDF::File::ws_char+0*([0-9]+)$PDF::API2::Basic::PDF::File::ws_char+([nf])$PDF::API2::Basic::PDF::File::cr//
!ll&&!rl&&r
210118
MC/DC50%1/2
$xnum-- > 0 and $buf =~ s/^0*([0-9]*)$PDF::API2::Basic::PDF::File::ws_char+0*([0-9]+)$PDF::API2::Basic::PDF::File::ws_char+([nf])$PDF::API2::Basic::PDF::File::cr//
$xnum-- > 0 $buf =~ s/^0*([0-9]*)$PDF::API2::Basic::PDF::File::ws_char+0*([0-9]+)$PDF::API2::Basic::PDF::File::ws_char+([nf])$PDF::API2::Basic::PDF::File::cr//
Truth table66%2/3
A and B
A= $xnum-- > 0B= $buf =~ s/^0*([0-9]*)$PDF::API2::Basic::PDF::File::ws_char+0*([0-9]+)$PDF::API2::Basic::PDF::File::ws_char+([nf])$PDF::API2::Basic::PDF::File::cr//
ABresult
0X0
100
111
1297 118 ▶ $xlist->{$xmin} = [$1, $2, $3] unless exists $xlist->{$xmin};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $xlist->{$xmin} 118 0 118
1298 118 $xmin++;
1299 }
1300 }
1301  
1302 16 ▶ if ($buf !~ /^\s*trailer\b/i) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($buf =~ /^\s*trailer\b/i) 0 16 16
1303 0 die "Malformed trailer in PDF file $self->{' fname'} at " . ($fh->tell - length($buf));
1304 }
1305  
1306 16 $buf =~ s/^\s*trailer\b//i;
1307  
1308 16 ($tdict, $buf) = $self->readval($buf);
1309 }
1310 elsif ($buf =~ m/^(\d+)\s+(\d+)\s+obj/i) {
1311 3 my ($xref_obj, $xref_gen) = ($1, $2);
1312  
1313 # XRef streams.
1314 3 ($tdict, $buf) = $self->readval($buf);
1315  
1316 3 ▶ unless ($tdict->{' stream'}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($tdict->{" stream"}) 0 3 3
1317 0 die "Malformed XRefStm at $xref_obj $xref_gen obj in PDF file $self->{' fname'}";
1318 }
1319 3 $tdict->read_stream(1);
1320  
1321 3 my $stream = $tdict->{' stream'};
1322 3 my @widths = map { $_->val } @{$tdict->{W}->val};
1323  
1324 3 my $start = 0;
1325 3 my $last;
1326  
1327 my @index;
1328 3 ▶ if (defined $tdict->{Index}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $tdict->{'Index'}) { } 1 2 3
1329 1 @index = map { $_->val() } @{$tdict->{Index}->val};
1330 }
1331 else {
1332 2 @index = (0, $tdict->{Size}->val);
1333 }
1334  
1335 3 ▶ while (scalar @index) {
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @index) 3 3 6
1336 3 $start = shift(@index);
1337 3 $last = $start + shift(@index) - 1;
1338  
1339 3 for my $i ($start...$last) {
1340 # Replaced "for $xmin" because it creates a loop-specific local variable, and we
1341 # need $xmin to be correct for maxobj below.
1342 26 $xmin = $i;
1343  
1344 26 my @cols;
1345  
1346 26 for my $w (@widths) {
1347 78 my $data;
1348 78 ▶ $data = $self->_unpack_xref_stream($w, substr($stream, 0, $w, '')) if $w;
Branch: 1 branch
BranchTrueFalseTotal
if $w 78 0 78
1349  
1350 78 push @cols, $data;
1351 }
1352  
1353 26 ▶ $cols[0] = 1 unless defined $cols[0];
Branch: 1 branch
BranchTrueFalseTotal
unless defined $cols[0] 1 25 26
1354 26 ▶ if ($cols[0] > 2) {
Branch: 1 branch
BranchTrueFalseTotal
if ($cols[0] > 2) 0 26 26
1355 0 die "Invalid XRefStm entry type ($cols[0]) at $xref_obj $xref_gen obj";
1356 }
1357  
1358 26 ▶ next if exists $xlist->{$xmin};
Branch: 1 branch
BranchTrueFalseTotal
if exists $xlist->{$xmin} 0 26 26
1359  
1360 26 ▶ my @objind = ($cols[1], defined($cols[2]) ? $cols[2] : ($xmin ? 0 : 65535));
Branch: 2 branches
BranchTrueFalseTotal
defined $cols[2] ? : 25 1 26
$xmin ? : 1 0 1
1361 26 ▶ push @objind, ($cols[0] == 0 ? 'f' : 'n') if $cols[0] < 2;
Branch: 2 branches
BranchTrueFalseTotal
if $cols[0] < 2 22 4 26
$cols[0] == 0 ? : 2 20 22
1362  
1363 26 $xlist->{$xmin} = \@objind;
1364 }
1365 }
1366 }
1367 else {
1368 0 die "Malformed xref in PDF file $self->{' fname'}";
1369 }
1370  
1371 19 $tdict->{' loc'} = $xpos;
1372 19 $tdict->{' xref'} = $xlist;
1373 19 ▶ $self->{' maxobj'} = $xmin + 1 if $xmin + 1 > $self->{' maxobj'};
Branch: 1 branch
BranchTrueFalseTotal
if $xmin + 1 > $self->{" maxobj"} 16 3 19
1374 $tdict->{' prev'} = $self->readxrtr($tdict->{'Prev'}->val)
1375 19 ▶ if (defined $tdict->{'Prev'} and $tdict->{'Prev'}->val != 0);
Branch: 1 branch
BranchTrueFalseTotal
if defined $tdict->{"Prev"} and $tdict->{"Prev"}->val != 0 3 16 19
Condition66%2/3
defined $tdict->{"Prev"} and $tdict->{"Prev"}->val != 0
!ll&&!rl&&r
1603
MC/DC50%1/2
defined $tdict->{"Prev"} and $tdict->{"Prev"}->val != 0
defined $tdict->{"Prev"} $tdict->{"Prev"}->val != 0
Truth table66%2/3
A and B
A= defined $tdict->{"Prev"}B= $tdict->{"Prev"}->val != 0
ABresult
0X0
100
111
1376 19 ▶ delete $tdict->{' prev'} unless defined $tdict->{' prev'};
Branch: 1 branch
BranchTrueFalseTotal
unless defined $tdict->{" prev"} 16 3 19
1377 19 return $tdict;
1378 }
1379  
1380  
1381 =head2 $p->out_trailer($tdict)
1382  
1383 Outputs the body and trailer for a PDF file by outputting all the objects in
1384 the ' outlist' and then outputting a xref table for those objects and any
1385 freed ones. It then outputs the trailing dictionary and the trailer code.
1386  
1387 =cut
1388  
1389 sub out_trailer {
1390 148 ▶ my ($self, $tdict, $update) = @_;
Subroutine out_trailer: called CC=31 SCAR=47.7
Pod documented
1391 148 my $fh = $self->{' OUTFILE'};
1392  
1393 148 ▶ while (@{$self->{' outlist'}}) {
Branch: 1 branch
BranchTrueFalseTotal
if (@{$self->{" outlist"};}) 154 148 302
1394 154 $self->ship_out();
1395 }
1396  
1397 # When writing new trailers, most dictionary entries get copied from the
1398 # previous trailer, but entries related to cross-reference streams should
1399 # get removed (and possibly recreated below).
1400 148 delete $tdict->{$_} for (# Entries common to streams
1401 qw(Length Filter DecodeParms F FFilter FDecodeParms DL),
1402  
1403 # Entries specific to cross-reference streams
1404 qw(Index W XRefStm));
1405  
1406 148 $tdict->{'Size'} = PDFNum($self->{' maxobj'});
1407  
1408 148 my $tloc = $fh->tell();
1409 148 my @out;
1410  
1411 148 ▶ my @xreflist = sort { $self->{' objects'}{$a->uid}[0] <=> $self->{' objects'}{$b->uid}[0] } (@{$self->{' printed'} || []}, @{$self->{' free'} || []});
Branch: 2 branches
BranchTrueFalseTotal
$self->{" printed"} or [] 3 145 148
$self->{" free"} or [] 3 145 148
1412  
1413 148 my ($i, $j, $k);
1414 148 ▶ unless ($update) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($update) 140 8 148
1415 140 $i = 1;
1416 140 ▶ for ($j = 0; $j < @xreflist; $j++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($j < @xreflist) 868 140 1008
1417 868 my @inserts;
1418 868 $k = $xreflist[$j];
1419 868 ▶ while ($i < $self->{' objects'}{$k->uid}[0]) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < $self->{" objects"}{$k->uid}[0]) 0 868 868
1420 0 my ($n) = PDF::API2::Basic::PDF::Objind->new();
1421 0 $self->add_obj($n, $i, 0);
1422 0 $self->free_obj($n);
1423 0 push(@inserts, $n);
1424 0 $i++;
1425 }
1426 868 splice(@xreflist, $j, 0, @inserts);
1427 868 $j += @inserts;
1428 868 $i++;
1429 }
1430 }
1431  
1432 148 ▶ my @freelist = sort { $self->{' objects'}{$a->uid}[0] <=> $self->{' objects'}{$b->uid}[0] } @{$self->{' free'} || []};
Branch: 1 branch
BranchTrueFalseTotal
$self->{" free"} or [] 3 145 148
1433  
1434 148 $j = 0; my $first = -1; $k = 0;
1435 148 ▶ for ($i = 0; $i <= $#xreflist + 1; $i++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i <= $#xreflist + 1) 1038 148 1186
1436 1038 ▶ if ($i > $#xreflist || $self->{' objects'}{$xreflist[$i]->uid}[0] != $j + 1) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i > $#xreflist or $self->{' objects'}{$xreflist[$i]->uid}[0] != $j + 1) { } 160 878 1038
Condition100%3/3
$i > $#xreflist or $self->{" objects"}{$xreflist[$i]->uid}[0] != $j + 1
l!l&&r!l&&!r
14812878
MC/DC100%2/2
$i > $#xreflist or $self->{" objects"}{$xreflist[$i]->uid}[0] != $j + 1
$i > $#xreflist $self->{" objects"}{$xreflist[$i]->uid}[0] != $j + 1
Truth table100%3/3
A or B
A= $i > $#xreflistB= $self->{" objects"}{$xreflist[$i]->uid}[0] != $j + 1
ABresult
1X1
011
000
1437 160 ▶ push @out, ($first == -1 ? "0 " : "$self->{' objects'}{$xreflist[$first]->uid}[0] ") . ($i - $first) . "\n";
Branch: 1 branch
BranchTrueFalseTotal
$first == -1 ? : 148 12 160
1438 160 ▶ if ($first == -1) {
Branch: 1 branch
BranchTrueFalseTotal
if ($first == -1) 148 12 160
1439 148 ▶ push @out, sprintf("%010d 65535 f \n", defined $freelist[$k] ? $self->{' objects'}{$freelist[$k]->uid}[0] : 0);
Branch: 1 branch
BranchTrueFalseTotal
defined $freelist[$k] ? : 0 148 148
1440 148 $first = 0;
1441 }
1442 160 ▶ for ($j = $first; $j < $i; $j++) {
Branch: 1 branch
BranchTrueFalseTotal
if ($j < $i) 890 160 1050
1443 890 my $xref = $xreflist[$j];
1444 890 ▶ if (defined($freelist[$k]) and defined($xref) and "$freelist[$k]" eq "$xref") {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $freelist[$k] and defined $xref and "$freelist[$k]" eq "$xref") { } 0 890 890
Condition33%2/6
defined $freelist[$k] and defined $xref and "$freelist[$k]" eq "$xref"
!ll&&!rl&&r
89000
defined $freelist[$k] and defined $xref
!ll&&!rl&&r
89000
MC/DC0%0/3
defined $freelist[$k] and defined $xref and "$freelist[$k]" eq "$xref"
defined $freelist[$k] defined $xref "$freelist[$k]" eq "$xref"
Truth table25%1/4
A and B and C
A= defined $freelist[$k]B= defined $xrefC= "$freelist[$k]" eq "$xref"
ABCresult
0XX0
10X0
1100
1111
1445 0 $k++;
1446 push @out, pack("A10AA5A4",
1447 sprintf("%010d", (defined $freelist[$k] ?
1448 $self->{' objects'}{$freelist[$k]->uid}[0] : 0)), " ",
1449 0 ▶ sprintf("%05d", $self->{' objects'}{$xref->uid}[1] + 1),
Branch: 1 branch
BranchTrueFalseTotal
defined $freelist[$k] ? : 0 0 0
1450 " f \n");
1451 }
1452 else {
1453 push @out, pack("A10AA5A4", sprintf("%010d", $self->{' locs'}{$xref->uid}), " ",
1454 890 sprintf("%05d", $self->{' objects'}{$xref->uid}[1]),
1455 " n \n");
1456 }
1457 }
1458 160 $first = $i;
1459 160 ▶ $j = $self->{' objects'}{$xreflist[$i]->uid}[0] if ($i < scalar @xreflist);
Branch: 1 branch
BranchTrueFalseTotal
if $i < scalar @xreflist 12 148 160
1460 }
1461 else {
1462 878 $j++;
1463 }
1464 }
1465 148 ▶ if (exists $tdict->{'Type'} and $tdict->{'Type'}->val() eq 'XRef') {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $tdict->{'Type'} and $tdict->{'Type'}->val eq 'XRef') { } 0 148 148
Condition33%1/3
exists $tdict->{"Type"} and $tdict->{"Type"}->val eq "XRef"
!ll&&!rl&&r
14800
MC/DC0%0/2
exists $tdict->{"Type"} and $tdict->{"Type"}->val eq "XRef"
exists $tdict->{"Type"} $tdict->{"Type"}->val eq "XRef"
Truth table33%1/3
A and B
A= exists $tdict->{"Type"}B= $tdict->{"Type"}->val eq "XRef"
ABresult
0X0
100
111
1466 0 my (@index, @stream);
1467 0 for (@out) {
1468 0 my @a = split;
1469 0 ▶ @a == 2 ? push @index, @a : push @stream, \@a;
Branch: 1 branch
BranchTrueFalseTotal
@a == 2 ? : 0 0 0
1470 }
1471 0 my $i = $self->{' maxobj'}++;
1472 0 $self->add_obj($tdict, $i, 0);
1473 0 $self->out_obj($tdict );
1474  
1475 0 push @index, $i, 1;
1476 0 push @stream, [$tloc, 0, 'n'];
1477  
1478 0 ▶ my $len = $tloc > 0xFFFF ? 4 : 2; # don't expect files > 4 Gb
Branch: 1 branch
BranchTrueFalseTotal
$tloc > 65535 ? : 0 0 0
1479 0 ▶ my $tpl = $tloc > 0xFFFF ? 'CNC' : 'CnC'; # don't expect gennum > 255, it's absurd.
Branch: 1 branch
BranchTrueFalseTotal
$tloc > 65535 ? : 0 0 0
1480 # Adobe doesn't use them anymore anyway
1481 0 my $stream = '';
1482 0 my @prev = (0) x ($len + 2);
1483 0 for (@stream) {
1484 0 ▶ $_->[1] = 0 if $_->[2] eq 'f' and $_->[1] == 65535;
Branch: 1 branch
BranchTrueFalseTotal
if $_->[2] eq "f" and $_->[1] == 65535 0 0 0
Condition0%0/3
$_->[2] eq "f" and $_->[1] == 65535
!ll&&!rl&&r
000
MC/DC0%0/2
$_->[2] eq "f" and $_->[1] == 65535
$_->[2] eq "f" $_->[1] == 65535
Truth table0%0/3
A and B
A= $_->[2] eq "f"B= $_->[1] == 65535
ABresult
0X0
100
111
1485 0 ▶ my @line = unpack 'C*', pack $tpl, $_->[2] eq 'n' ? 1 : 0, @{$_}[0..1];
Branch: 1 branch
BranchTrueFalseTotal
$_->[2] eq 'n' ? : 0 0 0
1486  
1487 $stream .= pack 'C*', 2, # prepend filtering method, "PNG Up"
1488 0 map {($line[$_] - $prev[$_] + 256) % 256 } 0 .. $#line;
1489 0 @prev = @line;
1490 }
1491 0 $tdict->{'Size'} = PDFNum($i + 1);
1492 0 $tdict->{'Index'} = PDFArray(map PDFNum( $_ ), @index);
1493 0 $tdict->{'W'} = PDFArray(map PDFNum( $_ ), 1, $len, 1);
1494 0 $tdict->{'Filter'} = PDFName('FlateDecode');
1495  
1496 0 $tdict->{'DecodeParms'} = PDFDict();
1497 0 $tdict->{'DecodeParms'}->val->{'Predictor'} = PDFNum(12);
1498 0 $tdict->{'DecodeParms'}->val->{'Columns'} = PDFNum($len + 2);
1499  
1500 0 $stream = PDF::API2::Basic::PDF::Filter::FlateDecode->new->outfilt($stream, 1);
1501 0 $tdict->{' stream'} = $stream;
1502 0 $tdict->{' nofilt'} = 1;
1503 0 delete $tdict->{'Length'};
1504 0 $self->ship_out();
1505 }
1506 else {
1507 148 $fh->print("xref\n", @out, "trailer\n");
1508 148 $tdict->outobjdeep($fh, $self);
1509 148 $fh->print("\n");
1510 }
1511 148 $fh->print("startxref\n$tloc\n%%EOF\n");
1512 }
1513  
1514  
1515 =head2 PDF::API2::Basic::PDF::File->_new
1516  
1517 Creates a very empty PDF file object (used by new and open)
1518  
1519 =cut
1520  
1521 sub _new {
1522 180 ▶ my $class = shift();
Subroutine _new: called CC=1 SCAR=0.0
1523 180 my $self = {};
1524  
1525 180 bless $self, $class;
1526 180 $self->{' outlist'} = [];
1527 180 $self->{' outlist_cache'} = {}; # A cache of whats in the 'outlist'
1528 180 $self->{' maxobj'} = 1;
1529 180 $self->{' objcache'} = {};
1530 180 $self->{' objects'} = {};
1531  
1532 180 return $self;
1533 }
1534  
1535 39 1;
1536  
1537 =head1 AUTHOR
1538  
1539 Martin Hosken Martin_Hosken@sil.org
1540  
1541 Copyright Martin Hosken 1999 and onwards
1542  
1543 No warranty or expression of effectiveness, least of all regarding anyone's
1544 safety, is implied in this software or documentation.
« API2/Resource/Font/SynFont.pm ↑ Summary API2/Resource/Font/BdFont.pm »