summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlgs/Resource/Init/gs_cmap.ps
diff options
context:
space:
mode:
Diffstat (limited to 'Master/tlpkg/tlgs/Resource/Init/gs_cmap.ps')
-rw-r--r--Master/tlpkg/tlgs/Resource/Init/gs_cmap.ps549
1 files changed, 549 insertions, 0 deletions
diff --git a/Master/tlpkg/tlgs/Resource/Init/gs_cmap.ps b/Master/tlpkg/tlgs/Resource/Init/gs_cmap.ps
new file mode 100644
index 00000000000..a9143efcb85
--- /dev/null
+++ b/Master/tlpkg/tlgs/Resource/Init/gs_cmap.ps
@@ -0,0 +1,549 @@
+% Copyright (C) 2001-2012 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., 7 Mt. Lassen Drive - Suite A-134, San Rafael,
+% CA 94903, 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 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
+
+ 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 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