home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dtp / ghostscript / 5.10 / gs_ttf.ps < prev    next >
Encoding:
Text File  |  1997-12-28  |  14.3 KB  |  462 lines
  1. %    Copyright (C) 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % Support code for direct use of TrueType fonts.
  19. % (Not needed for Type 42 fonts.)
  20.  
  21. % ---------------- Font loading machinery ---------------- %
  22.  
  23. % Augment the FONTPATH machinery so it recognizes TrueType fonts.
  24.  
  25. /.scanfontheaders where        % only defined if DISKFONTS is recognized
  26.  { pop
  27.    /.scanfontheaders [ .scanfontheaders aload pop (\000\001\000\000*) ] def
  28.  }
  29. if
  30. /.findnonttfontvalue /.findfontvalue load def
  31. /.findfontvalue        % <file> <key> .findfontvalue <value> true
  32.             % <file> <key> .findfontvalue false
  33.             % Closes the file in either case.
  34.  { 1 index read pop 2 index 1 index unread 0 eq
  35.     {        % If this is a font at all, it's a TrueType font.
  36.       dup /FontType eq
  37.        { pop closefile 42 true }
  38.        { dup /FontName eq
  39.       { pop .findttfontname }
  40.       { pop closefile false }
  41.      ifelse
  42.        }
  43.       ifelse
  44.     }
  45.     {        % Not a TrueType font.
  46.       .findnonttfontvalue
  47.     }
  48.    ifelse
  49.  } bind def
  50. /.findttfontname    % <file> .findttfontname <fname> true
  51.             % <file> .findttfontname false
  52.             % Closes the file in either case.
  53.  { .loadttfonttables
  54.    (name) findtableentry
  55.     { dup 8 getu32 f exch setfileposition
  56.       12 getu32 string f exch readstring pop
  57.       6 findname
  58.     }
  59.     { false
  60.     }
  61.    ifelse
  62.    f closefile end end
  63.  } bind def
  64.  
  65. % Load a font file that might be a TrueType font.
  66.  
  67. /.loadnonttfontfile /.loadfontfile load def
  68. /.loadfontfile        % <file> .loadfontfile -
  69.  { dup read pop 2 copy unread 0 eq
  70.     {        % If this is a font at all, it's a TrueType font.
  71.       .loadttfont pop
  72.     }
  73.     {        % Not a TrueType font.
  74.       .loadnonttfontfile
  75.     }
  76.    ifelse
  77.  } bind def
  78.  
  79. % ---------------- Automatic Type 42 generation ---------------- %
  80.  
  81. % Load a TrueType font from a file as a Type 42 PostScript font.
  82. % The thing that makes this really messy is the handling of encodings.
  83. % There are 3 interacting tables that affect the encoding:
  84. %    'cmap' provides multiple maps from character codes to glyph indices
  85. %    'glyf' maps glyph indices to outlines
  86. %    'post' maps glyph indices to glyph names (if present)
  87. % What we need to get out of this is:
  88. %    Encoding mapping character codes to glyph names
  89. %      (the composition of cmap and post)
  90. %    CharStrings mapping glyph names to glyph indices
  91. %      (the inverse of post)
  92. % If the post table is missing, we have to take a guess based on the cmap
  93. % table.
  94.  
  95. /.loadttfontdict mark
  96. /orgXUID 107 def    % Aladdin Enterprises organization XUID
  97. /maxstring 65500 def    % maximum length of a PostScript string
  98.  
  99. % Define the Macintosh standard mapping from characters to glyph indices.
  100. /MacRomanEncoding dup .findencoding def
  101. /MacGlyphEncoding mark
  102.     /.notdef /.null /CR
  103. MacRomanEncoding 32 95 getinterval aload pop
  104. MacRomanEncoding 128 45 getinterval aload pop
  105. % 143
  106.     /notequal /AE
  107.     /Oslash /infinity /plusinus /lessequal /greaterequal
  108.     /yen /mu1 /partialdiff /summation /product
  109.     /pi /integral /ordfeminine /ordmasculine /Ohm
  110.     /ae /oslash /questiondown /exclamdown /logicalnot
  111.     /radical /florin /approxequal /increment /guillemotleft
  112.     /guillemotright /ellipsis /nbspace
  113. MacRomanEncoding 203 12 getinterval aload pop
  114.     /lozenge
  115. MacRomanEncoding 216 24 getinterval aload pop
  116.     /applelogo
  117. MacRomanEncoding 241 7 getinterval aload pop
  118.     /overscore
  119. MacRomanEncoding 249 7 getinterval aload pop
  120. % 226
  121.     /Lslash /lslash /Scaron /scaron
  122.     /Zcaron /zcaron /brokenbar /Eth /eth
  123.     /Yacute /yacute /Thorn /thorn /minus
  124.     /multiply /onesuperior /twosuperior /threesuperior /onehalf
  125.     /onequarter /threequarters /franc /Gbreve /gbreve
  126.     /Idot /Scedilla /scedilla /Cacute /cacute
  127.     /Ccaron /ccaron /dmacron
  128. /packedarray where
  129.  { pop counttomark packedarray exch pop }
  130.  { ] readonly }
  131. ifelse def
  132.  
  133. % Procedures
  134. /getu16            % <string> <index> getu16 <integer>
  135.  { 2 copy get 8 bitshift 3 1 roll 1 add get add
  136.  } bind def
  137. /gets16            % <string> <index> gets16 <integer>
  138.  { getu16 16#8000 xor 16#8000 sub
  139.  } bind def
  140. /getu32            % <string> <index> getu32 <integer>
  141.  { 2 copy getu16 16 bitshift 3 1 roll 2 add getu16 add
  142.  } bind def
  143. /gets32            % <string> <index> gets32 <integer>
  144.  { getu32 dup 16#7fffffff gt { 4 { 16#40000000 sub } repeat } if
  145.  } bind def
  146. /getrange        % <offset> <length> getrange <string>
  147.             % Free variables: sfnts
  148.  { () sfnts
  149.     {        % Stack: offset length () sfnt
  150.       dup length 4 index gt { exch pop exit } if
  151.       4 -1 roll exch length sub 3 1 roll
  152.     }
  153.    forall 3 1 roll getinterval
  154.  } bind def
  155. /findtableentry        % <name4> findtableentry <tableentry> true
  156.             % <name4> findtableentry false
  157.             % Free variables: tables
  158.  { false 0 16 tables length 16 sub
  159.     {        % Stack: name4 false toffset
  160.       tables 1 index 4 getinterval 3 index eq
  161.        { tables exch 16 getinterval
  162.      exch pop exch true exit
  163.        }
  164.       if pop
  165.     }
  166.    for exch pop
  167.  } bind def
  168. /findtable        % <name4> findtable <table> true
  169.             % <name4> findtable false
  170.             % Free variables: tables
  171.  { findtableentry
  172.     { dup 8 getu32 exch 12 getu32 getrange true }
  173.     { false }
  174.    ifelse
  175.  } bind def
  176. /findname        % <nametable> <nameid> findname <string> true
  177.             % <nametable> <nameid> findname false
  178.  { false 3 1 roll 0 1 3 index 2 getu16 1 sub
  179.     {        % Stack: false table id index
  180.       12 mul 6 add 2 index exch 12 getinterval
  181.       dup 6 getu16 2 index eq
  182.        {    % We found the name we want.
  183.      exch pop
  184.         % Stack: false table record
  185.      dup 10 getu16 2 index 4 getu16 add
  186.      1 index 8 getu16 4 -1 roll 3 1 roll getinterval exch
  187.         % Stack: false string record
  188.         % Check for 8- vs. 16-bit characters.
  189.      is2byte { string2to1 } if true null 4 -1 roll exit
  190.        }
  191.       if pop
  192.     }
  193.    for pop pop
  194.  } bind def
  195. /is2byte        % <namerecord> is2byte <bool>
  196.  { dup 0 getu16
  197.     { { pop true }        % Apple Unicode
  198.       { pop false }        % Macintosh Script manager
  199.       { 1 getu16 1 eq }        % ISO
  200.       { 1 getu16 1 eq }        % Microsoft
  201.     }
  202.    exch get exec
  203.  } bind def
  204. /string2to1        % <string2> string2to1 <string>
  205.  { dup length 2 idiv string dup
  206.    0 1 3 index length 1 sub
  207.     { 3 index 1 index 2 mul 1 add get put dup }
  208.    for pop exch pop
  209.  } bind def
  210. /cmapformats mark
  211.         % Each procedure in this dictionary is called as follows:
  212.         %    -mark- encodingtable <<proc>> -mark- glyphindices...
  213.   0        % Apple standard 1-to-1 mapping.
  214.     { 6 256 getinterval { } forall
  215.     } bind
  216.   4        % Microsoft/Adobe segmented mapping.
  217.     { /etab exch def
  218.       /nseg2 etab 6 getu16 def
  219.       14 /endc etab 2 index nseg2 getinterval def
  220.         % The Apple TrueType documentation omits the 2-byte
  221.         % 'reserved pad' that follows the endCount vector!
  222.       2 add
  223.       nseg2 add /startc etab 2 index nseg2 getinterval def
  224.       nseg2 add /iddelta etab 2 index nseg2 getinterval def
  225.       nseg2 add /idroff etab 2 index nseg2 getinterval def
  226.         % The following hack allows us to properly handle
  227.         % idiosyncratic fonts that start at 0xf000:
  228.       /firstcode startc 0 getu16 16#ff00 and def
  229.       pop 0 2 nseg2 3 sub
  230.        { /i2 exch def
  231.          /scode startc i2 getu16 def
  232.      counttomark scode firstcode sub 256 min exch sub 0 max { 0 } repeat
  233.      /ecode endc i2 getu16 def
  234.      /delta iddelta i2 getu16 def
  235.      idroff i2 getu16 dup 0 eq
  236.       { pop scode 1 ecode { delta add 65535 and } for
  237.       }
  238.       {    % The +2 is for the 'reserved pad'.
  239.         /gloff exch 14 nseg2 3 mul add 2 add i2 add add def
  240.         0 1 ecode scode sub
  241.          { 2 mul gloff add etab exch getu16
  242.            dup 0 ne { delta add 65535 and } if
  243.          }
  244.         for
  245.       }
  246.      ifelse
  247.        }
  248.       for
  249.     } bind
  250.   6        % Single interval lookup.
  251.     { dup 6 getu16 { 0 exch } repeat
  252.       dup 8 getu16 0 exch 1 exch 1 sub
  253.        { 2 mul 10 add 2 copy getu16 exch pop exch }
  254.       repeat pop
  255.     } bind
  256. .dicttomark readonly def        % cmapformats
  257. /cmaparray        % <cmaptab> cmaparray -mark- <glyphs> ...
  258.  { mark exch dup 0 getu16 cmapformats exch .knownget
  259.     { exec }
  260.     { (Can't handle format ) print 0 getu16 = flush
  261.       0 1 255 { } for
  262.     }
  263.    ifelse
  264.  } bind def
  265. /postformats mark
  266.         % Each procedure in this dictionary is called as follows:
  267.         %    posttable <<proc>> glyphencoding
  268.   16#00020000    % Detailed map, required by Microsoft fonts.
  269.     { /postglyphs exch def
  270.       postglyphs 32 getu16 /numglyphs exch def
  271.       /glyphnames numglyphs 2 mul 34 add def
  272.       [ 0 1 numglyphs 1 sub
  273.        { 2 mul 34 add postglyphs exch getu16
  274.      dup 258 lt
  275.       { MacGlyphEncoding exch get
  276.       }
  277.       { 258 sub glyphnames exch
  278.          { postglyphs 1 index get 1 add add }
  279.         repeat
  280.         1 add postglyphs exch 2 copy 1 sub get getinterval cvn
  281.       }
  282.      ifelse
  283.        }
  284.       for ]
  285.     } bind
  286. .dicttomark readonly def        % postformats
  287. .dicttomark readonly def        % .loadttfontdict
  288. /.loadttfonttables    % <file> .loadttfonttables -
  289.             % Pushes .loadttfontdict & scratch dict on d-stack,
  290.             % defines f, offsets, tables
  291.  { .loadttfontdict begin
  292.    40 dict begin
  293.    /f exch def
  294.    /offsets f 12 string readstring pop def
  295.    /tables f offsets 4 getu16 16 mul string readstring pop def
  296.  } bind def
  297. /.readsfnts0 {        % <len0> .readsfnts0 <string>
  298.    dup string
  299.      dup 0 offsets putinterval
  300.      dup offsets length tables putinterval
  301.      dup offsets length tables length add
  302.             % Stack: len0 str str off+tab
  303.        3 index 1 index sub getinterval
  304.        f exch dup length 0 ne { readstring } if pop pop
  305.    exch pop
  306. } bind def
  307. /.dividesfnts {        % <length> .dividesfnts -
  308.    (glyf) findtableentry pop
  309.    dup 8 getu32 /len0 exch def
  310.    12 getu32 /len1 exch def
  311.    len0 len1 add sub /len2 exch def
  312.    /sfnts [
  313.    len0 .readsfnts0
  314.    len1 dup maxstring gt
  315.     {        % Bad news: we'll have to split the glyfs.
  316.         % Right now we only provide for splitting into 2 parts,
  317.         % but we could generalize this without too much trouble.
  318.       f maxstring string readstring pop
  319.       exch maxstring sub
  320.     }
  321.    if string f exch readstring pop
  322.    len2 0 ne { f len2 string readstring pop } if
  323.    ] def
  324.    /head (head) findtable pop def
  325.    len1 maxstring gt
  326.     {        % Determine where to split the glyfs by scanning loca.
  327.         % The very last entry in loca may be bogus.
  328.         % What a nuisance!
  329.       (loca) findtable pop dup length
  330.       head 50 getu16 0 ne
  331.        {    % 32-bit loca
  332.      8 sub -4 0
  333.       { 1 index exch getu32 dup maxstring le { exch pop exit } if pop }
  334.        }
  335.        {    % 16-bit loca
  336.      4 sub -2 0
  337.       { 1 index exch getu16 1 bitshift dup maxstring le { exch pop exit } if pop }
  338.        }
  339.       ifelse for
  340.         % Now the top element of the stack is the length of
  341.         % the first glyf string.
  342.       sfnts 1 get dup 0 3 index getinterval
  343.     sfnts exch 1 exch put
  344.       exch 1 index length 1 index sub getinterval
  345.     sfnts 2 get concatstrings sfnts exch 2 exch put
  346.     }
  347.    if
  348. } bind def
  349. /.makesfnts        % - .makesfnts -
  350.             % Defines head, sfnts
  351.  {        % Find the end of the last table, and also the end of
  352.         % the last table below the 64K mark.
  353.    0 8 16 tables length
  354.     {        % Stack: end toffset
  355.       DEBUG
  356.        { tables 1 index 8 sub 4 getinterval print ( ) print
  357.      tables 1 index getu32 =only ( ) print
  358.      tables 1 index 4 add getu32 =
  359.        }
  360.       if
  361.       tables 1 index getu32 exch tables exch 4 add getu32 add max
  362.     }
  363.    for
  364.    dup maxstring le {
  365.      .readsfnts0
  366.         % Pad to even length if necessary, per Adobe specification.
  367.      dup length 2 mod 0 ne {
  368.        <00> concatstrings
  369.      } if
  370.      1 array astore /sfnts exch def
  371.      /head (head) findtable pop def
  372.    } {
  373.         % If the total length exceeds maxstring, divide the data
  374.         % into 2+n strings: before glyf, glyfs, after glyf
  375.      .dividesfnts
  376.    } ifelse
  377.  } bind def
  378. /.loadttfont        % <file> .loadttfont <type42font>
  379.  { .loadttfonttables
  380.    .makesfnts
  381.    /upem head 18 getu16 def
  382.    (cmap) findtable pop
  383.            % The Apple cmap format is no help in determining the encoding.
  384.         % Look for a Microsoft table.  If we can't find one,
  385.         % just use the first table, whatever it is.
  386.    dup 4 8 getinterval exch        % the default
  387.    0 1 2 index 2 getu16 1 sub
  388.     { 8 mul 4 add 1 index exch 8 getinterval
  389.       dup 0 getu16 3 eq { exch 3 -1 roll pop exit } if pop
  390.     }
  391.    for
  392.         % Stack: subentry table
  393.    /cmapsub 2 index def
  394.    exch 4 getu32 1 index length 1 index sub getinterval
  395.    /cmaptab exch def
  396.         % See if we have PostScript glyph name information.
  397.    /post (post) findtable not { null } if def
  398.    /glyphencoding post null eq
  399.     { MacGlyphEncoding }
  400.     { postformats post 0 getu32 .knownget
  401.        { post exch exec }
  402.        { MacGlyphEncoding }
  403.      ifelse
  404.     }
  405.    ifelse def
  406.    /checksum head 8 getu32 def
  407.    mark
  408.      /FontType 42
  409.      /FontMatrix matrix
  410.      /PaintType 0
  411.      /FontBBox [ 36 2 42 { head exch gets16 upem div } for ]
  412.      (name) findtable
  413.       {        % Find the names from the 'name' table.
  414.     /names exch def
  415.     /FontName names 6 findname not { checksum 16 8 string cvrs } if
  416.     /FontInfo mark
  417.       names 0 findname { /Notice exch } if
  418.       names 1 findname { /FamilyName exch } if
  419.       names 4 findname { /FullName exch } if
  420.       names 5 findname { /Version exch } if
  421.       }
  422.       {        % No name table, fabricate a FontName.
  423.     /FontName checksum 16 8 string cvrs
  424.     /FontInfo mark
  425.       }
  426.      ifelse
  427.         % Stack: /FontInfo mark key1 value1 ...
  428.      post null ne
  429.       { /ItalicAngle post 4 gets32 65536.0 div
  430.     /isFixedPitch post 12 getu32 0 ne
  431.     /UnderlinePosition post 8 gets16 upem div
  432.     /UnderlineThickness post 10 gets16 upem div
  433.       }
  434.      if
  435.      counttomark 0 ne
  436.       { .dicttomark }
  437.       { pop pop }
  438.      ifelse
  439.      /Encoding
  440.        cmaptab cmaparray
  441.        counttomark array astore { glyphencoding exch get } forall
  442.        counttomark 256 sub dup 0 ge
  443.     { { pop } repeat }
  444.     { neg { /.notdef } repeat }
  445.        ifelse ]
  446.         % Until we can compute the MD5 fingerprint,
  447.         % just use the precomputed checksum.
  448.      /XUID [orgXUID 42 checksum]
  449.      /CharStrings glyphencoding dup length dict
  450.        0 1 3 index length 1 sub
  451.     {    % Stack: glyphencoding dict index
  452.       2 index 1 index get 2 index 1 index known
  453.        { pop pop }
  454.        { 2 index exch 3 -1 roll put }
  455.       ifelse
  456.     }
  457.        for exch pop readonly
  458.      /sfnts sfnts
  459.    .dicttomark
  460.    end end dup /FontName get exch definefont
  461.  } bind def
  462.