[EDIT] FILE: gs_cmap.ps

% Copyright (C) 2001-2019 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., 1305 Grant Avenue - Suite 200, Novato, % CA 94945, U.S.A., +1(415)492-9861, 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 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 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 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 //== 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 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 % 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
SAVE CANCEL