%    Copyright (C) 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.% % This file is part of Aladdin Ghostscript.% % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author% or distributor accepts any responsibility for the consequences of using it,% or for whether it serves any particular purpose or works at all, unless he% or she says so in writing.  Refer to the Aladdin Ghostscript Free Public% License (the "License") for full details.% % Every copy of Aladdin Ghostscript must include a copy of the License,% normally in a plain ASCII text file named PUBLIC.  The License grants you% the right to copy, modify and redistribute Aladdin Ghostscript, but only% under certain conditions described in the License.  Among other things, the% License requires that the copyright notice and this notice be preserved on% all copies. % $Id: gs_cmap.ps,v 1.1 2000/03/09 08:40:39 lpd Exp $% ProcSet for implementing CMap resources.% When this is run, systemdict is still writable. % NOTE: Rearranged fonts are not implemented yet. % ---------------- Public operators ---------------- % % composefont doesn't appear in CMap files -- it's documented in% the "PostScript Language Reference Manual Supplement"./composefont {		% <name> <cmap|cmapname> <fonts> composefont <font>  10 dict begin    /CMap 2 index dup type /dicttype ne { /CMap findresource } if def    /FDepVector 1 index cvlit def	% temporarily    /Encoding [ 0 1 FDepVector length 1 sub { } for ] def    /FDepVector [ 0 1 FDepVector length 1 sub {		% Stack: name cmap[name] fonts /FDepVector [ fonts... i      FDepVector 1 index get      dup type /dicttype ne {	dup /CIDFont resourcestatus {	  pop pop /CIDFont findresource	} {	  /Font findresource	} ifelse      } if      exch CMap /FontMatrices get dup length 2 index gt {	exch get dup null eq { pop } { makefont } ifelse      } {	pop pop      } ifelse    } for ] readonly def    /FMapType 9 def    /FontMatrix matrix def    /FontName 3 index def    /CMap load /WMode .knownget { /WMode exch def } if    /FontType 0 def  pop pop currentdict end /Font defineresource} bind odef % ---------------- CMap operators ---------------- % 40 dict begin % Our internal .CodeMaps structure is an array of two arrays: array 0% is the map for defined characters, array 1 is the map for notdefs.% Both are multi-level arrays indexed by the successive bytes of the% character code.  Each value is either a sub-array, null, a character name,% a CID (an integer), or a character code (expressed as a byte string).% .FontIndices is a similar array holding the corresponding usefont values,% except that if the only font index is 0, the .FontIndices element is 0.% FontMatrices is the array of matrices defined by begin/endusematrix.% All of the arrays and strings are read-only after they have been built.%% Note that the code in zfcmap.c that constructs the C structures from% the PostScript structures has intimate knowledge of the above format. % ------ Font-level operators ------ % /begincmap {		% - begincmap -  /.CodeMaps [256 array 256 array] def  /.FontIndices [0 0] def  /FontMatrices [] def  /.FontIndex 0 def} bind def/endcmap {		% - endcmap -  /.CodeMaps .CodeMaps .endmap def  /.FontIndices .FontIndices .endmap def  /FontMatrices FontMatrices .endmap def  /CodeMap null def		% for .buildcmap  currentdict end .buildcmap begin} bind def /begincodespacerange {	% <count> begincodespacerange -  pop mark} bind def/endcodespacerange {	% <code_lo> <code_hi> ... endcodespacerange -  counttomark 2 idiv {    .CodeMaps { 3 copy .addcodespacerange pop } forall pop pop  } repeat pop} bind def /.addcodespacerange {	% <code_lo> <code_hi> <map> .addcodespacerange -  2 index length 1 eq    { 2 { 3 -1 roll 0 get } repeat 1 exch       { 2 copy 0 put pop } for pop    }    { 2 index 0 get 1 3 index 0 get      6 -2 roll      2 { 1 1 index length 1 sub getinterval 6 1 roll } repeat		% Stack: lo hi map lo0 1 hi0       { 2 copy get null eq { 2 copy 256 array put } if         4 copy get .addcodespacerange pop       }      for pop pop pop    }  ifelse} bind def/.endmap {		% <map> .endmap <map>  dup type /arraytype eq {	% This might be a shared read-only array inherited via usecmap.	% Don't try to update its elements if this is the case.    dup wcheck {      dup { .endmap exch } forall astore readonly    } if  } {    dup type /stringtype eq { readonly } if  } ifelse} bind def /usecmap {		% <CMap_name> usecmap -  /CMap findresource  dup /.CodeMaps get dup length array copy /.CodeMaps exch def  /.FontIndices get /.FontIndices exch def} bind def /usefont {		% <fontID> usefont -  /.FontIndex exch def} bind def /beginusematrix {	% <fontID> beginusematrix -  FontMatrices wcheck not FontMatrices length 2 index le or {    FontMatrices length 1 index 1 add .max array    dup 0 FontMatrices putinterval    /FontMatrices exch def  } if} bind def/endusematrix {		% <matrix> endusematrix -  FontMatrices 3 1 roll put} bind def % ------ Rearranged font operators ------ % /beginrearrangedfont {	% <font_name> <font*> beginrearrangedfont -  10 dict begin  /.FontNames exch def  /.FontName exch def  begincmap} bind def/endrearrangedfont {	% - endrearrangedfont -  (REARRANGED FONTS NOT IMPLEMENTED YET.) = flush  FontName .FontNames 0 get findfont end definefont pop} bind def % ------ Character name/code selector operators ------ % /beginbfchar {		% <count> beginbfchar -  pop mark} bind def/endbfchar {		% <code> <to_code|charname> ... endbfchar  .endmapchar} bind def /beginbfrange {		% <count> beginbfrange -  pop mark} bind def/endbfrange {		% <code_lo> <code_hi> <to_code|(charname*)> ...			%   endbfrange -  counttomark 3 idiv {    counttomark -3 roll		% process in correct order    .addbfrange  } repeat pop} bind def /.addbfrange {		% <code_lo> <code_hi> <to_code|(charname*)>			%   .addbfrange  dup type /stringtype eq {    { dup length string copy dup dup length 1 sub 2 copy get 1 add put }    .addcharrange  } {    2 dict begin /codes 1 index def 0 get    { pop codes dup dup length 1 sub 1 exch getinterval /codes exch def      dup length 0 gt { 0 get } if    }    .addcharrange end  } ifelse} bind def % ------ CID selector operators ------ % /begincidchar {		% <count> begincidchar -  pop mark} bind def/endcidchar {		% <code> <cid> ... endcidchar -  .endmapchar} bind def /begincidrange {	% <count> begincidrange -  pop mark} bind def/endcidrange {		% <code_lo> <code_hi> <cid_base> ... endcidrange -  counttomark 3 idiv {    counttomark -3 roll		% process in correct order    { 1 add } .addcharrange  } repeat pop} bind def /.endmapchar {		% -mark- <code> <value> ... .endmapchar -  counttomark 2 idiv {    counttomark -2 roll		% process in correct order    1 index exch { } .addcharrange  } repeat pop} bind def /.addcharrange {	% <code_lo> <code_hi> <value_base> <next_proc>			%   .addcharrange -  0 .putmaprange} bind def /.putmaprange	 {	% <code_lo> <code_hi> <value_base> <next_proc> <0|1>			%   .putmaprange -  5 1 roll		% Most CMaps don't involve multiple fonts.		% For this reason, we create .FontIndices lazily.  .FontIndices 5 index get 0 eq .FontIndex 0 ne and {		% Create .FontIndices now.    .CodeMaps 5 index get .makecodespace      .FontIndices 6 index 3 -1 roll put  } if  .FontIndices 5 index get 0 ne {    3 index 3 index .FontIndex { } .FontIndices 9 index get .addmaprange      .FontIndices 7 index 3 -1 roll put pop  } if  .CodeMaps 5 index get .addmaprange    .CodeMaps 3 index 3 -1 roll put pop  pop} bind def/.makecodespace {	% <array|other> .makecodespace -  dup type /arraytype eq {    [ exch { .makecodespace } forall ]  } {    pop 0  } ifelse} bind def /.addmaprange {		% <code_lo> <code_hi> <value_base> <next_proc> <map>			%   .addmaprange <value_next> <map>	% We may be updating a (partly) read-only map from another CMap.	% If so, implement copy-on-write.   dup wcheck not { dup length array copy } if   4 index length 1 eq    { 2 { 5 -1 roll 0 get } repeat 1 exch       {	% Stack: value proc map code	 2 copy 5 index put pop	 3 -1 roll 2 index exec 3 1 roll       } for    }    { 4 index 0 get 1 5 index 0 get      8 -2 roll      2 { 1 1 index length 1 sub getinterval 8 1 roll } repeat		% Stack: lo hi next proc map lo0 1 hi0       { 6 copy get .addmaprange		% Stack: lo hi oldnext proc map i next submap	 exch 6 1 roll 5 -1 roll pop		% Stack: lo hi next proc map i submap	 3 copy put pop pop       }      for 5 -2 roll pop pop    }   ifelse exch pop} bind def % ------ notdef operators ------ % /beginnotdefchar {	% <count> beginnotdefchar -  pop mark} bind def/endnotdefchar {	% <code> <cid> ... endnotdefchar -  counttomark 2 idiv {    counttomark -2 roll		% process in correct order    1 index exch .addnotdefrange  } repeat pop} bind def /beginnotdefrange {	% <count> beginnotdefrange -  pop mark} bind def/endnotdefrange {	% <code_lo> <code_hi> <cid> ... endnotdefrange -  counttomark 3 idiv {    counttomark -3 roll		% process in correct order    .addnotdefrange  } repeat pop} bind def /.addnotdefrange {	% <code_lo> <code_hi> <cid_base> .addnotdefrange -  { } 1 .putmaprange} bind def % ---------------- Resource category definition ---------------- % currentdict end languagelevel exch 2 .setlanguagelevel /CMap /Generic /Category findresource dup length dict .copydict/Category defineresource pop	% We might have loaded CID font support already./CIDInit /ProcSet 2 copy { findresource } .internalstopped	% An interior `stopped' might have reset VM allocation to local.true .setglobal { pop pop 3 -1 roll } { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }ifelse exch defineresource pop .setlanguagelevel