% Copyright (C) 1994, 2000 Aladdin Enterprises. All rights reserved. % % This software is provided AS-IS with no warranty, either express or % implied. % % This software is distributed under license and may not be copied, % modified or distributed except as expressly authorized under the terms % of the license contained in the file LICENSE in this distribution. % % For more information about licensing, please refer to % http://www.ghostscript.com/licensing/. For information on % commercial licensing, go to http://www.artifex.com/licensing/ or % contact Artifex Software, Inc., 101 Lucas Valley Road #110, % San Rafael, CA 94903, U.S.A., +1(415)492-9861. % $Id: gs_type1.ps,v 1.16 2004/12/15 23:21:33 igor Exp $ % Type 1 font support code. % The standard representation for PostScript compatible fonts is described % in the book "Adobe Type 1 Font Format", published by Adobe Systems Inc. % Define an augmented version of .buildfont1 that inserts UnderlinePosition % and UnderlineThickness entries in FontInfo if they aren't there already, % and FontBBox isn't degenerate. % (This works around the incorrect assumption, made by many word processors, % that these entries are present in the built-in fonts.) /.buildfont1 { dup .fontbbox { pop pop pop pop dup /FontInfo known not { .growfontdict dup /FontInfo 2 dict put } if dup dup /FontInfo get dup dup /UnderlinePosition known exch /UnderlineThickness known and { pop pop % entries already present } { dup length 2 add dict .copydict dup /UnderlinePosition known not { dup /UnderlinePosition 3 index /FontBBox get 1 get 2 div put % 1/2 the font descent } if dup /UnderlineThickness known not { dup /UnderlineThickness 3 index /FontBBox get dup 3 get exch 1 get sub 20 div put % 1/20 the font height } if 1 index /FontInfo get wcheck not { readonly } if /FontInfo exch put } ifelse } if //.buildfont1 } bind def % If the diskfont feature isn't included, define a dummy .loadfontdict. /.loadfontdict where { pop } { /.loadfontdict 0 dict readonly def } ifelse /.loadfontfile % .loadfontfile - { mark exch DISKFONTS { .loadfontdict begin } if % In order to load fonts reliably, we should push systemdict % here. However, Ed Taft says that Adobe implementations % push userdict and nothing else! % We really would just like systemdict on the stack, % but fonts produced by Fontographer require a writable dictionary. % However, we can't use any of the other well-known dictionaries % (such as userdict), since the whole point of pushing systemdict % is to make sure that nothing important has been redefined. userdict begin % We can't just use `run', because we want to check for .PFB files. currentpacking { false setpacking .loadfont1 true setpacking } { .loadfont1 } ifelse end { stop } if DISKFONTS { end } if cleartomark } bind def % container for CloseSource flag (default true to prevent buildup of file handles) /closesourcedict mark /CloseSource true .dicttomark readonly def /.loadfont1 { % .loadfont1 { % We would like to use `false /PFBDecode filter', % but this occasionally produces a whitespace character as % the first of an eexec section, so we can't do it. % Also, since the real input file never reaches EOF if we are using % a PFBDecode filter (the filter stops just after reading the last % character), we must explicitly close the real file in this case. % Since the file might leave garbage on the operand stack, % we have to create a procedure to close the file reliably. dup read not { -1 } if 2 copy unread 16#80 eq { dup //closesourcedict //true /PFBDecode filter cvx exch .currentresourcefile eq { dup /.execasresource .systemvar } { {exec} } ifelse 2 index cvlit /closefile .systemvar 3 .execn } { cvx exec } ifelse } stopped } bind def % undefine a dict that is only used internally, and is immediately bound currentdict /closesourcedict .undef % Here are the BuildChar and BuildGlyph implementation for Type 1 fonts. % The names %Type1BuildChar and %Type1BuildGlyph are known to the interpreter. % The real work is done in an operator: % .type1execchar - (%Type1BuildChar) cvn { % %Type1BuildChar - 1 index /Encoding get 1 index get .type1build .type1execchar } bind def (%Type1BuildGlyph) cvn { % %Type1BuildGlyph - dup .type1build .type1execchar } bind def % Note: this procedure is used for both Type 1 and Type 2 fonts. /.type1build { % .type1build % 2 index begin dup CharStrings exch .knownget not { 2 copy eq { exch pop /.notdef exch } if QUIET not { (Substituting .notdef for ) print =string cvs print ( in the font ) print 1 index /FontName get = flush } { pop } ifelse /.notdef CharStrings /.notdef get } if end } bind def 1183615869 internaldict begin % CCRun is an undocumented procedure provided for Type 4 and Type 0 fonts. % Apparently there are two different argument lists for CCRun. % Handling the one with the extra Private dictionary requires fabricating % a Type 1 font on the fly, since we aren't currently prepared to parse the % dictionary any other way. /CCRun { % CCRun - % CCRun - dup type /dicttype eq { dup 4 index /Private .knownget { ne } { pop true } ifelse { % The Private dictionary was supplied, and is different % from the Private dictionary of the font. Fabricate a % Type 1 font with this Private dictionary. Most of the % font entries are arbitrary or not needed. .currentglobal false .setglobal 10 dict exch .setglobal begin /Private exch def /FontType 1 def /FontMatrix 3 index /FontMatrix get def /Encoding 3 index /Encoding .knownget not { StandardEncoding } if def /FontBBox 3 index /FontBBox .knownget not { {0 0 0 0} } if def /PaintType 0 def /CharStrings 1 dict dup /.notdef () put def 3 -1 roll pop () currentdict end .buildfont1 exch pop 3 1 roll } { pop } ifelse } if 1 index dup type /integertype eq { 3 index /Encoding get exch get } if exch .type1execchar } bind def % setweightvector is an undocumented procedure that force writes % weight vector to the font. Do extra checks for safety. /setweightvector { % setweightvector - dup type dup /arraytype ne exch /packedarraytype ne and 2 index type /dicttype ne or { /setweightvector cvx /typecheck signalerror } if 1 index /FontType known not { /setweightvector cvx /invalidfont signalerror } if dup gcheck 2 index gcheck not and { /setweightvector cvx /invalidaccess signalerror } if 2 copy /WeightVector exch .forceput .setweightvector } .bind executeonly def end % Register the font types for definefont. buildfontdict 1 /.buildfont1 cvx put buildfontdict 4 /.buildfont4 cvx put % Add Type 2 support if applicable. /.buildfont2 where not { (%END2) .skipeof } if pop (%Type2BuildChar) cvn { % %Type2BuildChar - 1 index /Encoding get 1 index get .type1build .type2execchar } bind def (%Type2BuildGlyph) cvn { % %Type2BuildGlyph - dup .type1build .type2execchar } bind def buildfontdict 2 /.buildfont2 cvx put %END2