Current File : //proc/thread-self/root/proc/thread-self/root/usr/share/ghostscript/Resource/Init/pdf_main.ps
% Copyright (C) 2001-2019 Artifex Software, Inc.
% All Rights Reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc., 1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%
% pdf_main.ps
% PDF file- and page-level operations.
/.setlanguagelevel where { pop 2 .setlanguagelevel } if
.currentglobal //true .setglobal
pdfdict begin
/GS_PDF_ProcSet dup load def % keep in pdfdict to hide it
userdict /GS_PDF_ProcSet undef
% Patch in an obsolete variable used by some third-party software.
/#? //false def
% Test whether the current output device handles pdfmark.
/.writepdfmarkdict 1 dict dup /pdfmark //null put readonly def
/.writepdfmarks { % - .writepdfmarks <bool>
currentdevice //.writepdfmarkdict .getdeviceparams
mark eq { //false } { pop pop //true } ifelse
systemdict /DOPDFMARKS known or
} bind executeonly def
% For simplicity, we use a single interpretation dictionary for all
% PDF graphics execution, even though this is too liberal.
/pdfopdict mark
objopdict { } forall
drawopdict { } forall
/endstream { exit } bind executeonly
(%%EOF) cvn { exit } bind executeonly % for filters
/obj { ( **** Error: Content stream is not terminated by 'endstream'.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} bind executeonly
% PDF 1.1 operators
/BX { /BXlevel BXlevel 1 add store } bind executeonly
/EX { /BXlevel BXlevel 1 sub store } bind executeonly
/PS { cvx exec } bind executeonly
% PDF 1.2 operators
/BMC {
/BMClevel BMClevel 1 add store
pop
} bind executeonly
/BDC {
/BMClevel BMClevel 1 add store
exch /OC eq {
dup type /nametype eq {
PDFfile fileposition exch % pos /Name
Page /Properties rget {
ocg-is-visible not {
OFFlevels BMClevel dup put
} if
} if
PDFfile exch setfileposition
} {
pop
} ifelse
} {
pop
} ifelse
} bind executeonly
/EMC {
OFFlevels BMClevel
2 copy known {
2 copy undef
} if
1 sub /BMClevel exch store
pop
} bind executeonly
/MP { pop } bind
/DP { pop pop } bind
/- { 0 % Bug 690016
( **** Error: Invalid operator '-' is assumed to be the number 0.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} bind executeonly
/Recursive_XObject_D 1 dict def
.dicttomark readonly def
% This dictionaty encapsulates all that is needed to generate pagelabel pdfmarks.
%
% This is provided by Leon Bottou for the benefit of the djvudigital device
% which is a device developed and maintained outside of Artifex, and which is
% not a contributed device.
%
% This device does not cope with the method used by pdfwrite to pass the pagelabels
% number tree as a 'blob' of data, but requires that the page labels be passed using
% a PAGELABEL pdfmark.
%
% We don't want to do that with pdfwrite because there is no mechanism in pdfmark syntax
% to pass a tree, which means we'd have to laboriously disassemble the pdfmarks for the
% page labels and rebuild a number tree for it. This would mean pattern matching each
% string passed via PAGELABEL to see if it could be defined as a continuation
% of the preceding string, uing prefixes. Its much easier for us just to pass the tree.
%
% Note that this code simply translates the PageLabels Number tree into a number of
% individual PAGELABEL pdfmarks, if used for pdfwrite this would result in a number
% tree which consists solely of leaf nodes, where each node has a string for its label.
% This can be considerably more verbose than the shorthand possible with a Page Label
% dictionary.
%
/pagelabeldict mark
% (TEXT) .toLower (text)
/.toLower {
dup length 1 sub -1 0 {
1 index exch 2 copy get 2#00100000 or put
} for
} bind executeonly
% int .cvAlpha (int in alphabetic base 26)
/.cvAlpha {
[ exch % construct an array of ASCII values, in reverse
{ % the remainder stays on the top of stack
dup 0 eq { pop exit } if % quit if the value is zero
dup 26 mod dup 0 eq { 26 add } if % so that the division is correct
dup 64 add 3 1 roll sub 26 idiv % save the ASCII value and iterate
} loop ]
dup length dup string 3 1 roll
dup -1 1 { % put the letters in a string
4 copy sub exch 4 -1 roll 1 sub get put
} for pop pop
} bind executeonly
% int .cvRoman (int in capital Roman numerals)
% convert a positive integer to capital Roman numerals
% return a decimal string if >= 4000
/.cvRoman {
dup 255 string cvs % start with the decimal representation
exch 4000 lt { % convert only if Roman numerals can represent this
dup length
[ [ () (I) (II) (III) (IV) (V) (VI) (VII) (VIII) (IX) ]
[ () (X) (XX) (XXX) (XL) (L) (LX) (LXX) (LXXX) (XC) ]
[ () (C) (CC) (CCC) (CD) (D) (DC) (DCC) (DCCC) (CM) ]
[ () (M) (MM) (MMM) ] ] % Roman equivalents
() % append the Roman equivalent of each decimal digit to this string
2 index -1 1 {
2 index 1 index 1 sub get
5 index 5 index 4 -1 roll sub get
48 sub get concatstrings
} for
4 1 roll pop pop pop
} if
} bind executeonly
% style printers
/PageStyle <<
/D { 255 string cvs } bind executeonly
/R { .cvRoman } executeonly
/r { .cvRoman .toLower } executeonly
/A { .cvAlpha } executeonly
/a { .cvAlpha .toLower } executeonly >>
% check whether we want to generate pdfmarks
/wantpagelabelmarks {
% WantsPageLabels means that pagelabels will be passed
% using .pdfpagelabels and not using pdfmarks
/WantsPageLabels /GetDeviceParam .special_op
{pop pop //false}{//true} ifelse
%% This is truly ugly.....
%% GSView 5 redefines pdfmark and processes it itself. However if it gets
%% a pdfmark it cannot cope with, it simply fails. Its not prepared to cope
%% with PAGELABEL pdfmarks, so we don't want to send it to them. There's no
%% way for us to fix GSView 5, its long out of any kind of support, but we do
%% try not to break it. We happen to know that GSView 5 installs a GSview
%% dictionary in userdict, so this test simply ensures we don't emit PAGELABEL
%% pdfmarks if that dictioanry is present.
userdict /GSview known {pop //false} if
} bind executeonly
% generate pagelabel pdfmark
/dopagelabel { % -- dopagelabel --
<< /S //null /P () /O 0 >> begin
wantpagelabelmarks {
Trailer /Root knownoget {
oforce /PageLabels knownoget {
oforce Page# 1 sub
numogetle
{ oforce
dup /S knownoget not { //false } if /S exch def
dup /P knownoget not { 0 string } if /P exch def
/St knownoget not { 1 } if exch sub /O exch def
} if
P Page# 1 sub O add PageStyle S knownoget { exec concatstrings } if
mark /Label 3 -1 roll /PAGELABEL pdfmark
} if
} if
} if
end
} bind executeonly
.dicttomark readonly def
% ======================== Main program ======================== %
end % pdfdict
userdict begin
/defaultfontname /Times-Roman def
% Make sure the registered encodings are loaded, so we don't run the risk
% that some of the indices for their names will overflow the packed
% representation. (Yes, this is a hack.)
SymbolEncoding pop
DingbatsEncoding pop
% Redefine 'run' so it recognizes PDF files.
systemdict begin
/.runps /run load def
/run {
dup type /filetype ne { (r) file } if
% skip leading whitespace characters (actually anything less than or equal to <sp>)
{ dup ( ) .peekstring not { //false exit } if
dup 0 get 32 le { pop dup read pop pop } { //true exit } ifelse
} loop
exch pop
{
% Appletalk PAP sends short strings with %! header expecting a response.
% 'gv' swallows the %!PS line, then sends DSC comments beginning with %%
% and also waits for a response. The following avoids those hangs.
dup 2 string .peekstring pop dup (%!) eq exch (%%) eq or {
cvx .runps
} {
dup 1023 string .peekstring pop
% "1024 string" exceeds current %stdin buffer
% Valid PDF file cannot be smaller than 400 bytes.
(%PDF-) search {
3 1 roll pop pop
dup (%!PS) search not {
length 0 ne {
1 index exch readstring pop pop
(%stderr) (w) file dup
( **** Warning: File has some garbage before %PDF- .\n)
writestring flushfile
} {
pop
} ifelse
dup (%stdin) (r) file eq {
% Copy PDF from stdin to temporary file then run it.
//null (w+) /.tempfile .systemvar exec exch 3 1 roll
% stack: tempname stdin tempfile
64000 string
{
% stack: tempname stdin tempfile string
2 index 1 index readstring
exch 3 index exch writestring
not { exit } if
}
loop
pop exch closefile
% stack: tempname tempfile
dup 0 setfileposition
dup
runpdf
closefile deletefile
} {
runpdf
} ifelse
} {
pop pop pop pop cvx .runps % (%!PS) found first
} ifelse
} {
pop cvx .runps % (%PDF-) not found
} ifelse
} ifelse
} {
closefile % file was empty
} ifelse
} bind odef
currentdict /runpdfstring .undef
/runpdfbegin { % <file> runpdfbegin -
userdict begin
% It turns out that the PDF interpreter uses memory more
% effectively if it is run under at least one level of save.
% This is counter-intuitive, and we don't understand why it happens,
% but the improvement is significant.
/PDFTopSave save def
<</ProcessDSCComment //null>> setuserparams
<</ProcessComment //null>> setuserparams
%% Bug #696487, allow dict stack to grow without limit, as these PDF
%% files have stupidly deep gsave nesting and we need a dictionary per gsave
%% at the moment.
%% Remove ths if bug #696511 is ever completed (move ExtGstate parameters into gstate)
<</MaxDictStack -1>> setuserparams
%% Bug #696567, same customer as above. Ths time they have a file with a page whch has
%% 447000 ExtGState references (all of hwch contain no gstate!) Because we allocate
%% these on the stack, allow the stack to grow indefinitely in order to accomodate
%% such stupid files. Also move these lines from the end of the routine, so that
%% the increases are in place before we call odfopen, which will build the
%% resources and needs this definition in place.
<</MaxOpStack -1>> setuserparams
0 setobjectformat
/Page# //null def
/Page //null def
/DSCPageCount 0 def
/PDFSave //null def
//pdfdict /GS_PDF_ProcSet get begin
//pdfdict begin
pdfopen begin
/CumulativePageCount currentpagedevice /PageCount get def
} bind executeonly def
/runpdfpagerange { % - runpdfpagerange <firstpage#> <lastpage#>
<</DisablePageHandler //true>> setpagedevice
/PortfolioPage where {
pop
PortfolioPage cvi dup pdfpagecount add % a b+1
/PortfolioPage dup load % a b+1 /P ()
( ) 1 index copy pop
dup 3 index exch cvs pop % a b+1 /P (b+1)
store
1 sub % a b
/FirstPage where { pop FirstPage <</DisablePageHandler //true>> setpagedevice} { 1 } ifelse
/LastPage where { pop LastPage <</DisablePageHandler //true>> setpagedevice} {2000000000} ifelse % a b fp lp
2 index 2 index lt { % b < fp
1e10
} {
3 index 2 index gt { % a > fp
1
} {
1 index 4 index sub 1 add
} ifelse
} ifelse % a b fp lp f
3 index 2 index lt { % b < bp
3 index 5 index sub 1 add % b-a+1=count
} {
4 index 2 index gt {
0
} {
1 index 5 index sub 1 add
} ifelse
} ifelse % a b fp lp f l
6 2 roll pop pop pop pop
QUIET not {
1 index 1 index gt {
(Skipping the subfile.) = flush
} {
(Processing pages ) print 1 index =only ( through ) print dup =only
(.) = flush
} ifelse
} if
} {
/PageList where {
pop PageList
(even) anchorsearch {
pop length 0 gt {
/runpdfpagerange /syntaxerror cvx signalerror
} if
/PDFPageList pdfpagecount 1 add array def
2 2 pdfpagecount {
PDFPageList exch 1 put
} for
1 pdfpagecount
QUIET not {
(Processing even-numbered pages\n) print
(.) = flush
} if
} {
(odd) anchorsearch {
pop length 0 gt {
/runpdfpagerange /syntaxerror cvx signalerror
} if
/PDFPageList pdfpagecount 1 add array def
1 2 pdfpagecount {
PDFPageList exch 1 put
} for
1 pdfpagecount
QUIET not {
(Processing odd-numbered pages\n) print 1 index =only ( through ) print dup =only
(.) = flush
} if
} {
%% validate string contents, check for digit comma or minus
dup
{
dup 44 eq not {
dup 45 eq not {
dup 48 lt 1 index 57 gt or {
/runpdfpagerange /syntaxerror cvx signalerror
} if
} if
} if
pop
}
forall
<</DisablePageHandler //true>> setpagedevice
/PDFPageList pdfpagecount 1 add array def
{
(,) search {
%% We now have (post) (,) (pre)
exch pop %% get rid of the (,), leave the (post) as the string for the next iteration, deal with the section up to the comma
(-) search {
%% Now we have (end) (-) (start)
exch pop %% get rid of the minus (end) (start)
0 exch {48 sub exch 10 mul add} forall
%% Make sure the start of the range is inside the number of available pages
dup pdfpagecount le {
exch
%% deal with a trailing '-' by replacing it with the number of pages in the file
dup length 0 eq {
pop pdfpagecount
}{
0 exch {48 sub exch 10 mul add} forall
} ifelse
1 exch %% start 1 end
%% Make sure the end of the range is inside the number of available pages
dup pdfpagecount gt {pop pdfpagecount} if
{PDFPageList exch 1 put} for
} {
%% start of range invalid, drop this range.
pop pop
}ifelse
}{
%% no minus signs, must be a simple page number
0 exch {48 sub exch 10 mul add} forall
%% ensure its in the valid range of pages
dup pdfpagecount le {
PDFPageList exch 1 put
} {
pop
} ifelse
} ifelse
}{
%% no commas separating pages, just the original string (), deal with its as a section, then exit the loop
(-) search {
%% Now we have (end) (-) (start)
exch pop %% get rid of the minus (end) (start)
0 exch {48 sub exch 10 mul add} forall
%% Make sure the start of the range is inside the number of available pages
dup pdfpagecount le {
exch
%% deal with a trailing '-' by replacing it with the number of pages in the file
dup length 0 eq {
pop pdfpagecount
}{
0 exch {48 sub exch 10 mul add} forall
} ifelse
1 exch %% start 1 end
%% Make sure the end of the range is inside the number of available pages
dup pdfpagecount gt {pop pdfpagecount} if
{PDFPageList exch 1 put} for
} {
%% start of range invalid, drop this range.
pop pop
}ifelse
}{
%% no minus signs, must be a simple page number
0 exch {48 sub exch 10 mul add} forall
%% ensure its in the valid range of pages
dup pdfpagecount le {
PDFPageList exch 1 put
} {
pop
} ifelse
} ifelse
exit %% done all the sections.
} ifelse
} loop
QUIET not {
(Processing pages ) print PageList =only
(.) = flush
} if
} ifelse
} ifelse
1 pdfpagecount
}{
/FirstPage where {
<</DisablePageHandler //true>> setpagedevice
pop FirstPage dup pdfpagecount gt {
(\nRequested FirstPage is greater than the number of pages in the file: ) print
pdfpagecount = flush
} if
} {
1
} ifelse
/LastPage where {<</DisablePageHandler //true>> setpagedevice pop LastPage pdfpagecount .min } { pdfpagecount } ifelse
1 index 1 index gt {
( No pages will be processed \(FirstPage > LastPage\).) = flush
} {
QUIET not {
(Processing pages ) print 1 index =only ( through ) print dup =only
(.) = flush
} if
} ifelse
} ifelse
}ifelse
} bind executeonly def
/dopdfpages { % firstpage# lastpage# dopdfpages -
<< /PDFScanRules //true >> setuserparams % set scanning rules for PDF vs. PS
<< /RenderTTNotdef systemdict
/RENDERTTNOTDEF get >> setuserparams % Should we render TT /.notdef
1 exch
{
%% If we have a array of pages to render, use it.
/PDFPageList where {
pop dup PDFPageList exch get 1 eq
}
{//true} ifelse
{
dup /Page# exch store
QUIET not { (Page ) print dup //== exec flush } if
pdfgetpage pdfshowpage
}{
pop
}ifelse
} for
% Indicate that the number of spot colors is unknown in case the next page
% imaged is a PS file.
currentpagedevice /PageSpotColors known { << /PageSpotColors -1 >> setpagedevice } if
<< /PDFScanRules //null >> setuserparams % restore scanning rules for PS
} bind executeonly def
/runpdfend {
RepairedAnError
{
printrepairederror
} {
Repaired { printrepaired } if
} ifelse
currentdict pdfclose
end % temporary dict
end % pdfdict
end % GS_PDF_ProcSet
PDFTopSave restore
end % userdict
2 vmreclaim % couldn't hurt
} bind executeonly def
% Copy stream to an external temporary file and
% return the file name as PS name.
/copy_embedded_file {
//true resolvestream % strm
dup 1023 string .peekstring pop % "1024 string" exceeds current %stdin buffer
dup length 400 ge { % Valid PDF file cannot be smaller than 400 bytes.
(%PDF-) search {
pop pop pop //true
} {
pop //false
} ifelse
} {
pop //false
} ifelse {
//null (w) /.tempfile % strm (name) null (w) /.tempfile
.systemvar exec % strm (name) file
3 -1 roll % (name) file strm
32768 string % (name) file strm (buf)
{ 3 copy readstring % (name) file strm (buf) file (data) bool
3 1 roll % (name) file strm (buf) bool file (data)
writestring % (name) file strm (buf) bool
not { exit } if
} loop
pop closefile % (name) file
closefile % (name)
cvn % /name
} {
closefile
} ifelse
} bind executeonly def
% Recursively enumerate /Names entries
% <node> pdf_collection_names /temp_file_name ...
/pdf_collection_names {
dup /Names knownoget {
exch pop
{ oforce
dup type /dicttype eq {
/EF knownoget {
/F knownoget {
copy_embedded_file
} if
} if
} {
pop
} ifelse
} forall
} {
/Kids knownoget {
{ oforce
dup //null ne {
pdf_collection_names
} {
pop
} ifelse
} forall
} if
} ifelse
} bind executeonly def
% Copy selected subfiles to temporary files and return the file names
% as a PostScript names to protect them from restore.
% Currently, all PDF files in the Portfolio are extracted and returned.
%
% - pdf_collection_files [ /temp_file_name ... /temp_file_name
/pdf_collection_files {
mark
Trailer /Root knownoget {
dup /Collection oknown {
/Names knownoget {
/EmbeddedFiles knownoget {
pdf_collection_names
} if
} if
} {
pop
} ifelse
} if
} bind executeonly def
/runpdf { % <file> runpdf -
%% Get the PDF filename (it *must* be a file even if it came from stdin it gets
%% copied to a temporary file) and store it in pdfdict. We will use this for
%% hashing fonts to detect if fonts with the same name are from different files.
%%
dup currentglobal exch //true setglobal .getfilename exch setglobal /InputPDFFileName exch //pdfdict 3 1 roll .forceput
//runpdfbegin exec
//pdf_collection_files exec
dup mark eq {
pop
process_trailer_attrs
//runpdfpagerange exec
//dopdfpages exec
//runpdfend exec
} {
//runpdfend exec
]
(1 ) 10 string copy exch
{
dup type /filetype eq {
//runpdfbegin exec
dup /PortfolioPage exch def
process_trailer_attrs
//runpdfpagerange exec
//dopdfpages exec
//runpdfend exec
closefile
} {
.namestring dup (r) file
//runpdfbegin exec
/PortfolioPage 2 index def
process_trailer_attrs
//runpdfpagerange exec
//dopdfpages exec
//runpdfend exec
deletefile
} ifelse
} forall
pop
} ifelse
} bind executeonly odef
currentdict /pdf_collection_files .undef
end % systemdict
% Redefine the procedure that the C code uses for running piped input.
% It is OK to use { (%stdin) run } here, because a startjob cannot occur.
/.runstdin {
{ (%stdin) run } execute0
} bind executeonly def
end % userdict
pdfdict begin
% ======================== File parsing ======================== %
% Read the cross-reference and trailer sections.
% I believe the definitions here are only used when parsing the trailer
% dictionary and cross-reference table. So, following on from bug 697351
% we will validate the operands to /R here, because the trailer and xref
% are comparatively small. Note that the bug does not expose a problem
% here, but we probably ought to validate the operands. Of course, if
% they are invalid, the PDF file is probably unreadable anyway.
/traileropdict mark
(<<) cvn { /dictlevelcount dictlevelcount 1 add store mark } bind executeonly
(>>) cvn { { .dicttomark } stopped {
( **** Warning: File has unbalanced >> in trailer.\n) pdfformatwarning
} if
/dictlevelcount dictlevelcount 1 sub def
dictlevelcount 0 eq { exit } if
} bind executeonly
([) cvn { mark } bind executeonly % ditto
(]) cvn dup load
% /true true % see .pdfexectoken in pdf_base.ps
% /false false % ibid.
% /null null % ibid.
/R {
1 index type /integertype eq 1 index type /integertype eq and {
/resolveR cvx 3 packedarray cvx
} {
( **** Error: indirect object reference \(R\) encountered with invalid arguments.) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} bind executeonly % see Objects below
.dicttomark readonly def
% After reading entry count: skip whitespace, exit on a digit
% (presumably the object offset, otherwise throw /syntaxerror
/xref-char-dict <<
0 {} % \000
9 1 index % \t
10 1 index % \r
12 1 index % \f
13 1 index % \n
32 1 index % ' '
48 { exit } bind % '0'
49 1 index % '1'
50 1 index % '2'
51 1 index % '3'
52 1 index % '4'
53 1 index % '5'
54 1 index % '6'
55 1 index % '7'
56 1 index % '8'
57 1 index % '9'
116 { % 't'railer
PDFfile 7 string .peekstring not { () } if
dup /trailer eq {
% Empty xref section
pop exit
} {
( **** Warning: Invalid string \() exch concatstrings
(\) follows xref section header.\n) concatstrings
pdfformatwarning
/setxrefentry cvx /syntaxerror signalerror
} ifelse
} bind
>> readonly def
% Read original version (pre PDF 1.5) of the xref table.
% Note: The position is the location of 'xref'. The current PDFfile
% position is just after the 'XREF'.
/readorigxref % <pos> readorigxref <trailerdict>
{
pop % We do not need the position.
% First we search this (and any Previous) trailers, looking for
% the /Size of the xref. We use ths to initialise our storage
% of xref and similar objects. This avoids us havign to continually
% resize these objescts which is very wasteful, and leads to us
% spending much time in memory amanagement.
% Bug #696454
PDFfile fileposition
/dictlevelcount 0 def
/TrailerSizeError //false def
/TrailerSize 0 def
{
% Throw away the 'xref' data up to the trailer dictionary
PDFfile 0 (trailer) /SubFileDecode filter flushfile
% Now read the trailer dictionary
PDFfile traileropdict .pdfrun
dup /Size known {
% If we have a /Size then use it and exit this loop
/Size get /TrailerSize exch def
exit
}{
dup /Prev known {
% We don't have a Size, but we have a Previous, set up to read it.
/Prev get PDFfile exch setfileposition
}{
% No size and no Prev with a Size. Fall back to resizing the xref as we go.
pop
(*** Warning: No trailer dictionary with a Size detected, xref processing will be dynamic and slower) pdfformatwarning
/TrailerDict 0 def
exit
} ifelse
}ifelse
}loop
% Initialise the objects with the detected Size.
TrailerSize growPDFobjects
PDFfile exch setfileposition
0 % Initialize xref table error counter
//false % Have we seen at least one section entry in this xref ? Bug #694342
{ PDFfile token pop % first object # or trailer
dup /trailer eq {
%% check to see if we have seen at least an empty section for this xref
pop {exit}
{
%% we have not seen any section entries in an xref, not even an empty section (xref 0 0)
%% Bug 694342, treat this as an error and rebuild the xref.
/setxrefentry cvx /syntaxerror signalerror
} ifelse
}
{
%% remove the boolean telling us if we have a section or not, leaving the first object number
exch pop
} ifelse
PDFfile token pop % entry count
% remaining must be whitespace only (otherwise this xref Size was invalid.
{ PDFfile (0) .peekstring not { pop exit } if
0 get //xref-char-dict exch .knownget {
exec
} {
( **** Warning: xref subsection header has extra characters.\n)
pdfformatwarning
/setxrefentry cvx /syntaxerror signalerror
} ifelse
PDFfile read { pop } { exit } ifelse
} loop
% This section might be adding new objects:
% ensure that Objects and Generations are big enough.
% stack: <err count> <first obj> <entry count>
2 copy add
TrailerSize gt {
TrailerSizeError not {
/TrailerSizeError //true def
PDFSTOPONERROR not {
(**** Warning: Discovered more entries in xref than declared in trailer /Size\n) pdfformatwarning
} {
/readorigxref cvx /rangecheckerror signalerror
} ifelse
} if
% We now know that the /Size was wrong. We could read the whole table
% resizing on every section, but if there are a lot of sections we
% end up spending lots of time in memory management (Bug #696454) so
% instead add 64k to the first object number in the section. This will
% waste some memory, but is faster in ths case.
1 index 65534 add dup /TrailerSize exch def
growPDFobjects
} if
{ % stack: <err count> <obj num>
% Read xref line
PDFfile 20 string readstring pop % always read 20 chars.
token pop % object position
exch token pop % generation #
exch token pop % n or f
exch % stack: <err count> <obj#> <loc> <gen#> <tag> <remainder of line>
% check to make sure trailing garbage is just white space
//false 1 index { 32 gt or } forall {
6 -1 roll 1 add 6 1 roll % bump error count on garbage
dup (\n) search {
exch pop exch pop
} {
(\r) search {
exch pop exch pop
} if
} ifelse
length
PDFfile fileposition exch sub PDFfile exch setfileposition
} if
pop % Stack: <err count> <obj#> <loc> <gen#> <tag>
dup /n eq { % xref line tag is /n
pop % pop dup of line tag
1 index 0 eq {
( **** Warning: considering '0000000000 XXXXX n' as a free entry.\n)
pdfformatwarning
} {
0 3 1 roll % Set ObjectStream object number = 0
//false setxrefentry % Save xref entry, don't change existing entries
3 -1 roll pop % Remove ObjectStream object onumber
} ifelse
}
{ % xref line tag was not /n
/f ne % verify that the tag was /f
{ /setxrefentry cvx /syntaxerror signalerror
} if
} ifelse
pop pop % pop <obj location> and <gen num>
% stack: <err count> <obj num>
1 add % increment object number
} repeat
pop % pop <obj #>
//true % We have seen at least one entry in an xref section Bug #694342
} loop
0 ne {
( **** Warning: length of some xref entries is not equal to 20 bytes.\n)
pdfformatwarning
} if
PDFfile traileropdict .pdfrun
} bind executeonly def
currentdict /xref-char-dict undef
% This dicitonary is used to read the xref dictionary. It should work for
% reading any dictionary. dictlevelcount must contain 0.
/xrefopdict mark
(<<) cvn { /dictlevelcount dictlevelcount 1 add def mark } bind executeonly
(>>) cvn { .dicttomark /dictlevelcount dictlevelcount 1 sub def
dictlevelcount 0 eq { exit} if } bind executeonly
([) cvn { mark } bind executeonly % ditto
(]) cvn dup load
% /true true % see .pdfexectoken in pdf_base.ps
% /false false % ibid.
% /null null % ibid.
/R { /resolveR cvx 3 packedarray cvx } bind executeonly % see Objects below
.dicttomark readonly def
% Get a variable length positive integer value from a stream. A value
% of zero is returned if the count is zero.
/getintn { % <stream> <count> getintn int
0 exch { 256 mul 1 index read pop add } repeat
exch pop % Discard stream
} bind executeonly def
% This array contains handlers for processing the different types of
% entries in the XRef stream.
% Stack: <Xrefdict> <xref stream> <Index array> <pair loc> <obj num>
% <field 2> <field 3>
% The handlers leave the stack unchanged.
/xref15entryhandlers [
{ % XRef entry type 0 - free or f type xref entry
% (free ) print
% (obj num: ) print 2 index pdfstring cvs print ( ) print
% (loc: ) print 1 index pdfstring cvs print ( ) print
% (gen: ) print dup === flush
} bind executeonly % Do nothing for free xref entries
% XRef entry type 1 - normal or n type xref entry
{ % field 2 = obj loc, field 3 = gen num
% (normal ) print
% (obj num: ) print 2 index pdfstring cvs print ( ) print
% (loc: ) print 1 index pdfstring cvs print ( ) print
% (gen: ) print dup === flush
0 3 1 roll % set stream number = 0
//false setxrefentry
3 -1 roll pop % remove stream number
} bind executeonly
% XRef entry type 2 - compressed object type xref entry
{ % field 2 = object stream num, field 3 = index into object stream
% (Compressed objects: ) print
% (obj num: ) print 2 index pdfstring cvs print ( ) print
% (field 2: ) print 1 index pdfstring cvs print ( ) print
% (field 3: ) print dup === flush
0 //false setxrefentry pop % set generation number = 0
} bind executeonly
] def
% Read the PDF 1.5 version of the xref table.
% Note: The position is the location of the start of the dictionary object
% In PDF 1.5, the XRef dictionary also serves as the trailer dictionary
/readpdf15xref % <pos> readpdf15xref <trailerdict>
{
/Classic-xref //false store
PDFfile exch setfileposition % move to start of object
% Get object number, revision, and 'obj' and discard
//false PDFfile token {
type /integertype eq {
PDFfile token {
type /integertype eq {
PDFfile token {
/obj eq or
} if
} if
} if
} if
} if
not {
/readpdf15xref cvx /syntaxerror signalerror
} if
% Get the XRef dicitionary
/dictlevelcount 0 def PDFfile xrefopdict .pdfrun
% Verify that we have an XRef dictionary
dup /Type get /XRef ne {
/readpdf15xref cvx /syntaxerror signalerror
} if
% Ensure that we we have room in the objects array, etc.
dup /Size get 1 index /Index .knownget {
%% if we have a /Index, remember to add the starting index on to the size
dup 0 get 3 -1 roll add exch
%% Get the staring index and number of entries from the Index array
%% add them, and see if the result is larger than the starting index plus
%% Size entry (yes they are *supposed* to be consistent.....)
%% Bug #696365
dup 0 get exch 1 get add 2 copy gt {
pop
}{
exch pop
} ifelse
} if
growPDFobjects
% Create a stream for the XRef data
PDFfile token pop pop % Skip over 'stream'
dup stream //false resolvestream
% Stack: <XRefdict> <xref stream>
% The Index array defines the ranges of object numbers in the
% XRef stream. Each value pair is consists of starting object
% number and the count of consecutive objects.
% Get the Index array, if present
1 index /Index .knownget not { % If no Index array ...
[ 0 3 index /Size get ] % Default = [ 0 Size ]
} if
% Loop through the Index array
0 2 2 index length 1 sub {
% Get start and end of object range
2 copy get % Start of the range
dup 3 index 3 index 1 add get % Number of entries in range
% Loop through the range of object numbers
add 1 sub 1 exch { % Form end of range, set increment = 1
% Stack: <Xrefdict> <xref stream> <Index array> <pair loc> <obj num>
% Get xref parameters. Note: The number of bytes for each parameter
% is defined by the entries in the W array.
4 index /W get aload pop % Get W array values
% The first field indicates type of entry. Get first field value.
% If the num. of bytes for field 1 is 0 then default field value is 1
3 -1 roll dup 0 eq { pop 1 } { 6 index exch getintn } ifelse
% Get the handler for the xref entry type. We will execute the
% handler after we get the other two field values.
xref15entryhandlers exch get
3 -1 roll 6 index exch getintn % Get second field
3 -1 roll 6 index exch getintn % Get third field
3 -1 roll exec % Execute Xref entry handler
pop pop pop % Remove field values and obj num
} for % Loop through Xref entries
pop % Remove Index array pair loc
} for % Loop through Index array entries
pop pop % Remove Index array and xref stream
} bind executeonly def
% Read the cross-reference table.
% <pos> is the position either from the startxref statement or the /Prev
% entry in the prior trailer dictionary.
/readxref % <pos> readxref <trailerdict>
{
PDFoffset add PDFfile exch
% Check that the given location is within the file.
dup PDFfilelen gt {
( **** Warning: Specified xref location is beyond end of file.\n)
pdfformatwarning
/readxref cvx /invalidaccess signalerror
} if
setfileposition
% In some PDF files, this position actually points to
% white space before the xref line. Skip over this here.
{
PDFfile fileposition PDFfile read pop 32 gt { exit } if pop
} loop
dup % Make copy of the file position (before last char was read).
PDFfile exch setfileposition
% The PDF specification says that the 'xref' must be on a line
% by itself. The code here formerly used readline and linene to
% check this. However, Acrobat Reader only requires the line to
% begin with 'xref', and there are enough applications producing
% non-compliant PDF files that we have to do this too.
PDFfile pdfstring 0 4 getinterval readstring pop
(xref) eq
{
readorigxref % 'xref' -> original xref table
% if hybrid-reference PDF, also fetch the entries
% found in the XRef stream pointed by /XRefStm
dup /XRefStm knownoget {
%% Bug #695883 the test file has an XRefStm which points beyond the end of the file.
%% We check that here and simply fall back to thje classic xref if this error occurs.
dup PDFfilelen lt{
PDFSTOPONERROR not {
mark exch {readpdf15xref pop} stopped
{
( **** Error: This hybrid file's XRefStm does not point to a valid stream.\n Ignoring error, output may be incorrect.\n) pdfformaterror
} if
cleartomark
} {
readpdf15xref pop
} ifelse
} {
( **** Error: This hybrid file's XRefStm points beyond the end of file.\n Ignoring error, output may be incorrect.\n) pdfformaterror
pop
}ifelse
} if
}
{ readpdf15xref } % otherwise assume PDF 1.5 xref stream
ifelse
} bind executeonly def
% Open a PDF file and read the header, trailer, and cross-reference.
/pdfopen { % <file> pdfopen <dict>
% Color space substitution in PDF is handled somewhat differently
% than in PostScript. A given device color space will be substituted
% if the corresponding "Default..." entry exists in the Page's
% Resource dictionary (which might be inhereted); there is no
% UseCIEColor to enable/disable color mapping.
%
% This behavior is achieved by always setting UseCIEColor to true
% in the page device dictionary. If the value of this parameter was
% originally false (i.e.: the output device does not perform color
% space substitution by default), the instances DefaultGray,
% DefaultRGB, and DefaultCMYK of the (local) ColorSpace category
% are redefined to be DeviceGray, DeviceRGB, and DeviceCMYK,
% respectively. This is not done if UseCIEColor is true by default,
% as in that case color substitution is presumably desired even
% if the file does not request it.
currentpagedevice /UseCIEColor .knownget dup { pop } if not
{ .currentglobal //false .setglobal
/DefaultGray { /DeviceGray } cvlit /ColorSpace defineresource pop
/DefaultRGB { /DeviceRGB } cvlit /ColorSpace defineresource pop
/DefaultCMYK { /DeviceCMYK } cvlit /ColorSpace defineresource pop
.setglobal
}
if
pdfopenfile begin
pdfopencache
currentdict end
} bind executeonly def
/process_trailer_attrs { % - process_trailer_attrs -
writeoutputintents
.writepdfmarks {
% Copy bookmarks (outline) to the output.
Trailer /Root knownoget {
/Outlines knownoget {
/NO_PDFMARK_OUTLINES where {pop NO_PDFMARK_OUTLINES not}{//true}ifelse
{
dup /First known {
100 dict exch %% dictionary for detecting circular references
/First get dup type /packedarraytype eq { %% << >> {} or << >>
dup 0 get dup %% << >> {} object_num object_num
3 index 3 1 roll %% << >> {} << >> object_num object_num
put
oforce
} if
dup type /dicttype eq {
{
dup
/Next known {
dup /Next get %% << >> <</Next...>> {} or << >>
dup type /packedarraytype eq {
dup 0 get %% << >> <</Next....>> {} object_num
dup 4 index exch known {
(\n **** ERROR: Circular reference detected in Outlines,\n) pdfformaterror
( terminating Outline processing.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
%% << >> <</Next....>> {} object_num
pop pop dup /Next undef %% << >> <<.....>>
writeoutline exit
} if
%% << >> <</Next....>> {} object_num
dup 3 index 3 1 roll put %% << >> <</Next....>> {}
oforce
} if
exch writeoutline %% << >> </Next object>
dup type /dicttype eq not
{pop exit} if
} {
writeoutline exit
}ifelse
} loop
pop
}
{pop pop} ifelse
}{
pop
}ifelse
} {
pop
}ifelse
} if
} if
count /pdfemptycount exch def
Trailer /Info {knownoget} stopped {
( **** Error: Unable to read Info dictionary from Trailer, Info will not be preserved.\n) pdfformaterror
count pdfemptycount sub {pop} repeat
/emitProducer where {/emitProducer //false put} if
}
{
{
%
% Bug #700820, if the Info dictionary isn't a dictionary, then don't try to use it....
%
dup type /dicttype eq {
mark exch
{ /Author /Creator /Title /Subject /Keywords
% /Producer is Ghostscript; /CreationDate is now; /ModDate is also now.
} {
2 copy knownoget { 3 -1 roll } { pop } ifelse
} forall
pop
dup mark ne { {/DOCINFO pdfmark} stopped {cleartomark} if } { pop } ifelse
}{
pop
( **** Error: The Info dictionary is not a dictionary, Info will not be preserved.\n) pdfformaterror
count pdfemptycount sub {pop} repeat
/emitProducer where {/emitProducer //false put} if
} ifelse
} if
} ifelse
} if
% Initialize OC groups
Trailer /Root knownoget {
/OCProperties knownoget {
% By default, OCGs are 'on'; mark only 'off' OCGs.
% If, contrary to the spec, BaseState is OFF, mark all OCGs
% and unmark ON ones. Bug 691491.
dup /OCGs knownoget not { {} } if exch
/D knownoget {
dup /BaseState knownoget { /OFF eq } { //false } ifelse {
( **** Warning: Default viewing OC config dictionary has /BaseState /OFF\n)
pdfformatwarning
1 index {
oforce dup type /dicttype eq {
/OFF 0 put
} {
pop
} ifelse
} forall
/ON knownoget {
{ oforce dup type /dicttype eq {
/OFF undef
} {
pop
} ifelse
} forall
} if
} {
/OFF knownoget {
{ oforce dup type /dicttype eq {
/OFF 0 put
} {
pop
} ifelse
} forall
} if
} ifelse
} if
pop
} if
} if
% Enumerate all AcroForm fields and link all separate widgets
% to the parent field.
Trailer /Root knownoget {
/AcroForm knownoget {
%% If we don't have a NeedAppearances entry, treat as if true.
%% We know Acrobat always regenerates all annotait
dup /NeedAppearances knownoget not { //true } if {
/NeedAppearances //true def
dup
/Fields knownoget {
{ oforce
%% Make sure the entry from the Fields array is a dictionary
%% Bug #692447.pdf has an array of nulls.
dup type /dicttype eq {
link_widget_annots
}if
pop
} forall
} if
pop
} {
pop
} ifelse
} if
} if
% Use OutputIntent ICC profile
systemdict /UsePDFX3Profile .knownget {
dup //false eq {
pop
} {
dup //true eq { pop 0 } if
dup type /integertype eq {
Trailer /Root oget /OutputIntents knownoget {
dup length 2 index le % i [] bool
2 index 0 lt or {
pop pop
(Source file has no OutputIntent with this number.\n)
} {
exch oget dup type /dicttype ne { pop << >> } if
/DestOutputProfile knownoget {
[ /ICCBased 3 -1 roll ] ICCBased-resolve
1 get .set_outputintent
()
} {
(This OutputputIntents dictionary has no profile.\n)
} ifelse
} ifelse
} {
pop (File has no /OutputIntents attribute\n)
} ifelse
} {
pop (UsePDFX3Profile must be a boolean or an integer.\n)
} ifelse
dup () eq {
pop
} {
( **** ) stderrprint stderrprint
} ifelse
} ifelse
} {
% If the user told us to use a named OutputIntent
systemdict /UseOutputIntent .knownget {
cvn
Trailer /Root oget /OutputIntents knownoget {
{
dup /OutputConditionIdentifier get cvn
dup /Custom eq {
pop
dup /Info get cvn
}if
2 index eq {
%% Found the required OutputIntent
/DestOutputProfile knownoget {
[ /ICCBased 3 -1 roll ] ICCBased-resolve
1 get .set_outputintent
()
} if
pop
exit
}{
pop
} ifelse
}
forall
pop
}{
pop
}ifelse
} if
}ifelse
Trailer /Root knownoget { /PageLabels knownoget {
%% Currenlty only the pdfwrite device can handle PageLabels
%% because we deal with these using putparams, not pdfmarks
%% This is because the pdfmark syntax can't handle all the
%% possible page label formats in a PDF file!
/WantsPageLabels /GetDeviceParam .special_op {
pop pop
.pdfpagelabels
} {
pop
} ifelse
} if
} if
} bind executeonly def
% Verify that each entry in the xref table is pointing at an object with
% the correct object number and generation number.
/verify_xref % - verify_xref -
{ PDFfilelen
1 1 Objects length 1 sub % stack: filesize 1 1 <number of objects - 1>
{ % Check if the object is free (i.e. not used). The values in
% Generations is the generation number plus 1. If the value in
% Generations is zero then the object is free.
% Stack: <filesize> <obj num>
Generations 1 index get % Get the genration number
0 ne { % Skip if object number is free
ObjectStream 1 index get % Check if object is in objectstream
0 eq { % We only check objects not in an objectstream
{ % Use stop context since we may get an error if object is invalid
dup Objects exch get % Get the object location
PDFoffset add dup 3 index ge % Compare object location to file size
{ pop //true } % Rebuild if location not in file
{ PDFfile exch setfileposition % Go to the object location
//true % Stack: <filesize> <obj num> <true>
PDFfile token pop % Read object number from file
2 index eq { % Verify object number
PDFfile token pop % Read generation number from file
Generations 3 index % Get specified generaton number
get 1 sub % Gen numbs are stored with 1 added.
eq { % Verify generation number
PDFfile token pop
/obj eq { % Verify 'obj' text
pop //false % We have valid object, do not rebuild
} if
} if
} if
} ifelse
} //.internalstopped exec
{ //true } if % If we stop then we need to rebuild
% Stack: <filesize> <obj num> <need rebuild flag>
{
( **** Warning: File has an invalid xref entry: )
pdfformatwarning
pdfstring cvs pdfformatwarning
(. Rebuilding xref table.\n) pdfformatwarning
search_objects
exit
} if % If the entry is invalid
} {
% The object is in an object stream. We currently do not rebuild
% objects in an object stream. So If we find one, then abort the
% verification of the xref table entries.
pop exit % Pop object number and then exit loop
} ifelse % If not in an object stream
} if % If object entry is not free
pop % Remove object number
} for
pop % Remove the size of the file
} bind odef
/pdfopencache { % - pdfopencache -
% Create and initialize some caches.
/PageCount pdfpagecount def
/PageNumbers PageCount 65534 .min dict def
/PageIndex PageCount 65534 .min array def
} bind executeonly def
/pdfopenfile { % <file> pdfopenfile <dict>
//pdfdict readonly pop % can't do it any earlier than this
32 dict begin
/LocalResources 0 dict def
/DefaultQstate //null def % establish binding
/Printed where { pop } {
% Guess whether the output device is a printer.
/Printed currentpagedevice /OutputFile known def
} ifelse
currentpagedevice /OutputFile known {
currentpagedevice /OutputFile get (%d) search {
pop pop pop
/NO_PDFMARK_OUTLINES //true def
/NO_PDFMARK_DESTS //true def
} {
pop
}ifelse
} if
/PSLevel1 where { pop } { /PSLevel1 //false def } ifelse
% NB: PDFfile is used outside of the PDF code to determine that a
% PDF job is being processed; to not change or hide this key.
cvlit /PDFfile exch def
/PDFsource PDFfile def
/Repaired //false def
/emitProducer //true def
/RepairedAnError //false def
/StreamRunAborted //false def
/NeedAppearances //false def
/ICCProfileNError //false def
currentglobal //true .setglobal globaldict begin
/UndefProcList 0 dict def
end .setglobal
PDFfile dup 0 setfileposition
0 () /SubFileDecode filter % to avoid file closure
pdfstring readstring pop
(%PDF-) search not {/pdfopen cvx /syntaxerror signalerror} if
length /PDFoffset exch def pop
% some badly formed PDF's (Visioneer) have something other than EOL
% after the version number. If we get an error, shorten the string
% and try again.
//false exch % error encountered
{ { cvr } stopped
{ exch pop //true exch 0 1 index length 1 sub dup 0 eq
{ pop 0 exit } if % exit if string now empty
getinterval % trim character from right end and retry
}
{ exch {
( **** Warning: PDF version number not followed by EOL.\n)
pdfformatwarning
}
if exit
}
ifelse
} loop
/Classic-xref //true def
/PDFversion exch def
% Read the last cross-reference table.
count /pdfemptycount exch def
/Trailer << >> def % Initialize to an emptry dict.
{initPDFobjects findxref readxref}
PDFSTOPONERROR not {
//.internalstopped exec {
recover_xref_data % Read failed. Attempt to recover xref data.
search_trailer % Search for the primary trailer
//false % search_trailer sets up /Trailer, so don't run the code to do that...
} {
//true
} ifelse
} {
exec //true
} ifelse
{
/Trailer exch def % Save trailer dict after first xref table
% Read any previous cross-reference tables. When we are done,
% verify that the entries in the xref tables are valid if NoVerifyXref
% is not defined.
/PrevArray [] def % Empty array, we use this to detect circular /Prev entries in xref (see below)
% For some reqason, leaving this on the stack messes up seom files.
Trailer
{ /Prev knownoget not { % If no previous xref table then ...
Classic-xref {
/NoVerifyXref where { pop } { verify_xref } ifelse
} if
exit
} if
%% This code is used to detect circular references in xref tables. Every time
%% we detect a /Prev in the xref, we check the given offset of the /Prev xref
%% against a list of all previously encountered /Prev offsets. If we find that
%% we have previously seen this one, we raise an error, stop processing the xref
%% but carry on with the PDF file (unless PDFSTOPONERROR is true).
//false exch PrevArray %% Used to determine if the looop found a circular ref
{ %% //false offset 'array entry'
1 index eq {
exch pop //true exch %% We've seen this offset before, pop the false and replace with true
exit %% //true offset
} if
} forall
exch %% [...] offset bool
{
(\n **** Error: Circular /Prev entry while reading xref.\n Aborting xref read, output may be incorrect.\n)
pdfformaterror
PDFSTOPONERROR {
/readxref /syntaxerror cvx signalerror
} if
pop exit %% [...] and then exit this loop
} if
PrevArray dup %% offset [...] [...]
length 1 add array %% offset [...] [ ]
dup 3 1 roll %% offset [ ] [...] [ ]
copy pop %% offset [... ]
dup dup length 1 sub %% offset [... ] [... ] index
3 index %% offset [... ] [... ] index offset
put /PrevArray exch def
{ readxref }
PDFSTOPONERROR not {
//.internalstopped exec {
recover_xref_data % Read failed. Attempt to recover xref data.
/PrevArray where {/PrevArray undef} if %% remove the array we were using to detect circular references
exit % Exit loop since recover gets all obj data.
} if % If readxref stopped
} {
exec
} ifelse
% The PDF spec. says that each trailer dict should contain the required
% entries. However we have seen a PDF file that only has a Prev entry in
% the initial trailer dict. Acrobat complains but it accepts these files.
% To work with these files, we are copying any entries which we find in
% a previous trailer dict which are not present in the initial dict.
dup {
Trailer 2 index known {
pop pop % discard if key already present
} {
Trailer 3 1 roll put % add key if not present
} ifelse
} forall
} loop % Loop to previous trailer
/PrevArray where {/PrevArray undef} if %% remove the array we were using to detect circular references
} if
/NumObjects Objects length def % To check that obj# < NumObjects
% Scan numbers in the range 2147483648..4294967295 in Encrypt dictionary
% as unsigned integers for compatibility with Acrobat Reader. Bug 689010.
<< /PDFScanUnsigned //true >> setuserparams
{ Trailer /Encrypt knownoget {
pop
pdf_process_Encrypt % signal error
} if
} stopped
<< /PDFScanUnsigned //false >> setuserparams
{ stop } if
% Check for recursion in the page tree. Bug 689954, MOAB-06-01-2007
verify_page_tree
currentdict end
} bind executeonly def
%% Executing token on a file will close the file if we reach EOF while
%% processing. When repairing broken files (or searching for startxref
%% and the xref offset) we do *NOT* want this to happen, because that
%% will close PDFfile and we don't have the filename to reopen it.
/token_no_close { %% -file- token_no_close <any> true | false
dup type /filetype eq {
<<
/EODCount 2 index bytesavailable %% fix data length at underlying bytes
/EODString () %% make sure filter passes that many bytes, no EOD
/CloseSource //false %% Be sure, tell the filter not to close the source file
>>
/SubFileDecode filter dup %% -filter- -filter-
token { %% -filter- <any> true | false
%% token returned a value
exch %% <any> filter
closefile %% <any>
//true %% <any> true
}{
%% token didn't find a value
closefile %% -
//false %% false
} ifelse
} {
token
} ifelse
} bind executeonly def
% Look for the last (startxref) from the current position
% of the file. Return the position after (startxref) if found or -1 .
/find-startxref { % <file> find_eof <file> <position>
-1
{ 1 index dup 0 (startxref) /SubFileDecode filter flushfile
bytesavailable 9 lt { exit } if
pop dup fileposition
} loop
} bind executeonly def
% Search for the last 'startxfer' and read a following token, which
% must be a number. Don't pay any attention to %%EOF because it's
% often mangled.
% There seems to be no limit on the amount of garbage that can be
% appended to the PDF file. Current record (60K) belongs to
% PDF-Out (v 2.0 - 35). We start the search from the last 1024
% bytes and continue from the beginning of the file.
/findxref { % - findxref <xrefpos>
PDFfile dup dup dup 0 setfileposition bytesavailable
dup /PDFfilelen exch def
% Find the last %%EOF string (within 1024 bytes)
1024 sub PDFoffset .max
setfileposition find-startxref % file pos|-1 % search the last 1024 bytes
dup 0 le {
pop
dup PDFoffset setfileposition find-startxref % search from the beginnibg
dup 0 le {
( **** Error: Cannot find a 'startxref' anywhere in the file.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
/findxref cvx /syntaxerror signalerror
} if
} if
2 copy setfileposition
pop token_no_close not { //null } if
dup type /integertype ne {
( **** Error: invalid token after startxref.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
/findxref cvx /syntaxerror signalerror
} if
} bind executeonly def
/stderrfile (%stderr) (w) file def
/stdoutfile (%stdout) (w) file def
/stderrprint { % <string> stderrprint -
//stderrfile dup 3 -1 roll writestring flushfile
} bind executeonly def
/stdoutprint { % <string> stderrprint -
//stdoutfile dup 3 -1 roll writestring flushfile
} bind executeonly def
/pdfformaterror { % <string> pdfformaterror -
stdoutprint
/Repaired //true store
/RepairedAnError //true store
} bind executeonly def
/pdfformatwarning { % <string> pdfformaterror -
QUIET not {stdoutprint}{pop}ifelse
/Repaired //true store
PDFSTOPONWARNING {/warning cvx /undefined signalerror} if
} bind executeonly def
/knownoget_safe
{ 2 copy knownoget { 3 1 roll pop pop //true } { pop pop //false } ifelse
} odef
/printProducer {
Trailer /Info { knownoget_safe } stopped { pop pop //false } if
{
/emitProducer where {/emitProducer get}{//true} ifelse
{
/Producer knownoget not { //null } if
}{
pop //null
} ifelse
} {
//null
} ifelse
dup //null eq {
pop
} {
( **** The file was produced by: \n **** >>>> ) stderrprint
% Handle a Unicode Producer.
(\376\377) anchorsearch {
pop dup length 2 idiv string 0 1 2 index length 1 sub {
% Stack: origstr newstr i
1 index exch 3 index 1 index 2 mul 1 add get put
} for exch pop
} if
stderrprint
( <<<<\n) stderrprint
} ifelse
} bind executeonly def
% The UndefProcList collects noisy warnings.
% This gets rid of many multiple warnings from pdf_font.ps
/printCollectedWarnings {
UndefProcList length 0 gt {
(\n **** Embedded font uses undefined procedure\(s\): ) stderrprint
UndefProcList {
exch .namestring stderrprint ( ) stderrprint
=string cvs stderrprint ( times, ) stderrprint
} forall
(\n) stderrprint
} if
} bind executeonly def
/printrepaired {
QUIET not
{
printCollectedWarnings
(\n **** This file had errors that were repaired or ignored.\n)
stdoutprint
printProducer
( **** Please notify the author of the software that produced this\n)
stdoutprint
( **** file that it does not conform to Adobe's published PDF\n)
stdoutprint
( **** specification.\n\n)
stdoutprint
} if
} bind executeonly def
/printrepairederror {
QUIET not
{
printrepaired
( **** The rendered output from this file may be incorrect.\n)
stdoutprint
} if
} bind executeonly def
% Write the outline structure for a file. Uses linkdest (below).
% omit links to pages that don't exist.
/writeoutline % <outlinedict> writeoutline -
{ mark
0 2 index /First knownoget
{ { exch 1 add exch /Next knownoget not { exit } if } loop }
if
% stack: dict mark count
dup 0 eq
{ pop 1 index }
{ 2 index /Count knownoget { 0 lt { neg } if } if
/Count exch 3 index
}
ifelse
{
dup /A knownoget {
dup /URI known {
/A mark 3 2 roll % <<>> /A [ <<action>>
{ oforce } forall
.dicttomark
3 2 roll
}
{
dup /S knownoget {
%% Because we process GoTo Destinations into absolute references in the PDF file
%% we need to resolve the /D or /Dest. However, we must *not* do this for
%% GoToR Destinations because (obviously) those are in a different file and
%% we cannot resolve them into absolute references. We don't need to anyway
%% because that file must already have a named destination.
dup /GoTo eq {
pop
dup /D knownoget {
exch pop exch dup length dict copy dup /Dest 4 -1 roll put
} if
}{
dup /GoToR eq {
pop /A mark % <<..action dict..>> /A [
3 2 roll % /A [ <<..action dict..>>
{ oforce } forall
.dicttomark
3 2 roll
}{
dup /Launch eq {
pop /A mark % <<..action dict..>> /A [
3 2 roll % /A [ <<..action dict..>>
{ oforce } forall
.dicttomark
3 2 roll
}{
/Named eq {
/N knownoget { % Assume /S /Named
namedactions exch .knownget { exec } if
} if
} if
} ifelse
} ifelse
} ifelse
} if
} ifelse
} if
linkdest
} stopped
{
cleartomark % ignore this link
( **** Warning: Outline has invalid link that was discarded.\n)
pdfformatwarning
} {
/Title knownoget {
{/Title exch /OUT pdfmark} stopped {cleartomark} if
} {
cleartomark
( **** Warning: Outline without /Title attribute was discarded.\n)
pdfformatwarning
} ifelse
}
ifelse
/First knownoget
{ { dup writeoutline /Next knownoget not { exit } if } loop }
if
} bind executeonly def
% Close a PDF file.
/pdfclose % <dict> pdfclose -
{ begin
PDFfile closefile
end
} bind executeonly def
% ======================== Page accessing ======================== %
% Get a (possibly inherited) attribute of a page.
/pget % <pagedict> <key> pget <value> -true-
% <pagedict> <key> pget -false-
{
2 copy knownoget
{ exch pop exch pop //true }
{
%% Check to see if there's a Parent
1 index
3 1 roll
exch /Parent knownoget
{
%% If there is a Parent, check to see if this dictionary has a stored object number
3 -1 roll /.gs.pdfobj# .knownget {
%% if it does, check the Parent as wwell
1 index /.gs.pdfobj# .knownget {
%% Both have object numbers, are they the same (ie its self-referencing)
eq {
pop pop
//false
}{
exch pget
}ifelse
}{
pop exch pget
}ifelse
} {
exch pget
}ifelse
}
% finally see if the key is (misplaced) in the Root Catalog dict
{ exch pop dup Trailer /Root oget exch knownoget dup {
3 -1 roll ( **** Error: The /) pdfformaterror 50 string cvs pdfformaterror
( key is missing from the Page tree.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
}
{ exch pop }
ifelse
}
ifelse
}
ifelse
} bind executeonly def
/parent_obj_get { % /ResourceName pagedict /ObjType LocalResourceDir
/ParentResources .knownget {
dup 2 index .knownget {
% Found ObjType directory
4 index .knownget {
0 get 5 1 roll pop pop pop pop
} {
parent_obj_get % not found -- check it's parent.
} ifelse
} {
parent_obj_get % not found -- check it's parent.
} ifelse
} {
pop pop pop 0
} ifelse
} bind executeonly def
/obj_get { % /ResourceName pagedict /ObjType obj_get
% success: /ResourceName objnumber
% fail: /ResourceName /ResourceName 0
LocalResources 1 index knownoget {
dup 4 index .knownget {
0 get 5 1 roll pop pop pop pop
} {
pop pop pop 0
} ifelse
} {
% Not in LocalResources. Try Page Resources.
1 index /Resources pget {
1 index knownoget {
dup 4 index known {
3 index get
0 get 4 1 roll pop pop pop
}{
% Not in Page Resources, recursively try ParentResources as a last resort
pop % page Resources
LocalResources parent_obj_get
}ifelse
}{
% No Page Resources, recursively try ParentResources as a last resort
pop % page Resources
LocalResources parent_obj_get
} ifelse
} {
% No Page Resources, recursively try ParentResources as a last resort
pop pop pop 0
}ifelse
}ifelse
}bind executeonly def
% Get the value of a resource on a given page.
/rget { % <resname> <pagedict> <restype> rget <value> -true-
% <resname> <pagedict> <restype> rget -false-
LocalResources 1 index knownoget {
3 index knownoget
} {
//false
} ifelse {
exch pop exch pop exch pop //true
} {
1 index /Resources pget {
1 index knownoget { 3 index knownoget } { //false } ifelse
} {
//false
} ifelse {
4 1 roll pop pop pop //true
} {
countdictstack array dictstack
//false 5 1 roll
dup length 1 sub -1 4 { % false /Name <<>> /Type [<<gstate>>] i
1 index exch get % false /Name <<>> /Type [] <<gstate>>
/FormResDict .knownget { % false /Name <<>> /Type [] <<res>>
2 index knownoget { % false /Name <<>> /Type [] <<type_dict>>
4 index knownoget { % false /Name <<>> /type [] <<res_dict>>
( **** Warning: resource was found only in an external (parent) context.\n) pdfformatwarning
//true 7 2 roll % <<res_dict>> true false /Name <<>> /Type []
pop exit
} if
} if
} if
} for
pop pop pop pop
} ifelse
} ifelse
} bind executeonly def
% Get the total number of pages in the document.
/pdfpagecount % - pdfpagecount <int>
{ Trailer /Root knownoget {
/Pages knownoget {
dup /Count knownoget {
dup type /integertype eq { dup 0 le } { //true } ifelse {
pop
dup /Kids knownoget {
pop
( **** Warning: Invalid Page count.\n) pdfformatwarning
% find the last page and use that as the Count
1 1 999999999 {
dup pdffindpage?
exch pop
//null eq { exit } { pop } ifelse
} for
1 sub % decrement to last page that we were able to find
2 copy /Count exch put
} {
0 % return 0 and keep 0 page count.
( **** Warning: PDF document has no pages.\n) pdfformatwarning
} ifelse
} if
exch pop
} {
dup /Type oget /Page eq {
<< exch 1 array astore /Kids exch /Count 1 /Type /Pages >>
Trailer /Root oget /Pages 3 -1 roll put
1
( **** Warning: No /Pages node. The document /Root points directly to a page.\n)
pdfformatwarning
} {
( **** Warning: Page count not found; assuming 1.\n)
pdfformatwarning
pop 1
} ifelse
} ifelse
} {
0
}ifelse
}{
0
} ifelse
} bind executeonly def
% Check for loops in the 'page tree' but accept an acyclic graph.
% - verify_page_tree -
/verify_page_tree {
Trailer /Root knownoget {
/Pages knownoget {
10 dict begin
/Count pdfpagecount def
/verify_page_tree_recursive {
Count 0 gt {
dup 1 def
dup /Kids knownoget {
{ oforce
dup //null ne {
currentdict 1 index known {
( **** Error: there's a loop in the Pages tree. Giving up.\n) pdfformaterror
/verify_page_tree cvx /syntaxerror signalerror
} if
verify_page_tree_recursive
} {
pop
} ifelse
} forall
} {
/Count Count 1 sub def
}ifelse
currentdict exch undef
} {
pop
( **** Error: Too many pages in Page tree.\n) pdfformaterror
} ifelse
} def
verify_page_tree_recursive
end
} if
} if
} bind executeonly def
/pdffindpage? { % <int> pdffindpage? 1 null (page not found)
% <int> pdffindpage? 1 noderef (page found)
% <int> pdffindpage? 0 null (Error: page not found)
Trailer /Root oget /Pages get
{ % We should be able to tell when we reach a leaf
% by finding a Type unequal to /Pages. Unfortunately,
% some files distributed by Adobe lack the Type key
% in some of the Pages nodes! Instead, we check for Kids.
dup oforce /Kids knownoget not { exit } if
exch pop //null
0 1 3 index length 1 sub {
2 index exch get
dup oforce dup /Kids known { /Count oget } { pop 1 } ifelse
% Stack: index kids null noderef count
dup 5 index ge { pop exch pop exit } if
5 -1 roll exch sub 4 1 roll pop
} for exch pop
% Stack: index null|noderef
dup //null eq { pop pop 1 //null exit } if
} loop
} bind executeonly def
% Find the N'th page of the document by iterating through the Pages tree.
% The first page is numbered 1.
/pdffindpageref { % <int> pdffindpage <objref>
dup pdffindpage?
% Stack: index countleft noderef
1 index 1 ne { pop pop /pdffindpage cvx /rangecheck signalerror } if
exch pop
PageIndex 2 index 1 sub 65533 .min 2 index oforce put
PageNumbers 1 index oforce 3 index dup 65534 le
{ put }
{ pop pop pop } % don't store more than 65534 pagenumbers
ifelse
exch pop
} bind executeonly def
/pdffindpage { % <int> pdffindpage <pagedict>
pdffindpageref oforce
} bind executeonly def
% Find the N'th page of the document.
% The first page is numbered 1.
/pdfgetpage % <int> pdfgetpage <pagedict>
{ PageIndex 1 index 1 sub dup 65533 lt
{ get }
{ pop pop //null }
ifelse
dup //null ne
{ exch pop oforce }
{ pop pdffindpage }
ifelse
} bind executeonly def
% Find the page number of a page object (inverse of pdfgetpage).
/pdfpagenumber % <pagedict> pdfpagenumber <int>
{ % We use the simplest and stupidest of all possible algorithms....
PageNumbers 1 index .knownget
{ exch pop
}
{ 1 1 PageCount 1 add % will give a rangecheck if not found
{ dup pdfgetpage oforce 2 index eq { exit } if pop
}
for exch pop
}
ifelse
} bind executeonly def
% Arrange the four elements that define a rectangle into a 'normal' order.
/normrect_elems % <x1> <y1> <x2> <y2> normrect_elems <llx> <lly> <urx> <ury>
{
4 { % Bug 693919
dup type dup /integertype ne exch /realtype ne and {
( **** Error: replacing malformed number ') pdfformaterror pdfstring cvs pdfformaterror
(' with 0.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
0
} if
4 1 roll
} repeat
exch 4 1 roll % <x2> <x1> <y1> <y2>
2 copy gt { exch } if % <x2> <x1> <lly> <ury>
4 2 roll 2 copy lt { exch } if % <lly> <ury> <urx> <llx>
4 1 roll exch % <llx> <lly> <urx> <ury>
} bind executeonly def
% Arrange a rectangle into a 'normal' order. I.e the lower left corner
% followed by the upper right corner.
/normrect % <rect> normrect <rect>
{
aload pop normrect_elems 4 array astore
} bind executeonly def
/fix_empty_rect_elems % </Name> <x1> <y1> <x2> <y2> fix_empty_rect_elems <x1> <y1> <x2'> <y2'>
{ dup 3 index eq { //true } { 1 index 4 index eq } ifelse {
pop pop pop pop
( **** Warning: File has an empty ) pdfformaterror pdfstring cvs pdfformaterror
(. Using the current page size instead.\n) pdfformaterror
( Output may be incorrect.\n) pdfformaterror
0 0 currentpagedevice /PageSize get aload pop
} {
5 -1 roll pop
} ifelse
} bind executeonly def
/boxrect % <llx> <lly> <urx> <ury> boxrect <x> <y> <w> <h>
{ exch 3 index sub exch 2 index sub
} bind executeonly def
/resolvedest { % <name|string|other> resolvedest <other|null>
dup type /nametype eq {
Trailer /Root oget /Dests knownoget {
exch knownoget not { //null } if
} {
pop //null
} ifelse
} {
dup type /stringtype eq {
Trailer /Root oget /Names knownoget {
/Dests knownoget {
exch nameoget
} {
pop //null
} ifelse
} {
pop //null
} ifelse
} if
} ifelse
} bind executeonly def
% Procedures to do the necessary transformations of view destinations
% <PDF2PS_matrix> <rot> <view> -- <view'>
/viewdestprocs 8 dict dup begin
/Fit { exch pop exch pop } bind executeonly def
/FitH {
aload length 2 lt {
1 array astore
3 1 roll pop pop
}{
0 4 -1 roll 1 and 0 eq { exch } if
4 -1 roll transform exch pop
2 array astore
} ifelse
} bind executeonly def
/FitV {
aload length 2 lt {
1 array astore
3 1 roll pop pop
}{
0 4 -1 roll 1 and 0 ne { exch } if
4 -1 roll transform pop
2 array astore
} ifelse
} bind executeonly def
/FitB /Fit load def
/FitBH /FitH load def
/FitBV /FitV load def
/XYZ {
dup length dup 4 gt {
pop /viewdestprocs cvx /rangecheck signalerror
}{
dup 4 eq {
pop aload pop
} {
dup 3 eq {
pop aload pop //null
} {
dup 2 eq {
pop aload pop //null //null
} {
dup 1 eq {
pop aload pop //null //null //null
} {
pop /viewdestprocs cvx /rangecheck signalerror
} ifelse
} ifelse
} ifelse
} ifelse
} ifelse
3 1 roll
2 copy 7 -1 roll 1 and 0 ne { exch } if 4 2 roll % odd rotation switches x<->y
2 { dup //null eq { pop 0 } if exch } repeat % replace nulls with 0
7 -1 roll transform % transform coordinates
2 { 3 -1 roll //null eq { pop //null } if exch } repeat % put the nulls back
3 -1 roll
4 array astore
} bind executeonly def
/FitR {
exch pop
aload pop
2 { 5 index transform 4 2 roll } repeat normrect_elems
5 array astore
exch pop
} bind executeonly def
end readonly def
/linkdest { % <link|outline> linkdest
% ([/Page <n>] /View <view> | ) <link|outline>
dup /NewWindow knownoget {
/NewWindow exch 3 -1 roll
} if
dup /F knownoget {
/File exch 3 -1 roll
} if
dup /Dest knownoget
{
resolvedest
dup type /dicttype eq { /D knownoget not { //null } if } if
dup //null eq
{ pop }
{ dup 0 oget
//false % don't have a page# and transformation matrix (yet)
1 index type /dicttype eq {
1 index /Type knownoget {
/Page eq {
pop % the "false" flag
dup pdf_cached_PDF2PS_matrix exch
dup /Rotate pget not { 0 } if cvi 90 idiv exch
pdfpagenumber /CumulativePageCount where {pop CumulativePageCount}{0}ifelse add
//true % now we have a page# and a transformation matrix
} if
} if
} if
% stack: <link|outline> <dest> ( <PDF2PS_matrix> <rot> <page#> true | <page> false )
{
/Page exch 6 2 roll
% stack: [/Page <page#>] <link|outline> <dest> <PDF2PS_matrix> <rot>
3 -1 roll dup length 1 sub 1 exch getinterval /View 4 1 roll
% stack: [/Page <page#>] <link|outline> /View <PDF2PS_matrix> <rot> <view>
//viewdestprocs 1 index 0 get get exec
3 -1 roll
} {
dup type /integertype eq {
/CumulativePageCount where {pop CumulativePageCount}{0}ifelse add
/Page exch 1 add 4 2 roll
} {
pop
} ifelse
dup length 1 sub 1 exch getinterval /View exch 3 -1 roll
} ifelse
}
ifelse
}
if
} bind executeonly def
%% Used to recursively check dictionaries for any /.gs.pdfobj# keys
%% and remove them if so
%% -any- /Removepdfobj# -any-
/Removepdfobj#
{
dup type /dicttype eq {
dup /.gs.pdfobj# known {
dup /.gs.pdfobj# undef
} if
dup {Removepdfobj# 2 index 3 1 roll put} forall
} if
}bind executeonly def
% <pagedict> mark ... -proc- <page#> <error>
/namedactions 8 dict dup begin
/FirstPage { 1 /CumulativePageCount where {pop CumulativePageCount}{0}ifelse add //false } bind executeonly def
/LastPage { pdfpagecount /CumulativePageCount where {pop CumulativePageCount}{0}ifelse add //false } bind executeonly def
/NextPage { counttomark 2 add index pdfpagenumber 1 add dup pdfpagecount gt exch /CumulativePageCount where {pop CumulativePageCount}{0}ifelse add exch} bind executeonly def
/PrevPage { counttomark 2 add index pdfpagenumber 1 sub dup 1 lt exch /CumulativePageCount where {pop CumulativePageCount}{0}ifelse add exch} bind executeonly def
end readonly def
% <pagedict> <annotdict> -proc- -
% **** The following procedure should not be changed to allow clients
% **** to directly interface with the constituent procedures. GSview
% **** and some Artifex customers rely on the pdfshowpage_init,
% **** pdfshowpage_setpage, pdfshowpage_finish so all logic should be
% **** implemented in one of those three procedures.
/pdfshowpage % <pagedict> pdfshowpage -
{ dup /Page exch store
pdfshowpage_init % <pagedict>
pdfshowpage_setpage % <pagedict>
pdfshowpage_finish % -
} bind executeonly def
/pdfpagecontents % <pagedict> pdfpagecontents <contents>
{ } bind executeonly def
/pdfshowpage_init % <pagedict> pdfshowpage_init <pagedict>
{ /DSCPageCount DSCPageCount 1 add store
} bind executeonly def
/get_media_box { % <pagedict> get_media_box <box> <bool>
/MediaBox pget {
oforce_array //true
} {
( **** Error: Page has no /MediaBox attribute. Using the current page size.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
[ 0 0 currentpagedevice /PageSize get aload pop ] //false
} ifelse
} bind executeonly def
/get_any_box { % <pagedict> get_any_box <box name> <box>
//systemdict /UseBleedBox .knownget dup { and } if {
dup /BleedBox pget {
/BleedBox exch
} if
} if
//systemdict /UseTrimBox .knownget dup { and } if {
dup /TrimBox pget {
/TrimBox exch
} if
} if
dup type /arraytype ne {
//systemdict /UseArtBox .knownget dup { and } if {
dup /ArtBox pget {
/ArtBox exch
} if
} if
} if
dup type /arraytype ne {
//systemdict /UseCropBox .knownget dup { and } if {
dup /CropBox pget {
/CropBox exch
} if
} if
} if
dup type /arraytype ne {
/MediaBox exch get_media_box pop
} {
oforce_elems % <<pdict>> /SomeBox x0 y0 x1 y1
%% Complicated stuff. We need to use the 'Box' we identified (if any), but we
%% need to clamp the boundaries of the 'Box' to the MediaBox. This appears to
%% be what Acrobat does. The complication arises because the Box values don't
%% have to be sensibly positive, its permissible to have the MediaBox set up
%% so that it extends down and left instead of up and right. We take care of the
%% content when we st up the CTM, but we do need to make sure that we clamp
%% the BoundingBox, and that means we need to take direcitonality into account...
6 -1 roll get_media_box { % /SomeBox x0 y0 x1 y1 [MediaBox]
aload pop % /SomeBox x0 y0 x1 y1 X0 Y0 X1 Y1
%% Start with the width, get the X0 and X1 values of the MediaBox
3 index % /SomeBox x0 y0 x1 y1 X0 Y0 X1 Y1 X0
2 index % /SomeBox x0 y0 x1 y1 X0 Y0 X1 Y1 X0 X1
gt {
%% Media extends to left
4 -1 roll % /SomeBox x0 y0 x1 y1 Y0 X1 Y1 X0
8 -1 roll % /SomeBox y0 x1 y1 Y0 X1 Y1 X0 x0
.min % /SomeBox y0 x1 y1 Y0 X1 Y1 mX0
7 1 roll % /SomeBox mX0 y0 x1 y1 Y0 X1 Y1
exch % /SomeBox mX0 y0 x1 y1 Y0 Y1 X1
5 -1 roll % /SomeBox mX0 y0 y1 Y0 Y1 X1 x1
.max % /SomeBox mX0 y0 y1 Y0 Y1 mX1
5 1 roll % /SomeBox mX0 mX1 y0 y1 Y0 Y1
}{
%% Media extends to right
4 -1 roll % /SomeBox x0 y0 x1 y1 Y0 X1 Y1 X0
8 -1 roll % /SomeBox y0 x1 y1 Y0 X1 Y1 X0 x0
.max % /SomeBox y0 x1 y1 Y0 X1 Y1 mX0
7 1 roll % /SomeBox mX0 y0 x1 y1 Y0 X1 Y1
exch % /SomeBox mX0 y0 x1 y1 Y0 Y1 X1
5 -1 roll % /SomeBox mX0 y0 y1 Y0 Y1 X1 x1
.min % /SomeBox mX0 y0 y1 Y0 Y1 mX1
5 1 roll % /SomeBox mX0 mX1 y0 y1 Y0 Y1
} ifelse
%% Now deal with the height
2 copy % /SomeBox mX0 mX1 y0 y1 Y0 Y1 Y0 Y1
gt {
%% Media extends down
exch % /SomeBox mX0 mX1 y0 y1 Y1 Y0
4 -1 roll % /SomeBox mX0 mX1 y1 Y1 Y0 y0
.min % /SomeBox mX0 mX1 y1 Y1 mY0
3 1 roll % /SomeBox mX0 mX1 mY0 y1 Y1
.max % /SomeBox mX0 mX1 mY0 mY1
}{
%% Media extends up
exch % /SomeBox mX0 mX1 y0 y1 Y1 Y0
4 -1 roll % /SomeBox mX0 mX1 y1 Y1 Y0 y0
.max % /SomeBox mX0 mX1 y1 Y1 mY0
3 1 roll % /SomeBox mX0 mX1 mY0 y1 Y1
.min % /SomeBox mX0 mX1 mY0 mY1
} ifelse
exch % /SomeBox mX0 mX1 mY1 mY0
3 1 roll % /SomeBox mX0 mY0 mX1 mY1
} {
pop
} ifelse
4 array astore % /SomeBox [mX0 mY0 mX1 mY1]
} ifelse
} bind executeonly def
% Compute the matrix that transforms the PDF->PS "default" user space
/pdf_PDF2PS_matrix { % <pdfpagedict> -- matrix
matrix currentmatrix matrix setmatrix exch
% stack: savedCTM <pdfpagedict>
dup get_any_box
% stack: savedCTM <pdfpagedict> /Trim|Crop|Art|MediaBox <Trim|Crop|Art|Media Box>
oforce_elems normrect_elems fix_empty_rect_elems 4 array astore
//systemdict /PDFFitPage known {
PDFDEBUG { (Fiting PDF to imageable area of the page.) = flush } if
currentpagedevice /.HWMargins get aload pop
currentpagedevice /PageSize get aload pop
% Adjust PageSize and .HWMargins for the page portrait/landscape orientation
2 copy gt % PageSize_is_landscape
7 index aload pop 3 -1 roll sub 3 1 roll exch sub exch
10 index /Rotate pget not { 0 } if cvi 90 idiv 1 and 0 ne { exch } if
gt % Box_is_landscape
xor % PageSize_is_landscape(or square) xor'ed with Box_is_lanscape suggests rotate
2 index 2 index eq not and { % don't rotate if Page is square
1 index 0 translate 90 rotate % add in a rotation
PDFDEBUG { ( Rotating the page for best fit) = flush } if
2 copy ne {
% rotate the .HWMargins
2 copy lt {
6 2 roll 4 -1 roll 6 -2 roll
} {
6 2 roll 4 1 roll 6 -2 roll
} ifelse
% rotate the page dimensions
exch
} if
} if
3 -1 roll sub 3 1 roll exch sub exch
% stack: savedCTM <pdfpagedict> <Crop|Media Box> Xmin Ymin Xmax Ymax
PDFDEBUG { ( Translate up by [ ) print 3 index =print (, ) print 2 index =print ( ]) = flush } if
3 index 3 index translate % move origin up to imageable area
2 index sub exch 3 index sub exch 4 2 roll pop pop
% stack: savedCTM <pdfpagedict> [Box] XImageable YImageable
2 index aload pop 2 index sub exch 3 index sub exch 4 2 roll pop pop
5 index /Rotate pget not { 0 } if 90 cvi idiv 1 and 0 ne { exch } if
% stack: savedCTM <pdfpagedict> [Box] XImageable YImageable XBox YBox
4 copy
3 -1 roll exch div 3 1 roll div .min
% stack: savedCTM <pdfpagedict> [Box] XImageable YImageable XBox YBox scale
PDFDEBUG { ( Scale by ) print dup = flush } if
5 -4 roll
% stack: savedCTM <pdfpagedict> [Box] scale XImageable YImageable XBox YBox
3 index 2 index 6 index mul sub 2 div 3 index 2 index 7 index mul sub 2 div
PDFDEBUG { ( Centering translate by [ ) print 1 index =print (, ) print dup =print ( ]) = flush } if
translate pop pop pop pop
} {
//systemdict /NoUserUnit .knownget not { //false } if {
1
} {
1 index /UserUnit knownoget {
PDFDEBUG { (Scaling due to UserUnit by ) print dup = flush } if
} {
1
} ifelse
} ifelse
} ifelse
% stack: savedCTM <pdfpagedict> [Box] scale
dup scale
% Rotate according to /Rotate
aload pop boxrect
{
{ pop pop }
{ -90 rotate pop neg 0 translate }
{ 180 rotate neg exch neg exch translate }
{ 90 rotate neg 0 exch translate pop }
}
5 index /Rotate pget not { 0 } if cvi
PDFDEBUG { dup 0 ne { (Rotating by ) print dup =print ( degrees.) = flush } if } if
90 idiv 3 and get exec
% Now translate to the origin given in the Crop|Media Box
exch neg exch neg translate
% stack: savedCTM <pdfpagedict>
pop
matrix currentmatrix exch setmatrix
} bind executeonly def
% Cache the matrix that transforms the PDF->PS "default" user space
% into <pdfpagedict> under the key //PDF2PS_matrix_key, then return it
/PDF2PS_matrix_key (PDF->PS matrix) cvn def
/pdf_cached_PDF2PS_matrix { % <pdfpagedict> -- <PDF2PS_matrix>
dup //PDF2PS_matrix_key .knownget {
exch pop
} {
dup dup pdf_PDF2PS_matrix //PDF2PS_matrix_key exch put
//PDF2PS_matrix_key get
} ifelse
} bind executeonly def
currentdict /PDF2PS_matrix_key undef
/.pdfshowpage_Install { % <pagedict> [<prevproc>] .pdfshowpage_Install -
0 get exec
pdf_cached_PDF2PS_matrix concat
} bind executeonly def
/pdfshowpage_setpage { % <pagedict> pdfshowpage_setpage <pagedict>
6 dict begin % for setpagedevice
% Stack: pdfpagedict
% This comment is no longer true, and is maintained here for history only:
%
% UseCIEColor is always true for PDF; see the comment in runpdf above
%
% We now test the page to see if it defines any Default* colour spaces and
% only set UseCIEColor if it does. This prevents a spurious warning from
% pdfwrite about not using UseCIEColor with pdfwrite.
%
pdfshowpage_detect_cspacesub {
/UseCIEColor //true def
} if
% Only lock in Orientation if we need to for pdfmarks
.writepdfmarks { /Orientation 0 def } if
currentpagedevice
% Stack: pdfpagedict currentpagedevicedict
1 index get_any_box
% Stack: pdfpagedict currentpagedevicedict /BoxName [box]
oforce_elems normrect_elems fix_empty_rect_elems boxrect 4 2 roll pop pop
3 index /Rotate pget not { 0 } if cvi 90 idiv 1 and 0 ne { exch } if
% stack: pdfpagedict currentpagedevicedict boxwidth boxheight
//systemdict /PDFFitPage known {
% Preserve page size,
% but choose portrait/landscape depending on box width:height ratio
% (if box width == height, select portrait orientation)
gt
1 index /PageSize get aload pop
2 copy gt
4 -1 roll ne { exch } if
} {
% Set the page size.
//systemdict /NoUserUnit .knownget not { //false } if not {
3 index /UserUnit knownoget {
dup 4 -1 roll mul 3 1 roll mul
} if
} if
} ifelse
2 array astore /PageSize exch def
% Determine the number of spot colors used on the page. Note: This searches
% the pages resources. It may be high if a spot color is in a resource but
% is not actually used on the page.
currentpagedevice /PageSpotColors known { /PageSpotColors 2 index countspotcolors def } if
% If the user told us to use a named OutputIntent
systemdict /UseOutputIntent .knownget {
cvn
% Check to see if this page has such an OutputIntent
2 index /OutputIntents knownoget {
{
dup /OutputConditionIdentifier get cvn
dup /Custom eq {
pop
dup /Info get cvn
}if
2 index eq {
%% Found the required OutputIntent
/DestOutputProfile knownoget {
[ /ICCBased 3 -1 roll ] ICCBased-resolve
1 get .set_outputintent
()
} if
pop
exit
}{
pop
} ifelse
}
forall
pop
}{
pop
}ifelse
} if
% Let the device know if we will be using PDF 1.4 transparency.
% The clist logic may need to adjust the size of bands.
1 index pageusestransparency /PageUsesTransparency exch def
dup /Install .knownget {
% Don't let the Install procedure get more deeply
% nested after every page.
dup type dup /arraytype eq exch /packedarraytype eq or {
dup length 4 eq {
dup 2 get /.pdfshowpage_Install load eq {
1 get 0 get % previous procedure
} if
} if
} if
} {
{ }
} ifelse 1 array astore
2 index exch /.pdfshowpage_Install load /exec load
4 packedarray cvx
% Stack: pagedict currentpagedict installproc
/Install exch def
% Stack: pagedict currentpagedict
pop currentdict end setpagedevice
} bind executeonly def
/.free_page_resources { % - .free_page_resources -
Page /Resources pget {
/Shading knownoget {
{ dup type /dicttype eq {
dup /.shading_dict known {
dup /.shading_dict undef
} if
} if
pop pop
} forall
} if
} if
} bind executeonly def
/pdfshowpage_finish { % <pagedict> pdfshowpage_finish -
save /PDFSave exch store
/PDFdictstackcount countdictstack store
/PDFexecstackcount count 2 sub store
(before exec) VMDEBUG
% set up color space substitution (this must be inside the page save)
pdfshowpage_setcspacesub
.writepdfmarks {
% Pagelabel
pagelabeldict begin dopagelabel end
% Copy the boxes.
% Copy the boxes.
{ /CropBox /BleedBox /TrimBox /ArtBox } {
2 copy pget {
% .pdfshowpage_Install transforms the user space do same here with the boxes
oforce_elems
2 { Page pdf_cached_PDF2PS_matrix transform 4 2 roll } repeat
normrect_elems 4 index 5 1 roll fix_empty_rect_elems 4 array astore
mark 3 1 roll {/PAGE pdfmark} stopped {cleartomark} if
} {
pop
} ifelse
} forall
} if % end .writepdfmarks
% Display the actual page contents.
9 dict begin
/BXlevel 0 def
/BMClevel 0 def
/OFFlevels 0 dict def
/BGDefault currentblackgeneration def
/UCRDefault currentundercolorremoval def
%****** DOESN'T HANDLE COLOR TRANSFER YET ******
/TRDefault currenttransfer def
matrix currentmatrix 2 dict
2 index /CropBox pget {
oforce_elems normrect_elems boxrect
4 array astore 1 index /ClipRect 3 -1 roll put
} if
dictbeginpage setmatrix
/DefaultQstate qstate store
count 1 sub /pdfemptycount exch store
% If the page uses any transparency features, show it within
% a transparency group. The scan was performed during pdfshowpage_setpage
% and the result was set in the pagedevice dictionary. Use it rather than
% scanning again IF it is present. If the pdfshowpage_setup was not called
% (eg GSView 5) then it will not be present, so we must rescan.
currentpagedevice /PageUsesTransparency .knownget not {dup pageusestransparency} if
dup /PDFusingtransparency exch def {
% If the current device isn't CMYK, or if it is a HighLevelDevice (pdfwrite) we
% don't need the special handling of Overprint transparency, so disable the checking.
currentpagedevice dup /Colors get 4 lt exch /HighLevelDevice known or {
/checkOPtrans { pop //false } def % NB: original will be restored from PDFsave
} if
% Show the page within a PDF 1.4 device filter.
0 .pushpdf14devicefilter {
/DefaultQstate qstate store % device has changed -- reset DefaultQstate
% If the page has a Group, enclose contents in transparency group.
% (Adobe Tech Note 5407, sec 9.2)
dup /Group knownoget {
1 index /CropBox pget {
/CropBox exch
} {
1 index get_media_box pop /MediaBox exch
} ifelse
oforce_elems normrect_elems fix_empty_rect_elems 4 array astore .beginpagegroup
showpagecontents
.endtransparencygroup
} {
showpagecontents
} ifelse
} stopped {
% abort the transparency device
.abortpdf14devicefilter
/DefaultQstate qstate store % device has changed -- reset DefaultQstate
stop
} if
{ } settransfer % identity transfer during popdevice (put_image)
.poppdf14devicefilter % NB: reset to DefaultQstate will also restore transfer function
/DefaultQstate qstate store % device has changed -- reset DefaultQstate
} {
/checkOPtrans { pop //false } def % no-op the check if the page doesn't use transparency
% NB: original will be restored from PDFsave
showpagecontents
} ifelse
.free_page_resources
% todo: mixing drawing ops outside the device filter could cause
% problems, for example with the pnga device.
endpage
end % scratch dict
% Some PDF files don't have matching q/Q (gsave/grestore) so we need
% to clean up any left over dicts from the dictstack
PDFdictstackcount //false
{ countdictstack 2 index le { exit } if
currentdict /n known not or
end
} loop {
StreamRunAborted not {
(\n **** Error: File has unbalanced q/Q operators \(too many q's\)\n Output may be incorrect.\n)
//pdfdict /.Qqwarning_issued .knownget
{
{
pop
}
{
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //true .forceput
.setglobal
pdfformaterror
} executeonly ifelse
} executeonly
{
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //true .forceput
.setglobal
pdfformaterror
} executeonly ifelse
} executeonly if
} executeonly if
pop
count PDFexecstackcount sub { pop } repeat
(after exec) VMDEBUG
Repaired % pass Repaired state around the restore
RepairedAnError
PDFSave restore
currentglobal //pdfdict gcheck .setglobal
//pdfdict /.Qqwarning_issued //false .forceput
.setglobal
/RepairedAnError exch def
/Repaired exch def
} bind executeonly odef
% Display the contents of a page (including annotations).
/showpagecontents { % <pagedict> showpagecontents -
dup % Save the pagedict for the Annotations
% We do a 'save' here in order to allow us to restore at the end of the page, before
% we run the annotations. There are two reasons for this; firstly so that the graphics state
% at the time we run the annotations is the same as when we ran the page, secondly in order
% to empty the font cache before we run the annotations.
%
% Bug #700096 an annotation uses Helvetica but doesn't embed it, however the page *does*
% use an embedded Helvetica, which is subset and not prefixed as such. For this file to
% render correctly we must not use the font from the page, but must find a replacement.
% However the file for Bug #695897 has a page which uses two versions of the same font,
% one embedded, one not. In order for *that* file to render correctly we *must* use the
% embedded font as a substitute for the missing font. So we divorce the fonts used
% for the page from the fonts used for Annotations, this allows both files to work as
% expected.
%
% We also need a countdictstack, so that we can check the dictionaries on the dictioanry
% stack after we run the page contents, and 'end' an extra ones before we try to restore
% otherwise we might try to restore back to a point before one of those dictionaries existed.
%
save
countdictstack
3 -1 roll
count 1 sub /pdfemptycount exch store
/Contents knownoget not { 0 array } if
dup type /arraytype ne { 1 array astore } if {
oforce dup type /dicttype eq {
//false resolvestream pdfopdict .pdfrun
} {
(**** Error: The Page /Contents array contains an element which is not a stream\n This page will not display correctly\n\n)
pdfformaterror
pop exit
}ifelse
} forall
% check for extra garbage on the ostack and clean it up
count pdfemptycount sub dup 0 ne {
( **** Error: File did not complete the page properly and may be damaged.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
{ pop } repeat
} {
pop
} ifelse
% Top of the stack should ow be the count of dictionaries on the stack at the time
% we did a save. If there are more than there were then, end dictionaries until
% we get back to the sme number.
{
countdictstack 1 index le {exit}if
end
} loop
% discard the count of dictionaries
pop
% and restore the state. This will take us back to a point before any fonts
% used on the page were defined, so the annotations won't inherit any of
% them.
restore
% Draw the annotations
//systemdict /ShowAnnots .knownget not { //true } if {
/Annots knownoget {
{ oforce
dup //null ne {
.writepdfmarks
%%
%% We don't want to preserve annotations with ps2write, because we don't convert them
%% back into pdfmarks on output.
%%
/ForOPDFRead /GetDeviceParam .special_op {
exch pop
}{
//false
}ifelse
not
and
//systemdict /PreserveAnnots .knownget not {//true} if and {
mark exch {preserveannot} PDFSTOPONERROR {exec}{stopped {(Error: Ignoring invalid annotation, output may be incorrect.\n) pdfformaterror} if} ifelse cleartomark
}{
mark exch {drawannot} PDFSTOPONERROR {exec}{stopped {(Error: Ignoring invalid annotation, output may be incorrect.\n) pdfformaterror} if} ifelse cleartomark
} ifelse
} {
pop
} ifelse
} forall
} if
} if
//systemdict /ShowAcroForm .knownget { //true eq } { //false } ifelse {
Trailer /Root oget /AcroForm knownoget { draw_acro_form } if
} if
} bind executeonly def
/processcolorspace { % - processcolorspace <colorspace>
% The following is per the PLRM3.
currentdevice 1 dict dup /ProcessColorModel dup put .getdeviceparams
exch pop exch pop
dup type /nametype ne { cvn } if
dup { setcolorspace } //.internalstopped exec { pop /DeviceRGB } if
} bind executeonly def
% ------ Transparency support ------ %
% Determine whether a page might invoke any transparency features:
% - Non-default BM, ca, CA, or SMask in an ExtGState
% - Image XObject with SMask
% Note: we deliberately don't check to see whether a Group is defined,
% because Adobe Illustrator 10 (and possibly other applications) define
% a page-level group whether transparency is actually used or not.
% Ignoring the presence of Group is justified because, in the absence
% of any other transparency features, they have no effect.
%
% Transparency is a 1.4 feature however we have seen files that claimed
% to be PDF 1.1 with transparency features. Bugs 689288, 691273.
/pageusestransparency { % <pagedict> pageusestransparency <bool>
NOTRANSPARENCY {
pop //false
} {
dup //false exch {
4 dict 1 index resourceusestransparency { pop not exit } if
%% Check the current dictionary and its Parent (if any) to see
%% if they both have stored object numbers. If they do then
%% check the numbers, don't allow self-references.
dup /Parent knownoget not { pop exit }
{
exch /.gs.pdfobj# .knownget
{
1 index /.gs.pdfobj# .knownget {
eq {
pop exit
}if
}{
pop
}ifelse
}if
} ifelse
} loop
% Also check for transparency in the annotation (if not in resources).
{ pop //true } { annotsusetransparency } ifelse
} ifelse
} bind executeonly def
% Check if transparency is specified in an ExtGState dict
/extgstateusestransparency { % <gstate dict> extgstateusestransparency <bool>
//false exch % Assume no transparency
dup //null eq {
pop % bug 692050
} {
{ % establish loop context
dup /BM knownoget {
dup /Normal ne exch /Compatible ne and { pop not exit } if
} if
dup /ca knownoget { 1 ne { pop not exit } if } if
dup /CA knownoget { 1 ne { pop not exit } if } if
dup /SMask knownoget { /None ne { pop not exit } if } if
pop exit
} loop
} ifelse
} bind executeonly def
% Check if transparency is used in a Pattern
/patternusestransparency { % <Pattern dict> patternusestransparency <bool>
dup //null eq NOTRANSPARENCY or
{ pop //false }
{ //false exch % Assume no transparency
{
4 dict 1 index resourceusestransparency { pop not exit } if
dup /ExtGState knownoget { extgstateusestransparency { pop not exit } if } if
pop exit
} loop
}
ifelse
} bind executeonly def
% Check the Resources of a page or Form. Check for loops in the resource chain.
/resourceusestransparency { % <dict> <dict> resourceusestransparency <bool>
{ % Use loop to provide an exitable context.
/Resources knownoget not { 0 dict } if
2 copy .knownget {
{ % Some circular references may be missed because scanning stops
% when the 1st transparency is found.
( **** Warning: Found circular references in resource dictionaries while checking for transparency.\n)
pdfformatwarning
} if
pop //false exit
} if
2 copy //true put % In the current chain.
dup /ExtGState knownoget {
//false exch
{ exch pop oforce extgstateusestransparency { pop //true exit } if
} forall
{ pop //true exit } if
} if
dup /Pattern knownoget {
//false exch
{ exch pop oforce patternusestransparency { pop //true exit } if
} forall
{ pop //true exit } if
} if
dup /XObject knownoget {
dup type /dicttype eq {
//false exch
{
exch pop oforce
dup //null ne {
dup type /dicttype eq {
dup /Subtype get
dup /Image eq {
1 index /SMask oknown { pop pop not exit } if
1 index /SMaskInData knownoget {
0 ne { pop pop not exit } if
} if
} if
/Form eq {
dup /Group known {pop pop //true exit}{
3 index exch resourceusestransparency { not exit } if
} ifelse
} {
pop
} ifelse
} {
pop
( **** Warning: Ignoring non-dictionary /XObject attribute while checking for transparency.\n)
pdfformatwarning
} ifelse
} {
pop
} ifelse
} forall
{ pop //true exit } if
} {
( **** Warning: Ignoring non-dictionary /XObject while checking for transparency.\n)
pdfformatwarning
pop
} ifelse
} if
dup /Font knownoget {
//false exch
{
exch pop oforce
dup type /dicttype eq {
dup /Subtype knownoget {
/Type3 eq
{
3 index exch resourceusestransparency
{ pop //true exit } if
}
{pop} ifelse
}
{
pop
}ifelse
}
{ % probably a name object
pop
}ifelse
} forall
{ pop //true exit } if
} if
2 copy //false put % Visited but not in the current chain.
pop //false exit
} loop
exch pop
} bind executeonly def
% Check if the annotations on a page use transparency
/annotsusetransparency { % <page dict> annotsusetransparency <bool>
//false exch % Assume no transparency
/Annots knownoget { % Get Annots array
{
oforce
dup //null ne {
dup /Subtype knownoget {
/Highlight eq { % Highlight annotation is always implemented
pop pop //true exit % as transparency.
} if
} if
dup /AP knownoget { % Get appearance dict for the annoation
/N knownogetdict { % Get the /N (i.e. normal) appearance stream
4 dict exch resourceusestransparency { pop pop //true exit } if
} if
} if % If AP dict known
dup /BM knownoget {
//true exit
} if
dup /CA knownoget {
1 le {
pop pop //true exit
} if
} if
/ca knownoget {
1 le {
pop //true exit
} if
} if
} {
pop
} ifelse
} forall % For all annots on the page
} if
} bind executeonly def
% Add a color name to our spot color list. Ignore /All and /None
/putspotcolor { % <name> <spotcolordict> putspotcolor -
% The 'name' could be a string. If so then convert to a name.
exch dup type /stringtype eq { cvn } if
dup dup /None eq exch /All eq or { pop pop } { 0 put } ifelse
} bind executeonly def
% Determine which spot colors are used within a color space Note: This
% dict will include all colors used in Separation or DeviceN color spaces.
% Thus it may include Cyan, Magenta, Yellow, and Black.
% <colorspace> <spotcolordict> colorspacespotcolors -
/colorspacespotcolors {
exch dup type /arraytype eq {
% If we have an Indexed color space then get the base space.
dup 0 oget % <<>> [csp] /Type
dup /Indexed eq {
pop 1 oget % <<>> [base]
2 copy exch colorspacespotcolors
} {
% Stack: <spotcolordict> <colorspace> <colorspacetype>
dup /Separation eq exch /DeviceN eq or {
dup 1 oget dup type /arraytype eq {
{ oforce 2 index putspotcolor } forall
} {
2 index putspotcolor
} ifelse
} if
} ifelse
} if
pop pop
} bind executeonly def
% Check the Resources of a page, form, or annotation. Determine which spot
% colors are used within the resource Note: The spot color dict will include
% all colors used in Separation or DeviceN color spaces. Thus it may include
% Cyan, Magenta, Yellow, and Black. We also pass a dict that is used to check
% for loops in the resource list.
% <spotcolordict> <loopdict> <page/form/annot dict>
% resourcespotcolors <spotcolordict> <loopdict>
/resourcespotcolors {
{ % Use loop to provide an exitable context.
% Exit if no Resources entry
/Resources knownoget not { exit } if
% Exit if we have already seen this dict
2 copy known { pop exit } if
% Save the Resources dict into our loop checking dict.
2 copy 0 put
% Scan resources that might contain a color space.
dup /ColorSpace knownoget {
{ exch pop oforce 3 index colorspacespotcolors } forall
} if
dup /Pattern knownoget {
{ exch pop oforce
dup /Shading knownoget {
exch pop
/ColorSpace oget 3 index colorspacespotcolors
} {
4 copy exch pop resourcespotcolors pop pop pop
} ifelse
} forall
} if
dup /Shading knownoget {
{ exch pop
oforce /ColorSpace
{ oget } stopped
{
pop pop
( **** Error: invalid color space in shading, output may be incorrect.\n) pdfformaterror
}
{ 3 index colorspacespotcolors}
ifelse
} forall
} if
/XObject knownoget {
dup type /dicttype eq {
{ exch pop oforce
dup type /dicttype eq {
dup //null ne {
dup /Subtype oget
dup /Form eq {
pop resourcespotcolors
} {
/Image eq {
/ColorSpace knownoget {
2 index colorspacespotcolors
} if
} {
pop
} ifelse
} ifelse
} {
pop
} ifelse
} {
pop
} ifelse
} forall
} {
pop % Just ignore here, already reported by resourceusestransparency.
} ifelse
} if
exit
} loop
} bind executeonly def
% Determine which spot colors are used within the annotations. Note: This
% dict will include all colors used in Separation or DeviceN color spaces.
% Thus it may include Cyan, Magenta, Yellow, and Black.
% <spotcolordict> <loopdict> <annotsarray>
% annotsspotcolors <spotcolordict> <loopdict>
/annotsspotcolors {
{ oforce
dup //null ne {
/AP knownoget { % Get appearance dict for the annoation
/N knownogetdict { % Get the /N (i.e. normal) appearance stream
resourcespotcolors
} if % If normal appearance streamknown
} if % If AP dict known
} {
pop
} ifelse
} forall
} bind executeonly def
% Determine spot colors are used within a page. We are creating a dict to
% hold the spot color names as keys. Using a dict avoids having to worry
% about duplicate entries. The keys in the dict contain the spot color
% names. However the values have no meaning. Note: This dict will include
% all colors used in Separation or DeviceN color spaces specified in the
% page's resources. Thus it may include Cyan, Magenta, Yellow, and Black.
% There is no attempt to verify that these color spaces are actually used
% within the object streams for the page.
/pagespotcolors { % <pagedict> pagespotcolors <spotcolordict>
dup
% Create a dict to hold spot color names.
0 dict exch
% Create a dict to be used to check for reference loops.
4 dict exch
% Check for color spaces in the Resources
resourcespotcolors
% now check upwards in the object hierarchy in case of inherited resources
2 index
{
/Parent knownoget
{
dup 4 1 roll
resourcespotcolors
3 -1 roll
}
{
exit
} ifelse
} loop
% Also check for color spaces in the annotations.
3 -1 roll
/Annots knownoget { annotsspotcolors } if
pop % Discard reference loop dict
} bind executeonly def
% Determine how many (if any) spot colors are used by a page.
% Note: This count does not include Cyan, Magenta, Yellow, or Black
/countspotcolors { % <pagedict> countspotcolors <count>
pagespotcolors % Get dict with all spot colors
dup length % spot color dict length
% Remove CMYK from the spot color count.
[ /Cyan /Magenta /Yellow /Black ]
{ 2 index exch known { 1 sub } if } forall
exch pop % Remove spot color dict
} bind executeonly def
% ------ ColorSpace substitution support ------ %
%%
%% <pagedict> pdf_colorspace_detect_cspacesub <boolean>
%%
/pdf_colorspace_detect_cspacesub {
//false exch
/Resources knownoget {
/ColorSpace knownoget {
dup /DefaultGray knownoget {
resolvecolorspace csncomp 1 eq {
pop pop //true
} if
} {
dup /DefaultRGB knownoget {
resolvecolorspace csncomp 3 eq {
pop pop //true
} if
} {
/DefaultCMYK knownoget {
resolvecolorspace csncomp 4 eq {
pop //true
} if
} if
} ifelse
} ifelse
} if
} if
} bind executeonly def
%% <loopdict> <Objectdict> <calling obj_num> pdfform_detect_cspacesub <boolean>
%%
/pdf_object_detect_cspacesub {
%% use loop operator for an exitable context
%% we need this to detect recursion/looping
{
exch %% <loopdict> <calling obj_num> <Objectdict>
dup pdf_colorspace_detect_cspacesub {
pop pop //true exit
}{ %% <loopdict> <calling obj_num> <Objectdict>
/Resources knownoget { %% <loopdict> <calling obj_num> <Resourcesdict>
2 index 1 index known {
%% We've already seen this object, ignore it and exit
pop pop //false exit
}{
2 index 1 index //null put
} ifelse
/XObject knownoget { %% <loopdict> <calling obj_num> <XObjectdict>
//false exch %% <loopdict> <calling obj_num> <XObjectdict> false
%% We have files where the XObject Resource is not a dictionary
dup type /dicttype eq { %% <loopdict> <calling obj_num> <XObjectdict> false
%% check each Xobject entry in the dictionary,
%% forall purs a key/value pair on the stack for us.
%%
{ %% <loopdict> <calling obj_num> <XObjectdict> false key value
exch pop %% <loopdict> <calling obj_num> <XObjectdict> false value
%% If this is an indirect reference, check if its the smae object
%% as the current one. If its not indirect, make the object number 0
%% for comparison purposes.
dup type /packedarraytype eq {
dup 0 get dup 4 index
eq
} {
0 //false
}ifelse
%% <calling obj_num> <XObjectdict> false value <form object or 0 if not indirect> <boolean>
not {
%% swap object number and value, and dereference value
exch oforce
%% Apparently we have files where the content of the XObject Resource dictionary is null
dup //null ne {
%% and files where the indivudal XObjects are not dictionaries
dup type /dicttype eq {
dup /Subtype get /Form eq {
exch
4 index 3 1 roll pdf_object_detect_cspacesub {
pop //true exit
} if
} {
pop pop
}ifelse
}{
pop pop
} ifelse
}{
pop pop
}
ifelse
}{
pop pop
} ifelse
} forall
}{
pop
}ifelse
} {
%% No forms, so can't be any Default* spaces
//false
}ifelse
} {
//false
} ifelse
} ifelse
%% Remove the calling object ID, return our boolean
exch pop exit
} loop
%% remove and discard the loopdict
exch pop
} bind executeonly def
%
% <pagedict> pdfshowpage_detect_cspacesub <pagedict> <boolean>
%
% this is used simply to detect whether the current page has any
% Default* color spaces defined. If it does then we want pdfshowpage_setpage
% to set UseCIEColor to true so that the Default* space is used. If the
% page doesn't use any Default* spaces, then we *don't* want to set
% UseCIEColor as that will confuse a warning in pdfwrite about
% not using UseCIEColor with pdfwrite.
%
/pdfshowpage_detect_cspacesub {
dup 0 1 dict 3 1 roll pdf_object_detect_cspacesub
/HighLevelDevice /GetDeviceParam .special_op {
exch pop not exch pop
}if
} bind executeonly def
%
% <pagedict> pdfshowpage_setcspacesub <pagedict>
%
% Set up color space substitution for a page. Invocations of this procedure
% must be bracketed by the save/restore operation for the page, to avoid
% unintended effects on other pages.
%
% If any color space substitution is used, and the current color space is a
% device dependent color space, make sure the current color space is updated.
% There is an optimization in the setcolorspace operator that does
% nothing if both the current and operand color spaces are the same. For
% PostScript this optimization is disabled if the UseCIEColor page device
% parameter is true. This is not the case for PDF, as performance suffers
% significantly on some PDF files if color spaces are set repeatedly. Hence,
% if color space substitution is to be used, and the current color space
% is a device dependent color space, we must make sure to "transition" the
% current color space.
%
/pdfshowpage_setcspacesub {
//false
/DefaultGray 2 index /ColorSpace //rget exec {
resolvecolorspace dup csncomp 1 eq {
dup type /nametype eq { 1 array astore } if
/DefaultGray exch /ColorSpace defineresource pop
pop //true
} {
pop
( **** Error: ignoring invalid /DefaultGray color space.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if
/DefaultRGB 2 index /ColorSpace //rget exec {
resolvecolorspace dup csncomp 3 eq {
dup type /nametype eq { 1 array astore } if
/DefaultRGB exch /ColorSpace defineresource pop
pop //true
} {
pop
( **** Error: ignoring invalid /DefaultRGB color space.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if
/DefaultCMYK 2 index /ColorSpace //rget exec {
resolvecolorspace dup csncomp 4 eq {
dup type /nametype eq { 1 array astore } if
/DefaultCMYK exch /ColorSpace defineresource pop
pop //true
} {
pop
( **** Error: ignoring invalid /DefaultCMYK color space.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if
{ % if using color space substitution, "transition" the current color space
currentcolorspace dup length 1 eq { % always an array
0 get
dup /DeviceGray eq 1 index /DeviceRGB eq or 1 index /DeviceCMYK eq or {
/Pattern setcolorspace setcolorspace
} {
pop
} ifelse
} {
pop
} ifelse
} if
} bind executeonly def
% Write OutputIntents to device if the device handles it
/writeoutputintents {
currentdevice 1 dict dup /OutputIntent //null put readonly
.getdeviceparams
mark ne { pop pop
% device supports OutputIntent parameter
% Make sure we don't have a badly broken PDF file!
Trailer /Root knownoget {
/OutputIntents knownoget {
dup type /arraytype eq {
{ % process all output profiles present
oforce
dup length dict .copydict
dup /DestOutputProfile knownoget {
PDFfile fileposition exch
mark exch { oforce } forall .dicttomark
//true resolvestream
[ { counttomark 1 add index
64000 string readstring
not { exit } if
} loop
] exch closefile
0 1 index { length add } forall .bytestring
0 3 2 roll {
3 copy putinterval
length add
} forall pop
exch PDFfile exch setfileposition
1 index /DestOutputProfile 3 2 roll put
} if
% Convert to string array because it's easier for the device
[ 1 index /OutputCondition knownoget not { () } if
2 index /OutputConditionIdentifier knownoget not { () } if
3 index /RegistryName knownoget not { () } if
4 index /Info knownoget not { () } if
5 index /DestOutputProfile knownoget not { () } if
]
[ /OutputIntent 3 2 roll /.pdfputparams where
{ pop .pdfputparams }
{ currentdevice //null //false counttomark 1 add 3 roll .putdeviceparamsonly }
ifelse
pop pop
pop % done with this OutputIntent dictionary
} forall
} {
pop
( **** Error: /OutputIntent is of an incorrect type, ignoring OutputIntent.\n)
pdfformaterror
( Output may be incorrect.\n) pdfformaterror
} ifelse
} if % OutputIntents known
% tell device there are no more OutputIntents
[ /OutputIntent [ ] /.pdfputparams where
{ pop .pdfputparams }
{ currentdevice //null //false counttomark 1 add 3 roll .putdeviceparamsonly }
ifelse
pop pop
} if
} if
} bind executeonly def
end % pdfdict
.setglobal
%% This list of operators are used internally by various parts of the Ghostscript PDF interpreter.
%% Since each operator is a potential security vulnerability, and any operator listed here
%% is not required once the initislisation is complete and functions are bound, we undefine
%% the ones that aren't needed at runtime.
/.PDF_UNDEF_OPLIST
[
/.pdfawidthshow /.pdfwidthshow /.currentblackptcomp /.setblackptcomp
/.setfillcolor /.setfillcolorspace /.setstrokecolor /.setstrokecolorspace /.currentrenderingintent /.setrenderingintent
/.currenttextrenderingmode /.settextspacing /.currenttextspacing /.settextleading /.currenttextleading
/.settextrise /.currenttextrise /.setwordspacing /.currentwordspacing /.settexthscaling /.currenttexthscaling
/.settextlinematrix /.currenttextlinematrix /.currenttextmatrix /.settextmatrix /.currentblendmode
/.currentopacityalpha /.currentshapealpha /.currenttextknockout
/.pushextendedgstate /.popextendedgstate /.begintransparencytextgroup
/.endtransparencytextgroup /.begintransparencymaskgroup /.begintransparencymaskimage /.endtransparencymask /.image3x
/.abortpdf14devicefilter /.pdfinkpath /.pdfFormName /.setstrokeconstantalpha
/.setfillconstantalpha /.setalphaisshape /.currentalphaisshape
/.settextspacing /.currenttextspacing /.settextleading /.currenttextleading /.settextrise /.currenttextrise
/.setwordspacing /.currentwordspacing /.settexthscaling /.currenttexthscaling /.setPDFfontsize /.currentPDFfontsize
/.setdistillerparams
% Used by our own test suite files
%/.pushpdf14devicefilter % transparency-example.ps
%/.poppdf14devicefilter % transparency-example.ps
%/.setopacityalpha % transparency-example.ps
%/.setshapealpha % transparency-example.ps
%/.endtransparencygroup % transparency-example.ps
% undefining these causes errors/incorrect output
%/.settextrenderingmode /.setblendmode /.begintransparencygroup /.settextknockout /.setstrokeoverprint /.setfilloverprint
%/.currentstrokeoverprint /.currentfilloverprint /.currentfillconstantalpha /.currentstrokeconstantalpha
] def
DELAYBIND not {
.PDF_UNDEF_OPLIST
{systemdict exch .undef} forall
systemdict /.PDF_UNDEF_OPLIST .undef
} if
Mini Shell