% % % % % % % % % % % % % %

Copyright (C) 2000, 2001 Aladdin Enterprises. 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. For more information about licensing, please refer to http://www.ghostscript.com/licensing/. For information on commercial licensing, go to http://www.artifex.com/licensing/ or contact Artifex Software, Inc., 101 Lucas Valley Road #110, San Rafael, CA 94903, U.S.A., +1(415)492-9861.

% $Id$ % PDF linearizer ("optimizer"). .currentglobal true .setglobal /pdfoptdict 200 dict def pdfoptdict begin % This linearizer is designed for simplicity, not for performance. % See the main program (the last procedure in the file) for comments % describing the main processing sequence. % ---------------- Utilities ---------------- % % ------ Data structures ------ % % Distinguish dictionaries, arrays, and everything else. /ifdaelse { % <obj> <dictproc> <arrayproc> <otherproc> ifdaelse 3 index type dup /dicttype eq { pop pop pop } { dup /arraytype ne exch /packedarraytype ne and { exch } if pop exch pop } ifelse exec } bind def % Implement dynamically growable arrays using a dictionary. /darray { % <size> darray <darray> dict } bind def /dadd { % <darray> <value> dadd 1 index length exch put } bind def /daforall { % <darray> <proc> daforall /exch cvx /get cvx 3 -1 roll /exec cvx 5 packedarray cvx 0 1 2 index 0 get length 1 sub 4 -1 roll for } bind def /dacontents { % <darray> dacontents <array> [ exch { } daforall ] } bind def /dacontstring { % <darray> dacontstring <string> 0 1 index { exch pop length add } forall string dup /NullEncode filter % Stack: darray str filter 3 -1 roll { 1 index exch writestring } daforall

closefile } bind def % Force an object, mapping it if it is a reference. /omforcenew { % <obj> omforce <obj'> <notseen> dup oforce 2 copy eq { pop true } { exch 0 get omapnew exch pop } ifelse } bind def /omforce { % <obj> omforce <obj'> omforcenew pop } bind def /omget { % <dict array> <key> omget <obj> get omforce } bind def % Visit an entire tree. /omvisit { % <obj> omvisit omforcenew { { { omvisit omvisit } forall } { { omvisit } forall } { pop } ifdaelse } { pop } ifelse } bind def % Visit a tree, stopping at references to Page objects. % (This is only needed for the OpenAction in the Catalog.) /omvisitnopage { % <obj> omvisitnopage dup oforce dup type /dicttype eq { /Type .knownget { /Page eq } { false } ifelse } { pop false } ifelse { pop % Page reference } { omforcenew { { { omvisitnopage omvisitnopage } forall } { { omvisitnopage } forall } { pop } ifdaelse } { pop } ifelse } ifelse } bind def % Collect the list of currently mapped object numbers, in order. /omapped { % - omapped <obj#s> RMap ld_length larray exch lgrowto RMap { 2 index 3 1 roll 1 sub exch lput } ld_forall } bind def % Collect the list of object numbers passed to omap by a procedure. /visited { % <proc> visited <obj#s> false currentomap 2 .execn omapped exch setomap } bind def % ------ Output ------ %

% Provide a framework for closure-based streams. .currentglobal false .setglobal userdict /clostreams 20 dict put % stream -> [data endproc] .setglobal % Create a closure-based stream. /clostream { % <data> <proc> <endproc> clostream <stream> 2 index 3 -1 roll /exec load 3 packedarray cvx /NullEncode filter % Stack: data endproc stream clostreams 1 index 5 -2 roll 2 array astore put } bind def % Close a closure-based stream. /closend { % <stream> closend <result> dup closefile clostreams exch 2 copy get 3 1 roll undef aload pop exec } bind def % Implement in-memory output streams. /msproc { % <data> <more> <accum> msproc <scratch> 3 -1 roll dadd { 100 string } { () } ifelse } bind def /mstream { % - mstream <mstream> 10 darray {msproc} {dacontstring} clostream } bind def /mcontents { % <mstream> mcontents <string> closend } bind def % Implement a stream that only keeps track of its position. % (All streams should do this, but the PLRM doesn't require it.) /posbuf 100 string def /posproc { % <data> <more> <accum> posproc <scratch> 0 2 copy get 5 -1 roll length add put pop //posbuf } bind def /postream { % - postream <postream> [0] {posproc} {0 get} clostream } bind def /poslength { % <postream> poslength <pos> closend } bind def % Implement streams with variable-bit-width data. % Note that these are dictionary objects, not stream objects. /bitstream { % <stream> bitstream <bstream> 4 dict begin /S exch def /N 8 def /B 0 def currentdict end } bind def /bitwrite { % <bstream> <value> <width> bitwrite PDFOPTDEBUG { ( ) print 1 index =only (:) print dup = } if 3 -1 roll begin N exch sub dup 0 ge { /N exch def N bitshift B add } { 2 copy bitshift B add S exch write % Stack: value -left { 8 add dup 0 ge { exit } if 2 copy bitshift 255 and S exch write } loop

/N 1 index def bitshift 255 and } ifelse /B exch def end } bind def /bitflush { % <bstream> bitflush begin N 8 ne { S B write /B 0 def /N 8 def } if end } bind def /bwn { % <value> <width> bwn 2 copy % v w v w 2 exch exp ge { % v w v>=2**w /bwn cvx /rangecheck signalerror } if bits 3 1 roll bitwrite } def % Capture OFile output on the temporary file, in memory, or just as a length. /totemp { % <proc> totemp <start> <end> TFile fileposition OFile /OFile TFile def 3 .execn /OFile exch def TFile fileposition } bind def /tomemory { % <proc> tomemory <string> OFile /OFile mstream def 2 .execn OFile mcontents exch /OFile exch def } bind def /tolength { % <proc> tolength <string> OFile /OFile postream def 2 .execn OFile poslength exch /OFile exch def } bind def % Copy a range of bytes from TFile to OFile. /copyrange { % <start> <end> copybytes TFile 2 index setfileposition exch sub 1024 string exch { % Stack: buf left 2 copy 1 index length .min 0 exch getinterval TFile exch readstring pop OFile exch writestring 1 index length sub dup 0 le { exit } if } loop pop pop } bind def % Pad with blanks to a specified position. /padto { % <pos> padto OFile fileposition sub dup 0 lt { (ERROR: file position incorrect by ) print = /padto cvx /rangecheck signalerror } { { ( ) ows } repeat } ifelse } bind def % ---------------- Read objects into memory ---------------- % /touch { % <object> touch { { touch touch } forall } {

dup xcheck { % Executable array, must be an indirect object. dup 0 get resolved? { pop pop } { oforce touch } ifelse } { { touch } forall } ifelse } { pop } ifdaelse } bind def % ---------------- Replace references with referents ---------------- % /replaceable? { % <value> replaceable? <bool> dup type /integertype eq exch xcheck not and } bind def /replacement { % <obj ref> replacement <obj'> dup oforce dup replaceable? { exch } if pop } bind def /replacerefs { % <object> replacerefs <object> { dup { 2 index 2 index undef exch replacement exch replacement 2 index 3 1 roll put } forall } { 0 1 2 index length 1 sub { 1 index exch 2 copy get replacement put } for } { } ifdaelse } bind def /replaceReferences { % - replaceReferences Objects { replacerefs pop } lforall % Delete replaced objects. 0 1 Objects llength 1 sub { Objects 1 index lget replaceable? { PDFOPTDEBUG { (Deleting ) print dup = } if Generations 1 index 0 lput } if pop } for } bind def % ---------------- Create new objects ---------------- % /createObjects { % [<obj>...] createObjects <firstobj#> Objects llength dup dup 3 index length add growPDFobjects % Stack: objects objn objn 3 1 roll exch { Objects 2 index 3 -1 roll lput Generations 1 index 1 lput 1 add } forall pop } bind def % ---------------- Propagate attributes ---------------- %

/nopropattrs << % Never propagate these. /Type dup /Kids dup /Count dup /Parent dup % Handle Resources specially. /Resources dup >> def % Merge Resources. /mergeres { % <fromdict> <todict> mergeres % Values in todict take priority over fromdict. 1 index /Resources .knownget { 1 index /Resources .knownget { % Stack: fromdict todict fromres tores exch oforce exch oforce % todict's Resources may be shared, so make a copy. dup length dict .copydict exch { % Stack: fromdict todict tores' fromkey fromvalue 2 index 2 index knownoget { % Stack: fromdict todict tores' fromkey fromvalue tovalue exch oforce exch % ProcSet is an array, other types are dictionaries. dup type /dicttype eq { % Dictionary, not ProcSet. exch dup length 2 index length add dict .copydict .copydict } { % Array or packed array, ProcSet. % Use dictionaries to do the merge. dup length 2 index length add dict begin exch { dup def } forall { dup def } forall mark currentdict end { pop } forall .packtomark } ifelse } if 2 index 3 1 roll put } forall } if /Resources exch put pop } { pop pop } ifelse } bind def % Merge attributes other than Resources. /mergeattrs { % <fromdict> <todict> mergeattrs <fromdict> <todict> % Values in todict take priority over fromdict. 1 index { % Stack: fromdict todict fromkey fromvalue //nopropattrs 2 index known { pop pop } { 2 index 2 index known { pop pop } { 2 index 3 1 roll put } ifelse } ifelse } forall } bind def % Propagate attributes to a subtree. /proppage { % <attrs> <subtree> % We should be able to tell % by finding a Type unequal % some files distributed by proppage when we reach a leaf to /Pages. Unfortunately, Adobe lack the Type key

% in some of the Pages nodes! Instead, we check for Kids. dup /Kids knownoget { % Accumulate inherited values. 3 1 roll % Stack: kids attrs pagesnode dup length dict .copydict mergeattrs dup 3 1 roll mergeres exch { oforce 1 index exch proppage } forall pop } { % Merge inherited values into the leaf. mergeattrs mergeres } ifelse } bind def % Propagate attributes to all pages. /propagateAttributes { % - propagateAttributes 0 dict Trailer /Root oget /Pages oget proppage } bind def % ---------------- Identify document-level objects ---------------- % /identifyDocumentObjects { % - identifyDocumentObjects <obj#s> { Trailer /Root omget dup /PageMode .knownget { omvisit } if % Don't allow omvisit to trace references to Page objects. dup /OpenAction .knownget { omvisitnopage } if Trailer /Encrypt .knownget { omvisit } if dup /Threads .knownget { omforce dup //null ne { { omvisitnopage } forall } { pop } ifelse } if dup /AcroForm .knownget { omvisitnopage } if pop } visited } bind def % ---------------- Identify the objects of each page ---------------- % /identifyfont { % <fontref> identifyfont omforce { exch /FontDescriptor eq { omforce dup /Flags .knownget { 32 and 0 ne } { false } ifelse exch { exch dup dup /FontFile eq exch /FontFile2 eq or exch /FontFile3 eq or 2 index and { fontfiles exch dadd } { omvisit } ifelse } forall pop } { omvisit } ifelse } forall } bind def % Collect all the objects referenced from a page. The first object number % (which may not be the smallest one) is that of the page object itself. /identifyPageObjects { % <extra> <page#> identifyPageObjects <obj#s> PDFOPTDEBUG {

(%Objects for page: ) print dup = } if pdffindpageref dup 0 get 3 1 roll 4 dict begin /filter_params 10 darray def /images 10 darray def /fontfiles 10 darray def { omforce % Stack: pageobj# extra page % Visit any extra objects if applicable. exch omvisitnopage % Visit Annots, if any. % We don't try to defer the drawing information. dup /Annots .knownget { omvisitnopage } if % Visit beads. dup /B .knownget { omvisitnopage } if % Visit resources dictionaries. dup /Resources .knownget { omforce dup { % Visit the first-level Resource dictionaries. omforce pop pop } forall { % Visit the resources themselves. % Skip Image XObjects, and FontFile streams if the % FontDescriptor Flags have bit 6 set. % We don't try to visit the resources in the order in which % the Contents stream(s) reference(s) them. exch dup /XObject eq { pop oforce { dup oforce /Subtype get /Image eq { dup oforce /DecodeParms .knownget { oforce { exch /JBIG2Globals eq { filter_params exch dadd } { pop } ifelse } forall } if images exch dadd } { omvisit } ifelse pop } forall } { /Font eq { oforce { identifyfont pop } forall } { oforce omvisit } ifelse } ifelse } forall } if % Visit the Contents stream(s). dup /Contents .knownget { omvisit } if % Visit Image XObjects. We don't try to visit them in % reference order. filter_params { omvisit } daforall

images { omvisit } daforall % Visit FontFile streams. We don't try to visit them in % reference order. fontfiles { omvisit } daforall pop } visited end % Stack: pageobj# obj#s_larray [ 3 1 roll { 2 copy eq { pop } { exch } ifelse } lforall counttomark 1 roll ] PDFOPTDEBUG { (%Objects = ) print dup === flush } if } bind def % Identify the objects of the first page. /identifyFirstPageObjects { % - identifyFirstPageObjects <obj#s> Trailer /Root oget null 1 index /PageMode knownoget { /UseOutlines eq { 1 index /Outlines knownoget { exch pop } if } if } if exch pop 1 identifyPageObjects } bind def % Identify the non-shared objects of the other pages, and the shared objects. % Note that the page objects themselves may appear to be shared, because of % references from Dest entries in annotations, but they must be treated as % non-shared. Note also that some objects referenced on the first page may % also be referenced from other pages. /identifyOtherPageObjects { % - identifyOtherPageObjects [<pageobj#s> ...] % <sharedobj#s> 4 dict begin /marks lstring Objects llength lgrowto def % Collect objects of other pages and identify sharing. [ 2 1 pdfpagecount { null exch identifyPageObjects } for ] dup { { marks exch 2 copy lget 1 add 254 .min lput } forall } forall % Mark document-level and first page objects. CatalogNs { marks exch 255 lput } lforall FirstPageNs { marks exch 255 lput } forall % Mark the page objects themselves as non-shared. dup { 0 get marks exch 1 lput } forall % Collect the non-shared objects of each page. dup [ exch { [ exch { marks 1 index lget 1 ne { pop } if } forall ] } forall ] % Collect the shared objects of each page. exch [ exch { [ exch { marks 1 index lget dup 1 le exch 255 eq or { pop } if } forall ]

} forall ] % Collect the shared objects. [ 1 1 marks llength 1 sub { marks 1 index lget dup 1 le exch 255 eq or { pop } if } for ] end } bind def % Identify objects not associated with any page. /identifyNonPageObjects { % - identifyNonPageObjects <obj#s> 4 dict begin /marks lstring Objects llength lgrowto def LPDictN PHSN CatalogNs FirstPageNs SharedNs OtherPageNs marks exch 1 lput marks exch 1 lput { marks exch 1 lput } { marks exch 1 lput } { marks exch 1 lput } { { marks exch 1 lput

lforall forall forall } forall } forall

%****** PUT THESE IN A REASONABLE ORDER ****** /npobj larray 0 1 1 Objects llength 1 sub { marks 1 index lget 0 eq { Generations exch lget 0 ne { 1 add } if } { pop } ifelse } for lgrowto def 0 1 1 Objects llength 1 sub { marks 1 index lget 0 eq { % i Generations 1 index lget 0 ne { npobj 2 index 3 -1 roll lput 1 add } { pop } ifelse } { pop } ifelse } for pop npobj end } bind def % ---------------- Assign object numbers ---------------- % % Assign object numbers to all objects that will be copied. % Return the first (translated) object number in the First Page xref table. % i % i nobj 0 % nobj 0 i

