ref: e4ce6aadac9e1de8d5ea625e9680d24cabce0e1a
dir: /sys/lib/ghostscript/font2c.ps/
% Copyright (C) 1992, 1993, 1994, 1995, 1999 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: font2c.ps,v 1.6 2003/07/10 02:56:51 ray Exp $
% font2c.ps
% Write out a PostScript Type 0 or Type 1 font as C code
% that can be linked with the interpreter.
% This even works on protected fonts, if you use the -dWRITESYSTEMDICT
% switch in the command line. The code is reentrant and location-
% independent and has no external references, so it can be put into
% a sharable library even on VMS.
/font2cdict 100 dict dup begin
% Define the maximum string length that all compilers will accept.
% This must be approximately
% min(max line length, max string literal length) / 4 - 5.
/max_wcs 50 def
% Define a temporary file for writing out procedures.
/wtempname (_.tmp) def
% ------ Protection utilities ------ %
% Protection values are represented by a mask:
/a_noaccess 0 def
/a_executeonly 1 def
/a_readonly 3 def
/a_all 7 def
/prot_names
[ (0) (a_execute) null (a_readonly) null null null (a_all)
] def
/prot_opers
[ {noaccess} {executeonly} {} {readonly} {} {} {} {}
] def
% Get the protection of an object.
/getpa
{ dup wcheck
{ pop a_all }
{ % Check for executeonly or noaccess objects in protected.
dup protected exch known
{ protected exch get }
{ pop a_readonly }
ifelse
}
ifelse
} bind def
% Get the protection appropriate for (all the) values in a dictionary.
/getva
{ a_noaccess exch
{ exch pop
dup type dup /stringtype eq 1 index /arraytype eq or
exch /packedarraytype eq or
{ getpa a_readonly and or }
{ pop pop a_all exit }
ifelse
}
forall
} bind def
% Keep track of executeonly and noaccess objects,
% but don't let the protection actually take effect.
.currentglobal
false .setglobal % so protected can reference local objs
/protected % do first so // will work
systemdict wcheck { 1500 dict } { 1 dict } ifelse
def
systemdict wcheck not
{ (Warning: you will not be able to convert protected fonts.\n) print
(If you need to convert a protected font, please\n) print
(restart the program and specify the -dWRITESYSTEMDICT switch.\n) print
flush
(%end) .skipeof
}
if
userdict begin
/executeonly
{ dup //protected exch //a_executeonly put readonly
} bind def
/noaccess
{ dup //protected exch //a_noaccess put readonly
} bind def
end
true .setglobal
systemdict begin
/executeonly
{ userdict /executeonly get exec
} bind odef
/noaccess
{ userdict /noaccess get exec
} bind odef
end
%end
.setglobal
% ------ Output utilities ------ %
% By convention, the output file is named cfile.
% Define some utilities for writing the output file.
/wtstring 100 string def
/wb {cfile exch write} bind def
/ws {cfile exch writestring} bind def
/wl {ws (\n) ws} bind def
/wt {wtstring cvs ws} bind def
% Write a C string. Some compilers have unreasonably small limits on
% the length of a string literal or the length of a line, so every place
% that uses wcs must either know that the string is short,
% or be prepared to use wcca instead.
/wbx
{ 8#1000 add 8 (0000) cvrs dup 0 (\\) 0 get put ws
} bind def
/wcst
[
32 { /wbx load } repeat
95 { /wb load } repeat
129 { /wbx load } repeat
] def
("\\) { wcst exch { (\\) ws wb } put } forall
/wcs
{ (") ws { dup wcst exch get exec } forall (") ws
} bind def
/can_wcs % Test if can use wcs
{ length max_wcs le
} bind def
/wncs % name -> C string
{ wtstring cvs wcs
} bind def
% Write a C string as an array of character values.
% We only need this because of line and literal length limitations.
/wca % <string> <prefix> <suffix> wca -
{ 0 4 -2 roll exch
{ % Stack: suffix n prefix char
exch ws
exch dup 19 ge { () wl pop 0 } if 1 add
exch dup 32 ge 1 index 126 le and
{ 39 wb dup 39 eq 1 index 92 eq or { 92 wb } if wb 39 wb }
{ wt }
ifelse (,)
} forall
pop pop ws
} bind def
/wcca % <string> wcca -
{ ({\n) (}) wca
} bind def
% Write object protection attributes. Note that dictionaries and arrays are
% the only objects that can be writable.
/wpa
{ dup xcheck { (a_executable|) ws } if
dup type dup /dicttype eq exch /arraytype eq or
{ getpa }
{ getpa a_readonly and }
ifelse prot_names exch get ws
} bind def
/wva
{ getva prot_names exch get ws
} bind def
% ------ Object writing ------ %
/wnstring 128 string def
% Convert an object to a string to be scanned at a later time.
/cvos % <obj> cvos <string>
{ % We'd like to use == and write directly to a string,
% but we can't do the former because of operators,
% and we can't do the latter because we can't predict
% how long the string would have to be....
wtempname (w) file dup 3 -1 roll wproc closefile
wtempname status pop pop pop exch pop string
wtempname (r) file dup 3 -1 roll readstring pop exch closefile
} bind def
% Write a string/name or null as an element of a string/name/null array.
% Convert any other kind of value to a token to be read back in.
/wsn
{ dup null eq
{ pop (\t255,255,) wl
}
{ dup type /nametype eq { wnstring cvs } if
dup type /stringtype ne { cvos (255,) ws } if
dup length 256 idiv wt (,) ws
dup length 256 mod wt
(,) (,\n) wca
}
ifelse
} bind def
% Write a packed string/name/null array.
/wsna % <name> <(string|name|null)*> wsna -
{ (\tstatic const unsigned char ) ws exch wt ([] = {) wl
{ wsn } forall
(\t0\n};) wl
} bind def
% Write a number or an array of numbers, as refs.
/isnumber
{ type dup /integertype eq exch /realtype eq or
} bind def
/wnums
{ dup isnumber
{ (real_v\() ws wt (\),) ws }
{ { wnums } forall }
ifelse
} bind def
% Test whether a procedure or unusual array can be written (printed).
/iswx 4 dict dup begin
/arraytype { { iswproc } isall } def
/nametype { pop true } def
/operatortype { pop true } def % assume it has been bound in
/packedarraytype /arraytype load def
end def
/iswnx 6 dict dup begin
/arraytype { { iswproc } isall } def
/integertype { pop true } def
/nametype { pop true } def
/realtype { pop true } def
/stringtype { pop true } def
/packedarraytype /arraytype load def
end def
/iswproc % <obj> iswproc <bool>
{ dup xcheck { iswx } { iswnx } ifelse
1 index type .knownget { exec } { pop false } ifelse
} bind def
% Write a printable procedure (one for which iswproc returns true).
/wproca 3 dict dup begin
/arraytype
{ 1 index ({) writestring
{ 1 index ( ) writestring 1 index exch wproc } forall
(}) writestring
} bind def
/packedarraytype /arraytype load def
/operatortype { .writecvs } bind def % assume binding would work
end def
/wproc % <file> <proc> wproc -
{ dup type wproca exch .knownget { exec } { write==only } ifelse
} bind def
% Write a named object. Return true if this was possible.
% Legal types are: boolean, integer, name, real, string,
% array of (integer, integer+real, name, null+string),
% and certain procedures and other arrays (see iswproc above).
% All other objects are either handled specially or ignored.
/isall % <array> <proc> isall <bool>
{ true 3 -1 roll
{ 2 index exec not { pop false exit } if }
forall exch pop
} bind def
/wott 8 dict dup begin
/arraytype
{ woatt
{ aload pop 2 index 2 index exec
{ exch pop exec exit }
{ pop pop }
ifelse
}
forall
} bind def
/booleantype
{ { (\tmake_true\(&) } { (\tmake_false\(&) } ifelse ws
wt (\);) wl true
} bind def
/integertype
{ (\tmake_int\(&) ws exch wt (, ) ws
wt (\);) wl true
} bind def
/nametype
{ (\tcode = (*pprocs->name_create)\(i_ctx_p, &) ws exch wt
(, ) ws wnstring cvs wcs % OK, names are short
(\);) wl
(\tif ( code < 0 ) return code;) wl
true
} bind def
/packedarraytype
/arraytype load def
/realtype
{ (\tmake_real\(&) ws exch wt (, (float)) ws
wt (\);) wl true
} bind def
/stringtype
{ ({\tstatic const unsigned char s_[] = ) ws
dup dup can_wcs { wcs } { wcca } ifelse
(;) wl
(\tmake_const_string\(&) ws exch wt
(, a_readonly, ) ws length wt (, (const byte *)s_\);) wl
(}) wl true
} bind def
end def
% Write some other kind of object, if known.
/wother
{ dup otherobjs exch known
{ otherobjs exch get (\t) ws exch wt ( = ) ws wt (;) wl true }
{ pop pop false }
ifelse
} bind def
% Top-level procedure.
/wo % name obj -> OK
{ dup type wott exch .knownget { exec } { wother } ifelse
} bind def
% Write an array (called by wo).
/wap % <name> <array> wap -
{ dup xcheck not 1 index wcheck not and 1 index rcheck and
{ pop pop }
{ (\tr_set_attrs\(&) ws exch wt (, ) ws wpa (\);) wl }
ifelse
} bind def
/wnuma { % <name> <array> <element_C_type> <<type>_v> wnuma -
({\tstatic const ref_\() ws exch ws (\) a_[] = {) wl exch
% Stack: name type_v array
dup length 0 eq {
(\t) ws 1 index ws (\(0\)) wl
} {
dup {
(\t) ws 2 index ws (\() ws wt (\),) wl
} forall
} ifelse exch pop
% Stack: name array
(\t};) wl
dup wcheck {
(\tcode = (*pprocs->scalar_array_create)\(i_ctx_p, &) ws exch wt
(, (const ref *)a_, ) ws dup length wt
(, ) ws wpa (\);) wl
(\tif ( code < 0 ) return code;) wl
} {
(\tmake_const_array\(&) ws exch wt
(, avm_foreign|) ws dup wpa (, ) ws length wt
(, (const ref *)a_\);) wl
} ifelse
(}) wl
} bind def
/woatt [
% Integers
{ { { type /integertype eq } isall }
{ (long) (integer_v) wnuma true }
}
% Integers + reals
{ { { type dup /integertype eq exch /realtype eq or } isall }
{ (float) (real_v) wnuma true }
}
% Strings + nulls
{ { { type dup /nulltype eq exch /stringtype eq or } isall }
{ ({) ws dup (sa_) exch wsna
(\tcode = (*pprocs->string_array_create)\(i_ctx_p, &) ws exch wt
(, \(const char *\)sa_, ) ws dup length wt (, ) ws wpa (\);) wl
(\tif ( code < 0 ) return code;) wl
(}) wl true
}
}
% Names
{ { { type /nametype eq } isall }
{ ({) ws dup (na_) exch wsna
(\tcode = (*pprocs->name_array_create)\(i_ctx_p, &) ws 1 index wt
(, \(const char *\)na_, ) ws dup length wt (\);) wl
(\tif ( code < 0 ) return code;) wl
wap (}) wl true
}
}
% Procedure
{ { iswproc }
{ dup cvos
% Stack: name proc string
({\tstatic const unsigned char s_[] = ) ws
dup dup can_wcs { wcs } { wcca } ifelse
(;) wl
(\tcode = (*pprocs->ref_from_string)\(i_ctx_p, &) ws 2 index wt
(, \(const char *\)s_, ) ws length wt (\);) wl
(\tif ( code < 0 ) return code;) wl
wap (}) wl true
wtempname deletefile
}
}
% Default
{ { pop true }
{ wother }
}
] def
% Write a named dictionary. We assume the ref is already declared.
/wd % <name> <dict> <extra> wd -
{ 3 1 roll
({) ws
(\tref v_[) ws dup length wt (];) wl
dup [ exch
{ counttomark 2 sub wtstring cvs
(v_[) exch concatstrings (]) concatstrings exch wo not
{ (Skipping ) print ==only (....\n) print }
if
} forall
]
% Stack: array of keys (names)
({) ws dup (str_keys_) exch wsna
(\tstatic const cfont_dict_keys keys_ =) wl
(\t { 0, 0, ) ws length wt (, ) ws 3 -1 roll wt (, ) ws
dup wpa (, ) ws dup wva ( };) wl pop
(\tcode = \(*pprocs->ref_dict_create\)\(i_ctx_p, &) ws wt
(, &keys_, \(const char *\)str_keys_, v_\);) wl
(\tif ( code < 0 ) return code;) wl
(}) wl
(}) wl
} bind def
% Write character dictionary keys.
% We save a lot of space by abbreviating keys which appear in
% StandardEncoding or ISOLatin1Encoding.
% Writes code to declare and initialize enc_keys_, str_keys, and keys_.
/wcdkeys % <dict> wcdkeys -
{ % Write keys present in StandardEncoding or ISOLatin1Encoding,
% pushing other keys on the o-stack.
(static const charindex enc_keys_[] = {) wl
dup [ exch 0 exch
{ pop decoding 1 index known
{ decoding exch get ({) ws dup -8 bitshift wt
(,) ws 255 and wt (}, ) ws
1 add dup 5 mod 0 eq { (\n) ws } if
}
{ exch }
ifelse
}
forall pop
]
({0,0}\n};) wl
% Write other keys.
(str_keys_) exch wsna
% Write the declaration for keys_.
(static const cfont_dict_keys keys_ = {) wl
(\tenc_keys_, countof\(enc_keys_\) - 1,) wl
(\t) ws dup length wt ( - \(countof\(enc_keys_\) - 1\), 0, ) ws
dup wpa (, ) ws wva () wl
(};) wl
} bind def
% Enumerate character dictionary values in the same order that
% the keys appear in enc_keys_ and str_keys_.
% <proc> is called with each value in turn.
/cdforall % <dict> <proc> cdforall -
{ 2 copy
{ decoding 3 index known
{ 3 -1 roll pop exec }
{ pop pop pop }
ifelse
}
/exec cvx 3 packedarray cvx
/forall cvx
5 -2 roll
{ decoding 3 index known
{ pop pop pop }
{ 3 -1 roll pop exec }
ifelse
}
/exec cvx 3 packedarray cvx
/forall cvx
6 packedarray cvx exec
} bind def
% ------ Writers for special objects ------ %
/writespecial 10 dict dup begin
/FontInfo { 0 wd } def
/Private { 0 wd } def
/CharStrings
{ ({) wl
dup wcdkeys
(static const unsigned char values_[] = {) wl
{ wsn } cdforall
(\t0\n};) wl
(\tcode = \(*pprocs->string_dict_create\)\(i_ctx_p, &) ws wt
(, &keys_, (const char *)str_keys_, \(const char *\)values_\);) wl
(\tif ( code < 0 ) return code;) wl
(}) wl
} bind def
/Metrics
{ ({) wl
dup wcdkeys
(static const ref_(float) values_[] = {) wl
dup { (\t) ws wnums () wl } cdforall
(\t0\n};) wl
(static const unsigned char lengths_[] = {) wl
{ (\t) ws dup isnumber
{ pop 0 }
{ length 1 add }
ifelse wt (,) wl
} cdforall
(\t0\n};) wl
(\tcode = \(*pprocs->num_dict_create\)\(i_ctx_p, &) ws wt
(, &keys_, str_keys_, (const ref *)values_, lengths_\);) wl
(\tif ( code < 0 ) return code;) wl
(}) wl
} bind def
/Metrics2 /Metrics load def
/FDepVector pop % (converted to a list of font names)
end def
% ------ The main program ------ %
% Construct an inverse dictionary of encodings.
[ /StandardEncoding /ISOLatin1Encoding
/SymbolEncoding /DingbatsEncoding
/KanjiSubEncoding
]
dup length dict begin
{ mark exch dup { .findencoding exch def } stopped cleartomark
} forall
currentdict end /encodingnames exch def
% Invert the StandardEncoding and ISOLatin1Encoding vectors.
512 dict begin
0 1 255 { dup ISOLatin1Encoding exch get exch 256 add def } for
0 1 255 { dup StandardEncoding exch get exch def } for
currentdict end /decoding exch def
/writefont % cfilename procname -> [writes the current font]
{ (gsf_) exch concatstrings
/fontprocname exch def
/cfname exch def
/cfile cfname (w) file def
% Remove unwanted keys from the font.
currentfont dup length dict begin { def } forall
{ /FID /MIDVector /CurMID } { currentdict exch undef } forall
/Font currentdict end def
% Replace the FDepVector with a list of font names.
Font /FDepVector .knownget
{ [ exch { /FontName get } forall ]
Font /FDepVector 3 -1 roll put
}
if
% Find all the special objects we know about.
% wo uses this to write out references to otherwise intractable objects.
/otherobjs writespecial length dict dup begin
writespecial
{ pop Font 1 index .knownget { exch def } { pop } ifelse
}
forall
end def
% Define a dummy FontInfo, in case the font doesn't have one.
/FontInfo 0 dict def
% Write out the boilerplate.
Font begin
(/****************************************************************) wl
( Portions of this file are subject to the following notice(s):) wl
systemdict /copyright get wl
FontInfo /Notice .knownget
{ (----------------------------------------------------------------) wl wl
} if
(****************************************************************/) wl
() wl
(/* ) ws cfname ws ( */) wl
(/* This file was created by the ) ws product ws ( font2c utility. */) wl
() wl
(#undef DEBUG) wl
(#include "ccfont.h") wl
() wl
% Write the procedure prologue.
(#ifdef __PROTOTYPES__) wl
(ccfont_proc\() ws fontprocname ws (\);) wl
(int) wl
fontprocname ws ((i_ctx_t *i_ctx_p, const cfont_procs *pprocs, ref *pfont)) wl
(#else) wl
(int) wl
fontprocname ws ((i_ctx_p, pprocs, pfont) i_ctx_t *i_ctx_p; const cfont_procs *pprocs; ref *pfont;) wl
(#endif) wl
({\tint code;) wl
(\tref Font;) wl
otherobjs
{ exch pop (\tref ) ws wt (;) wl }
forall
% Write out the special objects.
otherobjs
{ exch writespecial 2 index get exec
}
forall
% Write out the main font dictionary.
% If possible, substitute the encoding name for the encoding;
% PostScript code will fix this up.
{ /Encoding /PrefEnc }
{ Font 1 index .knownget
{ encodingnames exch .knownget { def } { pop } ifelse }
{ pop }
ifelse
}
forall
(Font) Font FontType 0 eq { 5 } { 1 } ifelse wd
% Finish the procedural initialization code.
(\t*pfont = Font;) wl
(\treturn 0;) wl
(}) wl
end % Font
cfile closefile
} bind def
end def % font2cdict
% Compute the procedure name from the font name.
% Replace all non-alphanumeric characters with '_'.
/makefontprocnamemap 256 string
0 1 255 { 2 copy 95 put pop } for
(0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz)
{ 2 copy dup put pop } forall
readonly def
/makefontprocname % <fontname> makefontprocname <procnamestring>
{ dup length string cvs
dup length 1 sub -1 0
{ % Stack: string index
2 copy 2 copy get //makefontprocnamemap exch get put pop
}
for
} def
/writefont { font2cdict begin writefont end } def
% If the program was invoked from the command line, run it now.
[ shellarguments
{ counttomark dup 2 eq exch 3 eq or
{ counttomark -1 roll cvn
(Converting ) print dup =only ( font.\n) print flush
% Ensure that we get a clean copy of the font from the
% file system.
2 { % do both local and global
currentglobal not setglobal
dup undefinefont
} repeat
findfont setfont
(FontName is ) print currentfont /FontName get ==only (.\n) print flush
counttomark 1 eq
{ % Construct the procedure name from the file name.
currentfont /FontName get makefontprocname
}
if
writefont
(Done.\n) print flush
}
{ cleartomark
(Usage: font2c fontname cfilename.c [shortname]\n) print
( e.g.: font2c Courier cour.c\n) print flush
mark
}
ifelse
}
if pop