ref: 28a855094261138b64839e35348f30c75c29f233
dir: /sys/lib/ghostscript/wrfont.ps/
% Copyright (C) 1991, 1995, 1996, 2002 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: wrfont.ps,v 1.5 2002/04/19 06:52:25 lpd Exp $
% wrfont.ps
% Write out a Type 1 font in readable, reloadable form.
% Note that this does NOT work on protected fonts, such as Adobe fonts
% (unless you have loaded unprot.ps first, in which case you may be
% violating the Adobe license).
% ****** NOTE: This file must be kept consistent with gs_pfile.ps.
/wrfont_dict 100 dict def
wrfont_dict begin
% ------ Options ------ %
% Define whether to use eexec encryption for the font.
% eexec encryption is only useful for compatibility with Adobe Type Manager
% and other programs; it only slows Ghostscript down.
/eexec_encrypt false def
% Define whether to write out the CharStrings in binary or in hex.
% Binary takes less space on the file, but isn't guaranteed portable.
/binary_CharStrings false def
% Define whether to use binary token encodings when possible.
% Binary tokens are smaller and load faster, but are a Level 2 feature.
/binary_tokens false def
% Define whether to encrypt the CharStrings on the file. (CharStrings
% are always encrypted in memory.) Unencrypted CharStrings load about
% 20% slower, but make the files compress much better for transport.
/encrypt_CharStrings true def
% Define whether the font must provide standard PostScript language
% equivalents for any facilities it uses that are provided in Ghostscript
% but are not part of the standard PostScript language.
/standard_only true def
% Define the value of lenIV to use in writing out the font.
% use_lenIV = 0 produces the smallest output, but this may not be
% compatible with old Adobe interpreters. use_lenIV = -1 means
% use the value of lenIV from the font.
/use_lenIV -1 def
% Define whether to produce the smallest possible output, relying
% as much as possible on Ghostscript-specific support code.
% Taking full advantage of this requires the following settings:
% binary_CharStrings = true, binary_tokens = true, standard_only = false.
/smallest_output false def
% Define whether to write out all currently known Encodings by name,
% or only StandardEncoding and ISOLatin1Encoding.
/name_all_Encodings false def
% ---------------- Runtime support ---------------- %
/.packedfilefilter where
{ pop }
{ (gs_pfile.ps) runlibfile }
ifelse
% ------ Output utilities ------ %
% By convention, the output file is named psfile.
% Define some utilities for writing the output file.
/wtstring 2000 string def
/wb {psfile exch write} bind def
/wnb {/wb load repeat} bind def
/w1 {psfile exch write} bind def
/ws {psfile exch writestring} bind def
/wl {ws (\n) ws} bind def
/wt {wtstring cvs ws ( ) ws} bind def
/wd % Write a dictionary.
{ dup length wo {dict dup begin} wol { we } forall
{end} wol
} bind def
/wld % Write a large dictionary more efficiently.
% Ignore the readonly attributes.
{ dup length wo {dict dup begin} wol
0 exch
{ exch wo wo () wl
1 add dup 200 eq
{ wo ({def} repeat) wl 0 }
if
}
forall
dup 0 ne
{ wo ({def} repeat) wl }
{ pop }
ifelse
(end) ws
} bind def
/we % Write a dictionary entry.
{ exch wo wo /def cvx wo (\n) ws
} bind def
/wcs % Write a CharString (or Subrs entry)
{ dup type /stringtype eq
{ 4330 exch changelenIV 0 ge
{ % Add some leading garbage bytes.
wtstring changelenIV 2 index length getinterval
.type1decrypt exch pop
wtstring exch 0 exch length changelenIV add getinterval
}
{ % Drop some leading garbage bytes.
wtstring .type1decrypt exch pop
changelenIV neg 1 index length 1 index sub getinterval
}
ifelse
binary_tokens encrypt_CharStrings and
{ % Suppress recognizing the readonly status of the string.
4330 exch dup .type1encrypt exch pop wo
}
{ encrypt_CharStrings
{ 4330 exch dup .type1encrypt exch pop
} if
smallest_output
{ wo
}
{ readonly dup length wo
binary_tokens not { ( ) ws } if
readproc ws wx
}
ifelse
}
ifelse
}
{ wo % PostScript procedure
}
ifelse
} bind def
% Construct the inversion of the system name table.
(\210\001) token pop exch pop 1 eq { % i.e., do we have binary tokens?
/snit 256 dict def
0 1 255 {
(\221 ) dup 1 3 index put
{ token } stopped {
pop pop
} {
% Stack: char () token true
pop exch pop exch snit 3 1 roll put
} ifelse
} for
} {
/snit 1 dict def
} ifelse
% Write an object, using binary tokens if requested and possible.
/woa % write in ascii
{ psfile exch write==only
} bind def
% Lookup table for ASCII output.
/intbytes % int nbytes -> byte*
{ { dup 255 and exch -8 bitshift } repeat pop
} bind def
/wotta 10 dict dup begin
{ /booleantype /integertype }
{ { ( ) ws woa } def }
forall
% Iterate over arrays so we can print operators.
/arraytype
{ dup xcheck {(}) ({)} {(]) ([)} ifelse ws exch dup wol exch ws wop
} bind def
/dicttype
{ ( ) ws wd } def
/nametype
{ dup xcheck { ( ) ws } if woa
} bind def
% Map back operators to their names,
% so we can write procedures.
/nulltype
{ pop ( null) ws
} bind def
/operatortype
{ wtstring cvs cvn cvx wo
} bind def
% Convert reals to integers if possible.
/realtype
{ dup cvi 1 index eq { cvi wo } { ( ) ws woa } ifelse
} bind def
% == truncates strings longer than 200 characters!
/stringtype
{ (\() ws dup
{ dup dup 32 lt exch 127 ge or
{ (\\) ws dup -6 bitshift 48 add w1
dup -3 bitshift 7 and 48 add w1
7 and 48 add
}
{ dup dup -2 and 40 eq exch 92 eq or {(\\) ws} if
}
ifelse w1
}
forall
(\)) ws wop
} bind def
/packedarraytype
{ ([) ws dup { wo } forall
encodingnames 1 index known
% This is an encoding, but not one of the standard ones.
% Use the built-in encoding only if it is available.
{ encodingnames exch get wo
({findencoding}stopped{pop) ws
(}{counttomark 1 add 1 roll cleartomark}ifelse)
}
{ pop ()
}
ifelse
(/packedarray where{pop counttomark packedarray exch pop}{]readonly}ifelse) ws
wl
}
def
end def
% Lookup table for binary output.
/wottb 8 dict dup begin
wotta currentdict copy pop
/integertype
{ dup dup 127 le exch -128 ge and
{ 136 wb 255 and wb }
{ dup dup 32767 le exch -32768 ge and
{ 134 wb 2 intbytes wb wb }
{ 132 wb 4 intbytes wb wb wb wb }
ifelse
}
ifelse
} bind def
/nametype
{ dup snit exch known
{ dup xcheck { 146 } { 145 } ifelse wb
snit exch get wb
}
{ wotta /nametype get exec
}
ifelse
} bind def
/stringtype
{ dup dup length dup 255 le { 142 2 } { 2 intbytes 143 3 } ifelse wnb
ws wop
} bind def
end def
/wop % Write object protection
{ wcheck not { /readonly cvx wo } if
} bind def
/wo % Write an object.
{ dup type binary_tokens { wottb } { wotta } ifelse
exch get exec
} bind def
/wol % Write a list of objects.
{ { wo } forall
} bind def
% Write a hex string for Subrs or CharStrings.
/wx % string ->
{ binary_CharStrings
{ ws
}
{ % Some systems choke on very long lines, so
% we break up the hexstring into chunks of 50 characters.
{ dup length 25 le {exit} if
dup 0 25 getinterval psfile exch writehexstring (\n) ws
dup length 25 sub 25 exch getinterval
} loop
psfile exch writehexstring
} ifelse
} bind def
% ------ CharString encryption utilities ------ %
/enc_dict 20 dict def
1 dict begin
/bind { } def % make sure we can print out the procedures
enc_dict begin
(type1enc.ps) runlibfile
enc_dict /.type1decrypt undef % we don't need this
end end
enc_dict { 1 index where { pop pop pop } { def } ifelse } forall
% ------ Other utilities ------ %
% Test whether two values are equal (for default dictionary entries).
/valueeq % <obj1> <obj2> valueeq <bool>
{ 2 copy eq
{ pop pop true }
{ % Special hack for comparing FontMatrix values
dup type /arraytype eq 2 index type /arraytype eq and
{ dup length 2 index length eq
{ true 0 1 3 index length 1 sub
{ % Stack: arr1 arr2 true index
3 index 1 index get 3 index 3 -1 roll get eq not
{ pop false exit }
if
}
for 3 1 roll pop pop
}
{ pop pop false
}
ifelse
}
{ pop pop false
}
ifelse
}
ifelse
} bind def
% ------ The main program ------ %
% Define the dictionary of keys to skip because they are treated specially.
/.fontskipkeys mark
/CharStrings dup
/Encoding dup
/FDepVector dup
/FID dup
/FontInfo dup
/Metrics dup
/Metrics2 dup
/Private dup
.dicttomark def
/.minfontskipkeys mark
.fontskipkeys { } forall
/FontName dup
/UniqueID dup
.dicttomark def
/.privateskipkeys mark
/ND dup
/NP dup
/RD dup
/Subrs dup
.dicttomark def
/.minprivateskipkeys mark
.privateskipkeys { } forall
/MinFeature dup
/Password dup
/UniqueID dup
.dicttomark def
% Define the procedures for the Private dictionary.
% These must be defined without `bind',
% for the sake of the DISKFONTS feature.
4 dict begin
/-! {string currentfile exch readhexstring pop} def
/-| {string currentfile exch readstring pop} def
/|- {readonly def} def
/| {readonly put} def
currentdict end /encrypted_procs exch def
4 dict begin
/-! {string currentfile exch readhexstring pop
4330 exch dup .type1encrypt exch pop} def
/-| {string currentfile exch readstring pop
4330 exch dup .type1encrypt exch pop} def
/|- {readonly def} def
/| {readonly put} def
currentdict end /unencrypted_procs exch def
% Construct an inverse dictionary of encodings.
/encodingnames mark
StandardEncoding /StandardEncoding
ISOLatin1Encoding /ISOLatin1Encoding
SymbolEncoding /SymbolEncoding
DingbatsEncoding /DingbatsEncoding
/resourceforall where
{ pop (*) { cvn dup findencoding exch } 100 string /Encoding resourceforall }
if
.dicttomark def
% Invert the standard encodings.
.knownEncodings length 256 mul dict begin
0 .knownEncodings
{ { currentdict 1 index known { pop } { 1 index def } ifelse
1 add
}
forall
}
forall pop
currentdict end /inverseencodings exch def
/writefont % <psfile> writefont - (writes the current font)
{ /psfile exch def
/Font currentfont def
/FontInfo Font /FontInfo .knownget not { 0 dict } if def
/FontType Font /FontType get def
/hasPrivate Font /Private known def
/Private hasPrivate { Font /Private get } { 0 dict } ifelse def
/readproc binary_CharStrings { (-| ) } { (-! ) } ifelse def
/privateprocs
encrypt_CharStrings binary_tokens not and
{ encrypted_procs } { unencrypted_procs } ifelse
def
/addlenIV false def
/changelenIV use_lenIV 0 lt
{ 0 }
{ use_lenIV Private /lenIV .knownget not
{ 4 /addlenIV use_lenIV 4 ne def } if sub }
ifelse def
/minimize
smallest_output
FontType 1 eq and
Font /UniqueID known and
def
(%!FontType) ws FontType wtstring cvs ws (-1.0: ) ws
currentfont /FontName get wt
FontInfo /version .knownget not { (001.001) } if wl
FontInfo /CreationDate .knownget { (%%Creation Date: ) ws wl } if
FontInfo /VMusage .knownget
{ (%%VMusage: ) ws dup wt wtstring cvs wl }
if
(systemdict begin) wl
% If we're going to use eexec, create the filters now.
/realpsfile psfile def
eexec_encrypt
{ /eexecfilter psfile binary_CharStrings not
{ pop /bxstring 35 string def
{ pop dup length 0 ne
{ realpsfile exch writehexstring realpsfile (\n) writestring }
{ pop }
ifelse bxstring
}
/NullEncode filter dup /hexfilter exch def
}
if 55665 /eexecEncode filter def
}
if
% Turn on binary tokens if relevant.
binary_tokens { (currentobjectformat 1 setobjectformat) wl } if
% If the file has a UniqueID, write out a check against loading it twice.
minimize
{ Font /FontName get wo
Font /UniqueID get wo
Private length addlenIV { 1 add } if wo
Font length 1 add wo % +1 for FontFile
( .checkexistingfont) wl
}
{ Font /UniqueID known
{ ({} FontDirectory) ws Font /FontName get dup wo ( known) wl
( {) ws wo ( findfont dup /UniqueID known) wl
( { dup /UniqueID get) ws Font /UniqueID get wo ( eq exch /FontType get 1 eq and }) wl
( { pop false } ifelse) wl
( { pop save /restore load } if) wl
( } if) wl
}
if
}
ifelse
% If we are writing unencrypted CharStrings for a standard environment,
% write out the encryption procedures.
privateprocs unencrypted_procs eq standard_only and
{ (systemdict /.type1encrypt known) wl
( { save /restore load } { { } } ifelse) wl
(userdict begin) wl
enc_dict { we } forall
(end exec) wl
}
if
% Write out the creation of the font dictionary and FontInfo.
minimize not
{ Font length 1 add wo {dict begin} wol % +1 for FontFile
}
if
(/FontInfo ) ws FontInfo wd {readonly def} wol
% Write out the other fixed entries in the font dictionary.
Font begin
Font
{ minimize
{ .minfontskipkeys 2 index known
{ pop pop
}
{ //.compactfontdefault 2 index .knownget
{ 1 index valueeq { pop pop } { we } ifelse }
{ we }
ifelse
}
ifelse
}
{ .fontskipkeys 2 index known { pop pop } { we } ifelse
}
ifelse
} forall
/Encoding
encodingnames Encoding known
name_all_Encodings
Encoding StandardEncoding eq or
Encoding ISOLatin1Encoding eq or and
{ encodingnames Encoding get cvx }
{ Encoding }
ifelse
dup /StandardEncoding cvx eq minimize and
{ pop pop }
{ we }
ifelse
% Write the FDepVector, if any.
Font /FDepVector .knownget
{ {/FDepVector [} wol
{ /FontName get wo {findfont} wol () wl } forall
{] readonly def} wol
}
if
% Write out the Metrics, if any.
Font /Metrics .knownget
{ (/Metrics ) ws wld {readonly def} wol
}
if
Font /Metrics2 .knownget
{ (/Metrics2 ) ws wld {readonly def} wol
}
if
% Start the eexec-encrypted section, if applicable.
eexec_encrypt
{ {currentdict currentfile eexec} wol () wl
/psfile eexecfilter store
(\000\000\000\000) ws {begin} wol
}
if
% Create and initialize the Private dictionary, if any.
hasPrivate
{
Private
minimize
{ begin {Private dup begin}
}
{ dup length privateprocs length add dict copy begin
privateprocs { readonly def } forall
/Private wo
currentdict length 1 add wo {dict dup begin}
}
ifelse wol () wl
currentdict
{ 1 index minimize { .minprivateskipkeys } { .privateskipkeys } ifelse
exch known
{ pop pop }
{ 1 index /lenIV eq use_lenIV 0 ge and { pop use_lenIV } if we }
ifelse
} forall
addlenIV { /lenIV use_lenIV we } if
}
if
% Write the Subrs entries, if any.
currentdict /Subrs known
{ (/Subrs[) wl
Subrs
{ dup null ne
{ wcs minimize not { () wl } if }
{ pop /null cvx wo }
ifelse
} forall
{] dup {readonly pop} forall readonly def} wol () wl
}
if
% Wrap up the Private dictionary.
hasPrivate
{ end % Private
minimize
{ {end readonly pop} } % Private
{ {end readonly def} } % Private in font
ifelse wol
}
if
% Write the CharStrings entries.
% Detect identical (eq) entries, which bdftops produces.
currentdict /CharStrings known
{
/CharStrings wo CharStrings length wo
minimize
{ encrypt_CharStrings not wo ( .readCharStrings) wl
CharStrings length dict
CharStrings
{ exch inverseencodings 1 index .knownget not { dup } if wo
% Stack: vdict value key
3 copy pop .knownget { wo pop pop } { 3 copy put pop wcs } ifelse
} forall
}
{ {dict dup Private begin begin} wol () wl
CharStrings length dict
CharStrings
{ 2 index 1 index known
{ exch wo 1 index exch get wo {load def} wol () wl
}
{ 2 index 1 index 3 index put
exch wo wcs ( |-) wl
}
ifelse
} forall
{end end} wol
}
ifelse
pop
{ readonly def } % CharStrings in font
wol
}
if
% Terminate the output.
end % Font
eexec_encrypt
{ {end mark currentfile closefile} wol () wl
eexecfilter dup flushfile closefile % psfile is eexecfilter
binary_CharStrings not { hexfilter dup flushfile closefile } if
/psfile realpsfile store
8
{ (0000000000000000000000000000000000000000000000000000000000000000)
wl
}
repeat {cleartomark} wol
}
if
{ FontName currentdict end definefont pop
}
wol
Font /UniqueID known { /exec cvx wo } if
binary_tokens { /setobjectformat cvx wo } if
( end) wl % systemdict
} bind def
% ------ Other utilities ------ %
% Prune garbage characters and OtherSubrs out of the current font,
% if the relevant dictionaries are writable.
/prunefont
{ currentfont /CharStrings get wcheck
{ currentfont /CharStrings get dup [ exch
{ pop dup (S????00?) .stringmatch not { pop } if
} forall
] { 2 copy undef pop } forall pop
}
if
} bind def
end % wrfont_dict
/writefont { wrfont_dict begin writefont end } def