/assignObjectNumbers { % - assignObjectNumbers OtherPageNs { { omap pop } forall } forall SharedNs { omap pop } forall NonPageNs { omap pop } lforall % Assign object numbers for the First Page xref table last. LPDictN omap % don't pop, this is the return value CatalogNs { omap pop } lforall FirstPageNs { omap pop } forall PHSN omap pop } bind def % ---------------- Create the LPDict ---------------- % % Create the contents of the LPDict. /createLPDict { % <phsstart> <phsend> <firstpageend> % <xref0start> <filelength> createLPDict LPDict dup /Linearized 1 put dup /L 4 -1 roll put % filelength dup /T 4 -1 roll put % xref0start dup /E 4 -1 roll put % firstpageend dup /H 5 -2 roll 1 index sub 2 array astore put % phsstart, end-start dup /O 1 pdffindpageref 0 get omap put /N pdfpagecount put } bind def % ---------------- Adjust object positions ---------------- % /adjustObjectPositions { % <boundary> <deltabelow> <deltaabove> % adjustObjectPositions % Objects fall into 4 categories: LPDict, PHS, Catalog, and others. % We handle the first two as special cases.

XRef { % Stack: bdy below above key loc dup 5 index ge { 2 } { 3 } ifelse index add XRef 3 1 roll ld_put } ld_forall pop pop pop XRef LPDictN omap HeaderLength ld_put XRef PHSN omap PHSStart ld_put } bind def % ---------------- Write the output file ---------------- % % Write objects /writeobjn { Generations 1 } bind def /writeobjns { { writeobjn } } bind def /lwriteobjns { { writeobjn } } bind def identified by object number. % <obj#> writeobjn index lget pdfwriteobj % <obj#s> writeobjns forall % <obj#s> writeobjns lforall

