Subversion Repositories planix.SVN

%    Copyright (C) 1995, 2000 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: gs_cmap.ps,v 1.19 2005/08/17 21:54:55 igor Exp $

% ProcSet for implementing CMap resources.

% When this is run, systemdict is still writable.

% NOTE: Rearranged fonts are not implemented yet.

[

   /CMERGE_DEBUG

   /USE_CIDCHAR_AS_RANGE

] {dup where {pop pop} { currentdict exch //false def pop } ifelse} forall

% ---------------- Public operators ---------------- %

/.rewriteTempMapsNotDef {

  %

  % Before building .CodeMapData from .TempMaps,

  % we need to replace dst type codes in the notdef map with the value 3,

  % which corresponds to CODE_VALUE_NOTDEF, see gxfcmap.h .

  %

  CMAPDEBUG { (rewriting TempMapsNotDef\n) print flush } if

  .TempMaps 2 get

  dup length 0 gt {

    CMAPDEBUG { (...original...\n) print flush } if

    1 5 2 index length 1 sub {

      { 1 index exch get 2 3 put } stopped

      { CMAPDEBUG { (cannot rewrite\n) print flush } if }

      { CMAPDEBUG { (rewrite\n) print flush } if } ifelse

    } for

  } if

  pop

  CMAPDEBUG { (...FINISHED...\n) print } if

} bind def

% 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

    /FontInfo 1 dict def % for .processToUnicode in pdf_font.ps .

    /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

	} {

	  /Font

	} ifelse findresource

      } 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 /WMode .knownget { /WMode exch def } if

    /FontType 0 def

  pop pop currentdict end /Font defineresource

} bind odef

% ---------------- CMap operators ---------------- %

40 dict begin

% Our internal .CodeMapData structure closely mirrors the structures

% defined in gxfcmap.h (q.v.).  () indicate a string, [] indicate an array,

% ? indicates a Boolean, # indicates an integer, {} for grouping.

%	[[[(first) (last) ...]+]		% code space ranges

%	 [[(prefix) (key_size,?is_range,value_type,value_size) (keys...)

%	   {(values...) | [value ...]} #font_index ]+]	% code mappings

%	  ...]

%	 <<same>>		% notdef mappings

%	]

% 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.

% ****** NOTE: The code currently only handles "well-behaved" CMaps:

%	- CID values only (no bfchars), 16-bit

%	- Entries (both code space and map) must be sorted

%	- Only the last byte must vary in each map range, except for

%	the identity mapping

% ------ Font-level operators ------ %

/begincmap {		% - begincmap -

  /.CodeMapData [[[]] [[]] [[]]] def

  /FontMatrices [] def

  /.FontIndex 0 def

  /.TempMaps [20 dict 50 dict 50 dict] def

  /CodeMap //null def		% for .buildcmap

} bind def

/endcmap {		% - endcmap -

  .rewriteTempMapsNotDef

  CMAPDEBUG {

    2 (*** undefined charmap ***)

    1 (*** defined charmap ***)

    3 { =

      .TempMaps exch get

        dup == (\t) print

        1 index exch get ==

      } for

      pop

    } repeat

  } if

  /.CodeMapData dup load [ exch

    .TempMaps aload pop begin begin begin 

    {

      [ exch aload pop

           currentdict exch get 

        } for 

      ]

      end

    } forall

  ] .endmap def

  CMAPDEBUG {

    (*** Content of .CodeMapData ***) =

    pop

  } if

  currentdict /.TempMaps undef

  /FontMatrices FontMatrices .endmap def

} 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 {

	2 copy 2 copy get .endmap put pop

      } for readonly

    } if

  } {

    dup type /stringtype eq { readonly } if

  } ifelse

} bind def

/.appendmap {		% -mark- <elt> ... <array#> .appendmap -

  .TempMaps exch get counttomark 1 add 1 roll

  ] 1 index length exch put

} bind def

/begincodespacerange {	% <count> begincodespacerange -

  pop mark

} bind def

/endcodespacerange {	% <code_lo> <code_hi> ... endcodespacerange -

} bind def

/usecmap {		% <CMap_name> usecmap -

  /CMap findresource dup

		% Copy the top level of .CodeMapData

  /.CodeMapData exch /.CodeMapData get copyarray def

  /FontMatrices exch /FontMatrices get copyarray 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

  counttomark 2 idiv {

    counttomark -2 roll		% process in correct order

    .addbfchar

  } repeat 1 .appendmap

} 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

    dup type dup /arraytype eq exch /packedarraytype eq or {

			% Array value, split up.

      exch pop {

			% Stack: code to_code|charname

	1 index exch .addbfchar

			% Increment the code.  As noted above, we require

			% that only the last byte vary, but we still must

			% mask it after incrementing, in case the last

			% value was 0xff.

			% Stack: code prefix params key value fontindex

	6 -1 roll dup length string copy

	dup dup length 1 sub 2 copy get 1 add 255 and put

      } forall pop

    } {

			% Single value, handle directly.

      .addbfrange

    } ifelse

  } repeat 1 .appendmap

} bind def

