home *** CD-ROM | disk | FTP | other *** search
/ jppd.dyndns.org / jppd.dyndns.org.tar / jppd.dyndns.org / QUERYPRO / Impressora_PDF / converter.exe / GPLGS / gs_ttf.ps < prev    next >
Text File  |  2004-08-05  |  43KB  |  1,343 lines
  1. %    Copyright (C) 1996-2003 artofcode LLC.  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: gs_ttf.ps,v 1.28.2.5 2004/08/04 15:20:10 ray Exp $
  17. % Support code for direct use of TrueType fonts.
  18. % (Not needed for Type 42 fonts.)
  19.  
  20. % Note that if you want to use this file without including the ttfont.dev
  21. % option when you built Ghostscript, you will need to load the following
  22. % files before this one:
  23. %    lib/gs_mgl_e.ps
  24. %    lib/gs_mro_e.ps
  25. %    lib/gs_wan_e.ps
  26.  
  27. % Thanks to B. Jackowski and GUST (the Polish TeX Users' Group) for
  28. % the glyf-splitting code.
  29.  
  30. % ---------------- Font loading machinery ---------------- %
  31.  
  32. % Augment the FONTPATH machinery so it recognizes TrueType fonts.
  33.  
  34. /.scanfontheaders where {
  35.   pop /.scanfontheaders [
  36.    .scanfontheaders aload pop (\000\001\000\000*) (true*)
  37.   ] def
  38. } if
  39.  
  40. % <file> <key> .findfontvalue <value> true
  41. % <file> <key> .findfontvalue false
  42. % Closes the file in either case.
  43. /.findnonttfontvalue /.findfontvalue load def
  44. /.findfontvalue {
  45.   1 index read {
  46.     2 index 1 index unread
  47.     dup 0 eq exch (t) 0 get eq or {
  48.         % If this is a font at all, it's a TrueType font.
  49.       dup /FontType eq {
  50.         pop closefile 42 true
  51.       } {
  52.         dup /FontName eq { pop .findttfontname } { pop closefile false } ifelse
  53.       } ifelse
  54.     } {
  55.         % Not a TrueType font.
  56.       .findnonttfontvalue
  57.     } ifelse
  58.   } { pop closefile false } ifelse
  59. } bind def
  60.  
  61. % <file> .findttfontname <fname> true
  62. % <file> .findttfontname false
  63. % Closes the file in either case.
  64. /.findttfontname {
  65.   //true 0 .loadttfonttables
  66.   tabdict /name .knownget {
  67.     dup 8 getu32 f exch setfileposition
  68.     12 getu32 string f exch readstring pop
  69.     6 findname
  70.   } {
  71.     false
  72.   } ifelse
  73.   f closefile end end
  74. } bind def
  75.  
  76. % Load a font file that might be a TrueType font.
  77.  
  78. % <file> .loadfontfile -
  79. /.loadnonttfontfile /.loadfontfile load def
  80. /.loadfontfile {
  81.   dup read pop 2 copy unread 0 eq {
  82.         % If this is a font at all, it's a TrueType font.
  83.     .loadttfont pop
  84.   } {
  85.         % Not a TrueType font.
  86.     .loadnonttfontfile
  87.   } ifelse
  88. } bind def
  89.  
  90. % ---------------- Automatic Type 42 generation ---------------- %
  91.  
  92. % Load a TrueType font from a file as a Type 42 PostScript font.
  93. % The thing that makes this really messy is the handling of encodings.
  94. % There are 2 interacting tables that affect the encoding:
  95. %       'cmap' provides multiple maps from character codes to glyph indices
  96. %       'post' maps glyph indices to glyph names (if present)
  97. % What we need to get out of this is:
  98. %       Encoding mapping character codes to glyph names
  99. %         (the composition of cmap and post)
  100. %       CharStrings mapping glyph names to glyph indices
  101. %         (the inverse of post)
  102. % If the post table is missing, we have to take a guess based on the cmap
  103. % table.
  104.  
  105. /.loadttfontdict 50 dict dup begin
  106.  
  107. /orgXUID AladdinEnterprisesXUID def
  108. /maxstring 32764 def    % half the maximum length of a PostScript string,
  109.             % must be a multiple of 4 (for hmtx / loca / vmtx)
  110.  
  111. /.invert_encoding   % <array> invert_encoding <dict>
  112. { dup 256 dict exch
  113.   0 exch 1 exch length 1 sub {     % [] <> i
  114.     dup 3 index exch get           % [] <> i v
  115.     dup /.notdef ne {
  116.       exch 2 index 2 index .knownget {
  117.         dup type /arraytype eq {
  118.       [ exch aload pop counttomark 2 add -1 roll ]
  119.         } {
  120.       exch 2 array astore
  121.         } ifelse
  122.       } if 2 index 3 1 roll put
  123.     } {
  124.       pop pop
  125.     } ifelse
  126.   } for
  127.   exch pop
  128. } bind def
  129.  
  130. % Define the Macintosh standard mapping from characters to glyph indices.
  131. /MacRomanEncoding dup .findencoding def
  132. /MacGlyphEncoding dup .findencoding def
  133.  
  134. % Invert the MacRomanEncoding.
  135. /.romanmacdict MacRomanEncoding .invert_encoding def
  136.  
  137. % Define remapping for misnamed glyphs in TrueType 'post' tables.
  138. % There are probably a lot more than this!
  139. /postremap mark
  140.   /Cdot /Cdotaccent
  141.   /Edot /Edotaccent
  142.   /Eoverdot /Edotaccent
  143.   /Gdot /Gdotaccent
  144.   /Ldot /Ldotaccent
  145.   /Zdot /Zdotaccent
  146.   /cdot /cdotaccent 
  147.   /edot /edotaccent 
  148.   /eoverdot /edotaccent
  149.   /gdot /gdotaccent 
  150.   /ldot /ldotaccent
  151.   /zdot /zdotaccent 
  152. .dicttomark readonly def
  153.  
  154. % Array used for fast pre-filling of cmap array
  155. /.array1024z [ 1024 { 0 } repeat ] def
  156.  
  157. % ---- Utilities ---- %
  158.  
  159. % Define a serial number for creating unique XUIDs for TrueType fonts.
  160. % We used to use the checkSumAdjustment value from the font, but this is
  161. % not reliable, since some fonts don't set it correctly.
  162. % Note that we must do this in a string to make it immune to save/restore.
  163. /xuidstring <80000000> def
  164. /curxuid {        % - curxuid <int>
  165.   0 xuidstring { exch 8 bitshift exch add } forall
  166. } bind def
  167. /nextxuid {        % - nextxuid -
  168.   3 -1 0 {
  169.     xuidstring 1 index 2 copy get dup 255 ne {
  170.       1 add put pop exit
  171.     } if pop 0 put pop
  172.   } for
  173. } bind def
  174.  
  175. % <string> <index> getu16 <integer>
  176. /getu16 {
  177.   2 copy get 8 bitshift 3 1 roll 1 add get add
  178. } bind def
  179.  
  180. % <string> <index> gets16 <integer>
  181. /gets16 {
  182.   getu16 16#8000 xor 16#8000 sub
  183. } bind def
  184.  
  185. % <string> <index> getu32 <integer>
  186. /getu32 {
  187.   2 copy getu16 16 bitshift 3 1 roll 2 add getu16 add
  188. } bind def
  189.  
  190. % <string> <index> gets32 <integer>
  191. /gets32 {
  192.   2 copy gets16 16 bitshift 3 1 roll 2 add getu16 add
  193. } bind def
  194.  
  195. 16#ffffffff 0 gt {  % 64-bit sign extension
  196.   { /curxuid /gets32 } {
  197.     mark 1 index load aload pop { 16#80000000 xor 16#80000000 sub } aload pop
  198.     .packtomark cvx def
  199.   } bind forall
  200. } if
  201.  
  202. % <string> <index> <integer> putu16 -
  203. /putu16 {
  204.   3 copy -8 bitshift put
  205.   exch 1 add exch 16#ff and put
  206. } bind def
  207.  
  208. % <string> <index> <integer> putu32 -
  209. /putu32 {
  210.   3 copy -16 bitshift putu16
  211.   exch 2 add exch 16#ffff and putu16
  212. } bind def
  213.  
  214. % <nametable> <nameid> findname <string> true
  215. % <nametable> <nameid> findname false
  216. /findname {
  217.   TTFDEBUG { (findname: ) print dup =only  } if
  218.   false 3 1 roll 0 1 3 index 2 getu16 1 sub {
  219.         % Stack: false table id index
  220.     12 mul 6 add 2 index exch 12 getinterval
  221.     dup 6 getu16 2 index eq {
  222.         % We found the name we want.
  223.       exch pop
  224.         % Stack: false table record
  225.       dup 10 getu16 2 index 4 getu16 add
  226.       1 index 8 getu16 4 -1 roll 3 1 roll
  227.       3 copy add 1 index length
  228.       le {
  229.         pop
  230.         getinterval exch
  231.         % Stack: false string record
  232.         % Check for 8- vs. 16-bit characters.
  233.         is2byte { string2to1 } if true null 4 -1 roll exit
  234.       } {
  235.         pop pop pop pop
  236.         false
  237.         exit
  238.       } ifelse
  239.     } if pop
  240.   } for pop pop
  241.   TTFDEBUG {
  242.     dup { ( = ) print 1 index == } { ( not found) = } ifelse
  243.   } if
  244. } bind def
  245.  
  246. % <namerecord> is2byte <bool>
  247. /is2byte {
  248.   dup 0 getu16 {
  249.     { pop true }        % Apple Unicode
  250.     { pop false }        % Macintosh Script manager
  251.     { 1 getu16 1 eq }        % ISO
  252.     { 1 getu16 1 eq }        % Microsoft
  253.   } exch get exec
  254. } bind def
  255.  
  256. % <string2> string2to1 <string>
  257. /string2to1 {
  258.   dup length 2 idiv string dup
  259.   0 1 3 index length 1 sub {
  260.     3 index 1 index 2 mul 1 add get put dup
  261.   } for pop exch pop
  262. } bind def
  263.  
  264. % Each procedure in this dictionary is called as follows:
  265. %       <encodingtable> proc <glypharray>
  266. /cmapformats mark
  267.   0 {        % Apple standard 1-to-1 mapping.
  268.     6 256 getinterval { } forall 256 packedarray
  269.   } bind
  270.   2 {        % Apple 16bit CJK (ShiftJIS etc)
  271.  
  272.     % /sHK_sz        subHeaderKey_size    % 1 * uint16
  273.     % /sH_sz        subHeader_size        % 4 * uint16
  274.     % /sH_len        subHeader_length
  275.     % /cmapf2_tblen    total table length
  276.     % /cmapf2_lang    language code (not used)
  277.     % /sHKs        subHeaderKeys
  278.  
  279.     /sHK_sz 2 def
  280.     /sH_sz 8 def
  281.     dup 2 getu16 /cmapf2_tblen exch def
  282.  
  283.     dup 4 getu16 /cmapf2_lang exch def
  284.  
  285.     dup 6 256 sHK_sz mul getinterval /sHKs exch def
  286.  
  287.     0        % initialization value for /sH_len
  288.     0 1 255 {
  289.        sHKs exch
  290.        2 mul getu16
  291.        1 index    % get current max
  292.        1 index    % get current subHeaderKey
  293.        lt {exch} if pop
  294.     } for
  295.     /sH_len exch def
  296.  
  297.     dup 6 256 sHK_sz mul add
  298.     cmapf2_tblen 1 index sub getinterval
  299.     /sH_gIA exch def
  300.  
  301.     /cmapf2_glyph_array 65535 array def
  302.  
  303.     /.cmapf2_putGID {
  304.         /cmapf2_ch cmapf2_ch_hi 8 bitshift cmapf2_ch_lo add def
  305.         firstCode cmapf2_ch_lo le
  306.         cmapf2_ch_lo firstCode entryCount add lt
  307.         and { % true: j is inside
  308.             sH_offset idRangeOffset add        % offset to gI
  309.             cmapf2_ch_lo firstCode sub 2 mul    % rel. pos. in range
  310.             add 6 add                % offset in sH_gIA
  311.             sH_gIA exch getu16
  312.             dup 0 gt { %
  313.                 idDelta add
  314.                 cmapf2_glyph_array exch cmapf2_ch exch put
  315.             } {
  316.                 pop
  317.                 % cmapf2_glyph_array cmapf2_ch 0 put
  318.             } ifelse
  319.         } {   % false: j is outside
  320.             % cmapf2_glyph_array cmapf2_ch 0 put
  321.         } ifelse
  322.     } def
  323.  
  324.     16#00 1 16#ff { % hi_byte scan
  325.         /cmapf2_ch_hi exch def
  326.         sHKs cmapf2_ch_hi sHK_sz mul getu16
  327.         /sH_offset exch def
  328.         sH_gIA sH_offset sH_sz getinterval
  329.             dup 0 getu16 /firstCode exch def
  330.             dup 2 getu16 /entryCount exch def
  331.             dup 4 gets16 /idDelta exch def
  332.             dup 6 getu16 /idRangeOffset exch def
  333.         pop
  334.         sH_offset 0 eq {
  335.            /cmapf2_ch_lo cmapf2_ch_hi def
  336.            /cmapf2_ch_hi 0 def
  337.            .cmapf2_putGID
  338.         } {
  339.            16#00 1 16#ff { % lo_byte scan
  340.                /cmapf2_ch_lo exch def
  341.                .cmapf2_putGID
  342.            } for
  343.         } ifelse
  344.      } for
  345.      pop
  346.      0 1 cmapf2_glyph_array length 1 sub { % rewrite null -> 0.
  347.         dup cmapf2_glyph_array exch get
  348.         null eq { cmapf2_glyph_array exch 0 put } {pop} ifelse
  349.      } for
  350.      cmapf2_glyph_array
  351.   } bind
  352.   4 {        % Microsoft/Adobe segmented mapping.
  353.     /etab exch def
  354.     /nseg2 etab 6 getu16 def
  355.     14 /endc etab 2 index nseg2 getinterval def
  356.         % The Apple TrueType documentation omits the 2-byte
  357.         % 'reserved pad' that follows the endCount vector!
  358.     2 add
  359.     nseg2 add /startc etab 2 index nseg2 getinterval def
  360.     nseg2 add /iddelta etab 2 index nseg2 getinterval def
  361.     nseg2 add /idroff etab 2 index nseg2 getinterval def
  362.         % The following hack allows us to properly handle
  363.         % idiosyncratic fonts that start at 0xf000:
  364.     pop
  365.     /firstcode startc 0 getu16 16#ff00 and dup 16#f000 ne { pop 0 } if def
  366.     /putglyph {
  367.       glyphs code 3 -1 roll put /code code 1 add def
  368.     } bind def
  369.         % Do a first pass to compute the size of the glyphs array.
  370.     /numcodes 0 def /glyphs 0 0 2 nseg2 3 sub {
  371.         % Stack: /glyphs numglyphs i2
  372.       /i2 exch def
  373.       /scode startc i2 getu16 def
  374.       /ecode endc i2 getu16 def
  375.       numcodes scode firstcode sub
  376.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  377.       %dup 16#e000 ge { 255 and } if
  378.       % the previous line is obstructive to CJK fonts, so it was removed
  379.       exch sub 0 .max ecode scode sub 1 add add
  380.       exch 1 index add exch
  381.       numcodes add /numcodes exch def
  382.     } for array def
  383.     % prefill the array with 0's faster than a { 0 putglyph } repeat
  384.     glyphs length 1024 ge {
  385.       .array1024z 0 1024 glyphs length 1023 sub { glyphs exch 2 index putinterval } for
  386.       glyphs dup length 1024 sub 3 -1 roll
  387.       putinterval
  388.     } {
  389.       0 1 glyphs length 1 sub { glyphs exch 0 put } for
  390.     } ifelse
  391.         % Now fill in the array.
  392.     /numcodes 0 def /code 0 def
  393.     0 2 nseg2 3 sub {
  394.       /i2 exch def
  395.       /scode startc i2 getu16 def
  396.       /ecode endc i2 getu16 def
  397.       numcodes scode firstcode sub
  398.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  399.       %dup 16#e000 ge { 255 and } if
  400.       % the previous line is obstructive to CJK fonts, so it was removed
  401.       exch sub 0 .max dup /code exch code exch add def
  402.       ecode scode sub 1 add add numcodes add /numcodes exch def
  403.       /delta iddelta i2 gets16 def
  404.       TTFDEBUG {
  405.     (scode=) print scode =only
  406.     ( ecode=) print ecode =only
  407.     ( delta=) print delta =only
  408.     ( droff=) print idroff i2 getu16 =
  409.       } if
  410.       idroff i2 getu16 dup 0 eq {
  411.     pop scode delta add 65535 and 1 ecode delta add 65535 and
  412.     { putglyph } for
  413.       } {    % The +2 is for the 'reserved pad'.
  414.         /gloff exch 14 nseg2 3 mul add 2 add i2 add add def
  415.         0 1 ecode scode sub {
  416.       2 mul gloff add etab exch getu16
  417.       dup 0 ne { delta add 65535 and } if putglyph
  418.     } for
  419.       } ifelse
  420.     } for glyphs /glyphs null def    % for GC
  421.   } bind
  422.   6 {        % Single interval lookup.
  423.     dup 6 getu16 /firstcode exch def dup 8 getu16 /ng exch def
  424.     firstcode ng add array
  425.         % Stack: tab array
  426.         % Fill elements 0 .. firstcode-1 with 0
  427.     0 1 firstcode 1 sub { 2 copy 0 put pop } for
  428.     dup firstcode ng getinterval
  429.         % Stack: tab array subarray
  430.         % Fill elements firstcode .. firstcode+nvalue-1 with glyph values
  431.     0 1 ng 1 sub {
  432.       dup 2 mul 10 add 4 index exch getu16 3 copy put pop pop
  433.     } for pop exch pop
  434.   } bind
  435. .dicttomark readonly def                % cmapformats
  436.  
  437. % <cmaptab> cmaparray <glypharray>
  438. /cmaparray {
  439.   dup 0 getu16 cmapformats exch .knownget {
  440.     TTFDEBUG {
  441.       (cmap: format ) print 1 index 0 getu16 = flush
  442.     } if exec
  443.   } {
  444.     (Can't handle format ) print 0 getu16 = flush
  445.     0 1 255 { } for 256 packedarray
  446.   } ifelse
  447.   TTFDEBUG {
  448.     (cmap: length=) print dup length = dup ==
  449.   } if
  450. } bind def
  451.  
  452. % Each procedure in this dictionary is called as follows:
  453. %       posttable <<proc>> glyphencoding
  454. /postformats mark
  455.   16#00010000  {    % 258 standard Macintosh glyphs.
  456.     pop MacGlyphEncoding
  457.   }
  458.   16#00020000  {    % Detailed map, required by Microsoft fonts.
  459.     dup length 36 lt {
  460.       TTFDEBUG { (post format 2.0 invalid.) = flush } if
  461.       pop [ ]
  462.     } {
  463.     /postglyphs exch def
  464.       postglyphs 32 getu16 /numglyphs exch def
  465.       /glyphnames numglyphs 2 mul 34 add def
  466.       % Build names array in the order they occur in the 'post' table
  467.       /postpos glyphnames def
  468.       [ numglyphs 1 sub {
  469.     postpos postglyphs length ge { exit } if
  470.     % No name available, /postnames will be defined as an empty
  471.     % array and the glyph won't get a name attached.
  472.     postglyphs postpos get 
  473.         postglyphs postpos 1 add 2 index getinterval cvn
  474.     exch postpos add 1 add /postpos exch def
  475.       } repeat
  476.       ] /postnames exch def
  477.       [ 0 1 numglyphs 1 sub {
  478.     2 mul 34 add postglyphs exch getu16
  479.     dup 258 lt {
  480.       MacGlyphEncoding exch get
  481.     } {
  482.       dup 32768 ge {
  483.         % According to the published TrueType spec, such values are
  484.         % "reserved for future use", but at least some PDF files
  485.         % produced by the Adobe PDF library contain entries with a
  486.         % value of 16#ffff.
  487.         pop /.notdef
  488.       } {
  489.         % Get the name for this glyph
  490.         258 sub dup postnames length ge {
  491.           TTFDEBUG { (   *** warning: glyph index past end of 'post' table) = flush } if
  492.           exit
  493.         } if
  494.         postnames exch get
  495.         % At least some of Microsoft's TrueType fonts use incorrect
  496.         % (Adobe-incompatible) names for some glyphs.
  497.         % Correct for this here.
  498.         postremap 1 index .knownget { exch pop } if
  499.       } ifelse
  500.     } ifelse
  501.       } for ]
  502.     }
  503.     ifelse
  504.   } bind
  505.   16#00030000  {    % No map.
  506.     pop [ ]
  507.   } bind
  508. .dicttomark readonly def                % postformats
  509.  
  510. % Each procedure in this dictionary is called as follows:
  511. %    <file> <length> -proc- <string|array_of_strings>
  512. % Note that each table must have an even length, because of a strange
  513. % Adobe requirement that each sfnts entry have even length.
  514. /readtables mark
  515.     % Ordinary tables
  516.   (cmap) { .readtable }
  517.   (head) 1 index
  518.   (hhea) 1 index
  519.   (maxp) 1 index
  520.   (name) 1 index
  521.   (OS/2) 1 index
  522.   (post) 1 index
  523.   (vhea) 1 index
  524.     % Big tables
  525.   (glyf) { .readbigtable }
  526.   (loca) 1 index
  527.   (hmtx) 1 index
  528.   (vmtx) 1 index
  529.     % Tables only needed for embedding in PDF files
  530.   (cvt ) { .readtable }
  531.   (fpgm) 1 index
  532.   (prep) 1 index
  533. .dicttomark
  534. % Normally there would be a 'readonly' here, but the ttf2pf utility wants
  535. % to include the 'kern' table as well, so we leave the readtables dictionary
  536. % writable.
  537. def                % readtables
  538.  
  539. /readtables_stripped readtables dup length dict copy
  540. dup (loca) { .skiptable } put
  541. dup (glyf) { .skiptable } put
  542. def
  543.  
  544. % Read a table as a single string.
  545. % <file> <length> .skiptable <string>
  546. /.skiptable {
  547.   pop pop ()
  548. } bind def
  549.  
  550. % Read a table as a single string.
  551. % <file> <length> .readtable <string>
  552. /.readtable {
  553.   dup dup 1 and add string
  554.         % Stack: f len str
  555.   dup 0 4 -1 roll getinterval
  556.         % Stack: f str str1
  557.     % Because of the absurd PostScript specification that gives an
  558.     % error for reading into an empty string, we have to check for
  559.     % this explicitly here.
  560.   3 -1 roll exch
  561.   dup () ne { readstring } if pop pop
  562. } bind def
  563.  
  564. % Read a big table (one that may exceed 64K).
  565. % <file> <length> .readbigtable <string[s]>
  566. /.readbigtable {
  567.   dup 65400 lt {
  568.     .readtable
  569.   } {
  570.     currentuserparams /VMReclaim get -2 vmreclaim
  571.     [ 4 2 roll {
  572.         % Stack: mark ... f left
  573.       dup maxstring le { exit } if
  574.       1 index maxstring string readstring pop 3 1 roll maxstring sub
  575.     } loop .readtable ]
  576.     exch vmreclaim
  577.   } ifelse
  578. } bind def
  579.  
  580. end readonly def                % .loadttfontdict
  581.  
  582. % <tab> .printtab -
  583. /.printtab {
  584.   dup 0 4 getinterval print ( ) print
  585.   dup 8 getu32 =only ( ) print
  586.   12 getu32 =
  587. } bind def
  588.  
  589. % <file> <bool> <SubfontID> .loadttfonttables -
  590. % Pushes .loadttfontdict & scratch dict on d-stack.
  591. % Defines f, offsets, tables, tabdict, tabs.
  592. % Skips loca nd glyf if <bool> is true.
  593. /.loadttfonttables {
  594.   .loadttfontdict begin
  595.   40 dict begin
  596.   /SubfontID exch def
  597.   /load_stripped exch def
  598.   /f exch def
  599.   /offsets f 12 string readstring pop def
  600.   load_stripped { readtables_stripped } { readtables } ifelse /readtables_ exch def
  601.   offsets 0 4 getinterval (ttcf) eq {
  602.     % We need to handle TT collections with disk fonts only.
  603.     % Therefore the file is a disk file and it can be positioned.
  604.     offsets 8 getu32 /num_fonts exch def
  605.     SubfontID num_fonts ge {
  606.       QUIET not { (True Type collection contains insufficient fonts.) = } if
  607.       /.loadttfonttables cvx /invalidfont signalerror
  608.     } if
  609.     SubfontID 4 mul 12 add f exch setfileposition
  610.     f 4 string readstring pop 0
  611.     getu32 /ttc_offset exch def
  612.     f ttc_offset setfileposition
  613.     /offsets f 12 string readstring pop def
  614.   } {
  615.     SubfontID 0 gt {
  616.       QUIET not { (SubfontID > 0 with a True Type file which is not a collection.) = } if
  617.       /.loadttfonttables cvx /invalidfont signalerror
  618.     } if
  619.     /ttc_offset 0 def
  620.   } ifelse
  621.   /tables f offsets 4 getu16 16 mul string readstring pop def
  622.   /tabdict tables length 16 idiv dict def
  623.     % tabs = tables we want to keep, sorted by file position.
  624.   /tabs [ 0 16 tables length 1 sub {
  625.     tables exch 16 getinterval
  626.     TTFDEBUG { dup .printtab } if
  627.     dup 0 4 getinterval readtables_ 1 index known {
  628.       1 index 12 4 getinterval (\0\0\0\0) eq {
  629.         pop pop    % Ignore zero-length table
  630.       } {
  631.         tabdict exch 2 index put
  632.       } ifelse
  633.     } {
  634.       pop pop
  635.     } ifelse
  636.   } for ] {
  637.     exch 8 getu32 exch 8 getu32 lt
  638.   } .sort def
  639.     % In certain malformed TrueType fonts, tables overlap.
  640.     % Truncate tables if necessary.
  641.   0 1 tabs length 2 sub {
  642.     dup tabs exch get exch 1 add tabs exch get
  643.     1 index 8 getu32 2 index 12 getu32 add
  644.     1 index 8 getu32 gt {
  645.       (**** Warning: ) print 1 index 0 4 getinterval print
  646.       ( overlaps ) print dup 0 4 getinterval print
  647.       (, truncating.) = flush
  648.       dup 8 getu32 2 index 8 getu32 sub
  649.       2 index 12 3 -1 roll putu32
  650.     } if pop pop
  651.   } for
  652. } bind def
  653.  
  654. /.file_table_pos_names
  655. mark
  656. /glyf 0
  657. /loca 0
  658. .dicttomark readonly def
  659.  
  660. % - .readttdata -
  661. % Read data.  Updates offsets, tabs; stores data in tabdict.
  662. /.readttdata {
  663.   /file_table_pos 10 dict def
  664.   /fpos offsets length tables length add ttc_offset add def
  665.   /sfpos offsets length tabs length 16 mul add def
  666.   offsets 4 tabs length putu16
  667.   tabs {
  668.     dup 0 4 getinterval /tname exch def
  669.     dup 8 getu32 /tpos exch def
  670.     dup 12 getu32 /tlen exch def
  671.     load_stripped //.file_table_pos_names tname known and {
  672.         pop
  673.         file_table_pos tname [tpos tlen] put
  674.         tabdict tname () put
  675.     } {
  676.       8 sfpos putu32
  677.       % Skip data between the end of the previous table and
  678.     % the beginning of this one, if any.
  679.       tpos fpos gt {
  680.         load_stripped {
  681.           % 'setfileposition' is faster for skipping a big data.
  682.           f tpos setfileposition
  683.         } {
  684.           f tpos fpos sub () /SubFileDecode filter dup flushfile closefile
  685.           /fpos tpos def
  686.         } ifelse
  687.       } if
  688.       f tlen readtables_ tname get exec
  689.       tabdict tname 3 -1 roll put
  690.     % Round up the table length to an even value.
  691.       /sfpos sfpos tlen dup 1 and add add def
  692.     } ifelse
  693.     /fpos fpos tlen add def
  694.   } forall
  695. } bind def
  696.  
  697. % Find the string in a list of strings that includes a given index.
  698. % <strings> <index> .findseg <string> <index'>
  699. /.findseg {
  700.   exch {
  701.     dup length 2 index gt { exch exit } if
  702.     length sub
  703.   } forall
  704. } bind def
  705.  
  706. % - .makesfnts -
  707. % Defines checksum, getloca, head, locatable, numloca, post, sfnts, upem
  708. /.makesfnts {
  709.   .readttdata
  710.   /head tabdict /head get def
  711.   /post tabdict /post .knownget not { null } if def
  712.   load_stripped not {
  713.     /locatable tabdict /loca get def
  714.     /numloca
  715.       locatable dup type /stringtype eq
  716.        { length }
  717.        { 0 exch { length add } forall }
  718.       ifelse    % no def yet
  719.     locatable type /stringtype eq {
  720.       /.indexloca {} def
  721.     } {
  722.       /.indexloca /.findseg load def
  723.     } ifelse
  724.     head 50 getu16 0 ne {
  725.       /getloca {
  726.         2 bitshift locatable exch .indexloca getu32
  727.       } def
  728.       4 idiv 1 sub
  729.     } {
  730.       /getloca {
  731.         dup add locatable exch .indexloca getu16 dup add
  732.       } def
  733.       2 idiv 1 sub
  734.     } ifelse def        % numloca
  735.     % If necessary, re-partition the glyfs.
  736.     tabdict /glyf get dup type /stringtype ne {
  737.       .dividesfnts tabdict /glyf 3 -1 roll put
  738.     } {
  739.       pop
  740.     } ifelse
  741.   } {
  742.     % We did not load loca, take the number of glyphs from maxp.
  743.     /numloca tabdict /maxp get 4 getu16 def
  744.   } ifelse
  745.   /sfnts [
  746.     offsets tabs { concatstrings } forall
  747.     tabs {
  748.       0 4 getinterval tabdict exch get
  749.       dup type /stringtype ne { aload pop } if
  750.     } forall
  751.   ] def
  752. } bind def
  753.  
  754. % <glyfs> .dividesfnts <glyfs'>
  755. /.dividesfnts {
  756.   /glyfs exch def
  757.   /len1 0 glyfs { length add } forall def
  758.         % Determine where to split the glyfs by scanning loca.
  759.         % The very last entry in loca may be bogus.
  760.         % Note that some loca entries may be odd, but we can only
  761.         % split at even positions.
  762.         %
  763.         % Construct splitarray, the array of final lengths of
  764.         % the sfnts entries covering the glyfs (i.e., all but
  765.         % the first and last sfnts entries).
  766.     /prevsplit 0 def
  767.     /prevboundary 0 def
  768.     /splitarray [
  769.       0 1 numloca 1 sub {
  770.     getloca dup prevsplit maxstring add gt {
  771.       prevboundary prevsplit sub exch
  772.       /prevsplit prevboundary def
  773.     } if
  774.     dup 1 and 0 eq { /prevboundary exch def } { pop } ifelse
  775.       } for
  776.       len1 prevsplit sub
  777.     ] def
  778.     currentuserparams /VMReclaim get -2 vmreclaim
  779.     [
  780.         % Re-split the sfnts glyfs strings according to splitarray.
  781.         % We do this by iterating over the final segments defined
  782.         % by splitarray, and constructing them from pieces of the
  783.         % current glyfs strings.  We recycle the current strings
  784.         % when possible, to avoid stressing the allocator.
  785.       /sfnt_idx 0 def
  786.       /strpos 0 def
  787.       /avail () def
  788.       splitarray {
  789.     /seglen exch def
  790.     /segpos 0 def
  791.     avail length seglen ge
  792.       { avail 0 seglen getinterval /avail () def } { seglen string }
  793.     ifelse
  794.     {
  795.       /str glyfs sfnt_idx get def
  796.       /strlen str length def
  797.       /strleft strlen strpos sub def
  798.       seglen segpos sub strleft lt { exit } if
  799.         % Copy the (rest of the) string into the new segment.
  800.         % We know strleft <= segleft.
  801.       dup segpos str strpos strleft getinterval putinterval
  802.       /segpos segpos strleft add def
  803.       /avail str def
  804.       /sfnt_idx sfnt_idx 1 add def
  805.       /strpos 0 def
  806.       segpos seglen eq { exit } if
  807.     } loop
  808.         % Fill up the segment with an initial piece of the next
  809.         % existing glyfs string.  We know strleft > segleft.
  810.     /segleft seglen segpos sub def
  811.     dup segpos str strpos segleft getinterval putinterval
  812.     /strpos strpos segleft add def
  813.       } forall
  814.     ]
  815.     exch vmreclaim
  816. } bind def
  817.  
  818. % - .getpost -
  819. % Uses post, defines glyphencoding
  820. /.getpost {
  821.   /glyphencoding post null eq {
  822.     TTFDEBUG { (post missing) = flush } if [ ]
  823.   } {
  824.     postformats post 0 getu32 .knownget {
  825.       TTFDEBUG {
  826.     (post: format ) print
  827.     post 0 getu16 =only (,) print post 2 getu16 = flush
  828.       } if
  829.       post exch exec
  830.     } {
  831.       TTFDEBUG { (post: unknown format ) print post 0 getu32 = flush } if [ ]
  832.     } ifelse
  833.   } ifelse def
  834. } bind def
  835.  
  836. % - .ttkeys <key> <value> ...
  837. /.ttkeys {
  838.   count /ttkeycount exch def
  839.   /upem head 18 getu16 def
  840.   /FontMatrix matrix
  841.   /FontBBox [ 36 2 42 { head exch gets16 upem div } for ]
  842.   nextxuid
  843.   tabdict /name .knownget {
  844.         % Find the names from the 'name' table.
  845.     /names exch def
  846.     /FontName names 6 findname not { curxuid 16 8 string cvrs } if
  847.       /fontname 1 index def
  848.     /FontInfo mark
  849.       names 0 findname { /Notice exch } if
  850.       names 1 findname { /FamilyName exch } if
  851.       names 4 findname { /FullName exch } if
  852.       names 5 findname { /Version exch } if
  853.   } {
  854.         % No name table, fabricate a FontName.
  855.     /FontName curxuid 16 8 string cvrs
  856.       /fontname 1 index def
  857.     /FontInfo mark
  858.   } ifelse
  859.         % Stack: ... /FontInfo mark key1 value1 ...
  860.   post null ne {
  861.     /ItalicAngle post 4 gets32 65536.0 div
  862.     /isFixedPitch post 12 getu32 0 ne
  863.     /UnderlinePosition post 8 gets16 upem div
  864.     /UnderlineThickness post 10 gets16 upem div
  865.   } if
  866.   counttomark 0 ne { .dicttomark } { pop pop } ifelse
  867.   /XUID [orgXUID 42 curxuid]
  868.   TTFDEBUG {
  869.     tabs { .printtab } forall
  870.     [ sfnts { length } forall ] ==
  871.     count ttkeycount sub array astore dup { == } forall aload pop
  872.   } if
  873.   /sfnts sfnts
  874. } bind def
  875.  
  876. % ---------------- Standard TrueType font loading ---------------- %
  877.  
  878. % - .pickcmap_with_no_xlatmap -
  879. % Defines cmapsub, cmaptab
  880. /.pickcmap_with_no_xlatmap {
  881.   tabdict /cmap get
  882.         % The Apple cmap format is no help in determining the encoding.
  883.         % Look for a Microsoft table.  If we can't find one,
  884.         % just use the first table, whatever it is.
  885.   dup 4 8 getinterval exch             % the default
  886.   0 1 2 index 2 getu16 1 sub {
  887.     8 mul 4 add 1 index exch 8 getinterval
  888.     TTFDEBUG {
  889.       (cmap: platform ) print dup 0 getu16 =only
  890.       ( encoding ) print dup 2 getu16 = flush
  891.     } if
  892.     dup 0 getu16 3 eq { exch 3 -1 roll pop exit } if pop
  893.   } for
  894.         % Stack: subentry table
  895.   /cmapsub 2 index def
  896.   exch 4 getu32 1 index length 1 index sub getinterval
  897.   /cmaptab exch def
  898. } bind def
  899.  
  900. % - .pickcmap_with_xlatmap -
  901. % Defines cmapsub, cmaptab
  902. /.pickcmap_with_xlatmap {
  903.   .xlatmap_dict /TrueType known not {
  904.     (Emulating a CID font with a True Type file, ) print
  905.     (the file gs/lib/xlatmap must contain /TrueType key.) =
  906.     /.pickcmap_with_xlatmap cvx /configurationerror signalerror
  907.   } if
  908.   false
  909.   .xlatmap_dict /TrueType get 
  910.   dup length 2 sub 0 exch 2 exch {                       % bool [] i
  911.     2 copy get                                           % bool [] i ()
  912.     (.) search {                                         % bool [] i post match pre
  913.       cvi exch pop exch cvi                              % bool [] i PlatID SpecID
  914.     } {
  915.       (gs/lib/xlatmap containg a record with an invalid (PlatformID.SpecificID)) =
  916.       /.pickcmap_with_xlatmap cvx /configurationerror signalerror
  917.     } ifelse
  918.     TTFDEBUG {
  919.       (Seeking a cmap for platform=) print 1 index =only ( encoding=) print dup =
  920.     } if
  921.     tabdict /cmap get                                   % bool [] i PlatID SpecID (cmap)
  922.     dup /cmaptab exch def % temporary
  923.     0 1 2 index 2 getu16 1 sub {                         % bool [] i PlatID SpecID (cmap) j
  924.       8 mul 4 add 1 index exch 8 getinterval             % bool [] i PlatID SpecID (cmap) (cmapsub)
  925.       TTFDEBUG {
  926.         (cmap: platform ) print dup 0 getu16 =only
  927.         ( encoding ) print dup 2 getu16 = flush
  928.       } if
  929.       dup 0 getu16 4 index eq {
  930.         dup 2 getu16 3 index eq {                        % bool [] i PlatID SpecID (cmap) (cmapsub)
  931.           TTFDEBUG {
  932.             (Choosen a cmap for platform=) print 3 index =only
  933.             ( encoding=) print 2 index =
  934.           } if
  935.           /cmapsub 1 index def
  936.           dup 4 getu32                                   % bool [] i PlatID SpecID (cmap) (cmapsub) p
  937.           cmaptab length 1 index sub                     % bool [] i PlatID SpecID (cmap) (cmapsub) p l
  938.           cmaptab 3 1 roll getinterval
  939.           /cmaptab exch def                              % bool [] i PlatID SpecID (cmap) (cmapsub)
  940.           5 index 5 index 1 add get                      % bool [] i PlatID SpecID (cmap) (cmapsub) /Decoding
  941.           /Decoding exch def                             % bool [] i PlatID SpecID (cmap) (cmapsub)
  942.           7 -1 roll pop true 7 1 roll                    % true [] i PlatID SpecID (cmap) (cmapsub)
  943.         } if
  944.       } if
  945.       pop                                                % true [] i PlatID SpecID (cmap)
  946.       5 index { exit } if
  947.     } for                                                % bool [] i PlatID SpecID (cmap)
  948.     pop pop pop pop                                      % bool []
  949.     1 index { exit } if
  950.   } for                                                  % bool []
  951.   pop                                                    % bool
  952.   not { 
  953.     QUIET not { (True Type font doesn't contain a charset listed in gs/lib/xlatmap.) = } if
  954.     /.pickcmap_with_xlatmap cvx /invalidfont signalerror
  955.   } if                                                   %
  956. } bind def
  957.  
  958. % - .pickcmap -
  959. % Defines cmapsub, cmaptab
  960. /.pickcmap {
  961.   % Currently we use xlatmap only for emulation CIDFontType 2 with
  962.   % a disk True Type font files, and use load_stripped
  963.   % to check this regime. We would like to do so
  964.   % while emulating a Type 42, but first the old code
  965.   % about handling them to be changed 
  966.   % with adding a handling of a Decoding.
  967.   % fixme : A correct way to fix this is to implenent 
  968.   % the Type 42 emulation with gs_fntem.ps .
  969.   % Also note that PDF embedded fonts probably don't need a xlatmap -
  970.   % see PDF spec, "Encodings for True Type fonts".
  971.   load_stripped {
  972.     //.pickcmap_with_xlatmap exec
  973.   } {
  974.     //.pickcmap_with_no_xlatmap exec
  975.   } ifelse
  976. } bind def
  977.  
  978. % <glyph> .nname <_name>
  979. /.nname {
  980.   =string cvs (_) exch concatstrings cvn
  981. } bind def
  982.  
  983. % - .charkeys /CharStrings <charstrings> /Encoding <encoding>
  984. % Resets glyphencoding
  985. /.charkeys {
  986.   TTFDEBUG {
  987.     (glyphencoding: length=) print glyphencoding dup length = === flush
  988.   } if
  989.         % Hack: if there is no usable post table but the cmap uses
  990.         % the Microsoft Unicode encoding, use ISOLatin1Encoding.
  991.   glyphencoding length 0 eq cmapsub 0 4 getinterval <00030001> eq and {
  992.     /glyphencoding ISOLatin1Encoding dup length array copy def
  993.   } if
  994.         % If necessary, fabricate additional glyphencoding entries
  995.         % to cover all of loca, or truncate glyphencoding.
  996.   glyphencoding length numloca lt {
  997.     /glyphencoding numloca array
  998.       glyphencoding length dup 1 sub 0 1 3 2 roll {
  999.         dup glyphencoding exch get
  1000.         3 index 3 1 roll put
  1001.       } for
  1002.       % /glyphencoding <newarray> <glyphencoding length>
  1003.       1 numloca 1 sub {
  1004.         1 index exch dup .nname put
  1005.       } for
  1006.     def
  1007.   } {
  1008.     /glyphencoding glyphencoding 0 numloca getinterval def
  1009.   } ifelse
  1010.         % Some badly designed Chinese fonts have a post table
  1011.         % in which all glyphs other than 0 are named .null.
  1012.         % Use CharStrings to keep track of the reverse map from
  1013.         % names to glyphs, and don't let any name be used for
  1014.         % more than one glyph.
  1015.   /CharStrings glyphencoding dup length 1 add dict    % +1 for .notdef
  1016.     0 1 3 index length 1 sub {
  1017.         % Stack: glyphencoding dict index
  1018.       2 index 1 index get 2 index 1 index known {
  1019.         % The same name maps to more than one glyph.
  1020.         % Change the name.
  1021.     pop dup .nname 3 index 2 index 2 index put
  1022.       } if
  1023.       2 index exch 3 -1 roll put
  1024.     } for exch pop
  1025.         % If there is no .notdef entry, map it to glyph 0.
  1026.   dup /.notdef known not { dup /.notdef 0 put } if
  1027.   readonly
  1028.   /Encoding
  1029.     [ cmaptab cmaparray dup length 256 gt { 0 256 getinterval } if
  1030.     { glyphencoding exch get } forall
  1031.     counttomark 256 exch sub { /.notdef } repeat ]
  1032.   TTFDEBUG { (Encoding: ) print dup === flush } if
  1033. } bind def
  1034.  
  1035. % -mark- <key> <value> ... .definettfont <font>
  1036. /.definettfont {
  1037.   /FontType 42
  1038.   /PaintType 0
  1039.   TTFDEBUG {
  1040.     (numloca=) print numloca =
  1041.   } if
  1042.   .dicttomark
  1043.   end end dup /FontName get exch definefont
  1044. } bind def
  1045.  
  1046. % <file> .loadttfont <type42font>
  1047. /.loadttfont {
  1048.   //false 0 .loadttfonttables
  1049.   .makesfnts
  1050.   .getpost
  1051.   .pickcmap
  1052.   mark
  1053.   .charkeys
  1054.   .ttkeys
  1055.   .definettfont
  1056. } bind def
  1057.  
  1058. % ---------------- CIDFontType 2 font loading ---------------- %
  1059.  
  1060. % Fill a string with sequential CIDs starting from the initial value.
  1061. % <string> <value> .fill_identity_cmap <string>
  1062. /.fill_identity_cmap {             % () v
  1063.   1 index length 2 sub          % () v n-2
  1064.   0 2 3 2 roll {                % () v 0 2 n-1
  1065.       3 copy exch               % () v i () i v 
  1066.       -8 bitshift               % () v i () i v>>8
  1067.       put                       % () v i
  1068.       3 copy 1 add              % () v i () v i+1
  1069.       exch 255 and              % () v i () i+1 v&255
  1070.       put                       % () v i 
  1071.       pop 1 add                 % () v+1
  1072.   } for
  1073.   pop
  1074. } bind def
  1075.  
  1076. % -mark- <key> <value> ... .definettcidfont <font>
  1077. /.definettcidfont {
  1078.   /CIDFontName fontname
  1079.   /CIDFontType 2
  1080.   /CIDSystemInfo mark
  1081.     /Registry (Adobe)
  1082.     /Ordering (Japan1)        % adhoc
  1083.     /Supplement 0
  1084.   .dicttomark
  1085.   /CharStrings mark /.notdef 0 .dicttomark
  1086.         % The cmap isn't of any use even if it is present.
  1087.         % Just construct an identity CIDMap covering all the glyphs.
  1088.  
  1089.   /CIDCount numloca % Wrong if a CIDFontType2 embedded into PDF with a non-Identity CIDToGIDMap.
  1090.                     % processCIDToGIDMap may replace.
  1091.   /CIDMap numloca maxstring le {
  1092.                 % Use a single string.
  1093.       numloca 2 mul string 0 .fill_identity_cmap
  1094.   } {
  1095.                 % We must use 2 strings.
  1096.       maxstring 2 mul string 0 .fill_identity_cmap
  1097.       numloca maxstring sub 2 mul string maxstring .fill_identity_cmap
  1098.       2 array astore
  1099.   } ifelse
  1100.  
  1101.   /GDBytes 2
  1102.   .dicttomark
  1103.   end end dup /CIDFontName get exch /CIDFont defineresource
  1104. } bind def
  1105.  
  1106. % <file> .loadttcidfont <cidtype2font>
  1107. /.loadttcidfont {
  1108.   //false 0 .loadttfonttables
  1109.   .makesfnts
  1110.     % CIDFontType2 fonts don't have a cmap: they are indexed by CID.
  1111.   mark
  1112.   .ttkeys
  1113.   .definettcidfont
  1114. } bind def
  1115.  
  1116. % <file> <SubfontID> .load_tt_font_stripped <font_data>
  1117. % The font_data includes sfnts, NumGlyphs, TT_cmap, file_table_pos, Decoding.
  1118. % CIDMap to be created later from TT_cmap.
  1119. /.load_tt_font_stripped {
  1120.   //true exch .loadttfonttables
  1121.   .makesfnts
  1122.   .pickcmap
  1123.   mark
  1124.   .ttkeys
  1125.   /NumGlyphs numloca
  1126.   /TT_cmap cmaptab cmaparray
  1127.   /file_table_pos file_table_pos
  1128.   /Decoding Decoding
  1129.   .dicttomark
  1130.   end end 
  1131. } bind def
  1132.  
  1133. % ---------------- PDF TrueType font loading ---------------- %
  1134.  
  1135. % Strictly speaking, this code should be loaded only if we have a PDF
  1136. % interpreter, but it's so closely tied to the rest of the code in this
  1137. % file that we always include it.
  1138.  
  1139. % <plat+enc> .findcmap <subtable> true
  1140. % <plat+enc> .findcmap false
  1141. /.findcmap {
  1142.   false exch tabdict /cmap get
  1143.         % Some fonts have multiple cmaps with the same platform and
  1144.         % encoding.  Use the first one we find.
  1145.   0 1 2 index 2 getu16 1 sub {
  1146.         % Stack: false plat+enc cmap index
  1147.     8 mul 4 add 1 index exch 8 getinterval 
  1148.     dup 0 4 getinterval 3 index eq {
  1149.       4 getu32 1 index exch 1 index length 1 index sub getinterval
  1150.       4 -1 roll not 4 2 roll exit
  1151.     } if pop
  1152.   } for
  1153.         % Stack: false plat+enc cmap || subtable true plat+enc cmap
  1154.   pop pop
  1155. } bind def
  1156.  
  1157. % Build .symbol_list for .pdfcharkeys .
  1158. % It is a dictionary containing all SymbolEncoding glyph names
  1159. % and random names for filling gaps in the character code range.
  1160. /.symbol_list 256 dict def
  1161. {
  1162.   =string 0 (x) 0 get put
  1163.   /SymbolEncoding .findencoding
  1164.   0 1 255 {
  1165.     dup 2 index exch get
  1166.     dup /.notdef eq {
  1167.       pop dup
  1168.       =string 1 3 getinterval cvs length 1 add
  1169.       =string exch 0 exch getinterval cvn
  1170.     } if
  1171.     exch //.symbol_list 3 1 roll put
  1172.   } for
  1173.   pop
  1174. } bind exec
  1175.  
  1176. % Create .GS_extended_SymbolEncoding as inverse of .symbol_list .
  1177. {
  1178.   /.GS_extended_SymbolEncoding 256 array
  1179.   //.symbol_list {
  1180.     exch 2 index 3 1 roll put  
  1181.   } forall
  1182.   .defineencoding
  1183. } bind exec
  1184.  
  1185. /.addglyph    % <name> <glyph#> .addglyph <name> <glyph#> 
  1186.               % <name> <glyph#> .addglyph -
  1187. {
  1188.   dup cmapencoding length lt {
  1189.     cmapencoding exch get dup 0 eq {
  1190.       pop pop
  1191.     } if
  1192.   } {
  1193.     pop pop
  1194.   } ifelse
  1195. } bind def
  1196.  
  1197. % <subcmap> <chartoglyphmap> .pdfmapchars
  1198. %   /CharStrings <charstrings>
  1199. /.pdfmapchars {
  1200.   exch cmaparray /cmapencoding exch def
  1201.   /CharStrings mark 
  1202.  
  1203.   % Add glyphs of <chartoglyphmap>*<subcmap> :
  1204.   3 2 roll {
  1205.     dup type /arraytype eq {
  1206.       exch /.name exch def
  1207.       { .name exch //.addglyph exec
  1208.       } forall
  1209.       currentdict /.name undef
  1210.     } {
  1211.       //.addglyph exec
  1212.     } ifelse
  1213.   } forall
  1214.  
  1215.         % stack: /CharStrings mark /name1 glyph#1 /name2 glyph#2 ... /namen glyph#n
  1216.         % Stack depth is restricted with AdobeGlyphList size.
  1217.  
  1218.   % Add glyphs of 'post' (with lower priority, see .dicttomark) :
  1219.   0 1 glyphencoding length 1 sub {
  1220.     dup glyphencoding exch get exch
  1221.     dup 0 eq {
  1222.       pop pop
  1223.     } if
  1224.   } for
  1225.  
  1226.   /.notdef 0
  1227.   .dicttomark
  1228. } bind def
  1229.  
  1230. % - .pdfcharkeys /CharStrings <charstrings> /Encoding <encoding>
  1231. /.pdfcharkeys {
  1232.     % The following algorithms are per the PDF Reference, Second Edition
  1233.     % (PDF 1.3 reference manual).
  1234.   
  1235.   is_symbolic {
  1236.     <00030001> .findcmap {
  1237.       %
  1238.       % Adobe PDF spec says that symbolic fonts should contain exactly one 
  1239.       % cmap subtable for Platform=1, Encoding=0.
  1240.       % Perhaps "Adobe Acrobat PDFWriter 4.0 for Windows" sometimes embeds
  1241.       % fonts with both subtables 3.1 and 1.0 (see comparefiles/159.pdf,
  1242.       % the font "Arial,Bold" with the character "registered"),
  1243.       % and both Acrobat Reader 4.0 and 5.0 choose 3.1.
  1244.       % Therefore we try 3.1 first.
  1245.       %
  1246.       (   **** Warning: Embedded symbolic TT fonts should not contain a cmap for Platform=3 Encoding=1.\n)
  1247.         pdfformaterror
  1248.       AdobeGlyphList .pdfmapchars 
  1249.       /Encoding /WinAnsiEncoding .findencoding
  1250.     } {
  1251.       %
  1252.       % Adobe PDF spec says that in this case PDF interpreter should
  1253.       % map character codes directly to glyphs using
  1254.       % the cmap <00010000>. But we use PS interpreter to emulate
  1255.       % a PDF interpreter. Therefore we need to construct
  1256.       % a type 42 font, which requires an Encoding and a Charstrings.
  1257.       % We construct them with symbol_list, which
  1258.       % includes all glyphs from SymbolEncoding and additional
  1259.       % random names for 1-to-1 mapping.
  1260.       %
  1261.       % A real TT font may use a different characters than
  1262.       % the Symbol charaster set. Perhaps our code
  1263.       % will give a correct printing, because glyph names are not
  1264.       % important for symbolic fonts in PDF.
  1265.       %
  1266.       <00010000> .findcmap {
  1267.         prebuilt_encoding null ne {
  1268.           prebuilt_encoding .invert_encoding .pdfmapchars
  1269.           /Encoding prebuilt_encoding
  1270.         } {
  1271.           .symbol_list .pdfmapchars
  1272.           /Encoding /.GS_extended_SymbolEncoding .findencoding
  1273.         } ifelse
  1274.       } {
  1275.         % This is illegal with PDF spec.
  1276.         (   **** Warning: Embedded symbolic TT fonts must contain a cmap for Platform=1 Encoding=0.\n)
  1277.         pdfformaterror
  1278.         % Try to map Unicode to SymbolEncoding
  1279.         <00030001> .findcmap {
  1280.           AdobeGlyphList .pdfmapchars
  1281.           /Encoding /SymbolEncoding .findencoding
  1282.         } {
  1283.           % Apply the default algorithm. Hopely it has 'post'.
  1284.           .charkeys
  1285.           % check if the CharStrings dict contains glyphs needed by the
  1286.       % prebuilt_encoding otherwise try the 3,0 cmap.
  1287.       prebuilt_encoding null ne {
  1288.         false prebuilt_encoding {    % false means no missing glyphs
  1289.           4 index exch known not { pop true exit } if
  1290.             } forall
  1291.             {
  1292.           (   **** Warning: Encoding derived from 'post' is incomplete.\n)
  1293.           pdfformaterror
  1294.           % Try another cmap format 3,0 -- Adobe doesn't mention it, but does
  1295.           % use it apparently (empirically determined).
  1296.           <00030000> .findcmap {
  1297.            5 1 roll pop pop pop pop             
  1298.         prebuilt_encoding null ne {
  1299.           prebuilt_encoding .invert_encoding .pdfmapchars
  1300.           /Encoding prebuilt_encoding
  1301.         } {
  1302.           AdobeGlyphList .pdfmapchars
  1303.           /Encoding /SymbolEncoding .findencoding
  1304.         } ifelse
  1305.           } if
  1306.             }if
  1307.           } if
  1308.         } ifelse
  1309.       } ifelse
  1310.     } ifelse
  1311.   } {
  1312.     <00030001> .findcmap {
  1313.       AdobeGlyphList .pdfmapchars 
  1314.       /Encoding /WinAnsiEncoding .findencoding
  1315.         % WinAnsiEncoding is just a stub here. 
  1316.         % It will be replaced with one from font resource,
  1317.         % because PDF spec requires it.
  1318.     } {
  1319.       <00010000> .findcmap {
  1320.     .romanmacdict .pdfmapchars 
  1321.         /Encoding /MacRomanEncoding .findencoding
  1322.       } {
  1323.         % Apply the default algorithm for using the 'post'.
  1324.     .charkeys
  1325.       } ifelse
  1326.     } ifelse
  1327.   } ifelse
  1328. } bind def
  1329.  
  1330. % <file> <is_symbolic> <Encoding|null> .loadpdfttfont <type42font>
  1331. /.loadpdfttfont {
  1332.   /prebuilt_encoding exch def     % for .pdfcharkeys
  1333.   /is_symbolic exch def
  1334.   //false 0 .loadttfonttables
  1335.   .makesfnts
  1336.   .getpost
  1337.   .pickcmap
  1338.   mark
  1339.   .pdfcharkeys
  1340.   .ttkeys
  1341.   .definettfont
  1342. } bind def
  1343.