% 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 6300 2005-12-28 19:56:24Z giles $ % 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 % valueeq { 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 % 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