/.addbfchar {		% <code> <to_code|charname> .addbfchar

			%   <prefix> <params> <key> <value> <font_index>

  1 index exch .addbfrange

} bind def

/.addbfrange {		% <code_lo> <code_hi> <to_code|charname>

			%   .addbfrange <<same as .addbfchar>>

  4 string dup 3

  3 index type /nametype eq {

    2 index 2 1 put % dst = CODE_VALUE_GLYPH, see gxfcmap.h .

    4 -1 roll 1 array astore 4 1 roll 4

  } {

    2 index 2 2 put % dst = CODE_VALUE_CHARS, see gxfcmap.h .

    3 index length

  } ifelse put

			% Stack: code_lo code_hi value params

  3 index 3 index eq {

			% Single value.

    3 -1 roll pop exch () exch

  } {

			% Range.

    dup 0 1 put dup 1 1 put

    4 2 roll

    dup dup length 1 sub 0 exch getinterval 5 1 roll	% prefix

			% Stack: prefix value params code_lo code_hi

    2 { exch dup length 1 sub 1 getinterval } repeat concatstrings

    3 -1 roll

  } ifelse

  .FontIndex

} bind def

% ------ CID selector operators ------ %

/begincidchar {		% <count> begincidchar -

  pop mark

} bind def

/endcidchar {		% <code> <cid> ... endcidchar -

  1 .endmapchars

} bind def

/begincidrange {	% <count> begincidrange -

  pop mark

} bind def

/endcidrange {		% <code_lo> <code_hi> <cid_base> ... endcidrange -

  1 .endmapranges

} bind def

/.endmapchars {         % -mark- <code> <cid> ... <map#> .endmapchars -

  counttomark 1 add 1 roll

  counttomark 2 idiv {

    counttomark -2 roll         % process in correct order

    exch        % <cid> <code>

                % Construct prefix, params, key, value, font_index

    dup length 1 eq {   % 1-byte

      <00 00 00 02> ()  % <prefix> <param> <null_key>

    } {                 % N-byte

      dup 0 1 getinterval exch  % make 1-byte prefix

      4 string dup 0

      USE_CIDCHAR_AS_RANGE {

        <00 01 00 02>   % skelton for param

      } {

        <00 00 00 02>   % skelton for param

      } ifelse

      putinterval

      exch              % <prefix> <param> <code>

      dup length        % <prefix> <param> <code> N

      1 sub             % <prefix> <param> <code> N-1

      dup               % <prefix> <param> <code> N-1 N-1

      3 index           % <prefix> <param> <code> N-1 N-1 <param>

      exch              % <prefix> <param> <code> N-1 <param> N-1

      put               % <prefix> <param'> <code> N-1

      1 exch            % <prefix> <param'> <code> 1 N-1

      getinterval       % <prefix> <param'> <key>

      USE_CIDCHAR_AS_RANGE {

        dup length 2 mul string % <key> <dkey>

        dup                     % <key> <dkey> <dkey>

        2 index                 % <key> <dkey> <dkey> <key>

        dup                     % <key> <dkey'> <dkey'>

        3 -1 roll               % <dkey'> <dkey'> <key>

        dup length              % <dkey'> <dkey'> <key> N-1

        exch putinterval        % <dkey''>

      } if

    } ifelse

    4 -1 roll           % <prefix> <param'> <key> <cid>

    .endmapvalue        % <prefix> <param'> <key> <hex_cid> <font_idx>

    % prefix params keys value fontindex

    counttomark 5 gt { % 2 (or more) ranges (1 range = 5 item)

       4 index 10 index eq      % compare prefix

       4 index 10 index eq and  % compare params

       1 index 7 index eq and   % compare fontindex

        {

          CMAPDEBUG { (merge! char\n) print } if

          pop 4 2 roll pop pop

           % prefix params keys value fontindex keys2 value2

          5 -1 roll 3 -1 roll concatstrings

           % prefix params value fontindex value2 keys'

          4 -1 roll 3 -1 roll concatstrings

           % prefix params fontindex keys' values'

          3 -1 roll

        } if

     } if % end of 2 (or more) ranges

    CMERGE_DEBUG {

    ( prefix:) print 4 index =only

    ( param:) print 3 index =only

    ( key:) print 2 index =only

    ( hex_cid:) print 1 index =only

    ( font_idx:) print 0 index == flush

    } if

  } repeat

  counttomark 2 add -1 roll .appendmap

} bind def

