home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 October / Chip_2002-10_cd1.bin / zkuste / pdf / download / gs704w32.exe / gs7.04 / lib / pdf_font.ps < prev    next >
Encoding:
Text File  |  2002-01-31  |  30.7 KB  |  958 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of AFPL Ghostscript.
  4. % 
  5. % AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6. % distributor accepts any responsibility for the consequences of using it, or
  7. % for whether it serves any particular purpose or works at all, unless he or
  8. % she says so in writing.  Refer to the Aladdin Free Public License (the
  9. % "License") for full details.
  10. % 
  11. % Every copy of AFPL Ghostscript must include a copy of the License, normally
  12. % in a plain ASCII text file named PUBLIC.  The License grants you the right
  13. % to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14. % conditions described in the License.  Among other things, the License
  15. % requires that the copyright notice and this notice be preserved on all
  16. % copies.
  17.  
  18. % $Id: pdf_font.ps,v 1.23 2001/10/19 16:42:47 masata-y Exp $
  19. % pdf_font.ps
  20. % PDF font operations.
  21.  
  22. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  23. .currentglobal true .setglobal
  24. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  25. GS_PDF_ProcSet begin
  26. pdfdict begin
  27.  
  28. % We cache the PostScript font in an additional element of the
  29. % font resource dictionary, called PSFont.
  30.  
  31. % ---------------- Encodings ---------------- %
  32.  
  33. % Apply a list of differences to an Encoding.
  34. % Note that the differences may cause the array to grow.
  35. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  36.     % Calculate the length of the result.
  37.   exch 0 2 index {
  38.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  39.   } forall
  40.   1 index length .max array dup 0 4 -1 roll putinterval
  41.   exch 0 exch {
  42.         % Stack: enc' code element
  43.     dup type /nametype ne
  44.       { exch pop }
  45.       { 3 copy put pop 1 add }
  46.     ifelse
  47.   } forall pop
  48. } bdef
  49.  
  50. % Get the Encoding for a font.
  51. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  52.  { /Encoding knownoget
  53.     { dup type /nametype eq
  54.        { 
  55.          % The published PDF specification says the Encoding name
  56.          % "must be" one of the 3 predefined Encodings, implying
  57.          % that an error should occur if it isn't.  However, Acrobat
  58.          % Reader simply ignores unknown names, and since there are
  59.          % some buggy applications that rely on this, we do the same.
  60.  
  61.          dup dup dup /MacRomanEncoding eq
  62.          exch /MacExpertEncoding eq or 
  63.          exch /WinAnsiEncoding eq or
  64.            { exch pop findencoding
  65.            }
  66.            { pop
  67.            }
  68.          ifelse
  69.        }
  70.        { dup /BaseEncoding knownoget
  71.       { findencoding 3 -1 roll pop exch
  72.       }
  73.      if
  74.      /Differences knownoget { updateencoding } if
  75.        }
  76.       ifelse
  77.     }
  78.    if
  79.  } bdef
  80.  
  81. % Rename a font with a generated name.
  82. /renamefont {        % <fontdict> renamefont <font'>
  83.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  84. } bind def
  85.  
  86. % Adjust a font according to the Encoding and Widths in the font resource.
  87. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  88.   getfontencoding
  89.   getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  90. } bind def
  91.  
  92. % Get the (possibly modified) encoding of a font.
  93. /getfontencoding {    % <font-resource> <font> getfontencoding
  94.             %   <font-resource> <font> <Encoding|null>
  95.   1 index /Encoding known {
  96.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  97.   } {
  98.     null
  99.   } ifelse
  100. } bdef
  101.  
  102. /find_in_diff     % <Differences> <index> find_in_diff <bool>
  103. { false exch 0 4 3 roll
  104.   { dup type /nametype ne { exch pop } { pop 1 add } ifelse
  105.     2 copy eq {
  106.       pop pop pop true 0 0 exit
  107.     } if
  108.   } forall
  109.   pop pop
  110. } bdef
  111.  
  112. % Get the metrics of a font, if specified.
  113. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  114.             %   <font-resource> <font> <Encoding|null>
  115.             %   <Metrics|null>
  116.   2 index /Widths known {
  117.     dup null eq { pop dup /Encoding get } if
  118.     4 dict begin
  119.       /Encoding exch def
  120.       /Metrics Encoding length dict def
  121.       exch
  122.       dup /Widths oget /Widths exch def
  123.         % Stack: font font-res
  124.         % Note that widths are always based on a 1000-unit
  125.         % character space, but the FontMatrix may specify
  126.         % some other scale factor.  Compensate for this here,
  127.         % by scaling the Widths if necessary.
  128.       0.001 2 index /FontMatrix get 0 get div
  129.         % Stack: font font-res mscale
  130.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  131.        {    % Stack: font font-res mscale first-char index
  132.      Encoding 1 index get
  133.      Widths 2 index 4 index sub oget
  134.          % Stack: font font-res mscale first-char index charname width
  135.      4 index mul
  136.         % The following 'loop' is only context for 'exit'.
  137.      {    
  138.         % Work around a bug in pdfTeX, which can generate Encoding
  139.         % vectors containing nulls :
  140.        1 index null eq { exit } if
  141.         % There is a hack here to deal with encodings where the
  142.         % same character appears more than once, because the Metrics
  143.         % dictionary works by character name, not by character code.
  144.         % We prefer to take (1) non-zero width, and (2) width for 
  145.         % the character code which appears in Differences.
  146.        Metrics 2 index .knownget not { 0 } if 0 ne {
  147.          5 index /Encoding knownoget not { exit } if
  148.          dup type /dicttype ne { pop exit } if
  149.          /Differences knownoget not { exit } if
  150.          3 index //find_in_diff exec not { exit } if
  151.        } if
  152.        2 copy Metrics 3 1 roll put
  153.        exit
  154.      } loop
  155.      pop pop pop
  156.        }
  157.       for pop
  158.         % Now fill in the MissingWidth for any encoded characters
  159.         % that aren't in Metrics already.  Note that built-in
  160.         % fonts may have Widths/FirstChar/LastChar but no
  161.         % FontDescriptor, so we must check for this.
  162.         % Stack: font font-res mscale
  163.       1 index /FontDescriptor knownoget {
  164.     Metrics exch
  165.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  166.     Encoding {
  167.         % Stack: font font-res mscale missing-width metrics charname
  168.         % Work around the abovementioned pdfTeX bug.
  169.       dup null ne {
  170.         2 copy known not { 2 copy 4 index put } if pop
  171.       } {
  172.         pop
  173.       } ifelse
  174.     } forall pop pop pop
  175.       } {
  176.     pop
  177.       } ifelse
  178.     exch Encoding Metrics end
  179.   } {
  180.     null
  181.   } ifelse
  182. } bdef
  183.  
  184. currentdict /find_in_diff undef
  185.  
  186. % ---------------- Descriptors ---------------- %
  187.  
  188. % Partial descriptors for the 14 built-in fonts.  Note that
  189. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  190. % object has undergone a subtle change in its meaning which has serious
  191. % consequences for searching with Acrobat:
  192. % In PDF 1.1, the flag meant: Font has StandardEncoding
  193. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  194. /standardfontdescriptors mark
  195.   /Courier mark /Flags 16#23 .dicttomark
  196.   /Courier-Oblique 1 index
  197.   /Courier-Bold 1 index
  198.   /Courier-BoldOblique 1 index
  199.   /Helvetica mark /Flags 16#20 .dicttomark
  200.   /Helvetica-Oblique 1 index
  201.   /Helvetica-Bold 1 index
  202.   /Helvetica-BoldOblique 1 index
  203.   /Times-Roman mark /Flags 16#22 .dicttomark
  204.   /Times-Bold 1 index
  205.   /Times-Italic mark /Flags 16#62 .dicttomark
  206.   /Times-BoldItalic 1 index
  207.   /Symbol mark /Flags 16#4 .dicttomark
  208.   /ZapfDingbats 1 index
  209. .dicttomark readonly def
  210.  
  211. % ---------------- Utilities ---------------- %
  212.  
  213. % Fabricate a font name by adding ?'s on the end.
  214. /genfontname        % <name> genfontname <name>
  215.  { dup length string cvs
  216.     { (?) concatstrings
  217.       dup cvn FontDirectory exch known not { cvn exit } if
  218.     }
  219.    loop
  220.  } bdef
  221.  
  222. % Find a font, and adjust its encoding if necessary.
  223. /.pdfdfndict mark
  224.   /defaultfontname /Helvetica
  225. .dicttomark readonly def
  226. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  227.         % If the font isn't available, synthesize one based on
  228.         % its descriptor.
  229.   dup /Font resourcestatus {
  230.     pop pop findfont
  231.   } {
  232.     1 index /FontDescriptor knownoget {
  233.         % Stack: font-res fontname fontdesc
  234.       dup /Flags oget
  235.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  236.       1 index 16#40000 and -17 bitshift add    % 2, bold
  237.       exch 16#2 and 2 bitshift add    % 8, serif
  238.         % We should look at the fixed flag, too.
  239.         % Stack: font-res fontname fontdesc properties
  240.       1 index /FontName oget exch
  241.         % Analyzes font name and extract "Narrow" property
  242.         % which is not described by the FontDescriptor Flags.
  243.       0 2 index .fontnameproperties 4 and or
  244.         % Rebind the default font name to Helvetica so that
  245.         % fonts with no properties are handled correctly.
  246.       //.pdfdfndict begin .substitutefontname end
  247.         % Stack: font-res fontname fontdesc substname|null
  248.       Fontmap 1 index known not {
  249.         % No available good substitution, use the standard one.
  250.     pop 1 index .substitutefont
  251.       } if
  252.       QUIET not {
  253.     (Substituting font ) print dup =only
  254.     ( for ) print 2 index =only (.) = flush
  255.       } if
  256.       3 -1 roll pop findfont
  257.         % Stack: font-res fontdesc font
  258.         % If this is a small-caps font, replace the CharString
  259.         % entries for a..z.
  260.       exch /Flags oget 16#20000 and 0 ne {
  261.     true .copyfontdict
  262.     dup /CharStrings 2 copy get dup length dict .copydict
  263.     4 index /FirstChar get 97 .max
  264.     5 index /LastChar get 122 .min 1 exch {
  265.         % Stack: font-res font' font' /CharStrings charstrings code
  266.         % Note that this only remaps a-z, not accented characters.
  267.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  268.       1 string dup 0 5 -1 roll put
  269.         % Stack: font-res font' font' /CharStrings charstrings code
  270.         %   width (x)
  271.       2 index exch dup cvn exch
  272.       dup 0 2 copy get 32 sub put 4 -1 roll {
  273.             % Stack: operand (X) width
  274.         0 setcharwidth exch pop
  275.         currentfont /FontMatrix get matrix invertmatrix concat
  276.         0.7 dup scale 0 0 moveto show
  277.       } /exec cvx 4 packedarray cvx put
  278.     } for put
  279.     renamefont
  280.       } if
  281.     } {
  282.         % No descriptor available, use the default algorithm.
  283.       findfont
  284.     } ifelse
  285.   } ifelse adjustfont
  286. } bdef
  287.  
  288. % ---------------- Type 1 fonts ---------------- %
  289.  
  290. /buildType1        % <Type1-font-resource> buildType1 <font>
  291.  { dup /BaseFont get pdffindfont
  292.  } bdef
  293.  
  294. % The state dictionary for the embedded Type 1 font reading procedure
  295. % has the following keys and values:
  296. %    data - stream (filter)
  297. %    buffer, buffer2 - string
  298. %    hexify - procedure to convert buffer to hex if needed
  299. %    leftstr - string containing (non-negative) integer
  300. %    sectionstr - string containing a character 0 .. 3
  301. %    stream - (stream) dictionary
  302. %    proc - procedure of the form {-dict- type1read}
  303. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  304. % When the procedure is executing, this dictionary is current.
  305. % leftstr and sectionstr are strings so that we can change their values
  306. % reliably in case the font executes a restore!
  307. % We also have to do something special about embedded fonts that
  308. % execute definefont more than once -- that is the function of topFontDict.
  309.  
  310. % Read an embedded Type 1 font.
  311. /readfontfilter {    % <proc> readfontfilter <filter>
  312.   0 () /SubFileDecode filter
  313. } bdef
  314. /readtype1dict 5 dict dup begin
  315.   /definefont {
  316.     dup topFontDict eq topFontDict null eq or {
  317.       dup wcheck not { dup length dict copy } if
  318.       exch pop savedFontName exch
  319.     } if
  320.     //systemdict /definefont get exec
  321.   } bdef
  322.   /eexec {
  323.     % Assume the font dictionary is directly below the file on the stack
  324.     count 0 gt { /topFontDict 2 index cvlit store } if
  325.     55665 /eexecDecode filter
  326.     //systemdict begin readtype1dictcopy begin cvx stopped
  327.     currentdict readtype1dictcopy eq { end } if
  328.     currentdict //systemdict eq { end } if
  329.      { stop } if
  330.   } bdef
  331. end readonly def
  332. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  333.         % Read the definition, using a procedure-based filter
  334.         % that turns binary/hex conversion on and off
  335.         % at the right times.
  336.    1 index exch
  337.    PDFfile fileposition 3 1 roll
  338.    11 dict begin
  339.      /leftstr (          ) 10 string copy def
  340.        dup /Length1 oget leftstr cvs pop
  341.      /sectionstr <00> 1 string copy def
  342.      /pfbhdr <00> 1 string copy def
  343.      /stream 1 index def
  344.      true resolvestream /data exch def
  345.      /buffer 1000 string def        % arbitrary
  346.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  347.      /hexify /buf2hex load def
  348.    currentdict end
  349.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  350.    readfontfilter
  351.         % Some buggy embedded fonts leave extra junk on the stack,
  352.         % so we have to make a closure that records the stack depth
  353.         % in a fail-safe way.
  354.    //systemdict begin
  355.         % The PDF specification is somewhat muddy about whether
  356.         % an embedded font's name is supposed to be the BaseFont
  357.         % from the Font object or the FontName from the descriptor.
  358.         % Acrobat Distiller requires the former.  Save away the
  359.         % name so we can substitute it at definefont time.
  360.    //readtype1dict dup length 3 add dict copy begin
  361.    1 index /BaseFont oget /savedFontName exch def
  362.    /topFontDict null def
  363.    /readtype1dictcopy currentdict def
  364.     { run } aload pop count 1 sub 2 packedarray cvx exec
  365.    end end
  366.    count exch sub { pop } repeat
  367.    PDFfile 3 -1 roll setfileposition
  368.    /BaseFont oget findfont
  369.    adjustfont
  370.  } bdef
  371.  
  372. % Execute the appropriate reading procedure.
  373. /type1read        % <dict> type1read <string>
  374.  { begin leftstr cvi
  375.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  376.    (          ) leftstr copy cvs pop end
  377.  } bdef
  378.  
  379. % Read the next block of data into the buffer.
  380. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  381.  { 0 2 index 2 index length min getinterval
  382.         % Adobe requires readstring to signal an error if given
  383.         % an empty string.  Work around this nonsense here.
  384.    dup length 0 ne { data exch readstring pop } if
  385.    dup length 3 -1 roll exch sub
  386.    DEBUG
  387.     { dup =only ( read ) print
  388.       1 index length =only (: ) print
  389.       1 index == flush
  390.     } if
  391.  } bdef
  392.  
  393. % Read the initial byte to see if we need to skip a 6 byte PFB header
  394. /type1read0 {         % <left> type1read0 <string> <left'>
  395.   sectionstr 0 1 put    % either way we go to the next stage
  396.   pfbhdr type1readdata
  397.   1 index 0 get 16#80 eq {
  398.     (\n   **** Warning: Embedded Type1 font in PFB format is not valid PDF.)
  399.     pdfformaterror
  400.     DEBUG { (skipping PFB header) = flush } if
  401.     exch pop buffer 0 5 getinterval type1readdata exch
  402.     dup 4 get 256 mul 1 index 3 get add 256 mul
  403.     1 index 2 get add 256 mul 1 index 1 get add
  404.     DEBUG { (PFB segment length = ) print dup = } if
  405.     exch pop  % discard the string keeping the PFB segment length
  406.     2 copy ne {
  407.       (\n   **** Warning: Type 1 PFB segment length and Length 1 value do not match.)
  408.       pdfformaterror
  409.       exch     % keep the PFB length instead
  410.     } if
  411.     pop
  412.     buffer type1readdata    % go ahead and read a block
  413.   }
  414.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  415. } bdef
  416.  
  417. % Read the next block of the initial text portion.
  418. /type1read1 {        % <left> type1read1 <string> <left'>
  419.   DEBUG { (read1 ) print } if
  420.   dup 0 eq {
  421.     pop sectionstr 0 2 put
  422.     stream /Length2 oget
  423.             % Determine whether to hexify data for eexec.
  424.     dup 8 lt {
  425.       type1read2    % Hexify.
  426.     } {
  427.       DEBUG { (read2 ) print } if
  428.       pfbhdr 0 get 16#80 eq {
  429.         % eat 6 more bytes of PFB junk before proceeding
  430.     DEBUG { (skipping PFB header in segment 2) = flush } if
  431.     buffer 0 6 getinterval type1readdata exch
  432.         dup 5 get 256 mul 1 index 4 get add 256 mul
  433.     1 index 3 get add 256 mul 1 index 2 get add
  434.         DEBUG { (PFB segment length = ) print dup = } if
  435.     exch pop  % discard the string keeping the PFB segment length
  436.     2 copy ne {
  437.           (\n   **** Warning: Type 1 PFB segment length and Length 2 value do not match.)
  438.           pdfformaterror
  439.       dup =
  440.       exch         % keep the PFB length instead
  441.     } if
  442.       pop
  443.       } if
  444.       buffer2 type1readdata exch
  445.             % The check doesn't have to be 100% accurate:
  446.             % hexifying is always OK.
  447.       dup 0 8 getinterval 0 exch { or } forall
  448.       128 ge {
  449.     /hexify { } store
  450.     /buffer2 buffer def    % We don't need an intermediate buffer.
  451.       } if hexify exch
  452.     } ifelse
  453.   } {
  454.     buffer type1readdata
  455.   } ifelse
  456. } bdef
  457.  
  458. % Convert a string from binary to hex for eexec.
  459. % Free variables: buffer.
  460. /buf2hex {        % <string> buf2hex <hexstring>
  461.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  462.   buffer (>) search pop exch pop exch pop
  463. } bdef
  464.  
  465. % Read the next block of the encrypted portion.
  466. /type1trailer
  467. (0000000000000000000000000000000000000000000000000000000000000000\n\
  468. 0000000000000000000000000000000000000000000000000000000000000000\n\
  469. 0000000000000000000000000000000000000000000000000000000000000000\n\
  470. 0000000000000000000000000000000000000000000000000000000000000000\n\
  471. 0000000000000000000000000000000000000000000000000000000000000000\n\
  472. 0000000000000000000000000000000000000000000000000000000000000000\n\
  473. 0000000000000000000000000000000000000000000000000000000000000000\n\
  474. 0000000000000000000000000000000000000000000000000000000000000000\n\
  475. cleartomark\n)
  476. readonly def
  477. /type1read2 {        % <left> type1read2 <string> <left'>
  478.   DEBUG { (read2 ) print } if
  479.    dup 0 eq
  480.     { pop sectionstr 0 3 put
  481.       stream /Length3 oget
  482.       dup 0 eq
  483.        { DEBUG { (trailer ) print } if
  484.      type1trailer exch
  485.        }
  486.        { 
  487.          pfbhdr 0 get 16#80 eq {
  488.            % eat 6 more bytes of PFB junk before proceeding
  489.        DEBUG { (skipping PFB header in segment 3) = flush } if
  490.        buffer 0 6 getinterval type1readdata exch
  491.            dup 5 get 256 mul 1 index 4 get add 256 mul
  492.        1 index 3 get add 256 mul 1 index 2 get add
  493.            DEBUG { (PFB segment length = ) print dup = } if
  494.        exch pop  % discard the string keeping the PFB segment length
  495.        2 copy ne {
  496.            (\n   **** Warning: Type 1 PFB segment length and Length 3 value do not match.)
  497.            pdfformaterror
  498.          exch     % keep the PFB length instead
  499.        } if
  500.        pop
  501.        (\n) pdfformaterror
  502.          } if
  503.          type1read3
  504.        }
  505.       ifelse
  506.     }
  507.     { buffer2 type1readdata exch hexify exch
  508.     }
  509.    ifelse
  510. } bdef
  511.  
  512. % Read the next block of the final text portion.
  513. % When finished, this procedure returns an empty string.
  514. /type1read3        % <left> type1read3 <string> <left'>
  515.  { DEBUG { (read3 ) print } if
  516.    buffer type1readdata
  517.  } bdef
  518.  
  519. % ---------------- Type 3 fonts ---------------- %
  520.  
  521. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  522.  
  523. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  524.   8 dict begin
  525.     /FontType 3 def
  526.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  527.     /FontBBox 1 index /FontBBox get cvx def
  528.     /FontMatrix 1 index /FontMatrix oget def
  529.     /CharProcs 1 index /CharProcs oget def
  530.     1 index /Widths knownoget {
  531.       /Widths exch def
  532.       /FirstChar 1 index /FirstChar oget def
  533.       /LastChar 1 index /LastChar oget def
  534.     } if
  535.     /FontName 1 index /Name get genfontname def
  536.     /Encoding .notdefEncoding 2 index getencoding def
  537.         % We have to define BuildChar rather than BuildGlyph:
  538.         % there is no PDF equivalent of glyphshow, and we need
  539.         % the character code to access the Widths.
  540.     /BuildChar {
  541.         % Stack: font charcode
  542.       1 index begin 3 dict begin
  543.       /Font 3 -1 roll def /CharCode 1 index def
  544.       % Make unknown characters map to /.notdef
  545.       Encoding exch get dup CharProcs exch known
  546.         { CharProcs exch oget }
  547.     { pop CharProcs /.notdef oget }
  548.       ifelse
  549.       PDFfile fileposition exch
  550.       false resolvestream
  551.         % Stack: filepos stream
  552.         % Don't let setgcolor set the color inside the BuildGlyph
  553.         % procedure, because this causes an /undefined error.
  554.       q null /FillColor gput null /StrokeColor gput
  555.       Font /Resources get exch pdfopdict .pdfruncontext
  556.       Q
  557.       PDFfile exch setfileposition
  558.       end end
  559.     } bdef
  560.     FontName currentdict end definefont exch pop
  561. } bdef
  562. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  563.   /Widths where {
  564.     begin
  565.     CharCode FirstChar ge CharCode LastChar le and {
  566.       exch pop Widths CharCode FirstChar sub get exch
  567.     } if end
  568.   } if
  569. } bdef
  570.  
  571. % ---------------- TrueType fonts ---------------- %
  572.  
  573. /TTfonts mark
  574.   /Arial /Helvetica
  575.   /Arial,Italic /Helvetica-Oblique
  576.   /Arial,Bold /Helvetica-Bold
  577.   /Arial,BoldItalic /Helvetica-BoldOblique
  578.   /CourierNew /Courier
  579.   /CourierNew,Bold /Courier-Bold
  580.   /TimesNewRoman /Times-Roman
  581.   /TimesNewRoman,Italic /Times-Italic
  582.   /TimesNewRoman,Bold /Times-Bold
  583.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  584. .dicttomark readonly def
  585.  
  586. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  587.   dup /BaseFont get
  588.   dup TTfonts exch .knownget {
  589.     exch pop
  590.         % Hack required by the PDF specification: if the
  591.         % font resource has Subtype = /TrueType but the actual
  592.         % (installed) font is not a TrueType font, ignore the
  593.         % Encoding in the font resource.  However, all current
  594.         % versions of Acrobat Reader have the 14 base TrueType
  595.         % fonts built in, so this produces incorrect output for
  596.         % badly designed PDF files that specify these file names
  597.         % with /Subtype = /TrueType but no embedded definition.
  598.         % Compensate for this by removing the /Subtype key when
  599.         % looking up the font.
  600.     exch dup length dict copy dup /Subtype null put exch
  601.   } if pdffindfont
  602. } bdef
  603.  
  604. % Read an embedded TrueType font.
  605. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  606.         % This is much simpler than readtype1, because we don't
  607.         % have to deal with the tripartite .PFB format.
  608.   1 index exch
  609.   PDFfile fileposition 3 1 roll
  610.   true resolvestream readfontfilter
  611.         % Stack: filepos fontres stream
  612.   1 index /Subtype get /CIDFontType2 eq {
  613.     .loadttcidfont
  614.         % Stack: filepos fontres cidfont
  615.     1 index /CIDToGIDMap knownoget {
  616.       dup /Identity eq {
  617.     pop
  618.       } {
  619.     true resolvestream
  620.         % The following doesn't work for CIDToGIDMaps with more
  621.         % than 32K-1 entries.  We'll fix it later if necessary.
  622.         % Stack: filepos fontres font mapstream
  623.     dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
  624.     exch dup length 5 add dict .copydict
  625.     dup /FID undef
  626.     dup /CIDMap 4 -1 roll put
  627.     dup /CIDFontName get exch /CIDFont defineresource
  628.       } ifelse
  629.     } if
  630.   } {
  631.     null 2 index getencoding .loadpdfttfont
  632.   } ifelse
  633.   exch pop
  634.   PDFfile 3 -1 roll setfileposition
  635.         % Ignore both the Encoding and the Widths.
  636.   exch pop
  637. } bdef
  638.  
  639. % ---------------- Type 0 fonts ---------------- %
  640.  
  641. % Predefine the known CMaps, but only create them on demand.
  642. /knownCMaps mark
  643.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  644.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  645. .dicttomark def
  646.  
  647. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  648.   .currentglobal true .setglobal 3 1 roll
  649.   /CIDInit /ProcSet findresource begin
  650.   12 dict begin
  651.     begincmap
  652.     /WMode exch def
  653.     /CMapName exch def
  654.     /CIDSystemInfo 3 dict dup begin
  655.       /Registry (Adobe) def
  656.       /Ordering (Identity) def
  657.       /Supplement 0 def
  658.     end def
  659.     %/CMapName (see above)
  660.     /CMapVersion 1 def
  661.     /CMapType 1 def
  662.     %WMode (see above)
  663.     % The PDF documentation says that these CMaps map CIDs
  664.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  665.     1 begincodespacerange
  666.     % <0001> <00ff>  <0100> <ffff>
  667.       <0000> <ffff>
  668.     endcodespacerange
  669.     1 begincidrange
  670.     % <0001> <00ff> 1   <0100> <ffff> 256
  671.       <0000> <ffff> 0
  672.     endcidrange
  673.     endcmap
  674.     CMapName currentdict /CMap defineresource
  675.     knownCMaps CMapName 2 index put
  676.   end        % CMap
  677.   end        % CIDInit ProcSet
  678.   exch .setglobal
  679. } bdef
  680.  
  681. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  682.   dup /BaseFont get    % FontName
  683.   1 index /Encoding oget
  684.   dup type /nametype eq {
  685.     dup /CMap resourcestatus {
  686.     pop pop /CMap findresource
  687.     } {
  688.     knownCMaps 1 index .knownget
  689.       { exch pop exec } { /undefined signalerror } ifelse
  690.     } ifelse
  691.   } {
  692.     PDFfile fileposition exch
  693.     dup /CMapName get exch true resolvestream cvx exec
  694.     /CMap findresource
  695.     exch PDFfile exch setfileposition
  696.   } ifelse        % CMap
  697.   [
  698.     3 index /DescendantFonts oget { exec resourcefont } forall
  699.   ]            % subfonts
  700.   composefont
  701.         % Stack: fontres font
  702.   1 index /FontMatrix knownoget {
  703.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  704.       1 index exch makefont exch /FontName get exch definefont
  705.     } {
  706.       pop
  707.     } ifelse
  708.   } if exch pop
  709. } bdef
  710.  
  711. % ---------------- CIDFontType0/2 fonts ---------------- %
  712.  
  713. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  714. % arrays and using a (currently very inefficient) CDevProc.
  715. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  716.   dup length 5 add dict .copydict
  717.   dup /FID undef
  718.   dup /UniqueID undef
  719.   dup /XUID undef
  720.     % Insert the widths into the font.
  721.   {W W2 DW DW2} {
  722.     % Stack: pdfresource newfont key
  723.     2 index 1 index .knownget {
  724.       2 index 3 1 roll put
  725.     } {
  726.       pop
  727.     } ifelse
  728.   } forall
  729.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  730.   exch pop
  731. } bdef
  732.  
  733. % Apply the [D]W[2] metrics to a character before displaying.
  734. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  735.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  736.             %   <w0x'> ... <vy'>
  737.   begin
  738.     % Look up and apply [D]W
  739.   10 index
  740.   currentdict /DW .knownget { 1000 div exch pop } if
  741.   currentdict /W .knownget {
  742.     % Search the W array for the CID.
  743.     % ****** NOT IMPLEMENTED YET ******
  744.     pop
  745.   } if
  746.   0 13 2 roll 11 -2 roll pop pop
  747.     % Look up and apply [D]W2
  748.     % ****** NOT IMPLEMENTED YET ******
  749.   pop end
  750. } bdef
  751. % <string> <match> tailmatch ==> <pre> true
  752. %                            ==> <string> false
  753. /tailmatch {
  754.   2 copy length 1 index length min
  755.   dup 2 index length exch sub exch getinterval
  756.   1 index eq {
  757.     length 1 index length exch sub
  758.     0 exch getinterval true
  759.   } {
  760.     pop false
  761.   } ifelse
  762. } bind def
  763.  
  764. /makeboldfont {
  765.   16 dict begin
  766.     /strokewidth exch def
  767.     /basecidfont exch def
  768.     /FontMatrix [ 1 0 0 1 0 0 ] def
  769.  
  770.     /CIDFontName /.boldfont def
  771.     /CIDFontType 1 def
  772.  
  773.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  774.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  775.  
  776.     /CIDSystemInfo dup basecidfont exch get def
  777.     /FontBBox [ basecidfont /FontBBox get cvx exec
  778.       4 2 roll basecidfont /FontMatrix get transform
  779.       4 2 roll basecidfont /FontMatrix get transform
  780.     ] def
  781.  
  782.     /tmpstr 2 string def
  783.     /BuildGlyph {
  784.       gsave
  785.       exch begin
  786.         dup 256 idiv tmpstr exch 0 exch put
  787.         256 mod tmpstr exch 1 exch put
  788.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  789.         { basefont-V } { basefont-H } ifelse setfont
  790.         strokewidth setlinewidth
  791.         1 setlinejoin
  792.         newpath
  793.         0 0 moveto tmpstr false charpath stroke
  794.         0 0 moveto tmpstr show
  795.         currentpoint setcharwidth
  796.       end
  797.       grestore
  798.     } bind def
  799.  
  800.    currentdict
  801.   end
  802.   dup /CIDFontName get exch /CIDFont defineresource
  803. } bind def
  804.  
  805. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  806. %   CIDFont-resource is not modified.
  807. /findCIDFont {
  808.   {
  809.     dup /CIDFont resourcestatus {
  810.       pop pop /CIDFont findresource
  811.       exit
  812.     } if
  813.  
  814.     dup dup length string cvs
  815.     (,Bold) tailmatch {
  816.       exch pop
  817.       cvn findCIDFont 0.03 makeboldfont
  818.       exit
  819.     } if
  820.     (,Italic) tailmatch {
  821.       exch pop
  822.       cvn findCIDFont
  823.       [ 1 0 0.3 1 0 0 ] makefont
  824.       exit
  825.     } if
  826.     (,BoldItalic) tailmatch {
  827.       exch pop
  828.       cvn findCIDFont 0.03 makeboldfont
  829.       [ 1 0 0.3 1 0 0 ] makefont
  830.       exit
  831.     } if
  832.     pop
  833.  
  834.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  835.     concatstrings concatstrings
  836.     cvn
  837.     QUIET not {
  838.       (Substituting ) print dup ==only
  839.       ( for ) print 1 index ==only (.\n) print
  840.     } if
  841.     exch pop
  842.     /CIDFont findresource
  843.     exit
  844.   } loop
  845. } bdef
  846.  
  847. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  848.   dup /BaseFont get exch 1 index findCIDFont
  849.   addCIDmetrics /CIDFont defineresource
  850. } bdef
  851.  
  852. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  853.   dup /BaseFont get exch 1 index findCIDFont
  854.   addCIDmetrics /CIDFont defineresource
  855. } bdef
  856.  
  857. % ---------------- Other embedded fonts ---------------- %
  858.  
  859. /fontloadprocs mark
  860.   /Type1C /readType1C cvx
  861.   /CIDFontType0C /readCIDFontType0C cvx
  862. .dicttomark readonly def
  863.  
  864. % Read an embedded compressed font.
  865. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  866.   1 index exch
  867.   PDFfile fileposition 3 1 roll
  868.   dup true resolvestream dup readfontfilter
  869.         % Stack: pos resource streamdict stream filter
  870.   3 index /FontDescriptor oget /FontName oget
  871.   1 index FRD
  872.   closefile closefile pop
  873.   PDFfile 3 -1 roll setfileposition
  874.   /FontDescriptor oget /FontName oget findfont
  875.   adjustfont
  876. } bdef
  877.  
  878. % Read an embedded CFF CIDFont.
  879. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  880.   PDFfile fileposition 3 1 roll
  881.   dup true resolvestream dup readfontfilter
  882.         % Stack: pos resource streamdict stream filter
  883.   3 index /FontDescriptor oget /FontName oget
  884.   1 index FRD
  885.   closefile closefile pop
  886.   PDFfile 3 -1 roll setfileposition
  887.         % Some broken Adobe software produces PDF files in which
  888.         % the FontName of the CFF font and the FontName in the
  889.         % FontDescriptor don't match the BaseFont in the font.
  890.         % Use the FontName, rather than the BaseFont, here.
  891.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  892.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  893. } bdef
  894.  
  895. % ---------------- Font lookup ---------------- %
  896.  
  897. /fonttypeprocs mark        % <font-resource> -proc- <font>
  898.   /Type0 /buildType0 cvx
  899.   /Type1 /buildType1 cvx
  900.   /MMType1 1 index
  901.   /Type3 /buildType3 cvx
  902.   /TrueType /buildTrueType cvx
  903.   /CIDFontType0 /buildCIDType0 cvx
  904.   /CIDFontType2 /buildCIDType2 cvx
  905. .dicttomark readonly def
  906.  
  907. /resourcefont            % <font-resource> resourcefont <font>
  908.  { dup /PSFont .knownget
  909.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  910.     { false }
  911.    ifelse
  912.     { /PSFont get
  913.     }
  914.     { dup dup /FontDescriptor knownoget
  915.        {    % Stack: font-res font-res font-desc
  916.      dup /FontFile knownoget
  917.       { exch pop readtype1 true }
  918.       { dup /FontFile2 knownoget
  919.          { exch pop readtruetype true }
  920.          { /FontFile3 knownoget
  921.         { dup /Subtype get fontloadprocs exch get exec true }
  922.         { false }
  923.            ifelse
  924.          }
  925.         ifelse
  926.       }
  927.      ifelse
  928.        }
  929.        { false }
  930.       ifelse
  931.         % Stack: font-res font-res false
  932.         %  -or-: font-res font true
  933.       not
  934.        { dup /Subtype get fonttypeprocs exch get exec }
  935.       if
  936.       2 copy /PSFont exch put
  937.       exch pop
  938.     }
  939.    ifelse
  940.  } bdef
  941.  
  942. drawopdict begin
  943.   /d0 {
  944.     .adjustcharwidth setcharwidth
  945.   } bdef
  946.   /d1 {
  947.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  948.   } bdef
  949.   /Tf {
  950.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  951.     resourcefont exch Tf pop
  952.   } bdef
  953. end
  954.  
  955. end            % pdfdict
  956. end            % GS_PDF_ProcSet
  957. .setglobal
  958.