| Current File : //proc/thread-self/root/usr/share/ghostscript/10.02.1/Resource/Init/gs_cmap.ps |
% Copyright (C) 2001-2023 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.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
% CA 94129, USA, for further information.
%
% 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 {
0 get
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
/.composefontdict { % <name> <cmap|cmapname> <fonts> composefont <name> <font_dict>
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
} bind executeonly odef
% composefont doesn't appear in CMap files -- it's documented in
% the "PostScript Language Reference Manual Supplement".
/composefont { % <name> <cmap|cmapname> <fonts> composefont <font>
.composefontdict /Font defineresource
} bind def
% ---------------- 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 exec
CMAPDEBUG {
2 (*** undefined charmap ***)
1 (*** defined charmap ***)
0 (*** code space ranges ***)
3 { =
.TempMaps exch get
0 1 2 index length 1 sub {
dup //== exec (\t) print
1 index exch get //== exec
} for
pop
} repeat
} if
/.CodeMapData dup load [ exch
.TempMaps aload pop begin begin begin
{
[ exch aload pop
0 1 currentdict length 1 sub {
currentdict exch get
} for
]
end
} forall
] .endmap def
CMAPDEBUG {
(*** Content of .CodeMapData ***) =
0 .CodeMapData { exch dup //== exec 1 add exch (\t) print //== exec } forall
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 {
0 1 2 index length 1 sub {
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 -
0 .appendmap
} 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
] [ //true % [<da><ta>] [ true
3 -1 roll % [ true [<da><ta>]
{
exch {
//false % [ <da> false
} { % [ <da> <ta>
.addbfchar % [ prefix params key value font_index
//true
} ifelse
} forall
pop
1 .appendmap
} bind def
/beginbfrange { % <count> beginbfrange -
pop mark
} bind def
/endbfrange { % <code_lo> <code_hi> <to_code|(charname*)> ...
% endbfrange -
] [ 0 % [<da><ta><set>] [ 0
3 -1 roll % [ 0 [<da><ta><set>]
{
exch % [ <da> 0
{ 1 2
{
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
0
}
} exch get exec
} forall
pop
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 4 index length put
dup 1 1 put
4 2 roll
1 index dup length 1 sub 0 exch getinterval 5 1 roll % prefix
% Stack: prefix value params code_lo code_hi
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
0 exch % <prefix> <param> <code> N-1 <param> 0 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>
0 exch putinterval % <key> <dkey'>
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 9 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 //== exec 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>
0 % initial value for N
{ % <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
/.endmapranges cvx /rangecheck 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 9 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
% Adobe PS CET 23-25 and others define an almost empty CMap. Tolerate this.
% With the above, we can actually tolerate: /name << >> defineresource
dup /CIDSystemInfo known not {
dup wcheck not {
.currentglobal exch dup wcheck .setglobal
dup length dict .copydict exch .setglobal
} if
dup /CIDSystemInfo [ //null ] put
} if
dup /CodeMap .knownget { //null eq { .buildcmap } if } if
/Generic /Category findresource /DefineResource get exec
} bind executeonly put
/Category defineresource pop
% We might have loaded CID font support already.
/CIDInit /ProcSet 2 copy { findresource } //.internalstopped exec
% 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
currentdict /.rewriteTempMapsNotDef .undef
.setlanguagelevel