/.endmapranges {	% -mark- <code_lo> <code_hi> <cid_base> ... <map#>

			%   .endmapranges -

  counttomark 1 add 1 roll

  counttomark 3 idiv {

    counttomark -3 roll		% process in correct order

		% Construct prefix, params, key_lo, key_hi, value, font_index

    3 1 roll	% <cid_base> <code_lo> <code_hi>

		%		prefix	key

		% 1-byte code:	()	.

		% 1-byte range:	()	.

		% N-byte code:	.	(*)

		% N-byte range:	(*)	(*)

    dup 2 index eq {	% <code_lo> == <code_hi>

           		% 0: prefix_len for 1-byte code

           		% 1: prefix_len for N-byte code

       dup length 1 eq { 0 } { 1 } ifelse

    } {			% <code_lo> != <code_hi>

     			% calculate prefix_len for *-byte range

       dup length 1 sub % <cid_base> <code_lo> <code_hi> <code_len-1>

       {		% <cid_base> <code_lo> <code_hi> (code_len-1)  N

           dup 2 index ge { exit } if % if (N >= len - 1) exit

           3 index 1 index get	% N-th byte of code_lo

           3 index 2 index get	% N-th byte of code_hi

           eq { 1 add } { exit } ifelse

       } loop

       exch pop 	% discard <code_len-1>

    } ifelse

				% cid_base code_lo code_hi prefix_len

    % Althogh Adobe CPSI with native CID/CMap support accept

    % multi-dimensional range specification in notdef & cidrange

    % (and CID is calculated as relative position in multi-dimensional

    % range), but older CPSI & ATM cannot handle it.

    % 

    % GS accepts such specification, but it's recommended to keep

    % from using this feature for notdef & cidrange.

    % Following is a disabler of this feature.

    % -------------------------------------------------------------

    % counttomark 1 add index 	% get map#

    % 0 ne {			% if not codespacerange

    %   1 index length 		% get code length

    %   1 index 			% get prefix length

    %   sub			% calculate key length

    %   1 gt {			% if (key_len > 1),

    %      (.endmapranges error) = flush

    %      (multi-dimensional range specification is used out of codespacerange)

    %      = flush

    %      (/) =only

    %      CMapName CMapName length string cvs =only

    %      (: <) =only

    %      2 index (%stdout) (w) file exch writehexstring

    %      (> <) =only

    %      1 index (%stdout) (w) file exch writehexstring

    %      (>\n) =only flush

    %      quit

    %   } if

    % } if

    % -------------------------------------------------------------

    1 index exch 0 exch getinterval

				% cid_base code_lo code_hi prefix

    dup length 3 index length exch sub

				% cid_base code_lo code_hi prefix range_len

    dup 255 gt {

       (too long coderange specification for current GS\n) print

       signalerror

    } if

    <00 01 00 02> 4 string copy	% create initialized param

    dup 0 4 -1 roll put		% put range_len into param

    % get key_hi

    3 -1 roll dup length 3 index length dup 3 1 roll sub getinterval

    % get key_lo

    4 -1 roll dup length 4 index length dup 3 1 roll sub getinterval

    % make "keys" (concatenated key_lo + key_hi)

    exch concatstrings

    % 

    4 -1 roll

    .endmapvalue

		% See if we can merge with the previous value.

		% The prefix, params, and font index must match.

    % prefix params keys value fontindex

    counttomark 5 gt { % 2 (or more) ranges (1 range = 5 item)

       4 index 10 index eq	% compare prefix

       4 index 10 index eq and	% compare params

       1 index 7 index eq and	% compare fontindex

	{

          CMAPDEBUG { (merge!\n) print } if

	  pop 4 2 roll pop pop

           % prefix params keys value fontindex keys2 value2

	  5 -1 roll 3 -1 roll concatstrings

           % prefix params value fontindex value2 keys'

	  4 -1 roll 3 -1 roll concatstrings

           % prefix params fontindex keys' values'

	  3 -1 roll

	} if

     } if % end of 2 (or more) ranges

  } repeat

  counttomark 2 add -1 roll .appendmap

} bind def

/.endmapvalue {		% <cid> .endmapvalue (hi,lo) .FontIndex

  2 string dup 0 3 index -8 bitshift put	% value

  dup 1 4 -1 roll 255 and put

  .FontIndex		% font_index

} bind def

% ------ notdef operators ------ %

/beginnotdefchar {	% <count> beginnotdefchar -

  pop mark

} bind def

/endnotdefchar {	% <code> <cid> ... endnotdefchar -

  2 .endmapchars

} bind def

/beginnotdefrange {	% <count> beginnotdefrange -

  pop mark

} bind def

/endnotdefrange {	% <code_lo> <code_hi> <cid> ... endnotdefrange -

  2 .endmapranges

} bind def

% ---------------- Resource category definition ---------------- %

currentdict end

languagelevel exch 2 .setlanguagelevel

/CMap /Generic /Category findresource dup length dict .copydict

dup /InstanceType /dicttype put

dup /DefineResource {

		% The AdobePS5 Windows driver emits code that attempts to

		% create CMaps without the required CMapName entry.

		% Work around this here.

  dup /CMapName known not {

    dup wcheck not {

      .currentglobal exch dup wcheck .setglobal

      dup length dict .copydict exch .setglobal

    } if

    dup gcheck 2 index gcheck not and {

      exch .currentglobal exch //true .setglobal

      dup length string copy exch .setglobal exch

    } if dup /CMapName 3 index put

  } if

  dup /CodeMap get //null eq { .buildcmap } if

  /Generic /Category findresource /DefineResource get exec

} put

/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