jppd.dyndns.org/jppd.dyndns.org.tar/jppd.dyndns.org/QUERYPRO/Impressora_PDF/converter.exe/GPLGS/pdf_rbld.ps

Text File | 2004-08-28 | 14KB | 304 lines

%    Copyright (C) 2002 artofcode LLC.  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., [phone].

% $Id: pdf_rbld.ps,v 1.4.4.2 2004/08/27 21:36:36 dan Exp $
% pdf_rbld.ps - Rebuilding of broken PDF files (xref errors)

% This module contains routines that are used if we detect an error
% while reading the xref tables.  These routines will scan the file and
% build an xref table by finding the objects.  We also need to find the
% appropriate trailer dictionary.  Note:  One procedure is also used
% even if we do not need to rebuild a PDF file.
%
% This module cannot rebuild a PDF file which has had errors created inside
% of objects or binary data streams.  It often succeeds with files that
% have had its end of lines converted between unix and dos versions.

% if true --> we have an object with duplicate object and generation numbers.
/dup_obj_gen_num false def

% Note:  This routine is also used by non-rebuild code.
% Store a line in the xref array (Actually Objects and Generations arrays)
% <obj num> <obj loc> <gen num>  setxrefentry <obj num> <obj loc> <gen num>
/setxrefentry
{    % We store generation numbers as value + 1
    % We reserve 0 to indicate an unknown generation (or xref entry)
  1 add            % increment generation number
    % To save space, generations numbers are stored in a lstring unless we
    % find a generation number greater than 255.  If so then transfer to
    % an larray.
  dup 255 gt {
    Generations ltype /stringtype eq {    % Convert Generations to an larray.
      larray Generations llength lgrowto dup    % Create new larray
      0 1 2 index llength 1 sub {    % Copy from old lstring to new larray
    Generations 1 index lget lput dup
      } for
      pop
      /Generations exch store        % Save new Generations larray
    } if
  } if
    % Verify that the new values are for a new object.  If the current
    % entry is null then we have a new entry.
  Objects 3 index lget null eq {
    Objects 3 index 3 index cvx lput    % Save object location
    Generations 3 index 2 index lput    % Save geenration number
  } {
    % Verify that the new entry has at least as high a generaton number
    % We accept equal entry number because we have found PDF files in
    % which there are multiple objects with the same object and entry
    % numbers.  The normal xref logic only accepts the first such
    % entry that it finds.  However the 'rebuild PDF' logic can find
    % both such entries.  The correct one is usually the last one.
    Generations 3 index lget 1 index le {
      Objects 3 index 3 index cvx lput    % Save object location
      Generations 3 index 2 index lput    % Save geenration number
    } if
    % Set error flag if we have equal object and generation numbers
    Generations 3 index lget 1 index eq { /dup_obj_gen_num true def } if
  } ifelse
} bind def

% Print the contents of the xref array.  This actually consists of two
% arrays (Objects and Generations).  Both are larrays.  larrays are a
% special Ghostscript object which can be arrays with more than 64k
% elements.
/print_xref                % - print_xref -
{ 0 1 Objects llength 1 sub        % stack: 0 1 <number of objects - 1>
  { dup =only                % print object number
    (  ) print
    dup Generations exch lget 1 sub =only % print Generation number
    (  ) print
    Objects exch lget ===        % print object location
  } for
} bind def

% This is the same as the postscript token operator except that
% errors are ignored.
/token_nofail
{
  { token } .internalstopped
  { pop false } if
} bind odef

% Get token from string and check its type
%   <string> <type> typed_token <false>        % no token or not match
%   <string> <type> typed_token <obj> <last> <true>    % matching token type
% Where last is the string remainder
/typed_token
{ exch
  token_nofail            % get token
  {
    dup type            % stack:  type last token type
    4 -1 roll eq {        % stack:  last token bool
      exch true            % desired object found - set exit status
    } {
      pop pop false        % not type - clear stack, set exit status
    } ifelse
  } {
    pop false            % no token - pop type, set exit status
  } ifelse            % check if we got token
} bind def

