% % % % % % % % % % % % % %

Copyright (C) 2000 Artifex Software, Inc. 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_cidcm.ps 9164 2008-10-17 13:44:34Z alexcher $ % Extending Font resource category with CIDFont-CMap fonts. languagelevel 2 .setlanguagelevel currentglobal true setglobal % % % % % In the comments below, 'CSI' is an abbreviation/acronym for CIDSystemInfo. We pre-scan resource files to retrieve the CSI from them. First we define a hidden procset .prs_dict containing necessary variables and procedures. Then we redefine the old /Font category using this procset.

% We maintain internal caches for the CSI values retrieved from % resource files. This supposes that document doesn't uninstall % resource files. To disable caching, set enable_cache to false. % We assume that names starting with '.prs' do not appear in resource files. % If this causes any problem, this prefix should be systematically changed % in this file. ('prs' is an abbreviation for 'prescan'.) 25 dict begin % Define local variables : /.prs_dict currentdict def /.prs_empty 0 dict readonly def /path_buffer 8192 string def /name_buffer 1024 string def /minus (-) 0 get def /period (.) 0 get def /CMap 10 dict def /CIDFont 10 dict def /enable_cache true def % self-reference (constant)

% % % % %

character character CSI cache CSI cache set false

code constant for '-' code constant for '.' for CMaps for CIDFonts to disable cache

% The folloving variables are just placeholders for ones to be set % dynamically : /.prsFile 0 def % file to prescan /.prsResult 0 def % result of prescan /.prsDictCount 0 def % save the dictionary stack depth % Define a dummy CIDInit procset to use while pre-scanning : /DummyCIDInit 15 dict begin

