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_font.ps < prev    next >
Encoding:
Text File  |  2006-07-06  |  44.4 KB  |  1,382 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  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_font.ps,v 1.53.2.12 2005/01/10 15:15:41 alexcher Exp $
  17. % PDF font operations.
  18.  
  19. % Finding a font by name can't give a proper result when PDF font names aren't unique.
  20. % But it is only the way to obtain a font in Postscript after a font file is executed.
  21. % Therefore using a FontName (and findfont) is allowed only
  22. % immediately after a font file is executed.
  23. % In all other cases the font to be found by a pointer through PDF structures.
  24. % 
  25. % This ideal logics can't work for documents,
  26. % which define a font resource with an embedded font,
  27. % and another font resource with same BaseFont but with no embedded font
  28. % (and possibly with no font descriptor).
  29. % Our testbase does contain such examples.
  30. % In this case we do find font by FontName (with findfont),
  31. % since there is no other way to get a reasonable result.
  32.  
  33. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  34. .currentglobal true .setglobal
  35. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  36. GS_PDF_ProcSet begin
  37. pdfdict begin
  38.  
  39. % We cache the PostScript font in an additional element of the
  40. % font resource dictionary, called PSFont.
  41.  
  42. % ---------------- Encodings ---------------- %
  43.  
  44. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  45.  
  46. % Apply a list of differences to an Encoding.
  47. % Note that the differences may cause the array to grow.
  48. /updateencoding {    % <encoding|null> <differences> updateencoding <enc'>
  49.     % Calculate the length of the result.
  50.   % in case the incoming Encoding is null, use .notdefEncoding
  51.   exch dup null eq { pop .notdefEncoding } if
  52.   0 0 3 index {
  53.     dup type /nametype ne { exch pop oforce } { pop 1 add } ifelse
  54.     % Differences list may not be in order, update the largest_index
  55.     % stack: <Differences> <encoding> <largest_index> <at_index>
  56.     2 copy lt { exch pop dup } if    % at_index is new largest
  57.   } forall
  58.   pop 1 index length .max array dup 0 4 -1 roll putinterval
  59.   exch 0 exch {
  60.         % Stack: enc' code element
  61.     dup type /nametype ne
  62.       { exch pop oforce }
  63.       { 3 copy put pop 1 add }
  64.     ifelse
  65.   } forall pop
  66. } bdef
  67.  
  68. % Get the Encoding for a font.
  69. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  70.  { /Encoding knownoget
  71.     { dup type /nametype eq
  72.        {
  73.          % The published PDF specification says the Encoding name
  74.          % "must be" one of the 3 predefined Encodings, implying
  75.          % that an error should occur if it isn't.  However, Acrobat
  76.          % Reader simply ignores unknown names, and since there are
  77.          % some buggy applications that rely on this, we do the same.
  78.  
  79.          dup dup dup /MacRomanEncoding eq
  80.          exch /MacExpertEncoding eq or 
  81.          exch /WinAnsiEncoding eq or
  82.            { exch pop findencoding
  83.            }
  84.            { pop
  85.            }
  86.          ifelse
  87.        }
  88.        { dup /BaseEncoding knownoget
  89.        {
  90.              dup / eq
  91.                { pop
  92.                  (   **** Warning: Ignoring bad BaseEncoding name.\n)  pdfformaterror
  93.                  % as found in a PDF file from J.D.Edwards OneWorld (B7333), bug 687786
  94.                }
  95.                {
  96.                  findencoding 3 -1 roll pop exch
  97.                }
  98.              ifelse
  99.       }
  100.      if
  101.      /Differences knownoget { updateencoding } if
  102.        }
  103.       ifelse
  104.     }
  105.    if
  106.  } bdef
  107.  
  108. % Define a font using it's FontName as the key.
  109. % Adjust a font according to the Encoding and Widths in the font resource.
  110. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  111.   getfontencoding
  112.   getfontmetrics 5 -1 roll pop .updatefont { dup /FontName get exch definefont } if
  113. } bind def
  114.  
  115. % Get the (possibly modified) encoding of a font.
  116. /getfontencoding {    % <font-resource> <font> getfontencoding
  117.             %   <font-resource> <font> <Encoding|null>
  118.   1 index /Encoding known {
  119.     dup /Encoding knownoget { 2 index getencoding } { null } ifelse
  120.   } {
  121.     null
  122.   } ifelse
  123. } bdef
  124.  
  125. % Returns true if the current glyph is in the Differences array at
  126. % the specified index value. This is needed because the Widths
  127. % array may map to the same glyph at different positions from the
  128. % Encoding. We want to use the Width that was associated with the
  129. % one specified in the Encoding::Differences list.
  130. /match_in_diff     % <Differences> <index> <glyphname> match_in_diff <bool>
  131. { false 4 1 roll 0 4 -1 roll    % stack: false index glyphname at_index==0 Differences
  132.   { exch 1 index type /nametype ne {
  133.       % stack: false index glyphname Diff_element at_index 
  134.       pop    % Diff_element is new at_index
  135.     } {
  136.       % stack: false index glyphname Diff_element at_index 
  137.       exch 2 index eq {
  138.         % stack: false index glyphname at_index 
  139.     dup 3 index eq {
  140.           true 5 1 roll    % stack: true false index glyphname at_index
  141.           pop exit
  142.         } if
  143.       } if
  144.       1 add        % at_index++ stack: false index glyphname at_index' 
  145.     } ifelse
  146.   } forall
  147.   % stack: true  false index     glyphname
  148.   %  or  : false index glyphname at_index
  149.   pop pop pop
  150. } bdef
  151.  
  152. /unique_name {  % <dict> </root> unique_name </unique>
  153.   %
  154.   %  Note : this function interacts with pdf_write_encoding in src/gdevpdtw.c
  155.   %  and with copied_drop_extension_glyphs in src\gxfcopy.c
  156.   %  by adding a reserved substring (~GS~).
  157.   %
  158.   .namestring       % <<>> (root)
  159.   0 1 65535 {
  160.     5 string cvs    % <<>> (root) (0)
  161.     (~GS~) exch concatstrings
  162.     1 index exch    % <<>> (root) (root) (~GS~0)
  163.     concatstrings   % <<>> (root) (root~GS~0)
  164.     dup             % <<>> (root) (root~GS~0) (root~GS~0)
  165.     3 index exch    % <<>> (root) (root~GS~0) <<>> (root~GS~0)
  166.     known not {
  167.       exch pop exit % <<>> (root~GS~0)
  168.     } if
  169.     pop
  170.   } for
  171.   exch pop cvn      % /root0
  172. } bdef
  173.                                
  174. % Get the metrics of a font, if specified.
  175. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  176.             %   <font-resource> <font> <Encoding|null>
  177.             %   <Metrics|null> <GlyphMap|null>
  178.   2 index /Widths known {
  179.     dup null eq { pop dup /Encoding get } if
  180.     4 dict begin
  181.       dup length dict
  182.       /Metrics exch def
  183.       /Encoding exch def
  184.       /GlyphMap //null def
  185.       exch
  186.       dup /Widths oget /Widths exch def
  187.         % Stack: font font-res
  188.         % Note that widths are always based on a 1000-unit
  189.         % character space, but the FontMatrix may specify
  190.         % some other scale factor.  Compensate for this here,
  191.         % by scaling the Widths if necessary.
  192.       0.001 2 index /FontMatrix get 0 get div
  193.         % Stack: font font-res mscale
  194.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  195.        {    % Stack: font font-res mscale first-char index
  196.      Encoding 1 index dup 2 index length ge {
  197.            (   **** Warning: Font Encoding array size is smaller than character range.\n)
  198.            pdfformaterror
  199.        pop pop /.notdef
  200.          } {
  201.        get
  202.      } ifelse
  203.      Widths 2 index 4 index sub dup 2 index length ge {
  204.            (   **** Warning: Font Widths array size is smaller than character range.\n)
  205.            pdfformaterror
  206.            % use MissingWidth if it's available, if not, default to 1000 (full width)
  207.        pop pop 4 index /FontDescriptor knownoget {
  208.          /MissingWidth knownoget not { 1000    } if
  209.        } { 1000 } ifelse
  210.          } {
  211.        get
  212.      } ifelse
  213.          % Stack: font font-res mscale first-char index charname width
  214.      4 index mul
  215.         % The following 'loop' is only context for 'exit'.
  216.      {    
  217.         % Work around a bug in pdfTeX, which can generate Encoding
  218.         % vectors containing nulls :
  219.        1 index //null eq { exit } if
  220.            Metrics 2 index .knownget {
  221.              1 index ne
  222.            } {
  223.              //false
  224.            } ifelse {
  225.              % Two or more Encoding elements refer same glyph name,
  226.              % and Widths specify different wihts for it.
  227.              % Since a Postscript font can't have different 
  228.              % Metrics for same glyph name, 
  229.              % we generate an unique name, and create a new 
  230.              % Charstrings entry with same glyph value.
  231.              GlyphMap //null eq {
  232.                /Encoding Encoding dup length array copy def
  233.                /GlyphMap 4 dict def
  234.              } if
  235.              % To prevent too many new names, check whether
  236.              % we can use one already created for same glyph.
  237.              //true
  238.              GlyphMap {                           % f r s c i n w b n1 n2
  239.                4 index eq {                       % f r s c i n w b n1
  240.                  dup Metrics exch get             % f r s c i n w b n1 w1
  241.                  3 index eq {                     % f r s c i n w b n1
  242.                    4 3 roll pop                   % f r s c i w b n1
  243.                    3 1 roll pop                   % f r s c i n1 w
  244.                    Encoding 3 index 3 index put
  245.                    //false                        % f r s c i n1 w b
  246.                    exit
  247.                  } {
  248.                    pop
  249.                  } ifelse
  250.                } {                                % f r s c i n w b n1
  251.                  pop
  252.                } ifelse
  253.              } forall                             % f r s c i n w b
  254.              { % Do create a new name.
  255.                Metrics 2 index //unique_name exec % f r s c i n w nn
  256.              Encoding 4 index 2 index put
  257.                GlyphMap 1 index 5 -1 roll put     % f r s c i w nn
  258.              exch
  259.                 % Stack: font font-res mscale first-char index new_name width
  260.              } if
  261.            } if
  262.            2 copy Metrics 3 1 roll put
  263.        exit
  264.      } loop
  265.      pop pop pop
  266.        }
  267.       for pop
  268.         % Now fill in the MissingWidth for any encoded characters
  269.         % that aren't in Metrics already.  Note that built-in
  270.         % fonts may have Widths/FirstChar/LastChar but no
  271.         % FontDescriptor, so we must check for this.
  272.         % Stack: font font-res mscale
  273.       1 index /FontDescriptor knownoget {
  274.     Metrics exch
  275.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  276.     Encoding {
  277.         % Stack: font font-res mscale missing-width metrics charname
  278.         % Work around the abovementioned pdfTeX bug.
  279.       dup //null ne {
  280.         2 copy known not { 2 copy 4 index put } if pop
  281.       } {
  282.         pop
  283.       } ifelse
  284.     } forall pop pop pop
  285.       } {
  286.     pop
  287.       } ifelse
  288.     exch Encoding Metrics GlyphMap end
  289.   } {
  290.     //null //null
  291.   } ifelse
  292. } bdef
  293.  
  294. currentdict /unique_name undef
  295. currentdict /match_in_diff undef
  296.  
  297. % ---------------- Descriptors ---------------- %
  298.  
  299. % Partial descriptors for the 14 built-in fonts.  Note that
  300. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  301. % object has undergone a subtle change in its meaning which has serious
  302. % consequences for searching with Acrobat:
  303. % In PDF 1.1, the flag meant: Font has StandardEncoding
  304. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  305. /standardfontdescriptors mark
  306.   /Courier mark /Flags 16#23 .dicttomark
  307.   /Courier-Oblique 1 index
  308.   /Courier-Bold 1 index
  309.   /Courier-BoldOblique 1 index
  310.   /Helvetica mark /Flags 16#20 .dicttomark
  311.   /Helvetica-Oblique 1 index
  312.   /Helvetica-Bold 1 index
  313.   /Helvetica-BoldOblique 1 index
  314.   /Times-Roman mark /Flags 16#22 .dicttomark
  315.   /Times-Bold 1 index
  316.   /Times-Italic mark /Flags 16#62 .dicttomark
  317.   /Times-BoldItalic 1 index
  318.   /Symbol mark /Flags 16#4 .dicttomark
  319.   /ZapfDingbats 1 index
  320. .dicttomark readonly def
  321.  
  322. % ---------------- Utilities ---------------- %
  323.  
  324.  
  325. /.pdforigfontcache_g 20 dict def
  326. currentglobal false setglobal
  327. systemdict /.pdforigfontcache_l 20 dict .forceput
  328. setglobal
  329.  
  330. % Find an original font, using cache to prevent adjustfont to accumulate changes.
  331. /pdffindcachedfont {   % <font_name> pdffindcachedfont <font>
  332.   dup //.pdforigfontcache_g exch .knownget {
  333.     exch pop
  334.   } {
  335.     dup .pdforigfontcache_l exch .knownget {
  336.       exch pop
  337.     } {
  338.       dup findfont dup    
  339.       dup gcheck { //.pdforigfontcache_g } { .pdforigfontcache_l } ifelse
  340.                      % Stack : font_name font font cache
  341.       4 2 roll .growput
  342.     } ifelse
  343.   } ifelse
  344. } bind def
  345.  
  346. % Add original font to cache to prevent adjustfont to accumulate changes.
  347. /pdfaddcachedfont {   % <font_name> pdfaddcachedfont <font>
  348.   dup findfont dup                   % name font font
  349.   dup gcheck { //.pdforigfontcache_g } {.pdforigfontcache_l} ifelse
  350.   4 2 roll                           % font d name font
  351.   put                                % font
  352. } bind def
  353.  
  354. /.remove_font_name_prefix {  % <name>  .remove_font_name_prefix <name>
  355.   dup .namestring (+) search {
  356.     true exch
  357.     { dup 65 lt exch 90 gt or {
  358.         pop false exit
  359.       } if
  360.     } forall
  361.     { pop exch pop cvn
  362.     } {
  363.       pop pop
  364.     } ifelse
  365.   } {
  366.     pop
  367.   } ifelse
  368. } bind def
  369.  
  370. % Find a font (except for embedded ones), and adjust its encoding if necessary.
  371. /.pdfdfndict mark
  372.   /defaultfontname /Helvetica
  373. .dicttomark readonly def
  374. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  375.         % If the font isn't available, synthesize one based on
  376.         % its descriptor.
  377.   dup /Font resourcestatus {
  378.     pop pop pdffindcachedfont
  379.   } {
  380.     1 index /FontDescriptor knownoget {
  381.         % Stack: font-res fontname fontdesc
  382.       dup /Flags oget
  383.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  384.       1 index 16#40000 and -17 bitshift add    % 2, bold
  385.       exch 16#2 and 2 bitshift add    % 8, serif
  386.         % We should look at the fixed flag, too.
  387.         % Stack: font-res fontname fontdesc properties
  388.  
  389.                 % Even though /FontName is a required key in FontDescriptor dict
  390.                 % (As of the PDF 1.4 Reference Manual), In the case of missing 
  391.                 % /FontName key, we substitue /BaseFont for the value of /FontName.
  392.                 % Yet another case of broken PDF's that Adobe Reader accepts.
  393.       1 index dup /FontName known {
  394.         /FontName oget
  395.       } {
  396.         (   **** FontDescriptor missing required /FontName key. BaseFont name used.\n)
  397.         pdfformaterror
  398.         pop 2 index        % grab the BaseFont from the stack.
  399.       } ifelse
  400.       .remove_font_name_prefix
  401.       exch
  402.         % Analyzes font name and extract "Narrow" property
  403.         % which is not described by the FontDescriptor Flags.
  404.       0 2 index .fontnameproperties 4 and or
  405.         % Rebind the default font name to Helvetica so that
  406.         % fonts with no properties are handled correctly.
  407.       //.pdfdfndict begin .substitutefontname end
  408.         % Stack: font-res fontname fontdesc substname|null
  409.       Fontmap 1 index known not {
  410.         % No available good substitution, use the standard one.
  411.     pop 1 index .substitutefont
  412.       } if
  413.       dup 3 index ne QUIET not and {
  414.     (Substituting font ) print dup =only
  415.     ( for ) print 2 index =only (.) = flush
  416.       } if
  417.       pdffindcachedfont
  418.         % Stack: font-res fontname fontdesc font
  419.         % If this is a small-caps font, replace the CharString
  420.         % entries for a..z.
  421.       exch /Flags oget 16#20000 and 0 ne {
  422.     true .copyfontdict
  423.     dup /CharStrings 2 copy get dup length dict .copydict
  424.     % stack: font-res fontname font font /CharStrings CharStringsdict
  425.     5 index /FirstChar get 97 .max
  426.     6 index /LastChar get 122 .min 1 exch {
  427.         % Stack: font-res fontname font' font' /CharStrings charstrings code
  428.         % Note that this only remaps a-z, not accented characters.
  429.       6 index /Widths oget 1 index 8 index /FirstChar get sub oget
  430.       1 string dup 0 5 -1 roll put
  431.         % Stack: font-res font' font' /CharStrings charstrings code
  432.         %   width (x)
  433.       2 index exch dup cvn exch
  434.       dup 0 2 copy get 32 sub put 4 -1 roll {
  435.             % Stack: operand (X) width
  436.         0 setcharwidth exch pop
  437.         currentfont /FontMatrix get matrix invertmatrix concat
  438.         0.7 dup scale 0 0 moveto show
  439.       } /exec cvx 4 packedarray cvx put
  440.     } for put
  441.       } if
  442.       dup /FontName get 2 index ne {
  443.         true .copyfontdict
  444.         2 copy exch /FontName exch put
  445.       } if
  446.       definefont
  447.     } {
  448.         % No descriptor available, use the default algorithm.
  449.       pdffindcachedfont
  450.     } ifelse
  451.   } ifelse
  452.   exch pop
  453. } bdef
  454.  
  455. % ---------------- Type 1 fonts ---------------- %
  456.  
  457. /buildType1        % <Type1-font-resource> buildType1 <font>
  458.  { dup /BaseFont get pdffindfont
  459.  } bdef
  460.  
  461. % The state dictionary for the embedded Type 1 font reading procedure
  462. % has the following keys and values:
  463. %    data - stream (filter)
  464. %    buffer, buffer2 - string
  465. %    hexify - procedure to convert buffer to hex if needed
  466. %    leftstr - string containing (non-negative) integer
  467. %    sectionstr - string containing a character 0 .. 3
  468. %    stream - (stream) dictionary
  469. %    proc - procedure of the form {-dict- type1read}
  470. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  471. % When the procedure is executing, this dictionary is current.
  472. % leftstr and sectionstr are strings so that we can change their values
  473. % reliably in case the font executes a restore!
  474. % We also have to do something special about embedded fonts that
  475. % execute definefont more than once -- that is the function of topFontDict.
  476.  
  477. % Read an embedded Type 1 font.
  478. /readfontfilter {    % <proc> readfontfilter <filter>
  479.   0 () /SubFileDecode filter
  480. } bdef
  481. /readtype1dict 5 dict dup begin
  482.   /definefont {
  483.     dup topFontDict eq topFontDict null eq or {
  484.       dup wcheck not { dup length dict copy } if
  485.       exch pop savedFontName exch
  486.     } if
  487.     //systemdict /definefont get exec
  488.   } bdef
  489.   /eexec {
  490.     % Assume the font dictionary is directly below the file on the stack
  491.     count 0 gt { /topFontDict 2 index cvlit store } if
  492.     //.eexec_param_dict /eexecDecode filter
  493.     //systemdict begin readtype1dictcopy begin cvx stopped
  494.     currentdict readtype1dictcopy eq { end } if
  495.     currentdict //systemdict eq { end } if
  496.      { stop } if
  497.   } bdef
  498.  
  499.   /undef_proc_warning {
  500.     (   **** Embedded font uses undefined procedure ) pdfformaterror
  501.         .namestring pdfformaterror (\n) pdfformaterror
  502.   } bdef
  503.  
  504.   /-| { string currentfile exch readstring pop /-| undef_proc_warning } executeonly bdef
  505.   /RD { string currentfile exch readstring pop /RD undef_proc_warning } executeonly bdef
  506.   /|- { noaccess def /|- undef_proc_warning } executeonly bdef
  507.   /ND { noaccess def /ND undef_proc_warning } executeonly bdef
  508.   /|  { noaccess put /|  undef_proc_warning } executeonly bdef
  509.   /NP { noaccess put /NP undef_proc_warning } executeonly bdef
  510.  
  511. end readonly def
  512. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  513.         % Read the definition, using a procedure-based filter
  514.         % that turns binary/hex conversion on and off
  515.         % at the right times.
  516.    1 index exch
  517.    PDFfile fileposition 3 1 roll
  518.    11 dict begin
  519.      /leftstr (          ) 10 string copy def
  520.        dup /Length1 oget leftstr cvs pop
  521.      /sectionstr <00> 1 string copy def
  522.      /pfbhdr <00> 1 string copy def
  523.      /stream 1 index def
  524.      true resolvestream /data exch def
  525.      /buffer 1000 string def        % arbitrary
  526.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  527.      /hexify /buf2hex load def
  528.    currentdict end
  529.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  530.    readfontfilter
  531.         % Some buggy embedded fonts leave extra junk on the stack,
  532.         % so we have to make a closure that records the stack depth
  533.         % in a fail-safe way. Also restore dictstack depth.
  534.    //systemdict begin
  535.         % The PDF specification is somewhat muddy about whether
  536.         % an embedded font's name is supposed to be the BaseFont
  537.         % from the Font object or the FontName from the descriptor.
  538.         % Acrobat Distiller requires the former.  Save away the
  539.         % name so we can substitute it at definefont time.
  540.    //readtype1dict dup length 3 add dict copy begin
  541.    1 index /BaseFont oget /savedFontName exch def
  542.    /topFontDict null def
  543.    /readtype1dictcopy currentdict def
  544.     { run } aload pop count 1 sub 2 packedarray cvx exec
  545.     % clean up the dictstack
  546.     { currentdict /topFontDict known not { end } { end end exit } ifelse } loop
  547.    count exch sub { pop } repeat
  548.    PDFfile 3 -1 roll setfileposition
  549.    /BaseFont oget pdfaddcachedfont
  550.    exch pop
  551.  } bdef
  552.  
  553. % Execute the appropriate reading procedure.
  554. /type1read        % <dict> type1read <string>
  555.  { begin leftstr cvi
  556.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  557.    (          ) leftstr copy cvs pop end
  558.  } bdef
  559.  
  560. % Read the next block of data into the buffer.
  561. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  562.  { 0 2 index 2 index length .min getinterval
  563.         % Adobe requires readstring to signal an error if given
  564.         % an empty string.  Work around this nonsense here.
  565.    dup length 0 ne { data exch readstring pop } if
  566.    dup length 3 -1 roll exch sub
  567.    PDFDEBUG
  568.     { dup =only ( read ) print
  569.       1 index length =only (: ) print
  570.       1 index == flush
  571.     } if
  572.  } bdef
  573.  
  574. % Read the initial byte to see if we need to skip a 6 byte PFB header
  575. /type1read0 {         % <left> type1read0 <string> <left'>
  576.   sectionstr 0 1 put    % either way we go to the next stage
  577.   pfbhdr type1readdata
  578.   1 index 0 get 16#80 eq {
  579.     (   **** Warning: Embedded Type1 font in PFB format is not valid PDF.\n)
  580.     pdfformaterror
  581.     PDFDEBUG { (skipping PFB header) = flush } if
  582.     exch pop buffer 0 5 getinterval type1readdata exch
  583.     dup 4 get 256 mul 1 index 3 get add 256 mul
  584.     1 index 2 get add 256 mul 1 index 1 get add
  585.     PDFDEBUG { (PFB segment length = ) print dup = } if
  586.     exch pop  % discard the string keeping the PFB segment length
  587.     2 copy ne {
  588.       (   **** Warning: Type 1 PFB segment length and Length 1 value do not match.\n)
  589.       pdfformaterror
  590.       exch     % keep the PFB length instead
  591.     } if
  592.     pop
  593.     buffer type1readdata    % go ahead and read a block
  594.   }
  595.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  596. } bdef
  597.  
  598. % Read the next block of the initial text portion.
  599. /type1read1 {        % <left> type1read1 <string> <left'>
  600.   PDFDEBUG { (read1 ) print } if
  601.   dup 0 eq {
  602.     pop sectionstr 0 2 put
  603.     stream /Length2 oget
  604.             % Determine whether to hexify data for eexec.
  605.     dup 8 lt {
  606.       type1read2    % Hexify.
  607.     } {
  608.       PDFDEBUG { (read2 ) print } if
  609.       pfbhdr 0 get 16#80 eq {
  610.         % eat 6 more bytes of PFB junk before proceeding
  611.     PDFDEBUG { (skipping PFB header in segment 2) = flush } if
  612.     buffer 0 6 getinterval type1readdata exch
  613.         dup 5 get 256 mul 1 index 4 get add 256 mul
  614.     1 index 3 get add 256 mul 1 index 2 get add
  615.         PDFDEBUG { (PFB segment length = ) print dup = } if
  616.     exch pop  % discard the string keeping the PFB segment length
  617.     2 copy ne {
  618.           (   **** Warning: Type 1 PFB segment length and Length 2 value do not match.\n)
  619.           pdfformaterror
  620.       exch         % keep the PFB length instead
  621.     } if
  622.       pop
  623.       } if
  624.       buffer2 type1readdata exch
  625.             % The check doesn't have to be 100% accurate:
  626.             % hexifying is always OK.
  627.       dup 0 8 getinterval 0 exch { or } forall
  628.       128 ge {
  629.     /hexify { } store
  630.     /buffer2 buffer def    % We don't need an intermediate buffer.
  631.       } if hexify exch
  632.     } ifelse
  633.   } {
  634.     buffer type1readdata
  635.   } ifelse
  636. } bdef
  637.  
  638. % Convert a string from binary to hex for eexec.
  639. % Free variables: buffer.
  640. /buf2hex {        % <string> buf2hex <hexstring>
  641.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  642.   buffer (>) search pop exch pop exch pop
  643. } bdef
  644.  
  645. % Read the next block of the encrypted portion.
  646. /type1trailer
  647. (0000000000000000000000000000000000000000000000000000000000000000\n\
  648. 0000000000000000000000000000000000000000000000000000000000000000\n\
  649. 0000000000000000000000000000000000000000000000000000000000000000\n\
  650. 0000000000000000000000000000000000000000000000000000000000000000\n\
  651. 0000000000000000000000000000000000000000000000000000000000000000\n\
  652. 0000000000000000000000000000000000000000000000000000000000000000\n\
  653. 0000000000000000000000000000000000000000000000000000000000000000\n\
  654. 0000000000000000000000000000000000000000000000000000000000000000\n\
  655. cleartomark\n)
  656. readonly def
  657. /type1read2 {        % <left> type1read2 <string> <left'>
  658.   PDFDEBUG { (read2 ) print } if
  659.    dup 0 eq
  660.     { pop sectionstr 0 3 put
  661.       stream /Length3 oget
  662.       dup 0 eq
  663.        { PDFDEBUG { (trailer ) print } if
  664.      type1trailer exch
  665.        }
  666.        { 
  667.          pfbhdr 0 get 16#80 eq {
  668.            % eat 6 more bytes of PFB junk before proceeding
  669.        PDFDEBUG { (skipping PFB header in segment 3) = flush } if
  670.        buffer 0 6 getinterval type1readdata exch
  671.            dup 5 get 256 mul 1 index 4 get add 256 mul
  672.        1 index 3 get add 256 mul 1 index 2 get add
  673.            PDFDEBUG { (PFB segment length = ) print dup = } if
  674.        exch pop  % discard the string keeping the PFB segment length
  675.        2 copy ne {
  676.            (   **** Warning: Type 1 PFB segment length and Length 3 value do not match.\n)
  677.            pdfformaterror
  678.          exch     % keep the PFB length instead
  679.        } if
  680.        pop
  681.          } if
  682.          type1read3
  683.        }
  684.       ifelse
  685.     }
  686.     { buffer2 type1readdata exch hexify exch
  687.     }
  688.    ifelse
  689. } bdef
  690.  
  691. % Read the next block of the final text portion.
  692. % When finished, this procedure returns an empty string.
  693. /type1read3        % <left> type1read3 <string> <left'>
  694.  { PDFDEBUG { (read3 ) print } if
  695.    buffer type1readdata
  696.  } bdef
  697.  
  698. % ---------------- Type 3 fonts ---------------- %
  699.  
  700. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  701.   8 dict begin
  702.     /FontType 3 def
  703.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  704.     /FontBBox 1 index /FontBBox get cvx def
  705.     /FontMatrix 1 index /FontMatrix oget def
  706.     /CharProcs 1 index /CharProcs oget def
  707.     1 index /Widths knownoget {
  708.       /Widths exch def
  709.       /FirstChar 1 index /FirstChar oget def
  710.       /LastChar 1 index /LastChar oget def
  711.     } if
  712.     /FontName 1 index /Name .knownget not { 
  713.        PDFfile fileposition 16 10 string cvrs cvn
  714.     } if def
  715.  
  716.     /Encoding .notdefEncoding 2 index getencoding def
  717.         % We have to define BuildChar rather than BuildGlyph:
  718.         % there is no PDF equivalent of glyphshow, and we need
  719.         % the character code to access the Widths.
  720.     /BuildChar {
  721.         % Stack: font charcode
  722.       1 index begin 3 dict begin
  723.       /Font 3 -1 roll def /CharCode 1 index def
  724.       % Make unknown characters map to /.notdef
  725.       Encoding exch get dup CharProcs exch known
  726.         { CharProcs exch oget }
  727.     { pop CharProcs /.notdef oget }
  728.       ifelse
  729.       PDFfile fileposition exch
  730.       false resolvestream
  731.         % Stack: filepos stream
  732.         % Don't let setgcolor set the color inside the BuildGlyph
  733.         % procedure, because this causes an /undefined error.
  734.       q null /FillColor gput null /StrokeColor gput
  735.       Font /Resources get exch pdfopdict .pdfruncontext
  736.       Q
  737.       PDFfile exch setfileposition
  738.       end end
  739.     } bdef
  740.     FontName currentdict end definefont exch pop
  741. } bdef
  742. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  743.   /Widths where {
  744.     begin
  745.     CharCode FirstChar ge CharCode LastChar le and {
  746.       exch pop Widths CharCode FirstChar sub get exch
  747.     } if end
  748.   } if
  749. } bdef
  750.  
  751. % ---------------- TrueType fonts ---------------- %
  752.  
  753. /TTfonts mark
  754.   /Arial /Helvetica
  755.   /Arial,Italic /Helvetica-Oblique
  756.   /Arial,Bold /Helvetica-Bold
  757.   /Arial,BoldItalic /Helvetica-BoldOblique
  758.   /CourierNew /Courier
  759.   /CourierNew,Bold /Courier-Bold
  760.   /TimesNewRoman /Times-Roman
  761.   /TimesNewRoman,Italic /Times-Italic
  762.   /TimesNewRoman,Bold /Times-Bold
  763.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  764. .dicttomark readonly def
  765.  
  766. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  767.   dup /BaseFont oget
  768.   (   **** Warning: Fonts with Subtype = /TrueType should be embedded.\n) pdfformaterror
  769.   (                 But ) pdfformaterror dup =string cvs pdfformaterror ( is not embedded.\n) pdfformaterror
  770.   dup TTfonts exch .knownget {
  771.     QUIET not {
  772.       (Substituting font ) print dup =only
  773.       ( for ) print 1 index =only (.) = flush
  774.     } if
  775.     exch 3 1 roll pdffindfont
  776.     true .copyfontdict
  777.     2 copy exch /FontName exch put
  778.     definefont
  779.   } {
  780.     pdffindfont
  781.   } ifelse
  782. } bdef
  783.  
  784. % Read an embedded TrueType font.
  785. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  786.         % This is much simpler than readtype1, because we don't
  787.         % have to deal with the tripartite .PFB format.
  788.   1 index exch
  789.   PDFfile fileposition 3 1 roll
  790.   true resolvestream readfontfilter
  791.         % Stack: filepos fontres stream
  792.   1 index /Subtype get /CIDFontType2 eq {
  793.     .loadttcidfont
  794.         % Stack: filepos fontres cidfont
  795.   } {
  796.                                   % filepos fontres stream
  797.     1 index /FontDescriptor oget          % filepos fontres stream fd   
  798.     /Flags get 4 and 0 ne                 % filepos fontres stream is_symbolic
  799.     dup {
  800.       2 index null exch getencoding       % filepos fontres stream is_symbolic Encoding
  801.       dup 4 index exch                    % filepos fontres stream is_symbolic Encoding fontres Encoding
  802.       /prebuilt_encoding exch put         % filepos fontres stream is_symbolic Encoding
  803.     } {
  804.       null
  805.     } ifelse
  806.     .loadpdfttfont
  807.   } ifelse
  808.   exch pop
  809.   PDFfile 3 -1 roll setfileposition
  810.         % Ignore both the Encoding and the Widths.
  811.   exch pop
  812. } bdef
  813.  
  814. % ---------------- Type 0 fonts ---------------- %
  815.  
  816. % Predefine the known CMaps, but only create them on demand.
  817. /knownCMaps mark
  818.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  819.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  820. .dicttomark def
  821.  
  822. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  823.   .currentglobal true .setglobal 3 1 roll
  824.   /CIDInit /ProcSet findresource begin
  825.   12 dict begin
  826.     begincmap
  827.     /WMode exch def
  828.     /CMapName exch def
  829.     /CIDSystemInfo 3 dict dup begin
  830.       /Registry (Adobe) def
  831.       /Ordering (Identity) def
  832.       /Supplement 0 def
  833.     end def
  834.     %/CMapName (see above)
  835.     /CMapVersion 1 def
  836.     /CMapType 1 def
  837.     %WMode (see above)
  838.     % The PDF documentation says that these CMaps map CIDs
  839.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  840.     1 begincodespacerange
  841.     % <0001> <00ff>  <0100> <ffff>
  842.       <0000> <ffff>
  843.     endcodespacerange
  844.     1 begincidrange
  845.     % <0001> <00ff> 1   <0100> <ffff> 256
  846.       <0000> <ffff> 0
  847.     endcidrange
  848.     endcmap
  849.     CMapName currentdict /CMap defineresource
  850.     knownCMaps CMapName 2 index put
  851.   end        % CMap
  852.   end        % CIDInit ProcSet
  853.   exch .setglobal
  854. } bdef
  855.  
  856. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  857.   dup /BaseFont get    % FontName
  858.   1 index /Encoding oget
  859.   dup type /nametype eq {
  860.     dup /CMap resourcestatus {
  861.     pop pop /CMap findresource
  862.     } {
  863.     knownCMaps 1 index .knownget
  864.       { exch pop exec } { /undefined signalerror } ifelse
  865.     } ifelse
  866.   } {
  867.     PDFfile fileposition exch
  868.     dup /CMapName get exch true resolvestream cvx exec
  869.     /CMap findresource
  870.     exch PDFfile exch setfileposition
  871.   } ifelse        % CMap
  872.   [
  873.     3 index /DescendantFonts oget { exec resourcefont } forall
  874.   ]            % subfonts
  875.   composefont
  876.         % Stack: fontres font
  877.   1 index /FontMatrix knownoget {
  878.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  879.       1 index exch makefont exch /FontName get exch definefont
  880.     } {
  881.       pop
  882.     } ifelse
  883.   } if exch pop
  884. } bdef
  885.  
  886. % ---------------- CIDFontType0/2 fonts ---------------- %
  887.  
  888. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  889. % arrays and using a (currently very inefficient) CDevProc.
  890. % For detail, refer "PDF Reference" 2nd ed., p314 "5.6.3 CIDFonts".
  891. % It notes default DW is 0, but Acrobat Reader uses 1000 as default.
  892. % If DW is 0, currentpoint does not move by default in rendering text
  893. % horizontally, the result is unreadable. You can check it by Acrobat.
  894.  
  895. /.pdfDefaultDW  1000 def
  896. /.pdfDefaultDW2 [ 880 -1000 ] def
  897.  
  898. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  899.   dup length 5 add dict .copydict
  900.   dup /FID undef
  901.   dup /UniqueID undef
  902.   dup /XUID undef
  903.     % Insert the widths into the font.
  904.  
  905.         % Stack: pdfresource newfont
  906.  
  907.   1 index /DW .knownget {
  908.     1 index /DW 3 -1 roll put
  909.   } {
  910.     dup /DW .pdfDefaultDW put
  911.   } ifelse
  912.  
  913.   1 index /W .knownget {
  914.     dup 2 index /W 3 -1 roll put
  915.     .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
  916.   } if
  917.  
  918.   1 index /DW2 .knownget {
  919.     1 index /DW2 3 -1 roll put
  920.   } {
  921.     dup /DW2 .pdfDefaultDW2 put
  922.   } ifelse
  923.  
  924.   1 index /W2 .knownget {
  925.     dup 2 index /W2 3 -1 roll put
  926.     .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
  927.   } if
  928.  
  929.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  930.   exch pop
  931. } bdef
  932.  
  933. /.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
  934.  
  935.   % convert /W or /W2 to internal expression
  936.   %
  937.   %   mtx_array: original /W or /W2 array
  938.   %   item_size: number of metrics values per CID
  939.   %
  940.   %   for detail of the metrics list format in PDF,
  941.   %   refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
  942.   % 
  943.   %   format of single entry in internal expression
  944.   %
  945.   %     [
  946.   %       [cid_begin cid_end]
  947.   %       value_is_varied (bool)
  948.   %       [ [values for cid_begin...]
  949.   %         [values for cid_begin + 1]
  950.   %         ... ]
  951.   %     ]
  952.   %
  953.  
  954.   7 dict
  955.   begin
  956.     /itemSize exch def
  957.     /M exch def            % original /W or /W2
  958.     /Msize M length def
  959.     /Mi { M i get } def        % W[i]
  960.     /Mi1 { M i 1 add get } def    % W[i + 1]
  961.     /putMTXEntry <<
  962.       /arraytype   {
  963.          [
  964.            [Mi Mi Mi1 length itemSize idiv add 1 sub]
  965.            true
  966.            [
  967.              0 itemSize Mi1 length 1 sub {
  968.                [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
  969.              } for
  970.            ]
  971.          ]
  972.          /i i 2 add def
  973.       }
  974.       /integertype {
  975.          [
  976.            [Mi Mi1]
  977.            false
  978.            [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
  979.          ]
  980.          /i i 3 add def
  981.       }
  982.     >> def
  983.  
  984.     /i 0 def
  985.  
  986.     [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
  987.   end
  988. } def
  989.  
  990. /.pdfMakeInternalW  { dup length 0 gt { 1 .pdfMakeInternalMTXArray } if } def
  991. /.pdfMakeInternalW2 { dup length 0 gt { 3 .pdfMakeInternalMTXArray } if } def
  992.  
  993. /.pdfGetMTXByCID { % <internalMTXArray> <cid>
  994.                    %     .pdfGetMTXByCID
  995.                    %         { <MTXEntry> true | false }
  996.  
  997.   % get values for given CID from internal format of /W or /W2
  998.  
  999.   exch
  1000.   {
  1001.     {
  1002.       dup 0 get {} forall      % Stack: <cid> <entry> <cid_0> <cid_1>
  1003.       3 index lt { pop pop false exit } if
  1004.       2 index exch sub dup 0 lt { pop pop false exit } if
  1005.       1 index 1 get not { pop 0 } if
  1006.       exch 2 get exch get true exit
  1007.     } loop
  1008.     { exit } if
  1009.   } forall
  1010.   dup type /arraytype eq { exch pop true } { pop false } ifelse
  1011. } def
  1012.  
  1013.  
  1014. % Apply the [D]W[2] metrics to a character before displaying.
  1015. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  1016.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  1017.             %   <w0x'> ... <vy'>
  1018.   begin % push <font> to currentdict
  1019.     % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
  1020.     5 1 roll pop pop pop pop
  1021.  
  1022.     {
  1023.       currentdict /DW .knownget not {   % no DW
  1024.         .pdfDefaultDW exit              % replace <w0x> by defaultDW
  1025.       } if
  1026.  
  1027.       currentdict /.internalW .knownget not {    % no W
  1028.         exit                            % use already-stacked DW
  1029.       } if
  1030.  
  1031.       dup length 0 eq {                 % W is null array
  1032.         pop                             % discard unusable W
  1033.         exit                            % use already-stacked DW
  1034.       } if
  1035.  
  1036.       % W is finite array, try to get W_cid
  1037.       2 index .pdfGetMTXByCID {           % got W, discard DW
  1038.         exch pop {} forall
  1039.         exit
  1040.       } if
  1041.  
  1042.       exit
  1043.     } loop
  1044.  
  1045.     FontType 11 eq {
  1046.       1000 div                  % <w0x'> (normalized W)
  1047.     } if
  1048.     0                           % <w0y'>
  1049.  
  1050.     % Stack: <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
  1051.     9 -2 roll pop pop           % discard <w0x> <w0y>
  1052.     7  2 roll                   % put <w0x'> <w0y'>
  1053.  
  1054.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
  1055.     0                           % <w1x'>
  1056.     exch                        % put <w1x'>
  1057.  
  1058.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
  1059.     {
  1060.       currentdict /DW2 .knownget not {  % no DW2, use defaultDW2
  1061.         .pdfDefaultDW2 exit
  1062.       } if
  1063.  
  1064.       currentdict /.internalW2 .knownget not {   % has DW2, no W2
  1065.         exit                            % use already-stacked DW2
  1066.       } if
  1067.  
  1068.       dup length 0 eq {                 % W2 is null array
  1069.         pop                             % discard unusable W2
  1070.         exit                            % use already-stacked DW2
  1071.       } if
  1072.  
  1073.       2 index .pdfGetMTXByCID {        % got W2_cid, discard DW2
  1074.         exch pop
  1075.         exit
  1076.       } if
  1077.  
  1078.       % could not get W2_cid
  1079.       exit
  1080.  
  1081.     } loop
  1082.  
  1083.     exch pop                            % discard <cid>
  1084.  
  1085.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
  1086.     dup length 2 eq {                   % this is DW2
  1087.       FontType 11 eq {{1000 div}} {{}} ifelse forall exch
  1088.       8 index 2 div                     % <vx'> = <w0x'> / 2
  1089.       exch
  1090.     }{                                  % assume W2
  1091.       FontType 11 eq {{1000 div}} {{}} ifelse forall
  1092.     } ifelse
  1093.   end                                   % recover currentdict
  1094.  
  1095. } def
  1096.  
  1097. % <string> <match> tailmatch ==> <pre> true
  1098. %                            ==> <string> false
  1099. /tailmatch {
  1100.   2 copy length 1 index length .min
  1101.   dup 2 index length exch sub exch getinterval
  1102.   1 index eq {
  1103.     length 1 index length exch sub
  1104.     0 exch getinterval true
  1105.   } {
  1106.     pop false
  1107.   } ifelse
  1108. } bind def
  1109.  
  1110. /makeboldfont {
  1111.   16 dict begin
  1112.     /strokewidth exch def
  1113.     /basecidfont exch def
  1114.     /FontMatrix [ 1 0 0 1 0 0 ] def
  1115.  
  1116.     /CIDFontName /.boldfont def
  1117.     /CIDFontType 1 def
  1118.  
  1119.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  1120.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  1121.  
  1122.     /CIDSystemInfo dup basecidfont exch get def
  1123.     /FontBBox [ basecidfont /FontBBox get cvx exec
  1124.       4 2 roll basecidfont /FontMatrix get transform
  1125.       4 2 roll basecidfont /FontMatrix get transform
  1126.     ] def
  1127.  
  1128.     /tmpstr 2 string def
  1129.     /BuildGlyph {
  1130.       gsave
  1131.       exch begin
  1132.         dup 256 idiv tmpstr exch 0 exch put
  1133.         256 mod tmpstr exch 1 exch put
  1134.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  1135.         { basefont-V } { basefont-H } ifelse setfont
  1136.         strokewidth setlinewidth
  1137.         1 setlinejoin
  1138.         newpath
  1139.         0 0 moveto tmpstr false charpath stroke
  1140.         0 0 moveto tmpstr show
  1141.         currentpoint setcharwidth
  1142.       end
  1143.       grestore
  1144.     } bind def
  1145.  
  1146.    currentdict
  1147.   end
  1148.   dup /CIDFontName get exch /CIDFont defineresource
  1149. } bind def
  1150.  
  1151. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  1152. %   CIDFont-resource is not modified.
  1153. /findCIDFont {
  1154.   {
  1155.     dup /CIDFont resourcestatus {
  1156.       pop pop /CIDFont findresource
  1157.       exit
  1158.     } if
  1159.     .remove_font_name_prefix
  1160.     dup dup length string cvs
  1161.     (,Bold) tailmatch {
  1162.       exch pop
  1163.       cvn findCIDFont 0.03 makeboldfont
  1164.       exit
  1165.     } if
  1166.     (,Italic) tailmatch {
  1167.       exch pop
  1168.       cvn findCIDFont
  1169.       [ 1 0 0.3 1 0 0 ] makefont
  1170.       exit
  1171.     } if
  1172.     (,BoldItalic) tailmatch {
  1173.       exch pop
  1174.       cvn findCIDFont 0.03 makeboldfont
  1175.       [ 1 0 0.3 1 0 0 ] makefont
  1176.       exit
  1177.     } if
  1178.     pop
  1179.  
  1180.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  1181.     concatstrings concatstrings
  1182.     cvn
  1183.     QUIET not {
  1184.       (Substituting CID font resource) print dup ==only
  1185.       ( for ) print 1 index ==only (.\n) print
  1186.     } if
  1187.     exch pop
  1188.     /CIDFont findresource
  1189.     exit
  1190.   } loop
  1191. } bdef
  1192.  
  1193. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  1194.   dup /BaseFont get findCIDFont exch pop
  1195. } bdef
  1196.  
  1197. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  1198.   dup /BaseFont get findCIDFont exch pop
  1199. } bdef
  1200.  
  1201. /processCIDToGIDMap { % <fontres> <cidfont> processCIDToGIDMap <fontres> <cidfont>
  1202.   1 index /CIDToGIDMap knownoget {
  1203.     PDFfile fileposition 4 1 roll
  1204.     dup /Identity eq {
  1205.       pop
  1206.     } {
  1207.       true resolvestream
  1208.         % Stack: filepos fontres font mapstream
  1209.     % Can't know the length of the decompressed stream, so allocate a big buffer...
  1210.       dup 65534 string readstring {
  1211.       % Length exceeded max string size, use an array of two strings
  1212.         1 index 65534 string readstring pop   % maybe a null string - not important.
  1213.         2 array astore
  1214.                     % Stack: filepos fontres font mapstream array
  1215.            dup 1 get length 65534 add
  1216.       } {
  1217.         dup length
  1218.         } ifelse
  1219.       2 idiv
  1220.         % Stack: filepos fontres font mapstream array/string CIDCount
  1221.       3 index exch /CIDCount exch put
  1222.       exch closefile exch
  1223.       dup /CIDMap 4 -1 roll put
  1224.     } ifelse
  1225.     3 2 roll PDFfile exch setfileposition
  1226.   } if
  1227. } bdef
  1228.  
  1229. % Adjust a CIDFontType0 DW[2] in the font resource.
  1230. /adjustCIDType0 {        % <font-resource> <font> adjustfont <font'>
  1231.   addCIDmetrics
  1232.   dup /CIDFontName get exch /CIDFont defineresource
  1233. } bind def
  1234.  
  1235. % Adjust a CIDFontType2 DW[2] and CIDToGIDMap in the font resource.
  1236. /adjustCIDType2 {        % <font-resource> <font> adjustfont <font'>
  1237.   addCIDmetrics
  1238.   processCIDToGIDMap
  1239.   dup /CIDFontName get exch /CIDFont defineresource
  1240. } bind def
  1241.  
  1242. % ---------------- Other embedded fonts ---------------- %
  1243.  
  1244. /fontloadprocs mark
  1245.   /Type1C /readType1C cvx
  1246.   /CIDFontType0C /readCIDFontType0C cvx
  1247. .dicttomark readonly def
  1248.  
  1249. % Read an embedded compressed font.
  1250. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  1251.   1 index exch
  1252.   PDFfile fileposition 3 1 roll
  1253.   dup true resolvestream dup readfontfilter
  1254.         % Stack: pos resource streamdict stream filter
  1255.   3 index /FontDescriptor oget /FontName oget
  1256.   1 index FRD
  1257.   closefile closefile pop
  1258.   PDFfile 3 -1 roll setfileposition
  1259.   /FontDescriptor oget /FontName oget pdfaddcachedfont
  1260.   exch pop
  1261. } bdef
  1262.  
  1263. % Read an embedded CFF CIDFont.
  1264. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  1265.   PDFfile fileposition 3 1 roll
  1266.   dup true resolvestream dup readfontfilter
  1267.         % Stack: pos resource streamdict stream filter
  1268.   3 index /FontDescriptor oget /FontName oget
  1269.   1 index FRD
  1270.   closefile closefile pop
  1271.   PDFfile 3 -1 roll setfileposition
  1272.         % Some broken Adobe software produces PDF files in which
  1273.         % the FontName of the CFF font and the FontName in the
  1274.         % FontDescriptor don't match the BaseFont in the font.
  1275.         % Use the FontName, rather than the BaseFont, here.
  1276.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  1277.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  1278. } bdef
  1279.  
  1280. % ---------------- Font lookup ---------------- %
  1281.  
  1282. /fonttypeprocs mark        % <font-resource> -proc- <font>
  1283.   /Type0 //buildType0
  1284.   /Type1 //buildType1
  1285.   /MMType1 //buildType1
  1286.   /Type3 //buildType3
  1287.   /TrueType //buildTrueType
  1288.   /CIDFontType0 //buildCIDType0
  1289.   /CIDFontType2 //buildCIDType2
  1290. .dicttomark readonly def
  1291.  
  1292. /adjustfonttypes mark
  1293.   /Type1 //adjustfont
  1294.   /MMType1 //adjustfont
  1295.   /TrueType //adjustfont
  1296.   /CIDFontType0 //adjustCIDType0
  1297.   /CIDFontType2 //adjustCIDType2
  1298. .dicttomark readonly def
  1299.  
  1300. /resourcefont            % <font-resource> resourcefont <font>
  1301. { dup /PSFont .knownget
  1302.   { /FID knownoget { type /fonttype eq } { //false } ifelse }
  1303.   { //false }
  1304.   ifelse
  1305.   { /PSFont get }
  1306.   { dup dup /FontDescriptor knownoget {    % Stack: font-res font-res font-desc
  1307.       dup /FontObject .knownget {
  1308.     3 1 roll pop pop
  1309.       } {
  1310.     dup /FontFile knownoget
  1311.     { dup /Length oget 0 eq
  1312.       { pop pop dup /Subtype get fonttypeprocs exch get exec }
  1313.       { exch pop readtype1 }
  1314.       ifelse
  1315.     }
  1316.     {
  1317.       dup /FontFile2 knownoget
  1318.       { exch pop readtruetype }
  1319.       { /FontFile3 knownoget
  1320.         { dup /Subtype get fontloadprocs exch get exec }
  1321.             { dup /Subtype get fonttypeprocs exch get exec }
  1322.         ifelse
  1323.       }
  1324.       ifelse
  1325.     }
  1326.     ifelse
  1327.     1 index /FontDescriptor oget
  1328.     1 index /FontObject exch put        % Save pointer to the font
  1329.       }
  1330.       ifelse
  1331.     }
  1332.     { dup /Subtype get fonttypeprocs exch dup () cvn eq {
  1333.         (   **** Warning: Font missing required Subtype, /Type1 assumed.\n)
  1334.         pdfformaterror
  1335.         pop /Type1
  1336.       } if get exec
  1337.     }
  1338.     ifelse
  1339.     % Stack: font-res font
  1340.     1 index 3 1 roll
  1341.     1 index /Subtype get
  1342.     //adjustfonttypes exch .knownget { exec } { exch pop } ifelse
  1343.     dup 3 1 roll /PSFont exch put
  1344.   }
  1345.   ifelse
  1346. } bdef
  1347.  
  1348. drawopdict begin
  1349.   /d0 {
  1350.     .adjustcharwidth setcharwidth
  1351.   } bdef
  1352.   /d1 {
  1353.     4 index 0 ne {
  1354.       % invalid wy parameter for d1 in Type3 font (must be 0)
  1355.       % Even though the PDF 1.4 specification states that this must be 0,
  1356.       % Distiller sometimes creates Type3 fonts with non-zero wy. We set
  1357.       % it to 0 since this is apparently what Acrobat Reader 4 and 5 do,
  1358.       % but if the specification is ever changed to allow non-zero wy, this
  1359.       % will not work.
  1360.       5 -1 roll pop 0 5 1 roll      % set wy to 0
  1361.     } if
  1362.  
  1363.     2 copy                           % ... llx lly urx ury | urx ury 
  1364.     0 ne exch 0 ne                   % ... llx lly urx ury | ury!=0 urx!=0
  1365.     3 index 6 index eq and           % ... llx lly urx ury | ury!=0 (urx!=0 && llx==urx)
  1366.     exch 2 index 5 index eq and or { % ... llx lly urx ury | (urx!=0 && llx==urx) || (ury!=0 && lly==ury)
  1367.       % The bounding box is empty and likely incorrect. Don't cache.
  1368.       pop pop pop pop .adjustcharwidth setcharwidth
  1369.     } {
  1370.       6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  1371.     } ifelse
  1372.   } bdef
  1373.   /Tf {
  1374.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  1375.     resourcefont exch Tf pop
  1376.   } bdef
  1377. end
  1378.  
  1379. end            % pdfdict
  1380. end            % GS_PDF_ProcSet
  1381. .setglobal
  1382.