% Allocate space for post_eof_count to be bound into procedures below.
/post_eof_count 0 def

% We want the location of the trailer dictionary at the start of file.
% First we will find the xref.  Then we will skip over the xref entries
% to the trailer.
/search_start_trailer        % - search_start_trailer <trailer loc>
{ % Read the first 300 bytes and check for xref
  PDFfile 0 setfileposition
  300 string 0 1 299 { 2 copy PDFfile read pop put pop } for
  (xref) search {
    % found 'xref'
    exch pop exch pop length 4 add PDFfile exch setfileposition
    PDFfile token pop        % get starting entry - or 'trailer'
    (trailer) ne {        % if we do not already have 'trailer'
      PDFfile token pop        % get number of entries
      PDFfile token pop pop    % this moves us into the middle of the first entry
      25 string exch        % define working string for readline
      { PDFfile 1 index readline pop pop
      } repeat            % skip entries
      pop            % pop working string
      PDFfile token pop        % get 'trailer'
      PDFfile fileposition    % get file position
    } if
  } {
    pop 0            % no xref - should not happen
  } ifelse
} bind def

% We want the location of the trailer dictionary at the end of file.
% We will read the last block of data and search for the final occurance
% of the word 'trailer'
/search_end_trailer        % - search_end_trailer <trailer loc>
{ % Position to read block of data from the end of the file.  Note:  We ignore
  % anything past the last %%EOF since this is not PDF data.
  PDFfile 0 setfileposition
  PDFfile bytesavailable post_eof_count sub    % location of end of data
  dup 4096 .min            % block size to read
                % stack: <file end pos> <block size>
  % move file position to the start of the block
  2 copy sub PDFfile exch setfileposition
  % read block of data
  dup string 0 1 4 -1 roll 1 sub { 2 copy PDFfile read pop put pop } for
  % search for last occurance of 'trailer'
  (trailer) { search not { exit } if pop } loop
  % determine where the trailer is in the file
  %   trailer loc = end loc - remaing string length
  length sub
} bind def

% We want to find the trailer dictionary.  There is a trailer dictionary
% for each xref object list.  We only want the trailer dictionary associated
% with the first xref object list.  In theory this can be anywhere in the
% file.  However since we are trying to repair a broken file, we cannot simply
% follow the xref links.  So we are falling back to a simple strategy.  We
% find the specified location of the first xref list.  If its location is in
% the first half of the file then we search for the first trailer dictionary
% at the start of the file.  Otherwise we search for the last trailer at the
% end of the file.
/search_trailer            % - search_trailer -
{ % Find the 'startxref' and associated position at the end of the file.
  % Position to read block of data from the end of the file.  Note:  We
  % actually end at the end of the last %%EOF since this is the end of the
  % useful PDF data.  (Some files contain trailing garbage.)
  PDFfile 0 setfileposition
  PDFfile bytesavailable    % size of file
  post_eof_count sub dup    % location of end of last %%EOF
  dup 4096 .min            % block size to read
  % stack: <useful file size> <useful file size file> <block size>
  % move file position to the start of the block
  2 copy sub PDFfile exch setfileposition
  % read block of data
  dup string 0 1 4 -1 roll 1 sub { 2 copy PDFfile read pop put pop } for
  % search for last occurance of 'startxref'
  (startxref) { search not { exit } if pop } loop
  % determine where the trailer is in the file
  %   trailer loc = end loc - remaing string length
  length sub 9 sub
  % move the file to this position and read startxref and position
  PDFfile exch setfileposition
  PDFfile token pop pop PDFfile token pop
  % compare xref position to 1/2 the length of the file and search for trailer
  exch 2 div lt { search_start_trailer } { search_end_trailer } ifelse
  % get the trailer
  PDFfile exch setfileposition        % set to the specified trailer location
  PDFfile traileropdict .pdfrun        % read trailer info
  /Trailer exch def
} bind def

