home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 October / Chip_2002-10_cd1.bin / zkuste / pdf / download / gs704w32.exe / gs7.04 / lib / gs_cmap.ps < prev    next >
Encoding:
Text File  |  2002-01-31  |  14.6 KB  |  456 lines
  1. %    Copyright (C) 1995, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of AFPL Ghostscript.
  4. % 
  5. % AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6. % distributor accepts any responsibility for the consequences of using it, or
  7. % for whether it serves any particular purpose or works at all, unless he or
  8. % she says so in writing.  Refer to the Aladdin Free Public License (the
  9. % "License") for full details.
  10. % 
  11. % Every copy of AFPL Ghostscript must include a copy of the License, normally
  12. % in a plain ASCII text file named PUBLIC.  The License grants you the right
  13. % to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14. % conditions described in the License.  Among other things, the License
  15. % requires that the copyright notice and this notice be preserved on all
  16. % copies.
  17.  
  18. % $Id: gs_cmap.ps,v 1.11 2001/06/16 19:02:31 igorm Exp $
  19. % ProcSet for implementing CMap resources.
  20. % When this is run, systemdict is still writable.
  21.  
  22. % NOTE: Rearranged fonts are not implemented yet.
  23.  
  24. % ---------------- Public operators ---------------- %
  25.  
  26. /.rewriteTempMapsNotDef {
  27.   DEBUG { (rewriting TempMapsNotDef\n) print flush } if
  28.   .TempMaps 2 get
  29.   dup length 0 gt {
  30.     0 get
  31.     DEBUG { (...original...\n) print flush } if
  32.     1 5 2 index length 1 sub {
  33.       { 1 index exch get 2 3 put } stopped
  34.       { DEBUG { (cannot rewrite\n) print flush } if }
  35.       { DEBUG { (rewrite\n) print flush } if } ifelse
  36.     } for
  37.   } if
  38.   pop
  39.   DEBUG { (...FINISHED...\n) print } if
  40. } bind def
  41.  
  42. % composefont doesn't appear in CMap files -- it's documented in
  43. % the "PostScript Language Reference Manual Supplement".
  44. /composefont {        % <name> <cmap|cmapname> <fonts> composefont <font>
  45.   10 dict begin
  46.     /CMap 2 index dup type /dicttype ne { /CMap findresource } if def
  47.     /FDepVector 1 index cvlit def    % temporarily
  48.     /Encoding [ 0 1 FDepVector length 1 sub { } for ] def
  49.     /FDepVector [ 0 1 FDepVector length 1 sub {
  50.         % Stack: name cmap[name] fonts /FDepVector [ fonts... i
  51.       FDepVector 1 index get
  52.       dup type /dicttype ne {
  53.     dup /CIDFont resourcestatus {
  54.       pop pop /CIDFont
  55.     } {
  56.       /Font
  57.     } ifelse findresource
  58.       } if
  59.       exch CMap /FontMatrices get dup length 2 index gt {
  60.     exch get dup null eq { pop } { makefont } ifelse
  61.       } {
  62.     pop pop
  63.       } ifelse
  64.     } for ] readonly def
  65.     /FMapType 9 def
  66.     /FontMatrix matrix def
  67.     /FontName 3 index def
  68.     CMap /WMode .knownget { /WMode exch def } if
  69.     /FontType 0 def
  70.   pop pop currentdict end /Font defineresource
  71. } bind odef
  72.  
  73. % ---------------- CMap operators ---------------- %
  74.  
  75. 40 dict begin
  76.  
  77. % Our internal .CodeMapData structure closely mirrors the structures
  78. % defined in gxfcmap.h (q.v.).  () indicate a string, [] indicate an array,
  79. % ? indicates a Boolean, # indicates an integer, {} for grouping.
  80. %    [[(first) (last) ...]        % code space ranges
  81. %     [(prefix) (key_size,?is_range,value_type,value_size) (keys...)
  82. %       {(values...) | [value ...]} #font_index    % code mappings
  83. %      ...]
  84. %     <<same>>        % notdef mappings
  85. %    ]
  86. % FontMatrices is the array of matrices defined by begin/endusematrix.
  87. % All of the arrays and strings are read-only after they have been built.
  88. %
  89. % Note that the code in zfcmap.c that constructs the C structures from
  90. % the PostScript structures has intimate knowledge of the above format.
  91.  
  92. % ****** NOTE: The code currently only handles "well-behaved" CMaps:
  93. %    - CID values only (no bfchars), 16-bit
  94. %    - Entries (both code space and map) must be sorted
  95. %    - Only the last byte must vary in each map range, except for
  96. %    the identity mapping
  97.  
  98. % ------ Font-level operators ------ %
  99.  
  100. /begincmap {        % - begincmap -
  101.   /.CodeMapData [[] [] []] def
  102.   /FontMatrices [] def
  103.   /.FontIndex 0 def
  104.   /.TempMaps [20 dict 50 dict 50 dict] def
  105.   /CodeMap null def        % for .buildcmap
  106. } bind def
  107. /endcmap {        % - endcmap -
  108.   .rewriteTempMapsNotDef
  109.   DEBUG {
  110.     (*** defined charmap ***\n) print
  111.     .TempMaps 1 get {exch == (\t) print ==} forall
  112.     (*** undefined charmap ***\n) print
  113.     .TempMaps 2 get {exch == (\t) print ==} forall
  114.   } if
  115.   10 dict begin 0 1 2 {
  116.     /i exch def
  117.         % Append data from .TempMaps to .CodeMapData.
  118.     /t .TempMaps i get def
  119.     .CodeMapData i get length t { exch pop length add } forall
  120.     DEBUG { (requested array size ) print dup == } if
  121.     array /a exch def
  122.     a 0 .CodeMapData i get .putmore
  123.     0 1 t length 1 sub {
  124.       t exch get .putmore
  125.     } for pop pop
  126.     .CodeMapData i a put
  127.   } for end
  128.   currentdict /.TempMaps undef
  129.   /.CodeMapData .CodeMapData .endmap def
  130.   /FontMatrices FontMatrices .endmap def
  131. } bind def
  132.  
  133. /.putmore {        % <array> <i> <array2> .putmore <array> <i+len(array2)>
  134.   3 copy putinterval length add
  135. } bind def
  136.  
  137. /.endmap {        % <map> .endmap <map>
  138.   dup type /arraytype eq {
  139.     % This might be a shared read-only array inherited via usecmap.
  140.     % Don't try to update its elements if this is the case.
  141.     dup wcheck {
  142.       0 1 2 index length 1 sub {
  143.     2 copy 2 copy get .endmap put pop
  144.       } for readonly
  145.     } if
  146.   } {
  147.     dup type /stringtype eq { readonly } if
  148.   } ifelse
  149. } bind def
  150.  
  151. /.appendmap {        % -mark- <elt> ... <array#> .appendmap -
  152.   .TempMaps exch get counttomark 1 add 1 roll
  153.   ] 1 index length exch put
  154. } bind def
  155.  
  156. /begincodespacerange {    % <count> begincodespacerange -
  157.   pop mark
  158. } bind def
  159. /endcodespacerange {    % <code_lo> <code_hi> ... endcodespacerange -
  160.   0 .appendmap
  161. } bind def
  162.  
  163. /usecmap {        % <CMap_name> usecmap -
  164.   /CMap findresource dup
  165.         % Copy the top level of .CodeMapData
  166.   /.CodeMapData exch /.CodeMapData get copyarray def
  167.   /FontMatrices exch /FontMatrices get copyarray def
  168. } bind def
  169.  
  170. /usefont {        % <fontID> usefont -
  171.   /.FontIndex exch def
  172. } bind def
  173.  
  174. /beginusematrix {    % <fontID> beginusematrix -
  175.   FontMatrices wcheck not FontMatrices length 2 index le or {
  176.     FontMatrices length 1 index 1 add .max array
  177.     dup 0 FontMatrices putinterval
  178.     /FontMatrices exch def
  179.   } if
  180. } bind def
  181. /endusematrix {        % <matrix> endusematrix -
  182.   FontMatrices 3 1 roll put
  183. } bind def
  184.  
  185. % ------ Rearranged font operators ------ %
  186.  
  187. /beginrearrangedfont {    % <font_name> <font*> beginrearrangedfont -
  188.   10 dict begin
  189.   /.FontNames exch def
  190.   /.FontName exch def
  191.   begincmap
  192. } bind def
  193. /endrearrangedfont {    % - endrearrangedfont -
  194.   (REARRANGED FONTS NOT IMPLEMENTED YET.) = flush
  195.   FontName .FontNames 0 get findfont end definefont pop
  196. } bind def
  197.  
  198. % ------ Character name/code selector operators ------ %
  199.  
  200. /beginbfchar {        % <count> beginbfchar -
  201.   pop mark
  202. } bind def
  203. /endbfchar {        % <code> <to_code|charname> ... endbfchar
  204.   counttomark 2 idiv {
  205.     counttomark -2 roll        % process in correct order
  206.     .addbfchar
  207.   } repeat 1 .appendmap
  208. } bind def
  209.  
  210. /beginbfrange {        % <count> beginbfrange -
  211.   pop mark
  212. } bind def
  213. /endbfrange {        % <code_lo> <code_hi> <to_code|(charname*)> ...
  214.             %   endbfrange -
  215.   counttomark 3 idiv {
  216.     counttomark -3 roll        % process in correct order
  217.     dup type dup /arraytype eq exch /packedarraytype eq or {
  218.             % Array value, split up.
  219.       exch pop {
  220.             % Stack: code to_code|charname
  221.     1 index exch .addbfchar
  222.             % Increment the code.  As noted above, we require
  223.             % that only the last byte vary, but we still must
  224.             % mask it after incrementing, in case the last
  225.             % value was 0xff.
  226.             % Stack: code prefix params key value fontindex
  227.     6 -1 roll dup length string copy
  228.     dup dup length 1 sub 2 copy get 1 add 255 and put
  229.       } forall pop
  230.     } {
  231.             % Single value, handle directly.
  232.       .addbfrange
  233.     } ifelse
  234.   } repeat 1 .appendmap
  235. } bind def
  236.  
  237. /.addbfchar {        % <code> <to_code|charname> .addbfchar
  238.             %   <prefix> <params> <key> <value> <font_index>
  239.   1 index exch .addbfrange
  240. } bind def
  241. /.addbfrange {        % <code_lo> <code_hi> <to_code|charname>
  242.             %   .addbfrange <<same as .addbfchar>>
  243.   4 string dup 3
  244.   3 index type /nametype eq {
  245.     2 index 2 1 put
  246.     4 -1 roll 1 array astore 4 1 roll 4
  247.   } {
  248.     2 index 2 2 put
  249.     3 index length
  250.   } ifelse put
  251.             % Stack: code_lo code_hi value params
  252.   3 index 3 index eq {
  253.             % Single value.
  254.     3 -1 roll pop exch () exch
  255.   } {
  256.             % Range.
  257.     dup 0 1 put dup 1 1 put
  258.     4 2 roll
  259.     dup dup length 1 sub 0 exch getinterval 5 1 roll    % prefix
  260.             % Stack: prefix value params code_lo code_hi
  261.     2 { exch dup length 1 sub 1 getinterval } repeat concatstrings
  262.     3 -1 roll
  263.   } ifelse
  264.   .FontIndex
  265. } bind def
  266.  
  267. % ------ CID selector operators ------ %
  268.  
  269. /begincidchar {        % <count> begincidchar -
  270.   pop mark
  271. } bind def
  272. /endcidchar {        % <code> <cid> ... endcidchar -
  273.   1 .endmapchars
  274. } bind def
  275.  
  276. /begincidrange {    % <count> begincidrange -
  277.   pop mark
  278. } bind def
  279. /endcidrange {        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  280.   1 .endmapranges
  281. } bind def
  282.  
  283. /.endmapchars {        % -mark- <code> <cid> ... <map#> .endmapchars -
  284.   counttomark 1 add 1 roll
  285.   counttomark 2 idiv {
  286.     counttomark -2 roll        % process in correct order
  287.         % Construct prefix, params, key, value, font_index
  288.     <00 00 00 02> ()    % params, key
  289.     3 -1 roll .endmapvalue
  290.   } repeat
  291.   counttomark 2 add -1 roll .appendmap
  292. } bind def
  293.  
  294. /.endmapranges {    % -mark- <code_lo> <code_hi> <cid_base> ... <map#>
  295.             %   .endmapranges -
  296.   counttomark 1 add 1 roll
  297.   counttomark 3 idiv {
  298.     counttomark -3 roll        % process in correct order
  299.         % Construct prefix, params, key_lo, key_hi, value, font_index
  300.     3 1 roll    % <cid_base> <code_lo> <code_hi>
  301.         %        prefix    key
  302.         % 1-byte code:    ()    .
  303.         % 1-byte range:    ()    .
  304.         % N-byte code:    .    (*)
  305.         % N-byte range:    (*)    (*)
  306.     dup 2 index eq {    % <code_lo> == <code_hi>
  307.                    % 0: prefix_len for 1-byte code
  308.                    % 1: prefix_len for N-byte code
  309.        dup length 1 eq { 0 } { 1 } ifelse
  310.     } {            % <code_lo> != <code_hi>
  311.                  % calculate prefix_len for *-byte range
  312.        dup length 1 sub % <cid_base> <code_lo> <code_hi> <code_len-1>
  313.        0        % initial value for N
  314.        {        % <cid_base> <code_lo> <code_hi> (code_len-1)  N
  315.            dup 2 index ge { exit } if % if (N >= len - 1) exit
  316.            3 index 1 index get    % N-th byte of code_lo
  317.            3 index 2 index get    % N-th byte of code_hi
  318.            eq { 1 add } { exit } ifelse
  319.        } loop
  320.        exch pop     % discard <code_len-1>
  321.     } ifelse
  322.                 % cid_base code_lo code_hi prefix_len
  323.  
  324.     % Althogh Adobe CPSI with native CID/CMap support accept
  325.     % multi-dimensional range specification in notdef & cidrange
  326.     % (and CID is calculated as relative position in multi-dimensional
  327.     % range), but older CPSI & ATM cannot handle it.
  328.     % 
  329.     % GS accepts such specification, but it's recommended to keep
  330.     % from using this feature for notdef & cidrange.
  331.     % Following is a disabler of this feature.
  332.     % -------------------------------------------------------------
  333.     % counttomark 1 add index     % get map#
  334.     % 0 ne {            % if not codespacerange
  335.     %   1 index length         % get code length
  336.     %   1 index             % get prefix length
  337.     %   sub            % calculate key length
  338.     %   1 gt {            % if (key_len > 1),
  339.     %      (.endmapranges error) = flush
  340.     %      (multi-dimensional range specification is used out of codespacerange)
  341.     %      = flush
  342.     %      (/) =only
  343.     %      CMapName CMapName length string cvs =only
  344.     %      (: <) =only
  345.     %      2 index (%stdout) (w) file exch writehexstring
  346.     %      (> <) =only
  347.     %      1 index (%stdout) (w) file exch writehexstring
  348.     %      (>\n) =only flush
  349.     %      quit
  350.     %   } if
  351.     % } if
  352.     % -------------------------------------------------------------
  353.  
  354.     1 index exch 0 exch getinterval
  355.                 % cid_base code_lo code_hi prefix
  356.     dup length 3 index length exch sub
  357.                 % cid_base code_lo code_hi prefix range_len
  358.     dup 255 gt {
  359.        (too long coderange specification for current GS\n) print stop
  360.     } if
  361.     <00 01 00 02> 4 string copy    % create initialized param
  362.     dup 0 4 -1 roll put        % put range_len into param
  363.  
  364.     % get key_hi
  365.     3 -1 roll dup length 3 index length dup 3 1 roll sub getinterval
  366.  
  367.     % get key_lo
  368.     4 -1 roll dup length 4 index length dup 3 1 roll sub getinterval
  369.  
  370.     % make "keys" (concatenated key_lo + key_hi)
  371.     exch concatstrings
  372.  
  373.     % 
  374.     4 -1 roll
  375.     .endmapvalue
  376.  
  377.         % See if we can merge with the previous value.
  378.         % The prefix, params, and font index must match.
  379.     % prefix params keys value fontindex
  380.     counttomark 5 gt { % 2 (or more) ranges (1 range = 5 item)
  381.        4 index 10 index eq    % compare prefix
  382.        4 index 10 index eq and    % compare params
  383.        1 index 7 index eq and    % compare fontindex
  384.     {
  385.           DEBUG { (merge!\n) print } if
  386.       pop 4 2 roll pop pop
  387.            % prefix params keys value fontindex keys2 value2
  388.       5 -1 roll 3 -1 roll concatstrings
  389.            % prefix params value fontindex value2 keys'
  390.       4 -1 roll 3 -1 roll concatstrings
  391.            % prefix params fontindex keys' values'
  392.       3 -1 roll
  393.     } if
  394.      } if % end of 2 (or more) ranges
  395.   } repeat
  396.   counttomark 2 add -1 roll .appendmap
  397. } bind def
  398.  
  399. /.endmapvalue {        % <cid> .endmapvalue (hi,lo) .FontIndex
  400.   2 string dup 0 3 index -8 bitshift put    % value
  401.   dup 1 4 -1 roll 255 and put
  402.   .FontIndex        % font_index
  403. } bind def
  404.  
  405. % ------ notdef operators ------ %
  406.  
  407. /beginnotdefchar {    % <count> beginnotdefchar -
  408.   pop mark
  409. } bind def
  410. /endnotdefchar {    % <code> <cid> ... endnotdefchar -
  411.   2 .endmapchars
  412. } bind def
  413.  
  414. /beginnotdefrange {    % <count> beginnotdefrange -
  415.   pop mark
  416. } bind def
  417. /endnotdefrange {    % <code_lo> <code_hi> <cid> ... endnotdefrange -
  418.   2 .endmapranges
  419. } bind def
  420.  
  421. % ---------------- Resource category definition ---------------- %
  422.  
  423. currentdict end
  424.  
  425. languagelevel exch 2 .setlanguagelevel
  426.  
  427. /CMap /Generic /Category findresource dup length dict .copydict
  428. dup /InstanceType /dicttype put
  429. dup /DefineResource {
  430.         % The AdobePS5 Windows driver emits code that attempts to
  431.         % create CMaps without the required CMapName entry.
  432.         % Work around this here.
  433.   dup /CMapName known not {
  434.     dup wcheck not {
  435.       .currentglobal exch dup wcheck .setglobal
  436.       dup length dict .copydict exch .setglobal
  437.     } if
  438.     dup gcheck 2 index gcheck not and {
  439.       exch .currentglobal exch true .setglobal
  440.       dup length string copy exch .setglobal exch
  441.     } if dup /CMapName 3 index put
  442.   } if
  443.   dup /CodeMap get null eq { .buildcmap } if
  444.   /Generic /Category findresource /DefineResource get exec
  445. } put
  446. /Category defineresource pop
  447.     % We might have loaded CID font support already.
  448. /CIDInit /ProcSet 2 copy { findresource } .internalstopped
  449.     % An interior `stopped' might have reset VM allocation to local.
  450. true .setglobal
  451.  { pop pop 3 -1 roll }
  452.  { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }
  453. ifelse exch defineresource pop
  454.  
  455. .setlanguagelevel
  456.