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