home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / Vyzkuste / gs / gs650w32.exe / gs6.50 / lib / gs_ttf.ps < prev    next >
Text File  |  2000-12-05  |  27KB  |  932 lines
  1. %    Copyright (C) 1996, 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: gs_ttf.ps,v 1.8 2000/09/23 18:47:06 lpd Exp $
  19. % Support code for direct use of TrueType fonts.
  20. % (Not needed for Type 42 fonts.)
  21.  
  22. % Note that if you want to use this file without including the ttfont.dev
  23. % option when you built Ghostscript, you will need to load the following
  24. % files before this one:
  25. %    lib/gs_mgl_e.ps
  26. %    lib/gs_mro_e.ps
  27. %    lib/gs_wan_e.ps
  28.  
  29. % Thanks to B. Jackowski and GUST (the Polish TeX Users' Group) for
  30. % the glyf-splitting code.
  31.  
  32. % ---------------- Font loading machinery ---------------- %
  33.  
  34. % Augment the FONTPATH machinery so it recognizes TrueType fonts.
  35.  
  36. /.scanfontheaders where {
  37.   pop /.scanfontheaders [
  38.    .scanfontheaders aload pop (\000\001\000\000*) (true*)
  39.   ] def
  40. } if
  41.  
  42. % <file> <key> .findfontvalue <value> true
  43. % <file> <key> .findfontvalue false
  44. % Closes the file in either case.
  45. /.findnonttfontvalue /.findfontvalue load def
  46. /.findfontvalue {
  47.   1 index read pop 2 index 1 index unread
  48.   dup 0 eq exch (t) 0 get eq or {
  49.         % If this is a font at all, it's a TrueType font.
  50.     dup /FontType eq {
  51.       pop closefile 42 true
  52.     } {
  53.       dup /FontName eq { pop .findttfontname } { pop closefile false } ifelse
  54.     } ifelse
  55.   } {
  56.         % Not a TrueType font.
  57.     .findnonttfontvalue
  58.   } ifelse
  59. } bind def
  60.  
  61. % <file> .findttfontname <fname> true
  62. % <file> .findttfontname false
  63. % Closes the file in either case.
  64. /.findttfontname {
  65.   .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 32000 def    % half the maximum length of a PostScript string,
  109.             % must be a multiple of 4 (for hmtx / loca / vmtx)
  110.  
  111. % Define the Macintosh standard mapping from characters to glyph indices.
  112. /MacRomanEncoding dup .findencoding def
  113. /MacGlyphEncoding dup .findencoding def
  114.  
  115. % Invert the MacRomanEncoding.
  116. /.romanmacdict 300 dict
  117. 0 1 MacRomanEncoding length 1 sub {
  118.   MacRomanEncoding 1 index get
  119.         % Stack: dict index charname
  120.   dup /.notdef ne {
  121.     exch 2 index 2 index .knownget {
  122.       dup type /arraytype eq {
  123.     [ exch aload pop counttomark 2 add -1 roll ]
  124.       } {
  125.     exch 2 array astore
  126.       } ifelse
  127.     } if 2 index 3 1 roll put
  128.   } {
  129.     pop pop
  130.   } ifelse
  131. } for def
  132.  
  133. % Define remapping for misnamed glyphs in TrueType 'post' tables.
  134. % There are probably a lot more than this!
  135. /postremap mark
  136.   /Cdot /Cdotaccent
  137.   /Edot /Edotaccent
  138.   /Eoverdot /Edotaccent
  139.   /Gdot /Gdotaccent
  140.   /Ldot /Ldotaccent
  141.   /Zdot /Zdotaccent
  142.   /cdot /cdotaccent 
  143.   /edot /edotaccent 
  144.   /eoverdot /edotaccent
  145.   /gdot /gdotaccent 
  146.   /ldot /ldotaccent
  147.   /zdot /zdotaccent 
  148. .dicttomark readonly def
  149.  
  150. % ---- Utilities ---- %
  151.  
  152. % Define a serial number for creating unique XUIDs for TrueType fonts.
  153. % We used to use the checkSumAdjustment value from the font, but this is
  154. % not reliable, since some fonts don't set it correctly.
  155. % Note that we must do this in a string to make it immune to save/restore.
  156. /xuidstring <80000000> def
  157. /curxuid {        % - curxuid <int>
  158.   0 xuidstring { exch 8 bitshift exch add } forall
  159. } bind def
  160. /nextxuid {        % - nextxuid -
  161.   3 -1 0 {
  162.     xuidstring 1 index 2 copy get dup 255 ne {
  163.       1 add put pop exit
  164.     } if pop 0 put pop
  165.   } for
  166. } bind def
  167.  
  168. % <string> <index> getu16 <integer>
  169. /getu16 {
  170.   2 copy get 8 bitshift 3 1 roll 1 add get add
  171. } bind def
  172.  
  173. % <string> <index> gets16 <integer>
  174. /gets16 {
  175.   getu16 16#8000 xor 16#8000 sub
  176. } bind def
  177.  
  178. % <string> <index> getu32 <integer>
  179. /getu32 {
  180.   2 copy getu16 16 bitshift 3 1 roll 2 add getu16 add
  181. } bind def
  182.  
  183. % <string> <index> gets32 <integer>
  184. /gets32 {
  185.   2 copy gets16 16 bitshift 3 1 roll 2 add getu16 add
  186. } bind def
  187.  
  188. % <string> <index> <integer> putu16 -
  189. /putu16 {
  190.   3 copy -8 bitshift put
  191.   exch 1 add exch 16#ff and put
  192. } bind def
  193.  
  194. % <string> <index> <integer> putu32 -
  195. /putu32 {
  196.   3 copy -16 bitshift putu16
  197.   exch 2 add exch 16#ffff and putu16
  198. } bind def
  199.  
  200. % <nametable> <nameid> findname <string> true
  201. % <nametable> <nameid> findname false
  202. /findname {
  203.   DEBUG { (findname: ) print dup =only  } if
  204.   false 3 1 roll 0 1 3 index 2 getu16 1 sub {
  205.         % Stack: false table id index
  206.     12 mul 6 add 2 index exch 12 getinterval
  207.     dup 6 getu16 2 index eq {
  208.         % We found the name we want.
  209.       exch pop
  210.         % Stack: false table record
  211.       dup 10 getu16 2 index 4 getu16 add
  212.       1 index 8 getu16 4 -1 roll 3 1 roll getinterval exch
  213.         % Stack: false string record
  214.         % Check for 8- vs. 16-bit characters.
  215.       is2byte { string2to1 } if true null 4 -1 roll exit
  216.     } if pop
  217.   } for pop pop
  218.   DEBUG {
  219.     dup { ( = ) print 1 index == } { ( not found) = } ifelse
  220.   } if
  221. } bind def
  222.  
  223. % <namerecord> is2byte <bool>
  224. /is2byte {
  225.   dup 0 getu16 {
  226.     { pop true }        % Apple Unicode
  227.     { pop false }        % Macintosh Script manager
  228.     { 1 getu16 1 eq }        % ISO
  229.     { 1 getu16 1 eq }        % Microsoft
  230.   } exch get exec
  231. } bind def
  232.  
  233. % <string2> string2to1 <string>
  234. /string2to1 {
  235.   dup length 2 idiv string dup
  236.   0 1 3 index length 1 sub {
  237.     3 index 1 index 2 mul 1 add get put dup
  238.   } for pop exch pop
  239. } bind def
  240.  
  241. % <array> <lt-proc> sort <array>
  242. /sort {
  243.   1 index length 1 sub -1 1 {
  244.     2 index exch 2 copy get 3 copy    % arr proc arr i arr[i] arr i arr[i]
  245.     0 1 3 index 1 sub {
  246.       3 index 1 index get    % arr proc arr i arr[i] arr imax amax j arr[j]
  247.       2 index 1 index 10 index exec {    % ... amax < arr[j]
  248.     4 2 roll
  249.       } if pop pop
  250.     } for            % arr proc arr i arr[i] arr imax amax
  251.     4 -1 roll exch 4 1 roll put put
  252.   } for pop
  253. } def
  254.  
  255. % Each procedure in this dictionary is called as follows:
  256. %       <encodingtable> proc <glypharray>
  257. /cmapformats mark
  258.   0 {        % Apple standard 1-to-1 mapping.
  259.     6 256 getinterval { } forall 256 packedarray
  260.   } bind
  261.   4 {        % Microsoft/Adobe segmented mapping.
  262.     /etab exch def
  263.     /nseg2 etab 6 getu16 def
  264.     14 /endc etab 2 index nseg2 getinterval def
  265.         % The Apple TrueType documentation omits the 2-byte
  266.         % 'reserved pad' that follows the endCount vector!
  267.     2 add
  268.     nseg2 add /startc etab 2 index nseg2 getinterval def
  269.     nseg2 add /iddelta etab 2 index nseg2 getinterval def
  270.     nseg2 add /idroff etab 2 index nseg2 getinterval def
  271.         % The following hack allows us to properly handle
  272.         % idiosyncratic fonts that start at 0xf000:
  273.     pop
  274.     /firstcode startc 0 getu16 16#ff00 and dup 16#f000 ne { pop 0 } if def
  275.     /putglyph {
  276.       glyphs code 3 -1 roll put /code code 1 add def
  277.     } bind def
  278.         % Do a first pass to compute the size of the glyphs array.
  279.     /numcodes 0 def /glyphs 0 0 2 nseg2 3 sub {
  280.         % Stack: /glyphs numglyphs i2
  281.       /i2 exch def
  282.       /scode startc i2 getu16 def
  283.       /ecode endc i2 getu16 def
  284.       numcodes scode firstcode sub
  285.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  286.       dup 16#e000 ge { 255 and } if
  287.       exch sub 0 max ecode scode sub 1 add add
  288.       exch 1 index add exch
  289.       numcodes add /numcodes exch def
  290.     } for array def
  291.         % Now fill in the array.
  292.     /numcodes 0 def /code 0 def
  293.     0 2 nseg2 3 sub {
  294.       /i2 exch def
  295.       /scode startc i2 getu16 def
  296.       /ecode endc i2 getu16 def
  297.       numcodes scode firstcode sub
  298.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  299.       dup 16#e000 ge { 255 and } if
  300.       exch sub 0 max dup { 0 putglyph } repeat
  301.       ecode scode sub 1 add add numcodes add /numcodes exch def
  302.       /delta iddelta i2 gets16 def
  303.       DEBUG {
  304.     (scode=) print scode =only
  305.     ( ecode=) print ecode =only
  306.     ( delta=) print delta =only
  307.     ( droff=) print idroff i2 getu16 =
  308.       } if
  309.       idroff i2 getu16 dup 0 eq {
  310.     pop scode delta add 65535 and 1 ecode delta add 65535 and
  311.     { putglyph } for
  312.       } {    % The +2 is for the 'reserved pad'.
  313.         /gloff exch 14 nseg2 3 mul add 2 add i2 add add def
  314.         0 1 ecode scode sub {
  315.       2 mul gloff add etab exch getu16
  316.       dup 0 ne { delta add 65535 and } if putglyph
  317.     } for
  318.       } ifelse
  319.     } for glyphs /glyphs null def    % for GC
  320.   } bind
  321.   6 {        % Single interval lookup.
  322.     dup 6 getu16 /firstcode exch def dup 8 getu16 /ng exch def
  323.     firstcode ng add array
  324.         % Stack: tab array
  325.         % Fill elements 0 .. firstcode-1 with 0
  326.     0 1 firstcode 1 sub { 2 copy 0 put pop } for
  327.     dup firstcode ng getinterval
  328.         % Stack: tab array subarray
  329.         % Fill elements firstcode .. firstcode+nvalue-1 with glyph values
  330.     0 1 ng 1 sub {
  331.       dup 2 mul 10 add 4 index exch getu16 3 copy put pop pop
  332.     } for pop exch pop
  333.   } bind
  334. .dicttomark readonly def                % cmapformats
  335.  
  336. % <cmaptab> cmaparray <glypharray>
  337. /cmaparray {
  338.   dup 0 getu16 cmapformats exch .knownget {
  339.     DEBUG {
  340.       (cmap: format ) print 1 index 0 getu16 = flush
  341.     } if exec
  342.   } {
  343.     (Can't handle format ) print 0 getu16 = flush
  344.     0 1 255 { } for 256 packedarray
  345.   } ifelse
  346.   DEBUG {
  347.     (cmap: length=) print dup length = dup ==
  348.   } if
  349. } bind def
  350.  
  351. % Each procedure in this dictionary is called as follows:
  352. %       posttable <<proc>> glyphencoding
  353. /postformats mark
  354.   16#00010000  {    % 258 standard Macintosh glyphs.
  355.     pop MacGlyphEncoding
  356.   }
  357.   16#00020000  {    % Detailed map, required by Microsoft fonts.
  358.     /postglyphs exch def
  359.       postglyphs 32 getu16 /numglyphs exch def
  360.       /glyphnames numglyphs 2 mul 34 add def
  361.       [ 0 1 numglyphs 1 sub {
  362.     2 mul 34 add postglyphs exch getu16
  363.     dup 258 lt {
  364.       MacGlyphEncoding exch get
  365.     } {
  366.       dup 32768 ge {
  367.         % According to the published TrueType spec, such values are
  368.         % "reserved for future use", but at least some PDF files
  369.         % produced by the Adobe PDF library contain entries with a
  370.         % value of 16#ffff.
  371.         pop /.notdef
  372.       } {
  373.         258 sub glyphnames exch {
  374.           postglyphs 1 index get 1 add add
  375.         } repeat
  376.         1 add postglyphs exch 2 copy 1 sub get getinterval cvn
  377.         % At least some of Microsoft's TrueType fonts use incorrect
  378.         % (Adobe-incompatible) names for some glyphs.
  379.         % Correct for this here.
  380.         postremap 1 index .knownget { exch pop } if
  381.       } ifelse
  382.     } ifelse
  383.       } for ]
  384.   } bind
  385.   16#00030000  {    % No map.
  386.     pop [ ]
  387.   } bind
  388. .dicttomark readonly def                % postformats
  389.  
  390. % Each procedure in this dictionary is called as follows:
  391. %    <file> <length> -proc- <string|array_of_strings>
  392. % Note that each table must have an even length, because of a strange
  393. % Adobe requirement that each sfnts entry have even length.
  394. /readtables mark
  395.     % Ordinary tables
  396.   (cmap) { .readtable }
  397.   (head) 1 index
  398.   (hhea) 1 index
  399.   (maxp) 1 index
  400.   (name) 1 index
  401.   (OS/2) 1 index
  402.   (post) 1 index
  403.   (vhea) 1 index
  404.     % Big tables
  405.   (glyf) { .readbigtable }
  406.   (loca) 1 index
  407.   (hmtx) 1 index
  408.   (vmtx) 1 index
  409.     % Tables only needed for embedding in PDF files
  410.   (cvt ) { .readtable }
  411.   (fpgm) 1 index
  412.   (prep) 1 index
  413. .dicttomark
  414. % Normally there would be a 'readonly' here, but the ttf2pf utility wants
  415. % to include the 'kern' table as well, so we leave the readtables dictionary
  416. % writable.
  417. def                % readtables
  418.  
  419. % Read a table as a single string.
  420. % <file> <length> .readtable <string>
  421. /.readtable {
  422.   dup dup 1 and add string
  423.         % Stack: f len str
  424.   dup 0 4 -1 roll getinterval
  425.         % Stack: f str str1
  426.   3 -1 roll exch readstring pop pop
  427. } bind def
  428.  
  429. % Read a big table (one that may exceed 64K).
  430. % <file> <length> .readbigtable <string[s]>
  431. /.readbigtable {
  432.   dup 65400 lt {
  433.     .readtable
  434.   } {
  435.     currentuserparams /VMReclaim get -2 vmreclaim
  436.     [ 4 2 roll {
  437.         % Stack: mark ... f left
  438.       dup maxstring le { exit } if
  439.       1 index maxstring string readstring pop 3 1 roll maxstring sub
  440.     } loop .readtable ]
  441.     exch vmreclaim
  442.   } ifelse
  443. } bind def
  444.  
  445. end readonly def                % .loadttfontdict
  446.  
  447. % <tab> .printtab -
  448. /.printtab {
  449.   dup 0 4 getinterval print ( ) print
  450.   dup 8 getu32 =only ( ) print
  451.   12 getu32 =
  452. } bind def
  453.  
  454. % <file> .loadttfonttables -
  455. % Pushes .loadttfontdict & scratch dict on d-stack.
  456. % Defines f, offsets, tables, tabdict, tabs.
  457. /.loadttfonttables {
  458.   .loadttfontdict begin
  459.   40 dict begin
  460.   /f exch def
  461.   /offsets f 12 string readstring pop def
  462.   /tables f offsets 4 getu16 16 mul string readstring pop def
  463.   /tabdict tables length 16 idiv dict def
  464.     % tabs = tables we want to keep, sorted by file position.
  465.   /tabs [ 0 16 tables length 1 sub {
  466.     tables exch 16 getinterval
  467.     DEBUG { dup .printtab } if
  468.     dup 0 4 getinterval readtables 1 index known {
  469.       tabdict exch 2 index put
  470.     } {
  471.       pop pop
  472.     } ifelse
  473.   } for ] {
  474.     exch 8 getu32 exch 8 getu32 lt
  475.   } sort def
  476.     % In certain malformed TrueType fonts, tables overlap.
  477.     % Truncate tables if necessary.
  478.   0 1 tabs length 2 sub {
  479.     dup tabs exch get exch 1 add tabs exch get
  480.     1 index 8 getu32 2 index 12 getu32 add
  481.     1 index 8 getu32 gt {
  482.       (**** Warning: ) print 1 index 0 4 getinterval print
  483.       ( overlaps ) print dup 0 4 getinterval print
  484.       (, truncating.) = flush
  485.       dup 8 getu32 2 index 8 getu32 sub
  486.       2 index 12 3 -1 roll putu32
  487.     } if pop pop
  488.   } for
  489. } bind def
  490.  
  491. % - .readttdata -
  492. % Read data.  Updates offsets, tabs; stores data in tabdict.
  493. /.readttdata {
  494.   /fpos offsets length tables length add def
  495.   /sfpos offsets length tabs length 16 mul add def
  496.   offsets 4 tabs length putu16
  497.   tabs {
  498.     dup 0 4 getinterval /tname exch def
  499.     dup 8 getu32 /tpos exch def
  500.     dup 12 getu32 /tlen exch def
  501.     8 sfpos putu32
  502.     % Skip data between the end of the previous table and
  503.     % the beginning of this one, if any.
  504.     tpos fpos gt {
  505.       f tpos fpos sub () /SubFileDecode filter dup flushfile closefile
  506.       /fpos tpos def
  507.     } if
  508.     f tlen readtables tname get exec
  509.     tabdict tname 3 -1 roll put
  510.     /fpos fpos tlen add def
  511.     % Round up the table length to an even value.
  512.     /sfpos sfpos tlen dup 1 and add add def
  513.   } forall
  514. } bind def
  515.  
  516. % Find the string in a list of strings that includes a given index.
  517. % <strings> <index> .findseg <string> <index'>
  518. /.findseg {
  519.   exch {
  520.     dup length 2 index gt { exch exit } if
  521.     length sub
  522.   } forall
  523. } bind def
  524.  
  525. % - .makesfnts -
  526. % Defines checksum, getloca, head, locatable, numloca, post, sfnts, upem
  527. /.makesfnts {
  528.   .readttdata
  529.   /head tabdict /head get def
  530.   /locatable tabdict /loca get def
  531.   /post tabdict /post .knownget not { null } if def
  532.   /numloca
  533.     locatable dup type /stringtype eq
  534.      { length }
  535.      { 0 exch { length add } forall }
  536.     ifelse    % no def yet
  537.   locatable type /stringtype eq {
  538.     /.indexloca {} def
  539.   } {
  540.     /.indexloca /.findseg load def
  541.   } ifelse
  542.   head 50 getu16 0 ne {
  543.     /getloca {
  544.       2 bitshift locatable exch .indexloca getu32
  545.     } def
  546.     4 idiv 1 sub
  547.   } {
  548.     /getloca {
  549.       dup add locatable exch .indexloca getu16 dup add
  550.     } def
  551.     2 idiv 1 sub
  552.   } ifelse def        % numloca
  553.     % If necessary, re-partition the glyfs.
  554.   tabdict /glyf get dup type /stringtype ne {
  555.     .dividesfnts tabdict /glyf 3 -1 roll put
  556.   } {
  557.     pop
  558.   } ifelse
  559.   /sfnts [
  560.     offsets tabs { concatstrings } forall
  561.     tabs {
  562.       0 4 getinterval tabdict exch get
  563.       dup type /stringtype ne { aload pop } if
  564.     } forall
  565.   ] def
  566. } bind def
  567.  
  568. % <glyfs> .dividesfnts <glyfs'>
  569. /.dividesfnts {
  570.   /glyfs exch def
  571.   /len1 0 glyfs { length add } forall def
  572.         % Determine where to split the glyfs by scanning loca.
  573.         % The very last entry in loca may be bogus.
  574.         % Note that some loca entries may be odd, but we can only
  575.         % split at even positions.
  576.         %
  577.         % Construct splitarray, the array of final lengths of
  578.         % the sfnts entries covering the glyfs (i.e., all but
  579.         % the first and last sfnts entries).
  580.     /prevsplit 0 def
  581.     /prevboundary 0 def
  582.     /splitarray [
  583.       0 1 numloca 1 sub {
  584.     getloca dup prevsplit maxstring add gt {
  585.       prevboundary prevsplit sub exch
  586.       /prevsplit prevboundary def
  587.     } if
  588.     dup 1 and 0 eq { /prevboundary exch def } { pop } ifelse
  589.       } for
  590.       len1 prevsplit sub
  591.     ] def
  592.     currentuserparams /VMReclaim get -2 vmreclaim
  593.     [
  594.         % Re-split the sfnts glyfs strings according to splitarray.
  595.         % We do this by iterating over the final segments defined
  596.         % by splitarray, and constructing them from pieces of the
  597.         % current glyfs strings.  We recycle the current strings
  598.         % when possible, to avoid stressing the allocator.
  599.       /sfnt_idx 0 def
  600.       /strpos 0 def
  601.       /avail () def
  602.       splitarray {
  603.     /seglen exch def
  604.     /segpos 0 def
  605.     avail length seglen ge
  606.       { avail 0 seglen getinterval /avail () def } { seglen string }
  607.     ifelse
  608.     {
  609.       /str glyfs sfnt_idx get def
  610.       /strlen str length def
  611.       /strleft strlen strpos sub def
  612.       seglen segpos sub strleft lt { exit } if
  613.         % Copy the (rest of the) string into the new segment.
  614.         % We know strleft <= segleft.
  615.       dup segpos str strpos strleft getinterval putinterval
  616.       /segpos segpos strleft add def
  617.       /avail str def
  618.       /sfnt_idx sfnt_idx 1 add def
  619.       /strpos 0 def
  620.       segpos seglen eq { exit } if
  621.     } loop
  622.         % Fill up the segment with an initial piece of the next
  623.         % existing glyfs string.  We know strleft > segleft.
  624.     /segleft seglen segpos sub def
  625.     dup segpos str strpos segleft getinterval putinterval
  626.     /strpos strpos segleft add def
  627.       } forall
  628.     ]
  629.     exch vmreclaim
  630. } bind def
  631.  
  632. % - .getpost -
  633. % Uses post, defines glyphencoding
  634. /.getpost {
  635.   /glyphencoding post null eq {
  636.     DEBUG { (post missing) = flush } if [ ]
  637.   } {
  638.     postformats post 0 getu32 .knownget {
  639.       DEBUG {
  640.     (post: format ) print
  641.     post 0 getu16 =only (,) print post 2 getu16 = flush
  642.       } if
  643.       post exch exec
  644.     } {
  645.       DEBUG { (post: unknown format ) print post 0 getu32 = flush } if [ ]
  646.     } ifelse
  647.   } ifelse def
  648. } bind def
  649.  
  650. % - .ttkeys <key> <value> ...
  651. /.ttkeys {
  652.   count /ttkeycount exch def
  653.   /upem head 18 getu16 def
  654.   /FontMatrix matrix
  655.   /FontBBox [ 36 2 42 { head exch gets16 upem div } for ]
  656.   nextxuid
  657.   tabdict /name .knownget {
  658.         % Find the names from the 'name' table.
  659.     /names exch def
  660.     /FontName names 6 findname not { curxuid 16 8 string cvrs } if
  661.       /fontname 1 index def
  662.     /FontInfo mark
  663.       names 0 findname { /Notice exch } if
  664.       names 1 findname { /FamilyName exch } if
  665.       names 4 findname { /FullName exch } if
  666.       names 5 findname { /Version exch } if
  667.   } {
  668.         % No name table, fabricate a FontName.
  669.     /FontName curxuid 16 8 string cvrs
  670.       /fontname 1 index def
  671.     /FontInfo mark
  672.   } ifelse
  673.         % Stack: ... /FontInfo mark key1 value1 ...
  674.   post null ne {
  675.     /ItalicAngle post 4 gets32 65536.0 div
  676.     /isFixedPitch post 12 getu32 0 ne
  677.     /UnderlinePosition post 8 gets16 upem div
  678.     /UnderlineThickness post 10 gets16 upem div
  679.   } if
  680.   counttomark 0 ne { .dicttomark } { pop pop } ifelse
  681.   /XUID [orgXUID 42 curxuid]
  682.   DEBUG {
  683.     tabs { .printtab } forall
  684.     [ sfnts { length } forall ] ==
  685.     count ttkeycount sub array astore dup { == } forall aload pop
  686.   } if
  687.   /sfnts sfnts
  688. } bind def
  689.  
  690. % ---------------- Standard TrueType font loading ---------------- %
  691.  
  692. % - .pickcmap -
  693. % Defines cmapsub, cmaptab
  694. /.pickcmap {
  695.   tabdict /cmap get
  696.         % The Apple cmap format is no help in determining the encoding.
  697.         % Look for a Microsoft table.  If we can't find one,
  698.         % just use the first table, whatever it is.
  699.   dup 4 8 getinterval exch             % the default
  700.   0 1 2 index 2 getu16 1 sub {
  701.     8 mul 4 add 1 index exch 8 getinterval
  702.     DEBUG {
  703.       (cmap: platform ) print dup 0 getu16 =only
  704.       ( encoding ) print dup 2 getu16 = flush
  705.     } if
  706.     dup 0 getu16 3 eq { exch 3 -1 roll pop exit } if pop
  707.   } for
  708.         % Stack: subentry table
  709.   /cmapsub 2 index def
  710.   exch 4 getu32 1 index length 1 index sub getinterval
  711.   /cmaptab exch def
  712. } bind def
  713.  
  714. % <glyph> .nname <_name>
  715. /.nname {
  716.   =string cvs (_) exch concatstrings cvn
  717. } bind def
  718.  
  719. % - .charkeys /CharStrings <charstrings> /Encoding <encoding>
  720. % Resets glyphencoding
  721. /.charkeys {
  722.   DEBUG {
  723.     (glyphencoding: length=) print glyphencoding dup length = === flush
  724.   } if
  725.         % Hack: if there is no usable post table but the cmap uses
  726.         % the Microsoft Unicode encoding, use ISOLatin1Encoding.
  727.   glyphencoding length 0 eq cmapsub 0 4 getinterval <00030001> eq and {
  728.     /glyphencoding ISOLatin1Encoding dup length array copy def
  729.   } if
  730.         % If necessary, fabricate additional glyphencoding entries
  731.         % to cover all of loca, or truncate glyphencoding.
  732.   glyphencoding length numloca lt {
  733.     /glyphencoding [ glyphencoding aload pop
  734.     counttomark 1 numloca 1 sub { .nname } for ] def
  735.   } {
  736.     /glyphencoding glyphencoding 0 numloca getinterval def
  737.   } ifelse
  738.         % Some badly designed Chinese fonts have a post table
  739.         % in which all glyphs other than 0 are named .null.
  740.         % Use CharStrings to keep track of the reverse map from
  741.         % names to glyphs, and don't let any name be used for
  742.         % more than one glyph.
  743.   /CharStrings glyphencoding dup length 1 add dict    % +1 for .notdef
  744.     0 1 3 index length 1 sub {
  745.         % Stack: glyphencoding dict index
  746.       2 index 1 index get 2 index 1 index known {
  747.         % The same name maps to more than one glyph.
  748.         % Change the name.
  749.     pop dup .nname 3 index 2 index 2 index put
  750.       } if
  751.       2 index exch 3 -1 roll put
  752.     } for exch pop
  753.         % If there is no .notdef entry, map it to glyph 0.
  754.   dup /.notdef known not { dup /.notdef 0 put } if
  755.   readonly
  756.   /Encoding
  757.     [ cmaptab cmaparray dup length 256 gt { 0 256 getinterval } if
  758.     { glyphencoding exch get } forall
  759.     counttomark 256 exch sub { /.notdef } repeat ]
  760.   DEBUG { (Encoding: ) print dup === flush } if
  761. } bind def
  762.  
  763. % -mark- <key> <value> ... .definettfont <font>
  764. /.definettfont {
  765.   /FontType 42
  766.   /PaintType 0
  767.   DEBUG {
  768.     (numloca=) print numloca =
  769.   } if
  770.   .dicttomark
  771.   end end dup /FontName get exch definefont
  772. } bind def
  773.  
  774. % <file> .loadttfont <type42font>
  775. /.loadttfont {
  776.   .loadttfonttables
  777.   .makesfnts
  778.   .getpost
  779.   .pickcmap
  780.   mark
  781.   .charkeys
  782.   .ttkeys
  783.   .definettfont
  784. } bind def
  785.  
  786. % ---------------- CIDFontType 2 font loading ---------------- %
  787.  
  788. % Create a string with N CIDs from the top of the stack.
  789. % <cid1> ... <cidN> <N> .makecidmap <string>
  790. /.makecidmap {
  791.   dup 2 mul string dup 3 -1 roll 1 sub 2 mul -2 0 {
  792.         % Stack: cids str str i2
  793.     2 copy 5 index -8 bitshift put
  794.     1 add 4 -1 roll 16#ff and put dup
  795.   } for pop
  796. } bind def
  797.  
  798. % -mark- <key> <value> ... .definettcidfont <font>
  799. /.definettcidfont {
  800.   /CIDFontName fontname
  801.   /CIDFontType 2
  802.   /CIDSystemInfo mark
  803.     /Registry (Adobe)
  804.     /Ordering (Japan1)        % adhoc
  805.     /Supplement 0
  806.   .dicttomark
  807.   /CharStrings mark /.notdef 0 .dicttomark
  808.         % The cmap isn't of any use even if it is present.
  809.         % Just construct an identity CIDMap covering all the glyphs.
  810.   mark 0 1 numloca 1 sub { } for
  811.   counttomark /cidcount exch def
  812.   cidcount maxstring le {
  813.         % Use a single string.
  814.     cidcount .makecidmap exch pop
  815.   } {
  816.         % We must use 2 strings.
  817.     maxstring .makecidmap counttomark 1 add 1 roll
  818.     counttomark .makecidmap exch pop exch 2 array astore
  819.   } ifelse
  820.   /CIDMap exch
  821.   /CIDCount cidcount
  822.   /GDBytes 2
  823.   .dicttomark
  824.   end end dup /CIDFontName get exch /CIDFont defineresource
  825. } bind def
  826.  
  827. % <file> .loadttcidfont <cidtype2font>
  828. /.loadttcidfont {
  829.   .loadttfonttables
  830.   .makesfnts
  831.     % CIDFontType2 fonts don't have a cmap: they are indexed by CID.
  832.   mark
  833.   .ttkeys
  834.   .definettcidfont
  835. } bind def
  836.  
  837. % ---------------- PDF TrueType font loading ---------------- %
  838.  
  839. % Strictly speaking, this code should be loaded only if we have a PDF
  840. % interpreter, but it's so closely tied to the rest of the code in this
  841. % file that we always include it.
  842.  
  843. % <plat+enc> .findcmap <subtable> true
  844. % <plat+enc> .findcmap false
  845. /.findcmap {
  846.   false exch tabdict /cmap get
  847.         % Some fonts have multiple cmaps with the same platform and
  848.         % encoding.  Use the first one we find.
  849.   0 1 2 index 2 getu16 1 sub {
  850.         % Stack: false plat+enc cmap index
  851.     8 mul 4 add 1 index exch 8 getinterval 
  852.     dup 0 4 getinterval 3 index eq {
  853.       4 getu32 1 index exch 1 index length 1 index sub getinterval
  854.       4 -1 roll not 4 2 roll exit
  855.     } if pop
  856.   } for
  857.         % Stack: false plat+enc cmap || subtable true plat+enc cmap
  858.   pop pop
  859. } bind def
  860.  
  861. % <subcmap> <chartoglyphmap> .pdfmapchars
  862. %   /CharStrings <charstrings> /Encoding <encoding>
  863. % Uses encoding
  864. /.pdfmapchars {
  865.   exch cmaparray /cmapencoding exch def
  866.     % Invert glyphencoding (post).
  867.   /inversepost glyphencoding length dict def
  868.   0 1 glyphencoding length 1 sub {
  869.     glyphencoding 1 index get exch inversepost 3 1 roll put
  870.   } for
  871.   /CharStrings mark 3 -1 roll {
  872.     dup type /arraytype eq {
  873.       exch /ch exch def { ch exch .pdfaddchar } forall
  874.     } {
  875.       .pdfaddchar
  876.     } ifelse
  877.   } forall
  878.     % Add a .notdef => 0 entry if needed.  Per Adobe's spec,
  879.     % .dicttomark (>>) adds pairs in top-to-bottom order.
  880.   /.notdef 0
  881.   .dicttomark
  882.   /Encoding encoding
  883. } bind def
  884. % <charname> <charcode> .pdfaddchar <charname> <glyph#>
  885. % <charname> <charcode> .pdfaddchar -
  886. /.pdfaddchar {
  887.   dup cmapencoding length lt {
  888.     cmapencoding exch get dup 0 eq {
  889.       pop .pdfaddpost
  890.     } if
  891.   } {
  892.     pop .pdfaddpost
  893.   } ifelse
  894. } bind def
  895. % <charname> .pdfaddpost <charname> <glyph#>
  896. % <charname> .pdfaddpost -
  897. /.pdfaddpost {
  898.   inversepost 1 index .knownget not { pop } if
  899. } bind def
  900.  
  901. % - .pdfcharkeys /CharStrings <charstrings> /Encoding <encoding>
  902. /.pdfcharkeys {
  903.     % The following algorithms are per the PDF Reference, Second Edition
  904.     % (PDF 1.3 reference manual).
  905.   encoding null eq {
  906.     .charkeys        % use default algorithm
  907.   } {
  908.     <00030001> .findcmap {
  909.       AdobeGlyphList .pdfmapchars
  910.     } {
  911.       <00010000> .findcmap {
  912.     .romanmacdict .pdfmapchars
  913.       } {
  914.     .charkeys    % use default algorithm
  915.       } ifelse
  916.     } ifelse
  917.   } ifelse
  918. } bind def
  919.  
  920. % <file> <encoding|null> .loadpdfttfont <type42font>
  921. /.loadpdfttfont {
  922.   exch .loadttfonttables
  923.   /encoding exch def
  924.   .makesfnts
  925.   .getpost
  926.   .pickcmap
  927.   mark
  928.   .pdfcharkeys
  929.   .ttkeys
  930.   .definettfont
  931. } bind def
  932.