home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / APPS / gs403osk.tgz / gs403osk.tar / pdf_base.ps < prev    next >
Text File  |  1996-10-12  |  13KB  |  388 lines
  1. %    Copyright (C) 1994, 1996 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. % pdf_base.ps
  19. % Basic parser for PDF reader.
  20.  
  21. % This handles basic parsing of the file (including the trailer
  22. % and cross-reference table), as well as objects, object references,
  23. % and streams; it doesn't include any facilities for making marks on
  24. % the page.
  25.  
  26. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  27. .currentglobal true .setglobal
  28. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  29. pdfdict begin
  30.  
  31. % Since PDF files can include extremely large dictionaries,
  32. % we increase the operand stack size here.
  33. /setuserparams where
  34.  { pop mark /MaxOpStack 10000 .dicttomark setuserparams
  35.  } if
  36.  
  37. % We rebind #, #?, #dsc, and #dscfile later if we're writing out PostScript.
  38. /#          % <arg1> ... <argN> <opname> <N> # -
  39.  { pop cvx exec
  40.  } bind def
  41. /#?
  42.  { false
  43.  } bind def
  44. /#dsc           % mark <obj1> ... #dsc -
  45.  { cleartomark
  46.  } bind def
  47. /#dscfile       % <filename> #dscfile -
  48.  { pop
  49.  } bind def
  50.  
  51. % Define the name interpretation dictionary for reading values.
  52. /valueopdict mark
  53.   (<<) cvn { mark } bind    % don't push an actual mark!
  54.   (>>) cvn /.dicttomark load
  55.   ([) cvn { mark } bind     % ditto
  56.   (]) cvn dup load
  57.   /true true
  58.   /false false
  59.   /null null
  60.   /F dup cvx        % see Objects section below
  61.   /R dup cvx        % see Objects section below
  62.   /stream dup cvx   % see Streams section below
  63. .dicttomark readonly def
  64.  
  65. % ------ Utilities ------ %
  66.  
  67. % Define a scratch string.  The PDF language definition says that
  68. % no line in a PDF file can exceed 255 characters.
  69. /pdfstring 255 string def
  70.  
  71. % Read the previous line of a file.  If we aren't at a line boundary,
  72. % read the line containing the current position.
  73. % Skip any blank lines.
  74. /prevline       % - prevline <startpos> <substring>
  75.  { PDFfile fileposition dup () pdfstring
  76.    2 index 257 sub 0 .max PDFfile exch setfileposition
  77.     {       % Stack: initpos linepos line string
  78.       PDFfile fileposition
  79.       PDFfile 2 index readline pop
  80.       dup length 0 gt
  81.        { 3 2 roll 5 -2 roll pop pop 2 index }
  82.        { pop }
  83.       ifelse
  84.         % Stack: initpos linepos line string startpos
  85.       PDFfile fileposition 5 index ge { exit } if
  86.       pop
  87.     }
  88.    loop pop pop 3 -1 roll pop
  89.  } bind def
  90.  
  91. % Execute a file, interpreting its executable names in a given
  92. % dictionary.  The name procedures may do whatever they want
  93. % to the operand stack.
  94. /.pdfrun            % <file> <opdict> .pdfrun -
  95.  {  % Construct a procedure with the file and opdict bound into it.
  96.    1 index cvlit mark mark 4 2 roll
  97.     { token not { (%%EOF) cvn cvx } if
  98.       dup xcheck
  99.        { DEBUG { dup == flush } if
  100.      2 copy .knownget
  101.       { exch pop exch pop exec }
  102.       { (%stderr) (w) file
  103.         dup (****************Unknown operator: ) writestring
  104.         dup 3 -1 roll .writecvs dup (\n) writestring flushfile
  105.         pop
  106.       }
  107.      ifelse
  108.        }
  109.        { exch pop DEBUG { dup ==only ( ) print flush } if
  110.        }
  111.       ifelse
  112.     }
  113.    aload pop .packtomark cvx
  114.    /loop cvx 2 packedarray cvx
  115.     { stopped /PDFsource } aload pop
  116.    PDFsource
  117.     { store { stop } if } aload pop .packtomark cvx
  118.    /PDFsource 3 -1 roll store exec
  119.  } bind def
  120.  
  121. % ------ File reading ------ %
  122.  
  123. % Read the cross-reference entry for an (unresolved) object.
  124. % The caller must save and restore the PDFfile position if desired.
  125. % For invalid (free) objects, we return 0.
  126. /readxrefentry      % <object#> readxrefentry <objpos>
  127.  { dup Objects exch get
  128.    PDFfile exch setfileposition
  129.    PDFfile token pop        % object position
  130.    PDFfile token pop        % generation #
  131.    PDFfile token pop        % n or f
  132.    dup /n eq
  133.     { pop 1 add dup 255 gt
  134.        { Generations type /stringtype eq
  135.       {     % Convert Generations from a string to an array.
  136.         Generations length array dup
  137.         0 1 2 index length 1 sub
  138.          { Generations 1 index get put dup
  139.          }
  140.         for pop /Generations exch store
  141.       }
  142.      if
  143.        }
  144.       if
  145.     }
  146.     { /f eq
  147.        { pop 0 }
  148.        { /readxrefentry cvx /syntaxerror signalerror }
  149.       ifelse
  150.     }
  151.    ifelse
  152.         % Stack: obj# objpos 1+gen#
  153.    Generations 4 -1 roll 3 -1 roll put
  154.  } bind def
  155.  
  156. % ================================ Objects ================================ %
  157.  
  158. % We represent an unresolved object reference by a procedure of the form
  159. % {obj# gen# resolveR}.  This is not a possible PDF object, because PDF has
  160. % no way to represent procedures.  Since PDF in fact has no way to represent
  161. % any PostScript object that doesn't evaluate to itself, we can 'force'
  162. % a possibly indirect object painlessly with 'exec'.
  163. % Note that since we represent streams by executable dictionaries
  164. % (see below), we need both an xcheck and a type check to determine
  165. % whether an object has been resolved.
  166. /unresolved?        % <object#> unresolved? <bool>
  167.  { Objects exch get dup xcheck exch type /integertype eq and
  168.  } bind def
  169. /oforce /exec load def
  170. /oget       % <array> <index> oget <object>
  171.         % <dict> <key> oget <object>
  172.  { 2 copy get dup xcheck
  173.     { exec dup 4 1 roll put }
  174.     { exch pop exch pop }
  175.    ifelse
  176.  } bind def
  177. % A null value in a dictionary is equivalent to an omitted key;
  178. % we must check for this specially.
  179. /knownoget
  180.  { 2 copy known
  181.     { oget dup null eq { pop false } { true } ifelse }
  182.     { pop pop false }
  183.    ifelse
  184.  } bind def
  185.  
  186. % PDF 1.1 defines a 'foreign file reference', but not its meaning.
  187. % Per the specification, we convert these to nulls.
  188. /F      % <file#> <object#> <generation#> F <object>
  189.  {      % Some PDF 1.1 files use F as a synonym for f!
  190.    count 3 lt { setfillcolor /fill fsexec } { pop pop pop null } ifelse
  191.  } bind def
  192.  
  193. % We keep track of objects in a pair of arrays, Objects and Generations.
  194. % Generations[N] is 1+ the current generation number for object number N.
  195. % (As far as we can tell, this is needed only for error checking.)
  196. % If object N is loaded, Objects[N] is the actual object;
  197. % otherwise, Objects[N] is an executable integer giving the file offset
  198. % of the object's entry in the cross-reference table.
  199. % For free objects, Generations[N] is 0.
  200. /checkgeneration  % <object#> <generation#> checkgeneration <object#> <OK>
  201.  { Generations 2 index get 1 sub 1 index eq
  202.     { pop true
  203.     }
  204.     { (Warning: wrong generation: ) print 1 index =only ( ) print = false
  205.     }
  206.    ifelse
  207.  } bind def
  208. /R      % <object#> <generation#> R <object>
  209.  { 1 index unresolved?
  210.     { /resolveR cvx 3 packedarray cvx }
  211.     { checkgeneration { Objects exch get } { pop null } ifelse }
  212.    ifelse
  213.  } bind def
  214.  
  215. % If we encounter an object definition while reading sequentially,
  216. % we just store it away and keep going.
  217. /objopdict mark
  218.   valueopdict { } forall
  219.   /endobj dup cvx
  220. .dicttomark readonly def
  221. /obj            % <object#> <generation#> obj <object>
  222.  { PDFfile objopdict .pdfrun
  223.  } bind def
  224. /endobj         % <object#> <generation#> <object> endobj <object>
  225.  { 3 1 roll
  226.         % Read the xref entry if we haven't yet done so.
  227.         % This is only needed for generation # checking.
  228.    1 index unresolved?
  229.     { PDFfile fileposition
  230.       2 index readxrefentry pop
  231.       PDFoffset add PDFfile exch setfileposition
  232.     } if
  233.    checkgeneration { Objects exch 2 index put } { pop pop null } ifelse
  234.  } bind def
  235.  
  236. % When resolving an object reference, we stop at the endobj.
  237. /resolveopdict mark
  238.   valueopdict { } forall
  239.   /endobj { endobj exit } bind
  240. .dicttomark readonly def
  241. /resolveR       % <object#> <generation#> resolveR <object>
  242.  { DEBUG { (%Resolving: ) print 2 copy 2 array astore == } if
  243.    1 index unresolved?
  244.     { PDFfile fileposition 3 1 roll
  245.       1 index readxrefentry
  246.       3 1 roll checkgeneration
  247.        {        % Stack: savepos objpos obj#
  248.      exch PDFoffset add PDFfile exch setfileposition
  249.      PDFfile token pop 2 copy ne
  250.       { (xref error!\n) print /resolveR cvx /rangecheck signalerror
  251.       }
  252.      if pop PDFfile token pop
  253.      PDFfile token pop /obj ne
  254.       { (xref error!\n) print /resolveR cvx /rangecheck signalerror
  255.       }
  256.      if
  257.      pdf_run_resolve    % PDFfile resolveopdict .pdfrun
  258.        }
  259.        { Objects exch null put pop null
  260.        }
  261.       ifelse exch PDFfile exch setfileposition
  262.     }
  263.     { pop Objects exch get
  264.     }
  265.    ifelse
  266.  } bind def      
  267.  
  268. %================================ Streams ================================ %
  269.  
  270. % We represent a stream by an executable dictionary that contains,
  271. % in addition to the contents of the original stream dictionary:
  272. %   /File - the file or string where the stream contents are stored;
  273. %   /FilePosition - iff File is a file, the position in the file
  274. %     where the contents start.
  275. %   /StreamKey - the key used to decrypt this stream if any
  276. % We do the real work of constructing the data stream only when the
  277. % contents are needed.
  278.  
  279. % Construct a stream.  The length is not reliable in the face of
  280. % different end-of-line conventions, but it's all we've got.
  281. %
  282. % PDF files are inconsistent about what may fall between the 'stream' keyword
  283. % and the actual stream data, and it appears that no one algorithm can
  284. % detect this reliably.  Furthermore, if we are already reading from a stream,
  285. % we can't back it up to determine what terminated the keyword.
  286. % We think the following is the best we can do:
  287. %   If we are already reading from a stream, skip the next character
  288. %   after the keyword terminator iff it is a \n.
  289. % This is chancy if the data are in binary form, but such files are
  290. % questionable to begin with.
  291. /streamskipeols
  292.  {      % We used to use the following algorithm:
  293. %    { PDFsource read not { /stream cvx /syntaxerror signalerror } if
  294. %      dup 10 eq 1 index 13 eq or not { PDFsource exch unread exit } if pop
  295. %    }
  296. %   loop
  297.         % But the one described above seems to work more often:
  298.     PDFsource read not { /stream cvx /syntaxerror signalerror } if
  299.     dup 10 ne { PDFsource exch unread } { pop } ifelse
  300.  } bind def
  301. /stream
  302.  { PDFsource PDFfile eq
  303.     { dup /File PDFfile put
  304.         % We used to do the following:
  305. %      prevline pop pop
  306.       streamskipeols
  307.       dup /FilePosition PDFfile fileposition put
  308.       DEBUG { (%FilePosition: ) print dup /FilePosition get == } if
  309.       PDFfile fileposition 1 index /Length oget add
  310.         PDFfile exch setfileposition
  311.     }
  312.     {   % We're already reading from a stream, which we can't reposition.
  313.     % Capture the sub-stream contents in a string.
  314.       streamskipeols
  315.       dup /Length oget string PDFsource exch readstring
  316.       not
  317.        { (Unexpected EOF in stream!\n) print
  318.      /stream cvx /rangecheck signalerror
  319.        }
  320.       if
  321.       1 index exch /File exch put
  322.     }
  323.    ifelse
  324.    PDFsource token pop
  325.      /endstream ne { /stream cvx /syntaxerror signalerror } if
  326.    cvx
  327.  } bind def
  328.  
  329. % Resolve a stream dictionary to a PostScript stream.
  330. % Streams with no filters require special handling:
  331. %   - If we are going to interpret their contents, we let endstream
  332. %     terminate the interpretation loop;
  333. %   - If we are just going to read data from them, we impose
  334. %     a SubFileDecode filter that reads just the requisite amount of data.
  335. % Note that, in general, resolving a stream repositions PDFfile.
  336. % Clients must save and restore the position of PDFfile themselves.
  337. /resolvestream      % <streamdict> <readdata?> resolvestream <stream>
  338.  { exch dup /FilePosition .knownget
  339.     { 1 index /File get exch setfileposition }
  340.    if
  341.         % Stack: readdata? dict
  342.    dup /DecodeParms .knownget not { null } if
  343.    1 index /Filter .knownget not { {} } if
  344.    dup type /nametype eq
  345.     { 1 array astore
  346.       1 index null ne { exch 1 array astore exch } if
  347.     }
  348.    if
  349.         % Stack: readdata? dict parms filternames
  350.    2 index /File get exch
  351.         % Stack: readdata? dict parms file/string filternames
  352.    pdf_decrypt_stream       % add decryption if needed
  353.    dup length 0 eq
  354.     {       % All the PDF filters have EOD markers, but in this case
  355.         % there is no specified filter.
  356.       pop exch pop
  357.         % Stack: readdata? dict file/string
  358.       2 index
  359.        {    % We're going to read data; use a SubFileDecode filter.
  360.      1 index /Length oget () /SubFileDecode filter
  361.        }
  362.        { dup type /filetype ne
  363.       { % Use a SubFileDecode filter to read from a string.
  364.         0 () SubFileDecode filter
  365.       }
  366.      if
  367.        }
  368.       ifelse
  369.     }
  370.     { 2 index null eq
  371.        { { filter }
  372.        }
  373.        {    % Stack: readdata? dict parms file/string filtername
  374.          { 2 index 0 get dup null eq { pop } { exch } ifelse filter
  375.        exch dup length 1 sub 1 exch getinterval exch
  376.      }
  377.        }
  378.       ifelse forall exch pop
  379.     }
  380.    ifelse
  381.         % Stack: readdata? dict file
  382.    exch pop exch pop
  383.  } bind def
  384. /endstream { exit } def
  385.  
  386. end         % pdfdict
  387. .setglobal
  388.