% This routine will determine if there is stuff after the %%EOF.  There is
% supposed to be only a line termination.  However many real life files
% contain some garbage.  This routine checks how much.  We then ignore this
% stuff when we are scanning for objects.
/determine_post_eof_count        % - determine_post_eof_count <count>
{ % Position to read block of data from the end of the file.
  PDFfile 0 setfileposition
  PDFfile bytesavailable    % size of file
  dup 4096 .min            % block size to read
  % stack: <file size> <file size> <block size>
  % move file position to the start of the block
  2 copy sub PDFfile exch setfileposition
  % read block of data
  dup string 0 1 4 -1 roll 1 sub { 2 copy PDFfile read pop put pop } for
  % search for last occurance of '%%EOF'
  (%%EOF) { search not { exit } if pop } loop
  % how much is left = remaining string length
  length exch pop        % pop /%%EOF
} bind def

% This routine will scan a file searaching for object locations to build
% an alternate version of the data in the xref tables.
% Its purpose is to provide a basis for an xref fixing facility.
/search_objects                % - search_objects -
{ % Initialize the Objects, Generations, etc. larrays
  initPDFobjects
  % reset duplicate object and generation numbers error flag
  /dup_obj_gen_num false def
  % Determine how many bytes are in the file after the final %%EOF
  /post_eof_count determine_post_eof_count def
  % Start at the beginning of the file
  PDFfile 0 setfileposition
  % Create a working string (and also store its length on stack)
  1024 dup string
  { % Now loop through the entire file lloking for objects
    PDFfile fileposition        % save current file position
    % When we get near the end of the file, we use a smaller interval of
    % our working string to prevent reading past the end.  (See comments on
    % EOF testing below.)
    PDFfile bytesavailable post_eof_count sub 10 sub dup 4 index lt {
      2 index 0 3 -1 roll getinterval    % near EOF, use interval of string
    } { pop 1 index            % not near end, use full working string
    }ifelse
    % Read a line from file.  If the line does not fit into our working string,
    % or any other error, then we will discard it.
    PDFfile exch { readline } .internalstopped
    { pop pop false } if        % indicate no string if we stopped
    { % stack: <length> <working_str> <loc> <string>
      % Now that we have line, get obj num, ref num, and 'obj'.  Verify that each
      % of these is correct type.
      /integertype typed_token {    % get obj number
        /integertype typed_token {    % get ref number
          /nametype typed_token {    % get 'obj' text
        pop                % pop remaining string
        /obj eq {            % verify name is 'obj'
          % make sure we have room in the arrays.  We work in increments
          % of 20 each time we increase the size.
          1 index 20 add 20 idiv 20 mul
          growPDFobjects
          % save xref parameters into Objects and Generations
          1 index 3 index 2 index    % rearrange parms for setxrefentry
          setxrefentry        % save parameters
          pop pop pop        % clear parameters
        } if            % check if name is 'obj'
          } if                % check if we got 'obj" string
          pop                % remove ref number
        } if                % check if we got ref number
        pop                % remove obj number
      } if                % check if we got object number
    } if                % check if got a string from readline
    pop                    % remove location
    % Check if we are approaching the end of the file.  We do not want to
    % read past the end of the file since that closes it.  We actually stop
    % 10-20 bytes early since there cannot be an object that close to the end.
    % (There is a Trailer dictionary, etc. at the end of the file.)
    PDFfile bytesavailable post_eof_count sub 20 lt { exit } if
  } loop                % loop through the entire file
  pop pop                % remove working string and its length
  % Output warning if we have two objects with the same object and generation
  % numbers.
  dup_obj_gen_num {
    (   **** Warning:  There are objects with matching object and generation\n)
    pdfformaterror
    (   **** numbers.  The accuracy of the resulting image is unknown.\n)
    pdfformaterror
  } if
} bind def

% Print xref warning message
/print_xref_warning
{
  (   **** Warning:  An error occurred while reading an XREF table.\n)
  pdfformaterror
  (   **** The file has been damaged.  This may have been caused\n)
  pdfformaterror
  (   **** by a problem while converting or transfering the file.\n)
  pdfformaterror
  (   **** Ghostscript will attempt to recover the data.\n)
  pdfformaterror
} bind def