% Write a part of the output file. /writePart { % <proc> <label> writePart PDFOPTDEBUG { dup print ( count=) print count =only ( start=) print OFile { .fileposition } stopped { pop (???) } if = 2 .execn

print ( end=) print OFile { .fileposition } stopped { pop (???) } if = } { pop exec } ifelse } bind def % Write the header. /writePart1 { { pdfwriteheader } (part1) writePart } bind def % Write the /writePart2 { LPDictN } (part2) } bind def % - writePart1 -

linearization parameters dictionary. { % - writePart2 writeobjn writePart

% Write the First Page xref table and trailer. % Free variables: FirstPageXN. /writePart3 { % <xrefstart> writePart3 { FirstPageXN NObjects 1 add 1 index sub pdfwritexref Trailer dup length 1 add dict copy Trailer xcheck { cvx } if dup /Size NObjects 1 add put dup /Prev 4 -1 roll put pdfwritetrailer 0 pdfwritestartxref } (part3) writePart } bind def % Write the Catalog and other required document-level objects. % Free variables: CatalogNs. /writePart4 { % - writePart4 { CatalogNs lwriteobjns } (part4) writePart } bind def % Write the Primary Hint Stream. /writePart5 { % - writePart5 { PHSN writeobjn } (part5) writePart } bind def % Write the First Page's objects. % Free variables: FirstPageNs. /writePart6 { % - writePart6 { FirstPageNs writeobjns } (part6) writePart } bind def % Write the objects of other pages (Page + non-shared objects). % Free variables: OtherPageNs. /writePart7 { % - writePart7 <lengths>

{ [ OtherPageNs { OFile fileposition exch writeobjns OFile fileposition exch sub } forall ] } (part7) writePart } bind def % Write the shared objects of other pages. % Free variables: SharedNs. /writePart8 { % - writePart8 { SharedNs writeobjns } (part8) writePart } bind def % Write the other objects not associated with pages. % Free variables: NonPageNs. /writePart9 { % - writePart9 { NonPageNs { writeobjn } lforall } (part9) writePart } bind def % Write the main xref table and trailer. % Free variables: FirstPageXN. /writePart11xref { % writePart11 { 0 FirstPageXN pdfwritexref } (part11xref) writePart } bind def /writePart11rest { % <part3start> writePart11rest { << /Size FirstPageXN >> pdfwritetrailer pdfwritestartxref } (part11rest) writePart } bind def % ---------------- Write hint tables ---------------- % /bitsneeded { % <maxvalue> bitsneeded <#bits> 0 exch { dup 0 eq { pop exit } if exch 1 add exch 2 idiv } loop } bind def % Find the start and end of objects in the output. /omstart { % <obj#> omstart <pos> PDFOPTDEBUG { (start\() print dup =only } if omap PDFOPTDEBUG { (=>) print dup =only } if XRef exch ld_get PDFOPTDEBUG { (\) = ) print dup = } if } bind def /omend { % <obj#> omend <pos> % The end of an object is the start of the next object. % The caller must be sure that this object is not the last one % in part 9. PDFOPTDEBUG { (end\() print dup =only } if omap PDFOPTDEBUG { (=>) print dup =only } if 1 add

% Check that the requested object wasn't the last one in part 6: % the next object in the output file is the first in part 7. PHSN omap 1 index eq { pop 1 } if XRef exch ld_get PDFOPTDEBUG { (\) = ) print dup = } if } bind def /omlength { % <obj#> omlength <length> dup omend exch omstart sub } bind def % Find the Contents of a page. /contentsobjects { % <pagedict> % <pagedict> /Contents .knownget { dup oforce dup type /dicttype eq { pop 0 get dup true } { exch pop dup length 0 ne { dup 0 get 0 get exch dup length 1 sub get 0 get true } { pop false } ifelse } ifelse } { false } ifelse } bind def /contentsstart { contentsobjects <firstobj#> <lastobj#> true contentsobjects false % ref [] % ref ref % [] % [] 1st % 1st [] [] % 1st last

% <pagedict> contentsstart <pos> true % <pagedict> contentsstart false contentsobjects { pop omstart true } { false } ifelse } bind def /contentslength { % <pagedict> contentslength <length> contentsobjects { omend exch omstart sub } { 0 } ifelse } bind def /writePageOffsetHints { PDFOPTDEBUG { /writePageOffsetHints == } if 20 dict begin /bits OFile bitstream def % Calculate least length of a page. FirstPageLength OtherPageLengths { .min } forall /minpl exch def % Calculate least contents length. FirstPageNs 0 get Objects exch lget contentslength OtherPageNs { 0 get Objects exch lget contentslength .min } forall /mincl exch def % The Adobe documentation says that all versions of Acrobat % require item 8 (mincl) to be zero. Patch this here. /mincl 0 def

% Calculate bits needed to represent greatest page length. FirstPageLength OtherPageLengths { .max } forall minpl sub bitsneeded /maxplbits exch def % Calculate bits needed to represent the greatest Contents length. FirstPageNs 0 get Objects exch lget contentslength OtherPageNs { 0 get Objects exch lget contentslength .max } forall mincl sub bitsneeded /maxclbits exch def % Per Adobe documentation, Acrobat requires that item 5 (maxplbits) % be equal to item 9 (maxclbits). Set both to the max of the two. maxplbits maxclbits .max /maxplbits 1 index def /maxclbits exch def % Mapping from object number to shared object reference /shared_id_dict FirstPageNs length SharedNs length add dict begin 0 FirstPageNs { 1 index def 1 add } forall SharedNs { 1 index def 1 add } forall pop currentdict end def % Table F.3 Page offset hint table, header section % 1: Least number of objects in a page: FirstPageNs length OtherPageNs { length .min } forall /minnop 1 index def 32 bwn % 2: Location of first page's Page object: FirstPageNs 0 get omap XRef exch ld_get 32 bwn % 3: Bits needed to represent greatest # of objects in a page: FirstPageNs length OtherPageNs { length .max } forall minnop sub bitsneeded /maxnopbits 1 index def 16 bwn % 4: Least length of a page: minpl 32 bwn % 5: Bits needed to represent the greatest page length: maxplbits 16 bwn % 6: Least start of Contents offset: 0 % (Acrobat requires that this be 0.) /minsco 1 index def 32 bwn % 7: Bits needed to represent the greatest start of Contents % offset: 0 % (Acrobat ignores this.) /maxscobits 1 index def 16 bwn % 8: Least contents length: mincl 32 bwn % 9: Bits needed to represent the greatest Contents length: maxclbits 16 bwn % 10: Bits needed to represent the greatest number of Shared % Object references: FirstPageNs length SharedPageNs { length .max } forall bitsneeded /maxsorbits 1 index def 16 bwn % 11: Bits needed to identify a Shared Object: FirstPageNs length SharedNs length add bitsneeded /sobits 1 index def 16 bwn % 12: Bits needed to represent numerator of fraction: 2 /numfbits 1 index def 16 bwn % 13: Denominator of fraction: 1 /denf 1 index def 16 bwn % Table F.4 Page offset hint table, per-page entry

% 1: Number of objects in pages: FirstPageNs length minnop sub maxnopbits bwn OtherPageNs { length minnop sub maxnopbits bwn } forall bits bitflush % 2: Total length of pages in bytes; FirstPageLength minpl sub maxplbits bwn OtherPageLengths { minpl sub maxplbits bwn } forall bits bitflush % 3: Number of shared objects referenced from page: FirstPageNs length maxsorbits bwn SharedPageNs { length maxsorbits bwn } forall bits bitflush % 4: A shared object identifier: FirstPageNs { shared_id_dict exch get sobits bwn } forall SharedPageNs { { shared_id_dict exch get sobits bwn } forall } forall bits bitflush % 5: Numerator of fractional position for each shared object: FirstPageNs { pop 0 numfbits bwn } forall SharedPageNs { { pop 0 numfbits bwn } forall } forall bits bitflush % 6: Contents offsets: % Following Implementation Note 133 section 6 is empty. maxscobits 0 gt { [FirstPageNs OtherPageNs aload pop] { 0 get Objects exch lget contentsstart { minsco sub } { 0 } ifelse maxscobits bwn } forall bits bitflush } if % 7: Contents lengths: [FirstPageNs OtherPageNs aload pop] { 0 get Objects exch lget contentslength mincl sub maxclbits bwn } forall bits bitflush end } bind def /writeSharedObjectHints { PDFOPTDEBUG { /writeSharedObjectHints == } if 20 dict begin /bits OFile bitstream def /obj_count SharedNs length FirstPageNs length add def

% Table F.5 Shared object hint table, header section % 1: Object number of first object in Shared Objects section 0 32 bwn % 2: Location of first object in Shared Objects section: % If there are no shared objects, % Acrobat sets this to the location of linearization % parameters object (the very first object). { pdfwriteheader } tomemory length 32 bwn % 3: Number of Shared Object entries for first page: FirstPageNs length 32 bwn % 4: Number of Shared Object entries for Shared Objects % section obj_count 32 bwn % 5: Bits needed to represent the greatest number of objects % in a shared object group (always 0, because all groups % have only 1 object): 0 16 bwn % 6: Least length of a Shared Object Group in bytes: 16#7fffffff FirstPageNs { omlength .min } forall SharedNs { omlength .min } forall /minsol 1 index def 32 bwn % 7: Bits needed to represent the greatest length of a % Shared Object Group: 0 FirstPageNs { omlength .max } forall SharedNs { omlength .max } forall minsol sub bitsneeded /maxsolbits 1 index def 16 bwn % Table F.6 Shared object hint table, shared object group entry % 1: Lengths of shared object groups: FirstPageNs { omlength minsol sub maxsolbits bwn } forall SharedNs { omlength minsol sub maxsolbits bwn } forall bits bitflush % 2: MD5 flag: obj_count { 0 1 bwn } repeat bits bitflush % 3: No MD5 shared object signatures. % 4: No number_number_of_objects_in_the_group - 1 end } bind def % ---------------- Main program ---------------- % /pdfOptimize { % <infile> <outfile> pdfOptimize realtime 3 1 roll exch pdfdict begin pdfopenfile dup begin 40 dict begin /IDict exch def /OFile exch def /starttime exch def /ToWrite 100 dict def /now { QUIET { pop } { print (, t = ) print realtime starttime sub = flush } ifelse } def omapinit % Create and open a temporary file.

% Because of .setsafe, we have to open it as read-write, rather than % opening for writing, then closing it and reopening it for reading. null (w+) .tempfile /TFile exch def /TFileName exch def .setsafe % Read all objects into memory. Trailer touch (Read objects) now % Encrypted files are not yet supported. Trailer /Encrypt known { (ERROR: Encrypted files are not yet supported.) = flush /pdfOptimize cvx /limitcheck signalerror } if % Replace indirect references to numbers. This is needed % for the Length of streams, and doesn't hurt anything else. replaceReferences (Replaced references) now % Create the two new objects: the linearization parameter % dictionary, and the Primary Hint Stream. /LPDict 10 dict def /PHS 10 dict cvx def % executable = stream [LPDict PHS] createObjects /LPDictN 1 index def 1 add /PHSN exch def PDFOPTDEBUG { << /LPDictN LPDictN /PHSN PHSN >> === } if % Count the number of objects in the output. 0 0 1 Objects llength 1 sub { Generations exch lget 0 ne { 1 add } if } for /NObjects exch def QUIET not { NObjects =only ( objects total) = flush } if % Propagate inherited attributes down the page tree. propagateAttributes (Propagated attributes) now % Identify the document-level objects (part 4). identifyDocumentObjects /CatalogNs exch def QUIET not { CatalogNs === flush } if (Identified Catalog) now % Identify the first page's objects (part 6), % including the Outlines tree if appropriate. pdfopencache /FirstPageNs identifyFirstPageObjects def QUIET not { FirstPageNs === flush } if (Identified first page) now

% Identify shared vs. non-shared objects for remaining pages % (parts 7 and 8). identifyOtherPageObjects /SharedNs exch def /SharedPageNs exch def /OtherPageNs exch def QUIET not { OtherPageNs === flush SharedNs === flush } if (Identified other pages) now % Identify objects not associated with any page (part 9). /NonPageNs identifyNonPageObjects def QUIET not { NonPageNs { === } forall flush } if (Identified non-pages) now % Assign final object numbers to all the objects. % (The omap is currently empty.) /FirstPageXN assignObjectNumbers def (Assigned objects #s) now % Write the document-level objects (part 4). { writePart4 } totemp /CatalogTempEnd exch def /CatalogTempStart exch def (Wrote Catalog) now % Write the first page's objects (part 6). { writePart6 } totemp /FirstPageTempEnd exch def /FirstPageTempStart exch def (Wrote first page) now % Write the non-shared objects for other pages (part 7). { writePart7 /OtherPageLengths exch def } totemp /OtherPageTempEnd exch def /OtherPageTempStart exch def (Wrote other pages) now % Write the shared objects for other pages (part 8). { writePart8 } totemp /SharedTempEnd exch def /SharedTempStart exch def (Wrote shared objects) now % Write the objects not associated with pages (part 9). { writePart9 } totemp /NonPageTempEnd exch def /NonPageTempStart exch def % Compute conservative lengths of parts 2,3,5,11 of the output. % It's OK for these to be too large, but not too small. % Make dummy XRef entres for LPDict and PHS. XRef LPDictN omap 0 ld_put XRef PHSN omap 0 ld_put /HeaderLength { writePart1 % this is exact % part 1

} tolength def /CatalogLength % this is exact CatalogTempEnd CatalogTempStart sub def % part 4 /FirstPageLength % this is exact FirstPageTempEnd FirstPageTempStart sub def % part 6 /OtherObjectsLength % this is exact NonPageTempEnd OtherPageTempStart sub def % parts 7,8,9 /ObjectsLength % this is exact CatalogLength FirstPageLength add OtherObjectsLength add def /XrefLength { % part 11 % The LPDict must end within the first 1024 bytes, % so the start of the FirstPage xref table can't exceed 1024. writePart11xref 1024 writePart11rest } tolength def /NominalFileLength % Make a generous allowance for parts 2,3,5. HeaderLength ObjectsLength 3 mul add 10000 add 99999 .max def /FirstPageXrefLength { % part 3 NominalFileLength writePart3 } tolength def /LPDictLength { % part 2 NominalFileLength dup 2 mul 2 copy add 1 index dup createLPDict writePart2 } tolength def % Compute a few additional values from the above. /XrefBeginLength { (xref\n0 ) ows OFile FirstPageXN write= } tolength def HeaderLength LPDictLength add /FirstPageXrefStart 1 index def FirstPageXrefLength add /CatalogStart 1 index def CatalogLength add % phsstart /PHSStart exch def % Adjust the object positions ignoring PHS. % (Writing the PHS needs these.) 0 0 CatalogStart CatalogTempStart sub adjustObjectPositions % Make a temporary XRef entry for the PHS, for the benefit of omend. XRef PHSN omap CatalogStart ld_put (Adjusted positions) now % Construct the hint tables (part 5). { writePageOffsetHints } totemp pop /PHSTempStart exch def { writeSharedObjectHints } totemp exch PHSTempStart sub PHS /S 3 -1 roll put PHSTempStart sub /PHSTempLength exch def (Wrote hints) now % Prepare to read TFile. % TFile closefile % /TFile TFileName (r) file def PHS dup /File TFile put dup /FilePosition PHSTempStart put

dup /Length PHSTempLength put pop /PHSLength { writePart5 } tolength def % Construct the linearization parameter dictionary (part 2). PHSStart dup PHSLength add % phsend /FirstPageStart 1 index def dup FirstPageLength add % firstpageend dup OtherObjectsLength add /XrefStart 1 index def XrefBeginLength add % xref0start dup XrefBeginLength sub XrefLength add % fileend % Because of a bug, Acrobat Reader doesn't recognize any file % shorter than 1K as linearized. Patch this here. % Acrobat 9 insists on 4KB 4096 .max /FileLength 1 index def createLPDict % Adjust the object positions again, taking the PHS into account. PHSStart 0 PHSLength adjustObjectPositions (Readjusted positions) now % Finally, write the output file. writePart1 writePart2 FirstPageXrefStart padto XrefStart writePart3 CatalogStart padto CatalogTempStart CatalogTempEnd copyrange % part 4 writePart5 FirstPageStart padto FirstPageTempStart NonPageTempEnd copyrange % parts 6,7,8,9 % No Overflow Hint Stream (part 10). XrefStart padto writePart11xref { FirstPageXrefStart writePart11rest } tomemory FileLength 1 index length sub padto ows (Wrote output file) now % Wrap up. TFile closefile TFileName deletefile end % temporary dict end % IDict } bind def end .setglobal % pdfoptdict

% Check for command line arguments. [ shellarguments { ] dup length 2 eq { % Load the pdfwrite utilities if necessary. /omapinit where { pop } { (pdfwrite.ps) runlibfile } ifelse save exch

aload pop exch (r) file exch (w) file 3000000 setvmthreshold 0 setobjectformat pdfoptdict begin pdfOptimize end restore } { (Usage: gs -dNODISPLAY -- pdfopt.ps input.pdf output.pdf) = flush quit } ifelse } { pop } ifelse