home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 August / PCWorld_2000-08_cd.bin / Software / TemaCD / ghostscr / gs601w32.exe / gs6.01 / lib / gs_cmap.ps < prev    next >
Text File  |  2000-03-09  |  10KB  |  322 lines
  1. %    Copyright (C) 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % $Id: gs_cmap.ps,v 1.1 2000/03/09 08:40:39 lpd 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. % composefont doesn't appear in CMap files -- it's documented in
  27. % the "PostScript Language Reference Manual Supplement".
  28. /composefont {        % <name> <cmap|cmapname> <fonts> composefont <font>
  29.   10 dict begin
  30.     /CMap 2 index dup type /dicttype ne { /CMap findresource } if def
  31.     /FDepVector 1 index cvlit def    % temporarily
  32.     /Encoding [ 0 1 FDepVector length 1 sub { } for ] def
  33.     /FDepVector [ 0 1 FDepVector length 1 sub {
  34.         % Stack: name cmap[name] fonts /FDepVector [ fonts... i
  35.       FDepVector 1 index get
  36.       dup type /dicttype ne {
  37.     dup /CIDFont resourcestatus {
  38.       pop pop /CIDFont findresource
  39.     } {
  40.       /Font findresource
  41.     } ifelse
  42.       } if
  43.       exch CMap /FontMatrices get dup length 2 index gt {
  44.     exch get dup null eq { pop } { makefont } ifelse
  45.       } {
  46.     pop pop
  47.       } ifelse
  48.     } for ] readonly def
  49.     /FMapType 9 def
  50.     /FontMatrix matrix def
  51.     /FontName 3 index def
  52.     /CMap load /WMode .knownget { /WMode exch def } if
  53.     /FontType 0 def
  54.   pop pop currentdict end /Font defineresource
  55. } bind odef
  56.  
  57. % ---------------- CMap operators ---------------- %
  58.  
  59. 40 dict begin
  60.  
  61. % Our internal .CodeMaps structure is an array of two arrays: array 0
  62. % is the map for defined characters, array 1 is the map for notdefs.
  63. % Both are multi-level arrays indexed by the successive bytes of the
  64. % character code.  Each value is either a sub-array, null, a character name,
  65. % a CID (an integer), or a character code (expressed as a byte string).
  66. % .FontIndices is a similar array holding the corresponding usefont values,
  67. % except that if the only font index is 0, the .FontIndices element is 0.
  68. % FontMatrices is the array of matrices defined by begin/endusematrix.
  69. % All of the arrays and strings are read-only after they have been built.
  70. %
  71. % Note that the code in zfcmap.c that constructs the C structures from
  72. % the PostScript structures has intimate knowledge of the above format.
  73.  
  74. % ------ Font-level operators ------ %
  75.  
  76. /begincmap {        % - begincmap -
  77.   /.CodeMaps [256 array 256 array] def
  78.   /.FontIndices [0 0] def
  79.   /FontMatrices [] def
  80.   /.FontIndex 0 def
  81. } bind def
  82. /endcmap {        % - endcmap -
  83.   /.CodeMaps .CodeMaps .endmap def
  84.   /.FontIndices .FontIndices .endmap def
  85.   /FontMatrices FontMatrices .endmap def
  86.   /CodeMap null def        % for .buildcmap
  87.   currentdict end .buildcmap begin
  88. } bind def
  89.  
  90. /begincodespacerange {    % <count> begincodespacerange -
  91.   pop mark
  92. } bind def
  93. /endcodespacerange {    % <code_lo> <code_hi> ... endcodespacerange -
  94.   counttomark 2 idiv {
  95.     .CodeMaps { 3 copy .addcodespacerange pop } forall pop pop
  96.   } repeat pop
  97. } bind def
  98.  
  99. /.addcodespacerange {    % <code_lo> <code_hi> <map> .addcodespacerange -
  100.   2 index length 1 eq
  101.     { 2 { 3 -1 roll 0 get } repeat 1 exch
  102.        { 2 copy 0 put pop } for pop
  103.     }
  104.     { 2 index 0 get 1 3 index 0 get
  105.       6 -2 roll
  106.       2 { 1 1 index length 1 sub getinterval 6 1 roll } repeat
  107.         % Stack: lo hi map lo0 1 hi0
  108.        { 2 copy get null eq { 2 copy 256 array put } if
  109.          4 copy get .addcodespacerange pop
  110.        }
  111.       for pop pop pop
  112.     }
  113.   ifelse
  114. } bind def
  115. /.endmap {        % <map> .endmap <map>
  116.   dup type /arraytype eq {
  117.     % This might be a shared read-only array inherited via usecmap.
  118.     % Don't try to update its elements if this is the case.
  119.     dup wcheck {
  120.       dup { .endmap exch } forall astore readonly
  121.     } if
  122.   } {
  123.     dup type /stringtype eq { readonly } if
  124.   } ifelse
  125. } bind def
  126.  
  127. /usecmap {        % <CMap_name> usecmap -
  128.   /CMap findresource
  129.   dup /.CodeMaps get dup length array copy /.CodeMaps exch def
  130.   /.FontIndices get /.FontIndices exch def
  131. } bind def
  132.  
  133. /usefont {        % <fontID> usefont -
  134.   /.FontIndex exch def
  135. } bind def
  136.  
  137. /beginusematrix {    % <fontID> beginusematrix -
  138.   FontMatrices wcheck not FontMatrices length 2 index le or {
  139.     FontMatrices length 1 index 1 add .max array
  140.     dup 0 FontMatrices putinterval
  141.     /FontMatrices exch def
  142.   } if
  143. } bind def
  144. /endusematrix {        % <matrix> endusematrix -
  145.   FontMatrices 3 1 roll put
  146. } bind def
  147.  
  148. % ------ Rearranged font operators ------ %
  149.  
  150. /beginrearrangedfont {    % <font_name> <font*> beginrearrangedfont -
  151.   10 dict begin
  152.   /.FontNames exch def
  153.   /.FontName exch def
  154.   begincmap
  155. } bind def
  156. /endrearrangedfont {    % - endrearrangedfont -
  157.   (REARRANGED FONTS NOT IMPLEMENTED YET.) = flush
  158.   FontName .FontNames 0 get findfont end definefont pop
  159. } bind def
  160.  
  161. % ------ Character name/code selector operators ------ %
  162.  
  163. /beginbfchar {        % <count> beginbfchar -
  164.   pop mark
  165. } bind def
  166. /endbfchar {        % <code> <to_code|charname> ... endbfchar
  167.   .endmapchar
  168. } bind def
  169.  
  170. /beginbfrange {        % <count> beginbfrange -
  171.   pop mark
  172. } bind def
  173. /endbfrange {        % <code_lo> <code_hi> <to_code|(charname*)> ...
  174.             %   endbfrange -
  175.   counttomark 3 idiv {
  176.     counttomark -3 roll        % process in correct order
  177.     .addbfrange
  178.   } repeat pop
  179. } bind def
  180.  
  181. /.addbfrange {        % <code_lo> <code_hi> <to_code|(charname*)>
  182.             %   .addbfrange
  183.   dup type /stringtype eq {
  184.     { dup length string copy dup dup length 1 sub 2 copy get 1 add put }
  185.     .addcharrange
  186.   } {
  187.     2 dict begin /codes 1 index def 0 get
  188.     { pop codes dup dup length 1 sub 1 exch getinterval /codes exch def
  189.       dup length 0 gt { 0 get } if
  190.     }
  191.     .addcharrange end
  192.   } ifelse
  193. } bind def
  194.  
  195. % ------ CID selector operators ------ %
  196.  
  197. /begincidchar {        % <count> begincidchar -
  198.   pop mark
  199. } bind def
  200. /endcidchar {        % <code> <cid> ... endcidchar -
  201.   .endmapchar
  202. } bind def
  203.  
  204. /begincidrange {    % <count> begincidrange -
  205.   pop mark
  206. } bind def
  207. /endcidrange {        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  208.   counttomark 3 idiv {
  209.     counttomark -3 roll        % process in correct order
  210.     { 1 add } .addcharrange
  211.   } repeat pop
  212. } bind def
  213.  
  214. /.endmapchar {        % -mark- <code> <value> ... .endmapchar -
  215.   counttomark 2 idiv {
  216.     counttomark -2 roll        % process in correct order
  217.     1 index exch { } .addcharrange
  218.   } repeat pop
  219. } bind def
  220.  
  221. /.addcharrange {    % <code_lo> <code_hi> <value_base> <next_proc>
  222.             %   .addcharrange -
  223.   0 .putmaprange
  224. } bind def
  225.  
  226. /.putmaprange     {    % <code_lo> <code_hi> <value_base> <next_proc> <0|1>
  227.             %   .putmaprange -
  228.   5 1 roll
  229.         % Most CMaps don't involve multiple fonts.
  230.         % For this reason, we create .FontIndices lazily.
  231.   .FontIndices 5 index get 0 eq .FontIndex 0 ne and {
  232.         % Create .FontIndices now.
  233.     .CodeMaps 5 index get .makecodespace
  234.       .FontIndices 6 index 3 -1 roll put
  235.   } if
  236.   .FontIndices 5 index get 0 ne {
  237.     3 index 3 index .FontIndex { } .FontIndices 9 index get .addmaprange
  238.       .FontIndices 7 index 3 -1 roll put pop
  239.   } if
  240.   .CodeMaps 5 index get .addmaprange
  241.     .CodeMaps 3 index 3 -1 roll put pop
  242.   pop
  243. } bind def
  244. /.makecodespace {    % <array|other> .makecodespace -
  245.   dup type /arraytype eq {
  246.     [ exch { .makecodespace } forall ]
  247.   } {
  248.     pop 0
  249.   } ifelse
  250. } bind def
  251.  
  252. /.addmaprange {        % <code_lo> <code_hi> <value_base> <next_proc> <map>
  253.             %   .addmaprange <value_next> <map>
  254.     % We may be updating a (partly) read-only map from another CMap.
  255.     % If so, implement copy-on-write.
  256.    dup wcheck not { dup length array copy } if
  257.    4 index length 1 eq
  258.     { 2 { 5 -1 roll 0 get } repeat 1 exch
  259.        {    % Stack: value proc map code
  260.      2 copy 5 index put pop
  261.      3 -1 roll 2 index exec 3 1 roll
  262.        } for
  263.     }
  264.     { 4 index 0 get 1 5 index 0 get
  265.       8 -2 roll
  266.       2 { 1 1 index length 1 sub getinterval 8 1 roll } repeat
  267.         % Stack: lo hi next proc map lo0 1 hi0
  268.        { 6 copy get .addmaprange
  269.         % Stack: lo hi oldnext proc map i next submap
  270.      exch 6 1 roll 5 -1 roll pop
  271.         % Stack: lo hi next proc map i submap
  272.      3 copy put pop pop
  273.        }
  274.       for 5 -2 roll pop pop
  275.     }
  276.    ifelse exch pop
  277. } bind def
  278.  
  279. % ------ notdef operators ------ %
  280.  
  281. /beginnotdefchar {    % <count> beginnotdefchar -
  282.   pop mark
  283. } bind def
  284. /endnotdefchar {    % <code> <cid> ... endnotdefchar -
  285.   counttomark 2 idiv {
  286.     counttomark -2 roll        % process in correct order
  287.     1 index exch .addnotdefrange
  288.   } repeat pop
  289. } bind def
  290.  
  291. /beginnotdefrange {    % <count> beginnotdefrange -
  292.   pop mark
  293. } bind def
  294. /endnotdefrange {    % <code_lo> <code_hi> <cid> ... endnotdefrange -
  295.   counttomark 3 idiv {
  296.     counttomark -3 roll        % process in correct order
  297.     .addnotdefrange
  298.   } repeat pop
  299. } bind def
  300.  
  301. /.addnotdefrange {    % <code_lo> <code_hi> <cid_base> .addnotdefrange -
  302.   { } 1 .putmaprange
  303. } bind def
  304.  
  305. % ---------------- Resource category definition ---------------- %
  306.  
  307. currentdict end
  308.  
  309. languagelevel exch 2 .setlanguagelevel
  310.  
  311. /CMap /Generic /Category findresource dup length dict .copydict
  312. /Category defineresource pop
  313.     % We might have loaded CID font support already.
  314. /CIDInit /ProcSet 2 copy { findresource } .internalstopped
  315.     % An interior `stopped' might have reset VM allocation to local.
  316. true .setglobal
  317.  { pop pop 3 -1 roll }
  318.  { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }
  319. ifelse exch defineresource pop
  320.  
  321. .setlanguagelevel
  322.