/begincmap {} def /usecmap {pop} bind def {stop} bind [ /begincodespacerange /endcodespacerange /beginnotdefchar /endnotdefchar /beginnotdefrange /endnotdefrange /begincidchar /endcidchar /begincidrange /endcidrange /endcmap /usefont /StartData ] { 1 index def } bind forall pop currentdict end def % Define a local 'findresource' for pre-scanning : % (it returns the dummy CIDInit instead of the regular CIDInit ProcSet) /findresource { % <InstName> <CatName> findresource <inst> 2 copy /ProcSet eq exch % /InstName /CatName bool /InstName /CIDInit eq and { pop pop //DummyCIDInit } { //findresource exec } ifelse } bind def % Define procedures for pre-scanning : /StopIfCSIDefined { o. % The search is limited to the top .prsDictCount dictionaries in the stack. % If so, retrieve the CSI, and execute stop to terminate the pre-scanning of t he file. % Otherwise, do nothing, so the pre-scanning continues. countdictstack //.prs_dict /.prsDictCount get sub dup { currentdict /CIDSystemInfo .knownget { //.prs_dict exch /.prsResult exch put stop } if currentdict exch end } repeat { begin } repeat } bind def /PrescanFile { % - PrescanFile { //.prs_dict /.prsFile get token { dup type % token type dup /nametype eq exch /operatortype eq or { dup xcheck { exec //StopIfCSIDefined exec } if } if } { stop } ifelse % - StopIfCSIDefined -

% Check if the dictionary stack contains a dictionary containing /CIDSystemInf

} loop } bind odef /GetCIDSystemInfoFromFile { % <file> GetCIDSystemInfoFromFile <CSI> % % % % % % This procedure reads resource files with 'token', executing the tokens untill /CIDSystemInfo appears to be defined. Normally the resource file creates a new dictionary on dictionary stack and defines /CIDSystemInfo in it. Returns an empty dictionary if no CIDSystemInfo is found.

RESMPDEBUG { (cidcm GetCIDSystemInfoFromFile beg) = } if //.prs_dict begin /.prsFile exch def /.prsResult //.prs_empty def /.prsDictCount countdictstack def RESMPDEBUG { (cidcm GetCIDSystemInfoFromFile will PrescanFile.) = } if { //PrescanFile } stopped pop //.prs_dict /.prsResult get end RESMPDEBUG { (cidcm GetCIDSystemInfoFromFile end) = } if } bind def /GetCIDSystemInfo { % <InstName> <CatName> GetCIDSystemInfo <CSI>

% Retrieve CSI, using caches. RESMPDEBUG { (cidcm GetCIDSystemInfo beg) = } if /Category findresource begin % /InstName dup ResourceStatus { pop 2 lt { FindResource /CIDSystemInfo .knownget not { //.prs_empty } if % CSI } { % /InstName currentdict /GetCIDSystemInfoFromMap .knownget { exec } if dup type /nametype eq { RESMPDEBUG { (cidcm GetCIDSystemInfo got a name.) = } if //.prs_dict Category get % /InstName CSIs dup 2 index known //enable_cache and { RESMPDEBUG { (cidcm GetCIDSystemInfo from cache.) = } if exch get % CSI } { RESMPDEBUG { (cidcm GetCIDSystemInfo from file.) = } if exch % CSIs /InstName dup //path_buffer ResourceFileName % CSIs /InstName (path) RESMPDEBUG { (cidcm GetCIDSystemInfo from file ) print dup = } if currentglobal exch true setglobal % CSIs /InstName g (path) mark exch % CSIs /InstName g [ (path) { (r) file } stopped { cleartomark //.prs_empty } { exch 1 index % CSIs /InstName g file [ file //GetCIDSystemInfoFromFile stopped {

cleartomark closefile //.prs_empty } { exch pop exch closefile } ifelse } ifelse % CSIs /InstName g CSI exch setglobal % CSIs /InstName CSI dup 4 1 roll % CSI CSIs /InstName CSI put % CSI RESMPDEBUG { (cidcm GetCIDSystemInfo got from file : <<) print dup { exch //=string cvs print ( ) print //=string cvs print ( ) print } forall (>>) = } if } ifelse } if } ifelse } { pop //.prs_empty } ifelse end RESMPDEBUG { (cidcm GetCIDSystemInfo end) = } if } bind def /IsCompatibleCSI { % <CSI-M> <CSI-F> IsCompatibleCSI <bool> % % % % % The CSI in a CIDFont may be an array, a dict, or null. If it is an array, it must be of 1 element, which is a dict. In this case the dict is used for testing the compatibility. Two dicts are compatible iff they contain same /Ordering and /Registry. Identity CMap is compatible with any CIDFont. % CSI-F CSI-M

exch { dup type /arraytype eq { dup length 1 ne { pop pop //false exit } if 0 get } if dup type /dicttype ne { pop pop //false exit } if exch dup type /dicttype ne { pop pop //false exit } if dup /Ordering .knownget { /Identity eq { pop pop //true exit } if } if //true [/Registry /Ordering] { 2 index 1 index .knownget not { 1234567 } if exch 4 index exch .knownget not { 7654321

% CSI-F CSI-M % CSI-F <<CSI-M>> % <<CSI-M>> CSI-F % <<CSI-M>> <<CSI-F>>

% <<CSI-M>> <<CSI-F>> bEQ

% <<CSI-M>> <<CSI-F>> bEQ /key vF % <<CSI-M>> <<CSI-F>> bEQ vF /key

} if eq and } forall exch pop exch pop exit } loop } bind def /IsWellComposed {

% <<CSI-M>> <<CSI-F>> bEQ vF vM % <<CSI-M>> <<CSI-F>> bEQ % bEQ

% <CIDFontName> <CMapName> IsWellComposed <bool> have compatible CSIs. % /CMapName /CIDFontName % /CMapName CSI-F % CSI-F /CMapName % CSI-F CSI-M % bool

% Check if the given CIDFont and CMap exch /CIDFont //GetCIDSystemInfo exec dup type /dicttype eq { dup length 0 ne { exch /CMap //GetCIDSystemInfo exec //IsCompatibleCSI exec } { pop pop false } ifelse } { pop pop false } ifelse } bind def /IsComposedFont {

% <FontName> IsComposedFont <CIDFontName> <CMapName> true % <FontName> IsComposedFont false

% Check if the given font name may be decomposed into CIDFont.CMap, CIDFont-CM ap % or into CIDFont--CMap, such that CIDFont and CMap have compatible CSIs. % FontName dup type /stringtype ne { //name_buffer cvs } if % (FontName) { dup length 2 sub -1 1 { % (FontName) i 2 copy get dup //minus eq exch //period eq or { 2 copy 2 copy % (FontName) i (FontName) i (FontName) i 2 copy get //minus eq { 2 copy 1 sub get //minus eq { 1 sub } if } if % (FontName) i (FontName) i (FontName) i 0 0 exch getinterval cvn 3 1 roll 1 add dup 1 i1 5 index length 1 i1 l exch sub getinterval cvn % (FontName) i /CIDFontName /CMapName 2 copy //IsWellComposed exec { % (FontName) i /CIDFontName /CMapName 4 2 roll pop pop % /CIDFontName /CMapName stop } if pop pop pop } { pop % (FontName) i /CIDFontName (FontName) i % (FontName) i (FontName) i /CIDFontName % (FontName) i /CIDFontName (FontName) i % (FontName) i /CIDFontName (FontName) i

} ifelse } for pop } stopped } bind def

% (FontName)

/ComposeName { % <CIDFont> <CMap> <scr> ComposeName <CIDFont-CMap> dup dup 5 2 roll % (scr) (scr) /CIDFont /CMap (scr) 3 2 roll exch cvs length dup % (scr) (scr) /CMap l0 l0 4 -1 roll exch //minus put % (scr) /CMap l0 1 add dup % (scr) /CMap l1 l1 3 index dup length % (scr) /CMap l1 l1 (scr) L 2 index sub % (scr) /CMap l1 l1 (scr) LT 3 2 roll % (scr) /CMap l1 (scr) LT l1 exch getinterval % (scr) /CMap l1 (scrT) 3 2 roll exch cvs length % (scr) l1 l2 add 0 exch getinterval % (CIDFont-CMap) } bind def % Redefine the /Font category with CIDFont-CMap construction : % The following code supposes that the following names are not % defined in the old /Font category dictionary : % /IsComposedFont, /IsWellComposed . /Font /Category findresource dup length dict copy begin /FindResource { % <InstName> FindResource <inst> dup //ResourceStatus exec { pop pop //FindResource exec } { dup //IsComposedFont exec { % /FontName /CIDFontName /CMapName exch [ exch ] composefont % inst } { //FindResource exec } ifelse } ifelse } bind def /ResourceStatus { % <InstName> ResourceStatus <nStatus> <nSize> true % <InstName> ResourceStatus false dup //ResourceStatus exec { 3 2 roll pop true % nStatus nSize true } { //IsComposedFont exec { % /CIDFontName /CMapName /CMap resourcestatus { % /CIDFontName nStatusM nSizeM exch pop exch % nSizeM /CIDFontName /CIDFont resourcestatus { % nSizeM nStatusF nSizeF exch pop % nSizeF nSizeM dup 0 ge { exch dup 0 ge { add } { exch pop } ifelse } { pop } ifelse % nSize 2 exch true % nStatus nSize true

} { pop pop pop false % work around buggy resource file } ifelse } { pop pop pop false % work around buggy resource file } ifelse } { false } ifelse } ifelse } bind def /ResourceForAll { % <template> <proc> <scratch> ResourceForAll % We suppose that the resourceforall procedure does not % define or install new fonts, CMaps, and/or CIDFonts. % First we create 3 temporary dictionaries to store temporary data % about fonts, CMaps and CIDFonts. % These dictionaries must be created dynamically, to allow for a possible % recursive call to resourceforall from the resourceforall procedure. currentglobal false setglobal 20 dict 20 dict 20 dict % (templ) proc (scr) g <<CIDFont>> << CMap>> <<Fonts>> % % % % % Store resource identifiers into local dictionaries A resource instance can have a key that is not a name or a string. In this case, resourceforall passes the key directly to proc instead of copying it into the scratch string. This case can arise only for a resource instance defined in virtual memory by a previous defineresource

% Discard non-string keys of CIDFont and CMap because <CIDFontName>-<CMapName> % is only defined for names. { /.DisableResourceOrdering pop % gs_resmp accesses this through execstack - d on't remove ! 6 index [ 2 index {exch //null put} aload pop ] cvx bind 6 index //ResourceF orAll exec (*) [ 3 index {exch dup type /stringtype eq { cvn dup put } { pop pop } ifel se } aload pop ] cvx bind 6 index /CMap resourceforall (*) [ 4 index {exch dup type /stringtype eq { cvn dup put } { pop pop } ifel se } aload pop ] cvx bind 6 index /CIDFont resourceforall exit } loop % This loop is a pattern for execstack_lookup - don't remove ! 4 -1 roll setglobal % (templ) proc (scr) <<CIDFont>> <<CMa p>> <<Fonts>> %% Make the list of fonts in the form (/Name status) : % (templ) proc (scr) <<CIDFont>> <<CMa p>> <<Fonts>> dup { pop dup

p>> p>>

} p>>

//ResourceStatus exec { pop 2 index <<Fonts>> /Name nStatus <<Font>> 3 1 roll put <<Fonts>> } { pop } ifelse forall <<Fonts>>

% (templ) proc (scr) <<CIDFont>> <<CMa % (templ) proc (scr) <<CIDFont>> <<CMa

% (templ) proc (scr) <<CIDFont>> <<CMa

%% Add CIDFont-CMap to it (filtering duplicates) : 3 2 roll { 3 index { 3 1 roll /CIDFont /CMap /CIDFont /CMap 6 index //ComposeName exec /CIDFont /CMap (Font) dup 8 index .stringmatch { cvn /CIDFont /CMap /Font dup 4 index exch known { pop pop } { 2 index /CIDFont /CMap /Font /CIDFont 4 2 roll /Font /CIDFont /CIDFont /CMap //IsWellComposed exec { exch 2 index exch 2 put /CIDFont } { exch pop } ifelse } ifelse } { pop pop } ifelse dup /CIDFont /CIDFont } forall pop pop } forall exch pop 4 3 roll pop

% (templ) proc (scr) <<CMap>> <<Font>> % (templ) proc (scr) <<CMap>> <<Font>> % (templ) proc (scr) <<CMap>> <<Font>>

% (templ) proc (scr) <<CMap>> <<Font>> % (templ) proc (scr) <<CMap>> <<Font>> % (templ) proc (scr) <<CMap>> <<Font>>

% (templ) proc (scr) <<CMap>> <<Font>> % % % % (templ) proc (scr) <<CMap>> <<Font>> (templ) proc (scr) <<CMap>> <<Font>> (templ) proc (scr) <<Font>> proc (scr) <<Font>>

% Make the enumerator and apply it : /MappedCategoryRedefiner /ProcSet findresource /MakeResourceEnumerator get exe c exec } bind def currentdict end /Font exch /Category defineresource pop end setglobal .setlanguagelevel