home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 10 / AU_CD10.iso / Updates / GhostScript / !GhostScr / 6_01 / lib / pdf_base.ps < prev    next >
Text File  |  2000-03-29  |  20KB  |  615 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % $Id: pdf_base.ps,v 1.2 2000/03/10 03:58:14 lpd Exp $
  19. % pdf_base.ps
  20. % Basic parser for PDF reader.
  21.  
  22. % This handles basic parsing of the file (including the trailer
  23. % and cross-reference table), as well as objects, object references,
  24. % streams, and name/number trees; it doesn't include any facilities for
  25. % making marks on the page.
  26.  
  27. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  28. .currentglobal true .setglobal
  29. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  30. pdfdict begin
  31.  
  32. % Define the name interpretation dictionary for reading values.
  33. /valueopdict mark
  34.   (<<) cvn { mark } bind    % don't push an actual mark!
  35.   (>>) cvn /.dicttomark load
  36.   ([) cvn { mark } bind        % ditto
  37.   (]) cvn dup load
  38.   /true true
  39.   /false false
  40.   /null null
  41.   /F dup cvx        % see Objects section below
  42.   /R dup cvx        % see Objects section below
  43.   /stream dup cvx    % see Streams section below
  44. .dicttomark readonly def
  45.  
  46. % ------ Utilities ------ %
  47.  
  48. % Define a scratch string.  The PDF language definition says that
  49. % no line in a PDF file can exceed 255 characters.
  50. /pdfstring 255 string def
  51.  
  52. % Read the previous line of a file.  If we aren't at a line boundary,
  53. % read the line containing the current position.
  54. % Skip any blank lines.
  55. /prevline        % - prevline <startpos> <substring>
  56.  { PDFfile fileposition dup () pdfstring
  57.    2 index 257 sub 0 .max PDFfile exch setfileposition
  58.     {        % Stack: initpos linepos line string
  59.       PDFfile fileposition
  60.       PDFfile 2 index readline pop
  61.       dup length 0 gt
  62.        { 3 2 roll 5 -2 roll pop pop 2 index }
  63.        { pop }
  64.       ifelse
  65.         % Stack: initpos linepos line string startpos
  66.       PDFfile fileposition 5 index ge { exit } if
  67.       pop
  68.     }
  69.    loop pop pop 3 -1 roll pop
  70.  } bind def
  71.  
  72. % Read a token from a file, recognizing the PDF 1.2 #nn escape convention.
  73. % This should be done in C!
  74. /.pdftoken {            % <file> .pdftoken <obj> -true-
  75.                 % <file> .pdftoken -false-
  76.   token {
  77.     dup type /nametype eq {
  78.       dup xcheck {
  79.     true
  80.       } {
  81.     PDFversion 1.2 ge {
  82.       dup .namestring (#) search {
  83.         name#escape cvn exch pop
  84.       } {
  85.         pop
  86.       } ifelse
  87.     } if true
  88.       } ifelse
  89.     } {
  90.       true
  91.     } ifelse
  92.   } {
  93.     false
  94.   } ifelse
  95. } bind def
  96. /name#escape            % <post> <(#)> <pre> name#escape <string>
  97. { exch pop
  98.   1 index 2 () /SubFileDecode filter dup (x) readhexstring
  99.         % Stack: post pre stream char t/f
  100.   not { /.pdftoken cvx /syntaxerror signalerror } if
  101.   exch closefile concatstrings
  102.   exch 2 1 index length 2 sub getinterval
  103.   (#) search { name#escape } if concatstrings
  104. } bind def
  105.  
  106. % Execute a file, interpreting its executable names in a given
  107. % dictionary.  The name procedures may do whatever they want
  108. % to the operand stack.
  109. /.pdfrun {            % <file> <opdict> .pdfrun -
  110.     % Construct a procedure with the stack depth, file and opdict
  111.     % bound into it.
  112.   1 index cvlit count 2 sub 3 1 roll mark mark 5 2 roll {
  113.     % Stack: ..operands.. count opdict file
  114.     .pdftoken not { (%%EOF) cvn cvx } if
  115.     dup xcheck {
  116.       DEBUG { dup == flush } if
  117.       2 copy .knownget {
  118.     exch pop exch pop exch pop exec
  119.       } {
  120.     BXlevel 0 le {
  121.       (%stderr) (w) file
  122.       dup (****************Unknown operator: ) writestring
  123.       dup 2 index .writecvs dup (\n) writestring flushfile
  124.     } if pop pop
  125.     count exch sub { pop } repeat    % pop all the operands
  126.       } ifelse
  127.     } {
  128.       exch pop exch pop DEBUG { dup ==only ( ) print flush } if
  129.     } ifelse
  130.   }
  131.   aload pop .packtomark cvx
  132.   /loop cvx 2 packedarray cvx
  133.   { stopped /PDFsource } aload pop
  134.   PDFsource
  135.   { store { stop } if } aload pop .packtomark cvx
  136.   /PDFsource 3 -1 roll store exec
  137. } bind def
  138.  
  139. % Execute a file, like .pdfrun, for a marking context.
  140. % This temporarily rebinds LocalResources.
  141. /.pdfruncontext {        % <resdict> <file> <opdict> .pdfruncontext -
  142.   /.pdfrun load /LocalResources LocalResources /store load
  143.   /LocalResources 8 -1 roll store 4 .execn
  144. } bind def
  145.  
  146. % Get the depth of the PDF operand stack.  The main program (pdf_main.ps)
  147. % sets pdfemptycount before calling .pdfrun.
  148. /.pdfcount {        % - .pdfcount <count>
  149.   count pdfemptycount sub
  150. } bind def
  151.  
  152. % ------ File reading ------ %
  153.  
  154. % Read the cross-reference entry for an (unresolved) object.
  155. % The caller must save and restore the PDFfile position if desired.
  156. % For invalid (free) objects, we return 0.
  157. /readxrefentry        % <object#> readxrefentry <objpos>
  158.  { dup Objects exch lget
  159.    PDFfile exch setfileposition
  160.    PDFfile token pop        % object position
  161.    PDFfile token pop        % generation #
  162.    PDFfile token pop        % n or f
  163.    dup /n eq
  164.     { pop 1 add dup 255 gt
  165.        { Generations ltype /stringtype eq
  166.       {        % Convert Generations from a string to an array.
  167.         larray Generations llength lgrowto dup
  168.         0 1 2 index llength 1 sub
  169.          { Generations 1 index lget lput dup
  170.          }
  171.         for pop /Generations exch store
  172.       }
  173.      if
  174.        }
  175.       if
  176.     }
  177.     { /f eq
  178.        { pop 0 }
  179.        { /readxrefentry cvx /syntaxerror signalerror }
  180.       ifelse
  181.     }
  182.    ifelse
  183.         % Stack: obj# objpos 1+gen#
  184.    Generations 4 -1 roll 3 -1 roll lput
  185.  } bind def
  186.  
  187. % ================================ Objects ================================ %
  188.  
  189. % Since we may have more than 64K objects, we have to use a 2-D array to
  190. % hold them (and the parallel Generations structure).
  191. /lshift 9 def
  192. /lnshift lshift neg def
  193. /lsubmask 1 lshift bitshift 1 sub def
  194. /lsublen lsubmask 1 add def
  195. /larray {    % - larray <larray>
  196.   [ [] ]
  197. } bind def
  198. /lstring {    % - lstring <lstring>
  199.   [ () ]
  200. } bind def
  201. /ltype {    % <lseq> type <type
  202.   0 get type
  203. } bind def
  204. /lget {        % <lseq> <index> lget <value>
  205.   dup //lsubmask and 3 1 roll //lnshift bitshift get exch get
  206. } bind def
  207. /lput {        % <lseq> <index> <value> lput -
  208.   3 1 roll
  209.   dup //lsubmask and 4 1 roll //lnshift bitshift get
  210.   3 1 roll put
  211. } bind def
  212. /llength {    % <lseq> llength <length>
  213.   dup length 1 sub dup //lshift bitshift
  214.   3 1 roll get length add
  215. } bind def
  216. % lgrowto assumes newlength > llength(lseq)
  217. /growto {    % <string/array> <length> growto <string'/array'>
  218.   1 index type /stringtype eq { string } { array } ifelse
  219.   2 copy copy pop exch pop
  220. } bind def
  221. /lgrowto {    % <lseq> <newlength> lgrowto <lseq'>
  222.     dup //lsubmask add //lnshift bitshift dup 3 index length gt {
  223.     % Add more sub-arrays.  Start by completing the last existing one.
  224.         % Stack: lseq newlen newtoplen
  225.     3 -1 roll dup llength 1 sub //lsubmask or 1 add lgrowto
  226.         % Stack: newlen newtoplen lseq
  227.     [ exch aload pop
  228.     counttomark 2 add -1 roll        % newtoplen
  229.     counttomark sub { dup 0 0 getinterval lsublen growto } repeat
  230.     dup 0 0 getinterval ] exch
  231.   } {
  232.     pop
  233.   } ifelse
  234.     % Expand the last sub-array.
  235.   1 sub //lsubmask and 1 add
  236.   exch dup dup length 1 sub 2 copy
  237.         % Stack: newsublen lseq lseq len-1 lseq len-1
  238.   get 5 -1 roll growto put
  239. } bind def
  240.  
  241. % We keep track of PDF objects using the following PostScript variables:
  242. %
  243. %    Generations (lstring): Generations[N] holds 1+ the current
  244. %        generation number for object number N.  (As far as we can tell,
  245. %        this is needed only for error checking.)  For free objects,
  246. %        Generations[N] is 0.
  247. %
  248. %    Objects (larray): If object N is loaded, Objects[N] is the actual
  249. %        object; otherwise, Objects[N] is an executable integer giving
  250. %        the file offset of the object's entry in the cross-reference
  251. %        table.
  252. %
  253. %    GlobalObjects (dictionary): If object N has been resolved in
  254. %        global VM, GlobalObjects[N] is the same as Objects[N]
  255. %        (except that GlobalObjects itself is stored in global VM,
  256. %        so the entry will not be deleted at the end of the page).
  257. %
  258. %    IsGlobal (lstring): IsGlobal[N] = 1 iff object N was resolved in
  259. %        global VM.  This is an accelerator to avoid having to do a
  260. %        dictionary lookup in GlobalObjects when resolving every object.
  261.  
  262. % Initialize the PDF object tables.
  263. /initPDFobjects {        % - initPDFobjects -
  264.   /Objects larray def
  265.   /Generations lstring def
  266.   .currentglobal true .setglobal
  267.   /GlobalObjects 20 dict def
  268.   .setglobal
  269.   /IsGlobal lstring def
  270. } bind def
  271.  
  272. % Grow the tables to a specified size.
  273. /growPDFobjects {        % <minsize> growPDFobjects -
  274.   dup Objects llength gt {
  275.     dup Objects exch lgrowto /Objects exch def
  276.   } if
  277.   dup Generations llength gt {
  278.     dup Generations exch lgrowto /Generations exch def
  279.   } if
  280.   dup IsGlobal llength gt {
  281.     dup IsGlobal exch lgrowto /IsGlobal exch def
  282.   } if
  283.   pop
  284. } bind def
  285.  
  286. % We represent an unresolved object reference by a procedure of the form
  287. % {obj# gen# resolveR}.  This is not a possible PDF object, because PDF has
  288. % no way to represent procedures.  Since PDF in fact has no way to represent
  289. % any PostScript object that doesn't evaluate to itself, we can 'force'
  290. % a possibly indirect object painlessly with 'exec'.
  291. % Note that since we represent streams by executable dictionaries
  292. % (see below), we need both an xcheck and a type check to determine
  293. % whether an object has been resolved.
  294. /unresolved? {        % <object#> unresolved? <bool>
  295.   Objects 1 index lget dup xcheck exch type /integertype eq and {
  296.     IsGlobal 1 index lget 0 eq {
  297.       pop true
  298.     } {
  299.         % Update Objects from GlobalObjects
  300.       DEBUG { (%Global=>local: ) print dup == } if
  301.       Objects exch GlobalObjects 1 index get lput false
  302.     } ifelse
  303.   } {
  304.     pop false
  305.   } ifelse
  306. } bind def
  307. /oforce /exec load def
  308. /oget {        % <array> <index> oget <object>
  309.         % <dict> <key> oget <object>
  310.   2 copy get dup xcheck {
  311.     exec dup 4 1 roll put
  312.   } {
  313.     exch pop exch pop
  314.   } ifelse
  315. } bind def
  316. % A null value in a dictionary is equivalent to an omitted key;
  317. % we must check for this specially.
  318. /knownoget {
  319.   2 copy .knownget {
  320.     dup xcheck {
  321.       exec dup 4 1 roll put
  322.     } {
  323.       exch pop exch pop
  324.     } ifelse
  325.     dup null eq { pop false } { true } ifelse
  326.   } {
  327.     pop pop false
  328.   } ifelse
  329. } bind def
  330.  
  331. % PDF 1.1 defines a 'foreign file reference', but not its meaning.
  332. % Per the specification, we convert these to nulls.
  333. /F {        % <file#> <object#> <generation#> F <object>
  334.         % Some PDF 1.1 files use F as a synonym for f!
  335.    .pdfcount 3 lt { f } { pop pop pop null } ifelse
  336. } bind def
  337.  
  338. /checkgeneration {  % <object#> <generation#> checkgeneration <object#> <OK>
  339.   Generations 2 index lget 1 sub 1 index eq {
  340.     pop true
  341.   } {
  342.     Generations 2 index lget 0 eq {
  343.       (Warning: reference to free object: )
  344.     } {
  345.       (Warning: wrong generation: )
  346.     } ifelse print 1 index =only ( ) print =only ( R) = false
  347.   } ifelse
  348. } bind def
  349. /R {        % <object#> <generation#> R <object>
  350.   1 index unresolved?
  351.     { /resolveR cvx 3 packedarray cvx }
  352.     { checkgeneration { Objects exch lget } { pop null } ifelse }
  353.    ifelse
  354. } bind def
  355.  
  356. % If we encounter an object definition while reading sequentially,
  357. % we just store it away and keep going.
  358. /objopdict mark
  359.   valueopdict { } forall
  360.   /endobj dup cvx
  361. .dicttomark readonly def
  362. /obj {            % <object#> <generation#> obj <object>
  363.   PDFfile objopdict .pdfrun
  364. } bind def
  365. /endobj {        % <object#> <generation#> <object> endobj <object>
  366.   3 1 roll
  367.         % Read the xref entry if we haven't yet done so.
  368.         % This is only needed for generation # checking.
  369.   1 index unresolved? {
  370.     PDFfile fileposition
  371.     2 index readxrefentry pop
  372.     PDFoffset add PDFfile exch setfileposition
  373.   } if
  374.   checkgeneration {
  375.         % The only global objects we bother to save are
  376.         % (resource) dictionaries.
  377.     1 index dup gcheck exch type /dicttype eq and {
  378.       DEBUG { (%Local=>global: ) print dup == } if
  379.       GlobalObjects 1 index 3 index put
  380.       IsGlobal 1 index 1 put
  381.     } if
  382.     Objects exch 2 index lput
  383.   } {
  384.     pop pop null
  385.   } ifelse
  386. } bind def
  387.  
  388. % When resolving an object reference, we stop at the endobj.
  389. /resolveopdict mark
  390.   valueopdict { } forall
  391.   /endobj { endobj exit } bind
  392. .dicttomark readonly def
  393. /resolveR        % <object#> <generation#> resolveR <object>
  394.  { DEBUG { (%Resolving: ) print 2 copy 2 array astore == } if
  395.    1 index unresolved?
  396.     { PDFfile fileposition 3 1 roll
  397.       1 index readxrefentry
  398.       3 1 roll checkgeneration
  399.        {        % Stack: savepos objpos obj#
  400.      exch PDFoffset add PDFfile exch setfileposition
  401.      PDFfile token pop 2 copy ne
  402.       { (xref error!) = /resolveR cvx /rangecheck signalerror
  403.       }
  404.      if pop PDFfile token pop
  405.      PDFfile token pop /obj ne
  406.       { (xref error!) = /resolveR cvx /rangecheck signalerror
  407.       }
  408.      if
  409.      pdf_run_resolve    % PDFfile resolveopdict .pdfrun
  410.        }
  411.        {        % Don't cache if the generation # is wrong.
  412.      pop pop null
  413.        }
  414.       ifelse exch PDFfile exch setfileposition
  415.     }
  416.     { pop Objects exch lget
  417.     }
  418.    ifelse
  419.  } bind def      
  420.  
  421. % ================================ Streams ================================ %
  422.  
  423. % We represent a stream by an executable dictionary that contains,
  424. % in addition to the contents of the original stream dictionary:
  425. %    /File - the file or string where the stream contents are stored,
  426. %      if the stream is not an external one.
  427. %    /FilePosition - iff File is a file, the position in the file
  428. %      where the contents start.
  429. %    /StreamKey - the key used to decrypt this stream, if any.
  430. % We do the real work of constructing the data stream only when the
  431. % contents are needed.
  432.  
  433. % Construct a stream.  The length is not reliable in the face of
  434. % different end-of-line conventions, but it's all we've got.
  435. %
  436. % PDF files are inconsistent about what may fall between the 'stream' keyword
  437. % and the actual stream data, and it appears that no one algorithm can
  438. % detect this reliably.  We used to try to guess whether the file included
  439. % extraneous \r and/or \n characters, but we no longer attempt to do so,
  440. % especially since the PDF 1.2 specification states flatly that the only
  441. % legal terminators following the 'stream' keyword are \n or \r\n, both of
  442. % which are properly skipped and discarded by the token operator.
  443. /stream {    % <dict> stream <modified_dict>
  444.   dup /F known dup PDFsource PDFfile eq or {
  445.     not {
  446.       dup /File PDFfile put
  447.       dup /FilePosition PDFfile fileposition put
  448.       DEBUG { (%FilePosition: ) print dup /FilePosition get == } if
  449.     } if
  450.     PDFfile fileposition 1 index /Length oget add
  451.       PDFfile exch setfileposition
  452.   } {
  453.     pop
  454.     % We're already reading from a stream, which we can't reposition.
  455.     % Capture the sub-stream contents in a string.
  456.     dup /Length oget string PDFsource exch readstring
  457.     not {
  458.       (Unexpected EOF in stream!) =
  459.       /stream cvx /rangecheck signalerror
  460.     } if
  461.     1 index exch /File exch put
  462.   } ifelse
  463.   PDFsource token pop
  464.     /endstream ne { /stream cvx /syntaxerror signalerror } if
  465.   cvx
  466. } bind def
  467. /endstream {
  468.   exit
  469. } bind def
  470.  
  471. % Contrary to the published PDF (1.3) specification, Acrobat Reader
  472. % accepts abbreviated filter names everywhere, not just for in-line images,
  473. % and some applications (notably htmldoc) rely on this.
  474. /unabbrevfilterdict mark
  475.   /AHx /ASCIIHexDecode  /A85 /ASCII85Decode  /CCF /CCITTFaxDecode
  476.   /DCT /DCTDecode  /Fl /FlateDecode  /LZW /LZWDecode  /RL /RunLengthDecode
  477. .dicttomark readonly def
  478.  
  479. % Extract and apply filters.
  480. /filterparms {        % <dict> <DPkey> <Fkey> filterparms
  481.             %   <dict> <parms> <filternames>
  482.   2 index exch .knownget {
  483.     exch 2 index exch .knownget {
  484.         % Both filters and parameters.
  485.       exch dup type /nametype eq {
  486.     1 array astore exch 1 array astore exch
  487.       } if
  488.     } {
  489.         % Filters, but no parameters.
  490.       null exch
  491.       dup type /nametype eq { 1 array astore } if
  492.     } ifelse
  493.   } {
  494.         % No filters: ignore parameters, if any.
  495.     pop null { }
  496.   } ifelse
  497. } bind def
  498. /filtername {        % <filtername> filtername <filtername'>
  499.   //unabbrevfilterdict 1 index .knownget { exch pop } if
  500. } bind def
  501. /applyfilters {        % <parms> <source> <filternames> applyfilters <stream>
  502.   2 index null eq {
  503.     { filtername filter }
  504.   } {
  505.     {        % Stack: parms stream filtername
  506.       2 index 0 get dup null eq { pop } { exch } ifelse filtername filter
  507.       exch dup length 1 sub 1 exch getinterval exch
  508.     }
  509.   } ifelse forall exch pop
  510. } bind def
  511.  
  512. % Resolve a stream dictionary to a PostScript stream.
  513. % Streams with no filters require special handling:
  514. %    - If we are going to interpret their contents, we let endstream
  515. %      terminate the interpretation loop;
  516. %    - If we are just going to read data from them, we impose
  517. %      a SubFileDecode filter that reads just the requisite amount of data.
  518. % Note that, in general, resolving a stream repositions PDFfile.
  519. % Clients must save and restore the position of PDFfile themselves.
  520. /resolvestream {    % <streamdict> <readdata?> resolvestream <stream>
  521.   1 index /F .knownget {
  522.         % This stream is stored on an external file.
  523.     (r) file exch
  524.     /FDecodeParms /FFilter filterparms
  525.         % Stack: readdata? dict parms filternames
  526.     4 -1 roll exch
  527.     pdf_decrypt_stream
  528.     applyfilters
  529.   } {
  530.     exch dup /FilePosition .knownget {
  531.       1 index /File get exch setfileposition
  532.     } if
  533.         % Stack: readdata? dict
  534.     /DecodeParms /Filter filterparms
  535.         % Stack: readdata? dict parms filternames
  536.     2 index /File get exch
  537.         % Stack: readdata? dict parms file/string filternames
  538.     pdf_decrypt_stream        % add decryption if needed
  539.     dup length 0 eq {
  540.         % All the PDF filters have EOD markers, but in this case
  541.         % there is no specified filter.
  542.       pop exch pop
  543.         % Stack: readdata? dict file/string
  544.       2 index {
  545.         % We're going to read data; use a SubFileDecode filter.
  546.     1 index /Length oget () /SubFileDecode filter
  547.       } {
  548.     dup type /filetype ne {
  549.         % Use a SubFileDecode filter to read from a string.
  550.       0 () /SubFileDecode filter
  551.     } if
  552.       } ifelse
  553.     } {
  554.       applyfilters
  555.     } ifelse
  556.   } ifelse
  557.         % Stack: readdata? dict file
  558.   exch pop exch pop
  559. } bind def
  560.  
  561. % ============================ Name/number trees ============================ %
  562.  
  563. /nameoget {        % <nametree> <key> nameoget <obj|null>
  564.   exch /Names exch .treeget
  565. } bind def
  566.  
  567. /numoget {        % <numtree> <key> numoget <obj|null>
  568.   exch /Nums exch .treeget
  569. } bind def
  570.  
  571. /.treeget {        % <key> <leafkey> <tree> .treeget <obj|null>
  572.   dup /Kids knownoget {
  573.     exch pop .branchget
  574.   } {
  575.     exch get .leafget
  576.   } ifelse
  577. } bind def
  578.  
  579. /.branchget {        %  <key> <leafkey> <kids> .branchget <obj|null>
  580.   dup length 0 eq {
  581.     pop pop pop null
  582.   } {
  583.     dup length -1 bitshift 2 copy oget
  584.             % Stack: key leafkey kids mid kids[mid]
  585.     dup /Limits oget aload pop
  586.             % Stack: key leafkey kids mid kids[mid] min max
  587.     6 index lt {
  588.       pop pop
  589.       1 add 1 index length 1 index sub getinterval .branchget
  590.     } {
  591.       5 index gt {
  592.     pop
  593.     0 exch getinterval .branchget
  594.       } {
  595.     exch pop exch pop .treeget
  596.       } ifelse
  597.     } ifelse
  598.   } ifelse
  599. } bind def
  600.  
  601. /.leafget {        % <key> <pairs> .leafget <obj|null>
  602.   dup length 2 eq {
  603.     dup 0 get 2 index eq { 1 oget } { pop null } ifelse
  604.     exch pop
  605.   } {
  606.     dup length -1 bitshift -2 and 2 copy oget
  607.             % Stack: key pairs mid pairs[mid]
  608.     3 index gt { 0 exch } { 1 index length 1 index sub } ifelse
  609.     getinterval .leafget
  610.   } ifelse
  611. } bind def
  612.  
  613. end            % pdfdict
  614. .setglobal
  615.