home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / share / gs-esp / 8.15 / lib / pdf_base.ps < prev    next >
Encoding:
Text File  |  2006-07-06  |  24.2 KB  |  706 lines
  1. %    Copyright (C) 1994-2003 artofcode LLC.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_base.ps,v 1.34.2.3 2004/08/31 18:18:51 ray Exp $
  17. % pdf_base.ps
  18. % Basic parser for PDF reader.
  19.  
  20. % This handles basic parsing of the file (including the trailer
  21. % and cross-reference table), as well as objects, object references,
  22. % streams, and name/number trees; it doesn't include any facilities for
  23. % making marks on the page.
  24.  
  25. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  26. .currentglobal true .setglobal
  27. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  28. pdfdict begin
  29.  
  30. % Define the name interpretation dictionary for reading values.
  31. /valueopdict mark
  32.   (<<) cvn { mark } bind    % don't push an actual mark!
  33.   (>>) cvn { { .dicttomark } stopped {
  34.       (   **** File has an unbalanced >> \(close dictionary\).\n)
  35.       pdfformaterror
  36.     } if
  37.   } bind
  38.   ([) cvn { mark } bind        % ditto
  39.   (]) cvn dup load
  40. %  /true true        % see .pdfexectoken below
  41. %  /false false        % ibid.
  42. %  /null null        % ibid.
  43.   /F dup cvx        % see Objects section below
  44.   /R dup cvx        % see Objects section below
  45.   /stream dup cvx    % see Streams section below
  46. .dicttomark readonly def
  47.  
  48. % ------ Utilities ------ %
  49.  
  50. % Define a scratch string.  The PDF language definition says that
  51. % no line in a PDF file can exceed 255 characters.
  52. /pdfstring 255 string def
  53.  
  54. % Read the previous line of a file.  If we aren't at a line boundary,
  55. % read the line containing the current position.
  56. % Skip any blank lines.
  57. /prevline        % - prevline <startpos> <substring>
  58.  { PDFfile fileposition dup () pdfstring
  59.    2 index 257 sub 0 .max PDFfile exch setfileposition
  60.     {        % Stack: initpos linepos line string
  61.       PDFfile fileposition
  62.       PDFfile 2 index readline pop
  63.       dup length 0 gt
  64.        { 3 2 roll 5 -2 roll pop pop 2 index }
  65.        { pop }
  66.       ifelse
  67.         % Stack: initpos linepos line string startpos
  68.       PDFfile fileposition 5 index ge { exit } if
  69.       pop
  70.     }
  71.    loop pop pop 3 -1 roll pop
  72.  } bind def
  73.  
  74. % Handle the PDF 1.2 #nn escape convention when reading from a file.
  75. % This should eventually be done in C.
  76. /.pdffixname {            % <execname> .pdffixname <execname'>
  77.   PDFversion 1.2 ge {
  78.     dup .namestring (#) search {
  79.       name#escape cvn exch pop
  80.     } {
  81.       pop
  82.     } ifelse
  83.   } if
  84. } bind def
  85. /name#escape            % <post> <(#)> <pre> name#escape <string>
  86. { exch pop
  87.   1 index 2 () /SubFileDecode filter dup (x) readhexstring
  88.         % Stack: post pre stream char t/f
  89.   not { /.pdftoken cvx /syntaxerror signalerror } if
  90.   exch closefile concatstrings
  91.   exch 2 1 index length 2 sub getinterval
  92.   (#) search { name#escape } if concatstrings
  93. } bind def
  94.  
  95. % Execute a file, interpreting its executable names in a given
  96. % dictionary.  The name procedures may do whatever they want
  97. % to the operand stack.
  98. /.pdftokenerror {        % <count> <opdict> <errtoken> .pdftokenerror -
  99.   BXlevel 0 le {
  100.     (   **** Unknown operator: ') pdfformaterror
  101.     dup =string cvs pdfformaterror 
  102.     % Attempt a retry scan of the element after changing to PDFScanInvNum
  103.     << /PDFScanInvNum true >> setuserparams
  104.     =string cvs
  105.     token pop exch pop dup type
  106.     dup /integertype eq exch /realtype eq or {
  107.       exch pop exch pop
  108.       (', processed as number, value: ) pdfformaterror
  109.       dup =string cvs pdfformaterror (\n) pdfformaterror
  110.      << /PDFScanInvNum null >> setuserparams    % reset to default scanning rules
  111.       false     % suppress any stack cleanup
  112.     } {
  113.       % error was non-recoverable with modified scanning rules
  114.       ('\n) pdfformaterror
  115.       true
  116.     } ifelse
  117.   } {
  118.     true
  119.   } ifelse
  120.   { % clean up the operand stack if this was non-recoverable
  121.     pop pop count exch sub { pop } repeat    % pop all the operands
  122.   } if
  123. } bind def
  124. /.pdfexectoken {        % <count> <opdict> <exectoken> .pdfexectoken ?
  125.   PDFDEBUG { dup == flush } if
  126.   2 copy .knownget {
  127.     exch pop exch pop exch pop exec
  128.   } {
  129.         % Normally, true, false, and null would appear in opdict
  130.         % and be treated as "operators".  However, there is a
  131.         % special fast case in the PostScript interpreter for names
  132.         % that are defined in, and only in, systemdict and/or
  133.         % userdict: putting these three names in the PDF dictionaries
  134.         % destroys this property for them, slowing down their
  135.         % interpretation in all PostScript code.  Therefore, we
  136.         % check for them explicitly here instead.
  137.     dup dup dup /true eq exch /false eq or exch /null eq or {
  138.       exch pop exch pop //systemdict exch get
  139.     } {
  140.       .pdftokenerror
  141.     } ifelse
  142.   } ifelse
  143. } bind def
  144. /.pdfrun {            % <file> <opdict> .pdfrun -
  145.     % Construct a procedure with the stack depth, file and opdict
  146.     % bound into it.
  147.   1 index cvlit count 2 sub 3 1 roll mark mark 5 2 roll
  148.   {    % Stack: ..operands.. count opdict file
  149.     token {
  150.       dup type /nametype eq {
  151.     dup xcheck {
  152.       .pdfexectoken
  153.     } {
  154.       .pdffixname
  155.       exch pop exch pop PDFDEBUG { dup ==only ( ) print flush } if
  156.     } ifelse
  157.       } {
  158.     exch pop exch pop PDFDEBUG { dup ==only ( ) print flush } if
  159.       } ifelse
  160.     } {
  161.       (%%EOF) cvn cvx .pdfexectoken
  162.     } ifelse
  163.   }
  164.   aload pop .packtomark cvx
  165.   /loop cvx 2 packedarray cvx
  166.   { stopped /PDFsource } aload pop
  167.   PDFsource
  168.   { store { stop } if } aload pop .packtomark cvx
  169.   /PDFsource 3 -1 roll store exec
  170. } bind def
  171.  
  172. % Execute a file, like .pdfrun, for a marking context.
  173. % This temporarily rebinds LocalResources and DefaultQstate.
  174. /.pdfruncontext {        % <resdict> <file> <opdict> .pdfruncontext -
  175.   /.pdfrun load LocalResources DefaultQstate
  176.   /LocalResources 7 -1 roll store
  177.   /DefaultQstate qstate store
  178.   3 .execn
  179.   /DefaultQstate exch store
  180.   /LocalResources exch store
  181. } bind def
  182.  
  183. % Get the depth of the PDF operand stack.  The caller sets pdfemptycount
  184. % before calling .pdfrun or .pdfruncontext.  It is initially set by
  185. % pdf_main, and is also set by any routine which changes the operand
  186. % stack depth (currently .pdfpaintproc, although there are other callers
  187. % of .pdfrun{context} which have not been checked for opstack depth.
  188. /.pdfcount {        % - .pdfcount <count>
  189.   count pdfemptycount sub
  190. } bind def
  191.  
  192. % ================================ Objects ================================ %
  193.  
  194. % Since we may have more than 64K objects, we have to use a 2-D array to
  195. % hold them (and the parallel Generations structure).
  196. /lshift 9 def
  197. /lnshift lshift neg def
  198. /lsubmask 1 lshift bitshift 1 sub def
  199. /lsublen lsubmask 1 add def
  200. /larray {    % - larray <larray>
  201.   [ [] ]
  202. } bind def
  203. /lstring {    % - lstring <lstring>
  204.   [ () ]
  205. } bind def
  206. /ltype {    % <lseq> type <type>
  207.   0 get type
  208. } bind def
  209. /lget {        % <lseq> <index> lget <value>
  210.   dup //lsubmask and 3 1 roll //lnshift bitshift get exch get
  211. } bind def
  212. /lput {        % <lseq> <index> <value> lput -
  213.   3 1 roll
  214.   dup //lsubmask and 4 1 roll //lnshift bitshift get
  215.   3 1 roll put
  216. } bind def
  217. /llength {    % <lseq> llength <length>
  218.   dup length 1 sub dup //lshift bitshift
  219.   3 1 roll get length add
  220. } bind def
  221. % lgrowto assumes newlength > llength(lseq)
  222. /growto {    % <string/array> <length> growto <string'/array'>
  223.   1 index type /stringtype eq { string } { array } ifelse
  224.   2 copy copy pop exch pop
  225. } bind def
  226. /lgrowto {    % <lseq> <newlength> lgrowto <lseq'>
  227.     dup //lsubmask add //lnshift bitshift dup 3 index length gt {
  228.     % Add more sub-arrays.  Start by completing the last existing one.
  229.         % Stack: lseq newlen newtoplen
  230.     3 -1 roll dup llength 1 sub //lsubmask or 1 add lgrowto
  231.         % Stack: newlen newtoplen lseq
  232.     [ exch aload pop
  233.     counttomark 2 add -1 roll        % newtoplen
  234.     counttomark sub { dup 0 0 getinterval lsublen growto } repeat
  235.     dup 0 0 getinterval ] exch
  236.   } {
  237.     pop
  238.   } ifelse
  239.     % Expand the last sub-array.
  240.   1 sub //lsubmask and 1 add
  241.   exch dup dup length 1 sub 2 copy
  242.         % Stack: newsublen lseq lseq len-1 lseq len-1
  243.   get 5 -1 roll growto put
  244. } bind def
  245. /lforall {    % <lseq> <proc> lforall -
  246.   /forall cvx 2 packedarray cvx forall
  247. } bind def
  248.  
  249. % We keep track of PDF objects using the following PostScript variables:
  250. %
  251. %    Generations (lstring): Generations[N] holds 1+ the current
  252. %        generation number for object number N.  (As far as we can tell,
  253. %        this is needed only for error checking.)  For free objects,
  254. %        Generations[N] is 0.
  255. %
  256. %    Objects (larray): If object N is loaded, Objects[N] is the actual
  257. %        object; otherwise, Objects[N] is an executable integer giving
  258. %        the file offset of the object's entry in the cross-reference
  259. %        table.
  260. %
  261. %    GlobalObjects (dictionary): If object N has been resolved in
  262. %        global VM, GlobalObjects[N] is the same as Objects[N]
  263. %        (except that GlobalObjects itself is stored in global VM,
  264. %        so the entry will not be deleted at the end of the page).
  265. %
  266. %    IsGlobal (lstring): IsGlobal[N] = 1 iff object N was resolved in
  267. %        global VM.  This is an accelerator to avoid having to do a
  268. %        dictionary lookup in GlobalObjects when resolving every object.
  269.  
  270. % Initialize the PDF object tables.
  271. /initPDFobjects {        % - initPDFobjects -
  272.   /Objects larray def
  273.   /Generations lstring def
  274.   .currentglobal true .setglobal
  275.   /GlobalObjects 20 dict def
  276.   .setglobal
  277.   /IsGlobal lstring def
  278. } bind def
  279.  
  280. % Grow the tables to a specified size.
  281. /growPDFobjects {        % <minsize> growPDFobjects -
  282.   dup Objects llength gt {
  283.     dup Objects exch lgrowto /Objects exch def
  284.   } if
  285.   dup Generations llength gt {
  286.     dup Generations exch lgrowto /Generations exch def
  287.   } if
  288.   dup IsGlobal llength gt {
  289.     dup IsGlobal exch lgrowto /IsGlobal exch def
  290.   } if
  291.   pop
  292. } bind def
  293.  
  294. % We represent an unresolved object reference by a procedure of the form
  295. % {obj# gen# resolveR}.  This is not a possible PDF object, because PDF has
  296. % no way to represent procedures.  Since PDF in fact has no way to represent
  297. % any PostScript object that doesn't evaluate to itself, we can 'force'
  298. % a possibly indirect object painlessly with 'exec'.
  299. % Note that since we represent streams by executable dictionaries
  300. % (see below), we need both an xcheck and a type check to determine
  301. % whether an object has been resolved.
  302. /resolved? {        % <object#> resolved? <value> true
  303.             % <object#> resolved? false
  304.   Objects 1 index lget dup xcheck {    % Check if executable
  305.     dup type /integertype eq {        % Check if an integer
  306.         % Check whether the object is in GlobalObjects.
  307.       pop IsGlobal 1 index lget 0 eq {    % 0 --> Not in GlabalObjects
  308.     pop false            % The object is not resolved
  309.       } {                % The object is in GlobalObjects
  310.         % Update Objects from GlobalObjects
  311.     PDFDEBUG { (%Global=>local: ) print dup == } if
  312.     GlobalObjects 1 index get dup Objects 4 1 roll lput true
  313.       } ifelse
  314.     } {                % Else object is executable but not integer
  315.       exch pop true        % Therefore must be executable dict. (stream)
  316.     } ifelse
  317.   } {                % Else object is not executable.
  318.     exch pop true        % Therefore it must have been resolved.
  319.   } ifelse
  320. } bind def
  321. /oforce /exec load def
  322. /oget {        % <array> <index> oget <object>
  323.         % <dict> <key> oget <object>
  324.         % Before release 6.20, this procedure stored the resolved
  325.         % object back into the referring slot.  In order to support
  326.         % PDF linearization, we no longer do this.
  327.   get oforce
  328. } bind def
  329. /oforce_array { % <array> oforce_array <array>
  330.   [ exch { oforce } forall ]
  331. } bind def
  332. /oforce_elems { % <array> oforce_elems <first> ... <last>
  333.   { oforce } forall
  334. } bind def
  335. % A null value in a dictionary is equivalent to an omitted key;
  336. % we must check for this specially.
  337. /knownoget {    % <dict> <key> knownoget <value> true
  338.         % <dict> <key> knownoget false
  339.         % See oget above regarding this procedure.
  340.   .knownget {
  341.     oforce dup null eq { pop false } { true } ifelse
  342.   } {
  343.     false
  344.   } ifelse
  345. } bind def
  346.  
  347. % PDF 1.1 defines a 'foreign file reference', but not its meaning.
  348. % Per the specification, we convert these to nulls.
  349. /F {        % <file#> <object#> <generation#> F <object>
  350.         % Some PDF 1.1 files use F as a synonym for f!
  351.    .pdfcount 3 lt { f } { pop pop pop null } ifelse
  352. } bind def
  353.  
  354. % Verify the generation number for a specified object
  355. % Note:  The values in Generations is the generation number plus 1.
  356. % If the value in Generations is zero then the object is free.
  357. /checkgeneration {  % <object#> <generation#> checkgeneration <object#> <OK>
  358.   Generations 2 index lget 1 sub 1 index eq {    % If generation # match ...
  359.     pop true                    % Then return true
  360.   } {                    % Else not a match ...
  361.     QUIET not {                % Create warning message if not QUIET
  362.       Generations 2 index lget 0 eq {    % Check if object is free ...
  363.     (   **** Warning: reference to free object: )
  364.       } {
  365.     (   **** Warning: wrong generation: )
  366.       } ifelse
  367.       2 index =string cvs concatstrings ( ) concatstrings    % put obj #
  368.       exch =string cvs concatstrings ( R\n) concatstrings    % put gen #
  369.       pdfformaterror            % Output warning message
  370.     } {                    % Else QUIET ...
  371.       pop                % Pop generation umber
  372.     } ifelse false            % Return false if gen # not match
  373.   } ifelse
  374. } bind def
  375. /R {        % <object#> <generation#> R <object>
  376.   /resolveR cvx 3 packedarray cvx
  377. } bind def
  378.  
  379. % If we encounter an object definition while reading sequentially,
  380. % we just store it away and keep going.
  381. /objopdict mark
  382.   valueopdict { } forall
  383.   /endobj dup cvx
  384. .dicttomark readonly def
  385.  
  386. /obj {            % <object#> <generation#> obj <object>
  387.   PDFfile objopdict .pdfrun
  388. } bind def
  389.  
  390. /endobj {        % <object#> <generation#> <object> endobj <object>
  391.   3 1 roll
  392.         % Read the xref entry if we haven't yet done so.
  393.         % This is only needed for generation # checking.
  394.   1 index resolved? {
  395.     pop
  396.   } if
  397.   checkgeneration {
  398.         % The only global objects we bother to save are
  399.         % (resource) dictionaries.
  400.     1 index dup gcheck exch type /dicttype eq and {
  401.       PDFDEBUG { (%Local=>global: ) print dup == } if
  402.       GlobalObjects 1 index 3 index put
  403.       IsGlobal 1 index 1 put
  404.     } if
  405.     Objects exch 2 index lput
  406.   } {
  407.     pop pop null
  408.   } ifelse
  409. } bind def
  410.  
  411. % When resolving an object reference, we stop at the endobj.
  412. /resolveopdict mark
  413.   valueopdict { } forall
  414.   /endobj { endobj exit } bind
  415.                 % OmniForm generates PDF file with endobj missing in some
  416.                 % objects. AR ignores this. So we have to do it too.
  417.   /obj { pop pop endobj exit } bind
  418. .dicttomark readonly def
  419.  
  420. /resolveR {        % <object#> <generation#> resolveR <object>
  421.   PDFDEBUG { (%Resolving: ) print 2 copy 2 array astore == } if
  422.   1 index resolved? {        % If object has already been resolved ...
  423.     exch pop exch pop        % then clear stack and return object
  424.   } {                % Else if not resolved ...
  425.     PDFfile fileposition 3 1 roll    % Save current file position
  426.     1 index Objects exch lget        % Get location of object from xref
  427.     3 1 roll checkgeneration {        % Verify the generation number
  428.             % Stack: savepos objpos obj#
  429.      exch PDFoffset add PDFfile exch setfileposition
  430.      PDFfile token pop 2 copy ne
  431.       { (   **** Unrecoverable error in xref!\n) pdfformaterror
  432.         /resolveR cvx /rangecheck signalerror
  433.       }
  434.      if pop PDFfile token pop
  435.      PDFfile token pop /obj ne
  436.       { (   **** Unrecoverable error in xref!\n) pdfformaterror
  437.         /resolveR cvx /rangecheck signalerror
  438.       }
  439.      if
  440.      pdf_run_resolve    % PDFfile resolveopdict .pdfrun
  441.     }
  442.     {        % Don't cache if the generation # is wrong.
  443.      pop pop null
  444.     } ifelse
  445.     exch PDFfile exch setfileposition
  446.   } ifelse
  447. } bind def      
  448.  
  449. % ================================ Streams ================================ %
  450.  
  451. % We represent a stream by an executable dictionary that contains,
  452. % in addition to the contents of the original stream dictionary:
  453. %    /File - the file or string where the stream contents are stored,
  454. %      if the stream is not an external one.
  455. %    /FilePosition - iff File is a file, the position in the file
  456. %      where the contents start.
  457. %    /StreamKey - the key used to decrypt this stream, if any.
  458. % We do the real work of constructing the data stream only when the
  459. % contents are needed.
  460.  
  461. % Construct a stream.  The length is not reliable in the face of
  462. % different end-of-line conventions, but it's all we've got.
  463. %
  464. % PDF files are inconsistent about what may fall between the 'stream' keyword
  465. % and the actual stream data, and it appears that no one algorithm can
  466. % detect this reliably.  We used to try to guess whether the file included
  467. % extraneous \r and/or \n characters, but we no longer attempt to do so,
  468. % especially since the PDF 1.2 specification states flatly that the only
  469. % legal terminators following the 'stream' keyword are \n or \r\n, both of
  470. % which are properly skipped and discarded by the token operator.
  471. % Unfortunately, this doesn't account for other whitespace characters that
  472. % may have preceded the EOL, such as spaces or tabs. Thus we back up one
  473. % character and scan until we find the \n terminator.
  474. /stream {    % <dict> stream <modified_dict>
  475.   dup /Length oget 0 eq {
  476.     dup /Filter undef    % don't confuse any filters that require data
  477.   } if
  478.   dup /F known dup PDFsource PDFfile eq or {
  479.     not {
  480.       dup /File PDFfile put
  481.       % make sure that we are just past the EOL \n character
  482.       PDFfile dup fileposition 1 sub setfileposition    % back up one
  483.       { PDFfile read pop dup 13 eq {
  484.       % If there had been a \n, token would have advanced over it
  485.       % thus, if the terminator was \r, we have a format error!
  486.       (   **** Warning: stream operator not terminated by valid EOL.\n) pdfformaterror
  487.       pop exit    % fileposition is OK (just past the \r).
  488.     } if 
  489.     10 eq { exit } if
  490.       } loop    % scan past \n
  491.       dup /FilePosition PDFfile fileposition put
  492.       PDFDEBUG { (%FilePosition: ) print dup /FilePosition get == } if
  493.     } if
  494.     % Some (bad) PDf files have invalid stream lengths.  This causes problems
  495.     % if we reposition beyond the end of the file.  So we compare the given
  496.     % length to number of bytes left in the file.
  497.     dup /Length oget 
  498.     dup PDFfile bytesavailable lt {    % compare to to bytes left in file
  499.       PDFfile fileposition         % reposition to the end of stream
  500.       add PDFfile exch setfileposition
  501.     } {
  502.       pop                % bad stream length - do not reposition.
  503.                           % This will force a length warning below
  504.     } ifelse
  505.   } {
  506.     pop
  507.     % We're already reading from a stream, which we can't reposition.
  508.     % Capture the sub-stream contents in a string.
  509.     dup /Length oget string PDFsource exch readstring
  510.     not {
  511.       (   **** Warning: Unexpected EOF in stream!\n) pdfformaterror
  512.       /stream cvx /rangecheck signalerror
  513.     } if
  514.     1 index exch /File exch put
  515.   } ifelse
  516.   PDFsource {token} stopped {
  517.     pop null
  518.   } {
  519.     not { null } if
  520.   } ifelse
  521.   dup /endobj eq {
  522.     % Another case that Acrobat Reader handles -- 'endobj' without 'endstream'.
  523.     (   **** Warning: stream missing 'endstream'.\n) pdfformaterror
  524.     pop /endstream        % fake a valid endstream
  525.   } if
  526.   /endstream ne { 
  527.     (   **** Warning: stream Length incorrect.\n) pdfformaterror
  528.     cvx endobj exit % exit from .pdfrun now.
  529.   } if
  530.   cvx
  531. } bind def
  532. /endstream {
  533.   exit
  534. } bind def
  535.  
  536. % Contrary to the published PDF (1.3) specification, Acrobat Reader
  537. % accepts abbreviated filter names everywhere, not just for in-line images,
  538. % and some applications (notably htmldoc) rely on this.
  539. /unabbrevfilterdict mark
  540.   /AHx /ASCIIHexDecode  /A85 /ASCII85Decode  /CCF /CCITTFaxDecode
  541.   /DCT /DCTDecode  /Fl /FlateDecode  /LZW /LZWDecode  /RL /RunLengthDecode
  542. .dicttomark readonly def
  543.  
  544. % Extract and apply filters.
  545. /filterparms {        % <dict> <DPkey> <Fkey> filterparms
  546.             %   <dict> <parms> <filternames>
  547.   2 index exch knownoget {
  548.     exch 2 index exch knownoget {
  549.         % Both filters and parameters.
  550.       exch dup type /nametype eq {
  551.     1 array astore exch 1 array astore exch
  552.       } if
  553.     } {
  554.         % Filters, but no parameters.
  555.       null exch
  556.       dup type /nametype eq { 1 array astore } if
  557.     } ifelse
  558.   } {
  559.         % No filters: ignore parameters, if any.
  560.     pop null { }
  561.   } ifelse
  562. } bind def
  563. /filtername {        % <filtername> filtername <filtername'>
  564.   //unabbrevfilterdict 1 index .knownget { exch pop } if
  565.   dup /Filter resourcestatus { pop pop } {
  566.     Repaired exch    % this error is not the creator's fault    
  567.     (   **** ERROR: Unable to process ) pdfformaterror
  568.     64 string cvs pdfformaterror
  569.     ( data. Page will be missing data.\n) pdfformaterror
  570.     /Repaired exch store % restore the previous "Repaired" state
  571.     % provide a filter that returns EOF (no data)
  572.     /.EOFDecode
  573.   } ifelse
  574. } bind def
  575. /applyfilters {        % <parms> <source> <filternames> applyfilters <stream>
  576.   2 index null eq {
  577.     { filtername filter }
  578.   } {
  579.     {        % Stack: parms source filtername
  580.       2 index 0 oget dup null eq { pop } {
  581.         exch filtername dup /JBIG2Decode eq { exch jbig2cachectx exch } if
  582.       } ifelse filter
  583.       exch dup length 1 sub 1 exch getinterval exch
  584.     }
  585.   } ifelse forall exch pop
  586. } bind def
  587.  
  588. % JBIG2 streams have an optional 'globals' stream obj for
  589. % sharing redundant data between page images. Here we resolve
  590. % that stream reference (if any) and run it through the decoder,
  591. % creating a special -jbig2globalctx- postscript object our
  592. % JBIG2Decode filter implementation looks for in the parm dict.
  593. /jbig2cachectx { % <parmdict> jbig2cachectx <parmdict>
  594.   dup /JBIG2Globals knownoget {
  595.     dup /Length oget
  596.     % make global ctx
  597.     PDFfile fileposition 3 1 roll % resolvestream is not reentrant
  598.     exch true resolvestream exch .bytestring
  599.     .readbytestring pop .jbig2makeglobalctx
  600.     PDFfile 3 -1 roll setfileposition
  601.     1 index exch
  602.     /.jbig2globalctx exch put
  603.   } if
  604. } bind def
  605.  
  606. % Resolve a stream dictionary to a PostScript stream.
  607. % Streams with no filters require special handling:
  608. %     - Whether we are going to interpret the stream, or If we are just
  609. %       going to read data from them, we impose a SubFileDecode filter
  610. %         that reads just the requisite amount of data.
  611. % Note that, in general, resolving a stream repositions PDFfile.
  612. % Clients must save and restore the position of PDFfile themselves.
  613. /resolvestream {    % <streamdict> <readdata?> resolvestream <stream>
  614.   1 index /F knownoget {
  615.         % This stream is stored on an external file.
  616.     (r) file 3 -1 roll
  617.     /FDecodeParms /FFilter filterparms
  618.         % Stack: readdata? file dict parms filternames
  619.     4 -1 roll exch
  620.     pdf_decrypt_stream
  621.     applyfilters
  622.   } {
  623.     exch dup /FilePosition .knownget {
  624.       1 index /File get exch setfileposition
  625.     } if
  626.         % Stack: readdata? dict
  627.     /DecodeParms /Filter filterparms
  628.         % Stack: readdata? dict parms filternames
  629.     2 index /File get exch
  630.         % Stack: readdata? dict parms file/string filternames
  631.     pdf_decrypt_stream        % add decryption if needed
  632.     dup length 0 eq {
  633.         % All the PDF filters have EOD markers, but in this case
  634.         % there is no specified filter.
  635.       pop exch pop
  636.         % Stack: readdata? dict file/string
  637.       2 index 1 index type /filetype eq or {
  638.               % Use length for any files or reading data from any source.
  639.         1 index /Length knownoget not { 0 } if
  640.       } {
  641.       0       % Otherwise length of 0 for whole string
  642.       } ifelse
  643.       2 index /IDFlag known { pop } { () /SubFileDecode filter } ifelse
  644.     } {
  645.       applyfilters
  646.     } ifelse
  647.   } ifelse
  648.         % Stack: readdata? dict file
  649.   exch pop exch pop
  650. } bind def
  651.  
  652. % ============================ Name/number trees ============================ %
  653.  
  654. /nameoget {        % <nametree> <key> nameoget <obj|null>
  655.   exch /Names exch .treeget
  656. } bind def
  657.  
  658. /numoget {        % <numtree> <key> numoget <obj|null>
  659.   exch /Nums exch .treeget
  660. } bind def
  661.  
  662. /.treeget {        % <key> <leafkey> <tree> .treeget <obj|null>
  663.   dup /Kids knownoget {
  664.     exch pop .branchget
  665.   } {
  666.     exch get .leafget
  667.   } ifelse
  668. } bind def
  669.  
  670. /.branchget {        %  <key> <leafkey> <kids> .branchget <obj|null>
  671.   dup length 0 eq {
  672.     pop pop pop null
  673.   } {
  674.     dup length -1 bitshift 2 copy oget
  675.             % Stack: key leafkey kids mid kids[mid]
  676.     dup /Limits oget aload pop
  677.             % Stack: key leafkey kids mid kids[mid] min max
  678.     6 index lt {
  679.       pop pop
  680.       1 add 1 index length 1 index sub getinterval .branchget
  681.     } {
  682.       5 index gt {
  683.     pop
  684.     0 exch getinterval .branchget
  685.       } {
  686.     exch pop exch pop .treeget
  687.       } ifelse
  688.     } ifelse
  689.   } ifelse
  690. } bind def
  691.  
  692. /.leafget {        % <key> <pairs> .leafget <obj|null>
  693.   dup length 2 eq {
  694.     dup 0 get 2 index eq { 1 oget } { pop null } ifelse
  695.     exch pop
  696.   } {
  697.     dup length -1 bitshift -2 and 2 copy oget
  698.             % Stack: key pairs mid pairs[mid]
  699.     3 index gt { 0 exch } { 1 index length 1 index sub } ifelse
  700.     getinterval .leafget
  701.   } ifelse
  702. } bind def
  703.  
  704. end            % pdfdict
  705. .setglobal
  706.