796 lines
23 KiB
PostScript
796 lines
23 KiB
PostScript
% Copyright (C) 1990, 1995, 1996 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: bdftops.ps,v 1.7 2003/08/06 17:05:09 alexcher Exp $
|
|
% bdftops.ps
|
|
% Convert a BDF file (possibly with (an) associated AFM file(s))
|
|
% to a PostScript Type 1 font (without eexec encryption).
|
|
% The resulting font will work with any PostScript language interpreter,
|
|
% but not with ATM or other font rasterizers lacking a complete interpreter.
|
|
|
|
/envBDF 120 dict def
|
|
envBDF begin
|
|
|
|
% "Import" the image-to-path package.
|
|
% This also brings in the Type 1 opcodes (type1ops.ps).
|
|
(impath.ps) runlibfile
|
|
|
|
% "Import" the font-writing package.
|
|
(wrfont.ps) runlibfile
|
|
wrfont_dict begin
|
|
/binary_CharStrings false def
|
|
/binary_tokens false def
|
|
/encrypt_CharStrings true def
|
|
/standard_only true def
|
|
end
|
|
/lenIV 0 def
|
|
|
|
% Invert the StandardEncoding vector.
|
|
256 dict dup begin
|
|
0 1 255 { dup StandardEncoding exch get exch def } for
|
|
end /StandardDecoding exch def
|
|
|
|
% Define the properties copied to FontInfo.
|
|
mark
|
|
(COPYRIGHT) /Notice
|
|
(FAMILY_NAME) /FamilyName
|
|
(FULL_NAME) /FullName
|
|
(WEIGHT_NAME) /Weight
|
|
.dicttomark /properties exch def
|
|
|
|
% Define the character sequences for synthesizing missing composite
|
|
% characters in the standard encoding.
|
|
mark
|
|
/AE [/A /E]
|
|
/OE [/O /E]
|
|
/ae [/a /e]
|
|
/ellipsis [/period /period /period]
|
|
/emdash [/hyphen /hyphen /hyphen]
|
|
/endash [/hyphen /hyphen]
|
|
/fi [/f /i]
|
|
/fl [/f /l]
|
|
/germandbls [/s /s]
|
|
/guillemotleft [/less /less]
|
|
/guillemotright [/greater /greater]
|
|
/oe [/o /e]
|
|
/quotedblbase [/comma /comma]
|
|
.dicttomark /composites exch def
|
|
|
|
% Define the procedure for synthesizing composites.
|
|
% This must not be bound.
|
|
/compose
|
|
{ exch pop
|
|
FontMatrix Private /composematrix get invertmatrix concat
|
|
0 0 moveto
|
|
dup gsave false charpath pathbbox currentpoint grestore
|
|
6 2 roll setcachedevice show
|
|
} def
|
|
% Define the CharString procedure that calls compose, with the string
|
|
% on the stack. This too must remain unbound.
|
|
/compose_proc
|
|
{ Private /compose get exec
|
|
} def
|
|
|
|
% Define aliases for missing characters similarly.
|
|
mark
|
|
/acute /quoteright
|
|
/bullet /asterisk
|
|
/cedilla /comma
|
|
/circumflex /asciicircum
|
|
/dieresis /quotedbl
|
|
/dotlessi /i
|
|
/exclamdown /exclam
|
|
/florin /f
|
|
/fraction /slash
|
|
/grave /quoteleft
|
|
/guilsinglleft /less
|
|
/guilsinglright /greater
|
|
/hungarumlaut /quotedbl
|
|
/periodcentered /asterisk
|
|
/questiondown /question
|
|
/quotedblleft /quotedbl
|
|
/quotedblright /quotedbl
|
|
/quotesinglbase /comma
|
|
/quotesingle /quoteright
|
|
/tilde /asciitilde
|
|
.dicttomark /aliases exch def
|
|
|
|
% Define overstruck characters that can be synthesized with seac.
|
|
mark
|
|
[ /Aacute /Acircumflex /Adieresis /Agrave /Aring /Atilde
|
|
/Ccedilla
|
|
/Eacute /Ecircumflex /Edieresis /Egrave
|
|
/Iacute /Icircumflex /Idieresis /Igrave
|
|
/Lslash
|
|
/Ntilde
|
|
/Oacute /Ocircumflex /Odieresis /Ograve /Otilde
|
|
/Scaron
|
|
/Uacute /Ucircumflex /Udieresis /Ugrave
|
|
/Yacute /Ydieresis
|
|
/Zcaron
|
|
/aacute /acircumflex /adieresis /agrave /aring /atilde
|
|
/ccedilla
|
|
/eacute /ecircumflex /edieresis /egrave
|
|
/iacute /icircumflex /idieresis /igrave
|
|
/lslash
|
|
/ntilde
|
|
/oacute /ocircumflex /odieresis /ograve /otilde
|
|
/scaron
|
|
/uacute /ucircumflex /udieresis /ugrave
|
|
/yacute /ydieresis
|
|
/zcaron
|
|
]
|
|
{ dup =string cvs
|
|
[ exch dup 0 1 getinterval cvn
|
|
exch dup length 1 sub 1 exch getinterval cvn
|
|
]
|
|
} forall
|
|
/cent [/c /slash]
|
|
/daggerdbl [/bar /equal]
|
|
/divide [/colon /hyphen]
|
|
/sterling [/L /hyphen]
|
|
/yen [/Y /equal]
|
|
.dicttomark /accentedchars exch def
|
|
|
|
% ------ Output utilities ------ %
|
|
|
|
/ws {psfile exch writestring} bind def
|
|
/wl {ws (\n) ws} bind def
|
|
/wt {=string cvs ws ( ) ws} bind def
|
|
|
|
% ------ BDF file parsing utilities ------ %
|
|
|
|
% Define a buffer for reading the BDF file.
|
|
/buffer 400 string def
|
|
|
|
% Read a line from the BDF file into the buffer.
|
|
% Ignore empty (zero-length) lines.
|
|
% Define /keyword as the first word on the line.
|
|
% Define /args as the remainder of the line.
|
|
% If the keyword is equal to commentword, skip the line.
|
|
% (If commentword is equal to a space, never skip.)
|
|
/nextline
|
|
{ { bdfile buffer readline not
|
|
{ (Premature EOF\n) print stop } if
|
|
dup length 0 ne { exit } if pop
|
|
}
|
|
loop
|
|
( ) search
|
|
{ /keyword exch def pop }
|
|
{ /keyword exch def () }
|
|
ifelse
|
|
/args exch def
|
|
keyword commentword eq { nextline } if
|
|
} bind def
|
|
|
|
% Get a word argument from args. We do *not* copy the string.
|
|
/warg % warg -> string
|
|
{ args ( ) search
|
|
{ exch pop exch }
|
|
{ () }
|
|
ifelse /args exch def
|
|
} bind def
|
|
|
|
% Get an integer argument from args.
|
|
/iarg % iarg -> int
|
|
{ warg cvi
|
|
} bind def
|
|
|
|
% Get a numeric argument from args.
|
|
/narg % narg -> int|real
|
|
{ warg cvr
|
|
dup dup cvi eq { cvi } if
|
|
} bind def
|
|
|
|
% Convert the remainder of args into a string.
|
|
/remarg % remarg -> string
|
|
{ args copystring
|
|
} bind def
|
|
|
|
% Get a string argument that occupies the remainder of args.
|
|
/sarg % sarg -> string
|
|
{ args (") anchorsearch
|
|
{ pop /args exch def } { pop } ifelse
|
|
args args length 1 sub get (") 0 get eq
|
|
{ args 0 args length 1 sub getinterval /args exch def } if
|
|
args copystring
|
|
} bind def
|
|
|
|
% Check that the keyword is the expected one.
|
|
/checkline % (EXPECTED-KEYWORD) checkline ->
|
|
{ dup keyword ne
|
|
{ (Expected ) print =
|
|
(Line=) print keyword print ( ) print args print (\n) print stop
|
|
} if
|
|
pop
|
|
} bind def
|
|
|
|
% Read a line and check its keyword.
|
|
/getline % (EXPECTED-KEYWORD) getline ->
|
|
{ nextline checkline
|
|
} bind def
|
|
|
|
% Find the first/last non-zero bit of a non-zero byte.
|
|
/fnzb
|
|
{ 0 { exch dup 128 ge { pop exit } { dup add exch 1 add } ifelse }
|
|
loop
|
|
} bind def
|
|
/lnzb
|
|
{ 7 { exch dup 1 and 0 ne { pop exit } { -1 bitshift exch 1 sub } ifelse }
|
|
loop
|
|
} bind def
|
|
|
|
% ------ Type 1 encoding utilities ------ %
|
|
|
|
% Parse the side bearing and width information that begins a CharString.
|
|
% Arguments: charstring. Result: sbx sby wx wy substring.
|
|
/parsesbw
|
|
{ mark exch lenIV
|
|
{ % stack: mark ... string dropcount
|
|
dup 2 index length exch sub getinterval
|
|
dup 0 get dup 32 lt { pop exit } if
|
|
dup 246 le
|
|
{ 139 sub exch 1 }
|
|
{ dup 250 le
|
|
{ 247 sub 8 bitshift 108 add 1 index 1 get add exch 2 }
|
|
{ dup 254 le
|
|
{ 251 sub 8 bitshift 108 add 1 index 1 get add neg exch 2 }
|
|
{ pop dup 1 get 128 xor 128 sub
|
|
8 bitshift 1 index 2 get add
|
|
8 bitshift 1 index 3 get add
|
|
8 bitshift 1 index 4 get add exch 5
|
|
} ifelse
|
|
} ifelse
|
|
} ifelse
|
|
} loop
|
|
counttomark 3 eq { 0 3 1 roll 0 exch } if
|
|
6 -1 roll pop
|
|
} bind def
|
|
|
|
% Find the side bearing and width information that begins a CharString.
|
|
% Arguments: charstring. Result: charstring sizethroughsbw.
|
|
/findsbw
|
|
{ dup parsesbw 4 { exch pop } repeat skipsbw
|
|
} bind def
|
|
/skipsbw % charstring sbwprefix -> sizethroughsbw
|
|
{ length 1 index length exch sub
|
|
2 copy get 12 eq { 2 } { 1 } ifelse add
|
|
} bind def
|
|
|
|
% Encode a number, and append it to a string.
|
|
% Arguments: str num. Result: newstr.
|
|
/concatnum
|
|
{ dup dup -107 ge exch 107 le and
|
|
{ 139 add 1 string dup 0 3 index put }
|
|
{ dup dup -1131 ge exch 1131 le and
|
|
{ dup 0 ge { 16#f694 } { neg 16#fa94 } ifelse add
|
|
2 string dup 0 3 index -8 bitshift put
|
|
dup 1 3 index 255 and put
|
|
}
|
|
{ 5 string dup 0 255 put exch
|
|
2 copy 1 exch -24 bitshift 255 and put
|
|
2 copy 2 exch -16 bitshift 255 and put
|
|
2 copy 3 exch -8 bitshift 255 and put
|
|
2 copy 4 exch 255 and put
|
|
exch
|
|
}
|
|
ifelse
|
|
}
|
|
ifelse exch pop concatstrings
|
|
} bind def
|
|
|
|
% ------ Point arithmetic utilities ------ %
|
|
|
|
/ptadd { exch 4 -1 roll add 3 1 roll add } bind def
|
|
/ptexch { 4 2 roll } bind def
|
|
/ptneg { neg exch neg exch } bind def
|
|
/ptpop { pop pop } bind def
|
|
/ptsub { ptneg ptadd } bind def
|
|
|
|
% ------ The main program ------ %
|
|
|
|
/readBDF % <infilename> <outfilename> <fontname>
|
|
% <encodingname> <uniqueID> <xuid> readBDF -> <font>
|
|
{ /xuid exch def % may be null
|
|
/uniqueID exch def % may be -1
|
|
/encodingname exch def
|
|
/encoding encodingname cvx exec def
|
|
/fontname exch def
|
|
/psname exch def
|
|
/bdfname exch def
|
|
gsave % so we can set the CTM to the font matrix
|
|
|
|
% Open the input files. We don't open the output file until
|
|
% we've done a minimal validity check on the input.
|
|
bdfname (r) file /bdfile exch def
|
|
/commentword ( ) def
|
|
|
|
% Check for the STARTFONT.
|
|
(STARTFONT) getline
|
|
args (2.1) ne { (Not version 2.1\n) print stop } if
|
|
|
|
% Initialize the font.
|
|
/Font 20 dict def
|
|
Font begin
|
|
/FontName fontname def
|
|
/PaintType 0 def
|
|
/FontType 1 def
|
|
uniqueID 0 gt { /UniqueID uniqueID def } if
|
|
xuid null ne { /XUID xuid def } if
|
|
/Encoding encoding def
|
|
/FontInfo 20 dict def
|
|
/Private 20 dict def
|
|
currentdict end currentdict end
|
|
exch begin begin % insert font above environment
|
|
|
|
% Initialize the Private dictionary in the font.
|
|
Private begin
|
|
/-! {string currentfile exch readhexstring pop} readonly def
|
|
/-| {string currentfile exch readstring pop} readonly def
|
|
/|- {readonly def} readonly def
|
|
/| {readonly put} readonly def
|
|
/BlueValues [] def
|
|
/lenIV lenIV def
|
|
/MinFeature {16 16} def
|
|
/password 5839 def
|
|
/UniqueID uniqueID def
|
|
end % Private
|
|
|
|
% Invert the Encoding, for synthesizing composite characters.
|
|
/decoding encoding length dict def
|
|
0 1 encoding length 1 sub
|
|
{ dup encoding exch get exch decoding 3 1 roll put }
|
|
for
|
|
|
|
% Now open the output file.
|
|
psname (w) file /psfile exch def
|
|
|
|
% Put out a header compatible with the Adobe "standard".
|
|
(%!FontType1-1.0: ) ws fontname wt (000.000) wl
|
|
(% This is a font description converted from ) ws
|
|
bdfname wl
|
|
(% by bdftops running on ) ws
|
|
statusdict /product get ws ( revision ) ws
|
|
revision =string cvs ws (.) wl
|
|
|
|
% Copy the initial comments, up to FONT.
|
|
true
|
|
{ nextline
|
|
keyword (COMMENT) ne {exit} if
|
|
{ (% Here are the initial comments from the BDF file:\n%) wl
|
|
} if false
|
|
(%) ws remarg wl
|
|
} loop pop
|
|
() wl
|
|
/commentword (COMMENT) def % do skip comments from now on
|
|
|
|
% Read and process the FONT, SIZE, and FONTBOUNDINGBOX.
|
|
% If we cared about FONT, we'd use it here. If the BDF files
|
|
% from MIT had PostScript names rather than X names, we would
|
|
% care; but what's there is unusable, so we discard FONT.
|
|
% The FONTBOUNDINGBOX may not be reliable, so we discard it too.
|
|
(FONT) checkline
|
|
(SIZE) getline
|
|
/pointsize iarg def /xres iarg def /yres iarg def
|
|
(FONTBOUNDINGBOX) getline
|
|
nextline
|
|
|
|
% Initialize the font bounding box bookeeping.
|
|
/fbbxo 1000 def
|
|
/fbbyo 1000 def
|
|
/fbbxe -1000 def
|
|
/fbbye -1000 def
|
|
|
|
% Read and process the properties. We only care about a few of them.
|
|
keyword (STARTPROPERTIES) eq
|
|
{ iarg
|
|
{ nextline
|
|
properties keyword known
|
|
{ FontInfo properties keyword get sarg readonly put
|
|
} if
|
|
} repeat
|
|
(ENDPROPERTIES) getline
|
|
nextline
|
|
} if
|
|
|
|
% Compute and set the FontMatrix.
|
|
Font /FontMatrix
|
|
[ 0.001 0 0 0.001 xres mul yres div 0 0 ] readonly
|
|
dup setmatrix put
|
|
|
|
% Read and process the header for the bitmaps.
|
|
(CHARS) checkline
|
|
/ccount iarg def
|
|
|
|
% Initialize the CharStrings dictionary.
|
|
/charstrings ccount
|
|
composites length add
|
|
aliases length add
|
|
accentedchars length add
|
|
1 add dict def % 1 add for .notdef
|
|
/isfixedwidth true def
|
|
/fixedwidth null def
|
|
/subrcount 0 def
|
|
/subrs [] def
|
|
|
|
% Read the bitmap data. This reads the remainder of the file.
|
|
% We do this before processing the bitmaps so that we can compute
|
|
% the correct FontBBox first.
|
|
/chardata ccount dict def
|
|
ccount -1 1
|
|
{ (STARTCHAR) getline
|
|
/charname remarg def
|
|
(ENCODING) getline
|
|
/eindex iarg def
|
|
eindex dup 0 ge exch 255 le and
|
|
{ charname /charname StandardEncoding eindex get def
|
|
charname /.notdef eq eindex 0 gt and
|
|
{ /charname (A) eindex =string cvs concatstrings cvn def
|
|
}
|
|
if
|
|
(/) print charname =string cvs print (,) print print
|
|
}
|
|
{ (/) print charname print
|
|
}
|
|
ifelse
|
|
10 mod 1 eq { (\n) print flush } if
|
|
(SWIDTH) getline
|
|
/swx iarg pointsize mul 1000 div xres mul 72 div def
|
|
/swy iarg pointsize mul 1000 div xres mul 72 div def
|
|
(DWIDTH) getline % Ignore, use SWIDTH instead
|
|
(BBX) getline
|
|
/bbw iarg def /bbh iarg def /bbox iarg def /bboy iarg def
|
|
nextline
|
|
keyword (ATTRIBUTES) eq
|
|
{ nextline
|
|
} if
|
|
(BITMAP) checkline
|
|
|
|
% Update the font bounding box.
|
|
/fbbxo fbbxo bbox .min def
|
|
/fbbyo fbbyo bboy .min def
|
|
/fbbxe fbbxe bbox bbw add .max def
|
|
/fbbye fbbye bboy bbh add .max def
|
|
|
|
% Read the bits for this character.
|
|
/raster bbw 7 add 8 idiv def
|
|
/cbits raster bbh mul string def
|
|
cbits length 0 gt
|
|
{ 0 raster cbits length raster sub
|
|
{ cbits exch raster getinterval
|
|
bdfile buffer readline not
|
|
{ (EOF in bitmap\n) print stop } if
|
|
% stack has <cbits.interval> <buffer.interval>
|
|
0 () /SubFileDecode filter
|
|
exch 2 copy readhexstring pop pop pop closefile
|
|
} for
|
|
} if
|
|
|
|
(ENDCHAR) getline
|
|
|
|
% Save the character data.
|
|
chardata charname [swx swy bbw bbh bbox bboy cbits] put
|
|
} for
|
|
|
|
(ENDFONT) getline
|
|
|
|
% Allocate the buffers for the bitmap and the outline,
|
|
% according to the font bounding box.
|
|
/fbbw fbbxe fbbxo sub def
|
|
/fbbh fbbye fbbyo sub def
|
|
/fraster fbbw 7 add 8 idiv def
|
|
/bits fraster fbbh mul 200 .max 65535 .min string def
|
|
/outline bits length 16 mul 65535 .min string def
|
|
|
|
% Process the characters.
|
|
chardata
|
|
{ exch /charname exch def aload pop
|
|
/cbits exch def
|
|
/bboy exch def /bbox exch def
|
|
/bbh exch def /bbw exch def
|
|
/swy exch def /swx exch def
|
|
|
|
% The bitmap handed to type1imagepath must have the correct height,
|
|
% because type1imagepath uses this to compute the scale factor,
|
|
% so we have to clear the unused parts of it.
|
|
/raster bbw 7 add 8 idiv def
|
|
bits dup 0 1 raster fbbh mul 1 sub
|
|
{ 0 put dup } for
|
|
pop pop
|
|
bits raster fbbh bbh sub mul cbits putinterval
|
|
|
|
% Compute the font entry, converting the bitmap to an outline.
|
|
bits 0 raster fbbh mul getinterval % the bitmap image
|
|
bbw fbbh % bitmap width & height
|
|
swx swy % width x & y
|
|
bbox neg bboy neg % origin x & y
|
|
% Account for lenIV when converting the outline.
|
|
outline lenIV outline length lenIV sub getinterval
|
|
type1imagepath
|
|
length lenIV add
|
|
outline exch 0 exch getinterval
|
|
|
|
% Check for a fixed width font.
|
|
isfixedwidth
|
|
{ fixedwidth null eq
|
|
{ /fixedwidth swx def }
|
|
{ fixedwidth swx ne { /isfixedwidth false def } if }
|
|
ifelse
|
|
} if
|
|
|
|
% Finish up the character.
|
|
copystring
|
|
charname exch charstrings 3 1 roll put
|
|
} forall
|
|
|
|
% Add CharStrings entries for aliases.
|
|
aliases
|
|
{ charstrings 2 index known not charstrings 2 index known and
|
|
{ charstrings exch get charstrings 3 1 roll put
|
|
}
|
|
{ pop pop
|
|
}
|
|
ifelse
|
|
}
|
|
forall
|
|
|
|
% If this is not a fixed-width font, synthesize missing characters
|
|
% out of available ones.
|
|
isfixedwidth not
|
|
{ false composites
|
|
{ 1 index charstrings exch known not
|
|
1 index { decoding exch known and } forall
|
|
{ ( /) print 1 index bits cvs print
|
|
/combine exch def
|
|
0 1 combine length 1 sub
|
|
{ dup combine exch get decoding exch get
|
|
bits 3 1 roll put
|
|
} for
|
|
bits 0 combine length getinterval copystring
|
|
[ exch /compose_proc load aload pop ] cvx
|
|
charstrings 3 1 roll put
|
|
pop true
|
|
}
|
|
{ pop pop }
|
|
ifelse
|
|
}
|
|
forall flush
|
|
{ Private /composematrix matrix put
|
|
Private /compose /compose load put
|
|
}
|
|
if
|
|
}
|
|
if
|
|
|
|
% Synthesize accented characters with seac if needed and possible.
|
|
accentedchars
|
|
{ aload pop /accent exch def /base exch def
|
|
buffer cvs /accented exch def
|
|
charstrings accented known not
|
|
charstrings base known and
|
|
charstrings accent known and
|
|
StandardDecoding base known and
|
|
StandardDecoding accent known and
|
|
encoding StandardDecoding base get get base eq and
|
|
encoding StandardDecoding accent get get accent eq and
|
|
{ ( /) print accented print
|
|
charstrings base get findsbw 0 exch getinterval
|
|
/acstring exch def % start with sbw of base
|
|
charstrings accent get parsesbw
|
|
4 { pop } repeat % just leave sbx
|
|
acstring exch concatnum
|
|
0 concatnum 0 concatnum % adx ady
|
|
decoding base get concatnum % bchar
|
|
decoding accent get concatnum % achar
|
|
s_seac concatstrings
|
|
charstrings exch accented copystring exch put
|
|
} if
|
|
} forall
|
|
|
|
% Make a CharStrings entry for .notdef.
|
|
outline lenIV <8b8b0d0e> putinterval % 0 0 hsbw endchar
|
|
charstrings /.notdef outline 0 lenIV 4 add getinterval copystring put
|
|
|
|
% Encrypt the CharStrings and Subrs (in place).
|
|
charstrings
|
|
{ % Be careful not to encrypt aliased characters twice,
|
|
% since they share their CharString.
|
|
aliases 2 index known
|
|
{ charstrings aliases 3 index get .knownget
|
|
{ 1 index ne }
|
|
{ true }
|
|
ifelse
|
|
}
|
|
{ true
|
|
}
|
|
ifelse
|
|
1 index type /stringtype eq and
|
|
{ 4330 exch dup .type1encrypt exch pop
|
|
readonly charstrings 3 1 roll put
|
|
}
|
|
{ pop pop
|
|
}
|
|
ifelse
|
|
}
|
|
forall
|
|
0 1 subrcount 1 sub
|
|
{ dup subrs exch get
|
|
4330 exch dup .type1encrypt exch pop
|
|
subrs 3 1 roll put
|
|
}
|
|
for
|
|
|
|
% Make most of the remaining entries in the font dictionaries.
|
|
|
|
% The Type 1 font machinery really only works with a 1000 unit
|
|
% character coordinate system. Set this up here, by computing the factor
|
|
% to make the X entry in the FontMatrix come out at exactly 0.001.
|
|
/fontscale 1000 fbbh div yres mul xres div def
|
|
Font /FontBBox
|
|
[ fbbxo fontscale mul
|
|
fbbyo fontscale mul
|
|
fbbxe fontscale mul
|
|
fbbye fontscale mul
|
|
] cvx readonly put
|
|
Font /CharStrings charstrings readonly put
|
|
FontInfo /FullName known not
|
|
{ % Some programs insist on FullName being present.
|
|
FontInfo /FullName FontName dup length string cvs put
|
|
}
|
|
if
|
|
FontInfo /isFixedPitch isfixedwidth put
|
|
subrcount 0 gt
|
|
{ Private /Subrs subrs 0 subrcount getinterval readonly put
|
|
} if
|
|
|
|
% Determine the italic angle and underline position
|
|
% by actually installing the font.
|
|
save
|
|
/_temp_ Font definefont setfont
|
|
[1000 0 0 1000 0 0] setmatrix % mitigate rounding problems
|
|
% The italic angle is the multiple of -5 degrees
|
|
% that minimizes the width of the 'I'.
|
|
0 9999 0 5 85
|
|
{ dup rotate
|
|
newpath 0 0 moveto (I) false charpath
|
|
dup neg rotate
|
|
pathbbox pop exch pop exch sub
|
|
dup 3 index lt { 4 -2 roll } if
|
|
pop pop
|
|
}
|
|
for pop
|
|
% The underline position is halfway between the bottom of the 'A'
|
|
% and the bottom of the FontBBox.
|
|
newpath 0 0 moveto (A) false charpath
|
|
FontMatrix concat
|
|
pathbbox pop pop exch pop
|
|
% Put the values in FontInfo.
|
|
3 -1 roll
|
|
restore
|
|
Font /FontBBox get 1 get add 2 div cvi
|
|
dup FontInfo /UnderlinePosition 3 -1 roll put
|
|
2 div abs FontInfo /UnderlineThickness 3 -1 roll put
|
|
FontInfo /ItalicAngle 3 -1 roll put
|
|
|
|
% Clean up and finish.
|
|
grestore
|
|
bdfile closefile
|
|
Font currentdict end end begin % remove font from dict stack
|
|
(\n) print flush
|
|
|
|
} bind def
|
|
|
|
% ------ Reader for AFM files ------ %
|
|
|
|
% Dictionary for looking up character keywords
|
|
/cmdict 6 dict dup begin
|
|
/C { /c iarg def } def
|
|
/N { /n warg copystring def } def
|
|
/WX { /w narg def } def
|
|
/W0X /WX load def
|
|
/W /WX load def
|
|
/W0 /WX load def
|
|
end def
|
|
|
|
/readAFM % fontdict afmfilename readAFM -> fontdict
|
|
{ (r) file /bdfile exch def
|
|
/Font exch def
|
|
/commentword (Comment) def
|
|
|
|
% Check for the StartFontMetrics.
|
|
(StartFontMetrics) getline
|
|
args cvr 2.0 lt { (Not version 2.0 or greater\n) print stop } if
|
|
|
|
% Look for StartCharMetrics, then parse the character metrics.
|
|
% The only information we care about is the X width.
|
|
/metrics 0 dict def
|
|
{ nextline
|
|
keyword (EndFontMetrics) eq { exit } if
|
|
keyword (StartCharMetrics) eq
|
|
{ iarg dup dict /metrics exch def
|
|
{ /c -1 def /n null def /w null def
|
|
nextline buffer
|
|
{ token not { exit } if
|
|
dup cmdict exch known
|
|
{ exch /args exch def cmdict exch get exec args }
|
|
{ pop }
|
|
ifelse
|
|
} loop
|
|
c 0 ge n null ne or w null ne and
|
|
{ n null eq { /n Font /Encoding get c get def } if
|
|
metrics n w put
|
|
}
|
|
if
|
|
}
|
|
repeat
|
|
(EndCharMetrics) getline
|
|
} if
|
|
} loop
|
|
|
|
% Insert the metrics in the font.
|
|
metrics length 0 ne
|
|
{ Font /Metrics metrics readonly put
|
|
} if
|
|
Font
|
|
} bind def
|
|
|
|
end % envBDF
|
|
|
|
% Enter the main program in the current dictionary.
|
|
/bdfafmtops % infilename afmfilename* outfilename fontname
|
|
% encodingname uniqueID xuid
|
|
{ envBDF begin
|
|
7 -2 roll exch 7 2 roll % afm* in out fontname encodingname uniqueID xuid
|
|
readBDF % afm* font
|
|
exch { readAFM } forall
|
|
save exch
|
|
dup /FontName get exch definefont
|
|
setfont
|
|
psfile writefont
|
|
restore
|
|
psfile closefile
|
|
end
|
|
} bind def
|
|
|
|
% If the program was invoked from the command line, run it now.
|
|
[ shellarguments
|
|
{ counttomark 4 ge
|
|
{ dup 0 get
|
|
dup 48 ge exch 57 le and % last arg starts with a digit?
|
|
{ /StandardEncoding } % no encodingname
|
|
{ cvn } % have encodingname
|
|
ifelse
|
|
exch (.) search % next-to-last arg has . in it?
|
|
{ mark 4 1 roll % have xuid
|
|
{ cvi exch pop exch (.) search not { exit } if }
|
|
loop cvi ]
|
|
3 -1 roll cvi exch
|
|
}
|
|
{ cvi null % no xuid
|
|
}
|
|
ifelse
|
|
counttomark 5 roll
|
|
counttomark 6 sub array astore
|
|
7 -2 roll cvn 7 -3 roll % make sure fontname is a name
|
|
bdfafmtops
|
|
}
|
|
{ cleartomark
|
|
(Usage:\n bdftops xx.bdf [yy1.afm ...] zz.gsf fontname uniqueID [xuid] [encodingname]\n) print flush
|
|
mark
|
|
}
|
|
ifelse
|
|
}
|
|
if pop
|