home *** CD-ROM | disk | FTP | other *** search
/ Freelog 41 / Freelog041.iso / PDF / gs704w32.exe / gs7.04 / lib / gs_cidcm.ps < prev    next >
Text File  |  2002-01-31  |  19KB  |  499 lines
  1. %    Copyright (C) 2000 artofcode LLC.  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_cidcm.ps,v 1.5 2001/07/01 08:55:34 igorm Exp $
  19. % Extending Font resource category with CIDFont-CMap fonts.
  20.  
  21. languagelevel 2 .setlanguagelevel currentglobal true setglobal
  22.  
  23.  
  24. % In the comments below, 'CSI' is an abbreviation/acronym for CIDSystemInfo.
  25. % We pre-scan resource files to retrieve the CSI from them.
  26. % First we define a hidden procset .prs_dict containing
  27. % necessary variables and procedures.
  28. % Then we redefine the old /Font category using this procset.
  29.  
  30. % We maintain internal caches for the CSI values retrieved from
  31. % resource files. This supposes that document doesn't uninstall
  32. % resource files. To disable caching, set enable_cache to false.
  33.  
  34. % We suppose that names starting with '.prs' do not appear in resource files.
  35. % If this causes any problem, this prefix should be systematically changed
  36. % in this file.  ('prs' is an abbreviation for 'prescan'.)
  37.  
  38. 25 dict begin
  39.  
  40. % Define local variables :
  41.  
  42. /.prs_dict currentdict def       % self-reference (constant)
  43. /.prs_empty 0 dict readonly def  
  44. /path_buffer 255 string def
  45. /name_buffer 255 string def
  46. /minus (-) 0 get def             % character code constant for '-'
  47. /period (.) 0 get def            % character code constant for '.'
  48. /CMap 10 dict def                % CSI cache for CMaps
  49. /CIDFont 10 dict def             % CSI cache for CIDFonts
  50. /enable_cache true def           % set false to disable cache
  51.  
  52. % The folloving variables are just placeholders for ones to be set
  53. % dynamically :
  54. /.prsFile 0 def                   % file to prescan
  55. /.prsResult 0 def                 % result of prescan
  56. /.prsDictCount 0 def              % save the dictionary stack depth
  57.  
  58. % Define a dummy CIDInit procset to use while pre-scanning :
  59.  
  60. /DummyCIDInit 15 dict 
  61. begin
  62.  
  63.   /begincmap {} def
  64.   /usecmap {pop} bind def
  65.  
  66.   {stop} bind
  67.   [ /begincodespacerange /endcodespacerange /beginnotdefchar /endnotdefchar
  68.     /beginnotdefrange /endnotdefrange /begincidchar /endcidchar /begincidrange 
  69.     /endcidrange /endcmap /usefont /StartData
  70.   ] {
  71.     1 index def
  72.   } bind forall
  73.   pop
  74.  
  75. currentdict end def
  76.  
  77. % Define a local 'findresource' for pre-scanning :
  78. % (it returns the dummy CIDInit instead of the regular CIDInit ProcSet)
  79.  
  80. /findresource { % <InstName> <CatName> findresource <inst>
  81.   2 copy /ProcSet eq exch             % /InstName /CatName bool /InstName
  82.   /CIDInit eq and {
  83.     pop pop //DummyCIDInit
  84.   } {
  85.     //findresource exec
  86.   } ifelse
  87. } bind def
  88.  
  89. % Define procedures for pre-scanning :
  90.  
  91. /StopIfCSIDefined {   % - StopIfCSIDefined -
  92.   
  93.   % Check if the dictionary stack contains a dictionary containing /CIDSystemInfo. 
  94.   % The search is limited to the top .prsDictCount dictionaries in the stack.
  95.   % If so, retrieve the CSI, and execute stop to terminate the pre-scanning of the file.
  96.   % Otherwise, do nothing, so the pre-scanning continues.
  97.  
  98.   countdictstack //.prs_dict /.prsDictCount get sub dup {
  99.     currentdict /CIDSystemInfo .knownget {
  100.       //.prs_dict exch /.prsResult exch put
  101.       stop
  102.     } if
  103.     currentdict exch end
  104.   } repeat {
  105.     begin
  106.   } repeat
  107. } bind def
  108.  
  109. /PrescanFile {     % - PrescanFile -
  110.   { //.prs_dict /.prsFile get token {      
  111.       dup type                          % token type
  112.       dup /nametype eq exch /operatortype eq or {
  113.         dup xcheck {
  114.           exec
  115.           //StopIfCSIDefined exec
  116.         } if
  117.       } if
  118.     } {
  119.       stop
  120.     } ifelse
  121.   } loop
  122. } bind odef
  123.  
  124. /GetCIDSystemInfoFromFile { % <file> GetCIDSystemInfoFromFile <CSI>
  125.   
  126.   % This procedure reads resource files with 'token',
  127.   % executing the tokens untill /CIDSystemInfo appears to be defined.
  128.   % Normally the resource file creates a new dictionary on
  129.   % dictionary stack and defines /CIDSystemInfo in it.
  130.   %
  131.   % Returns an empty dictionary if no CIDSystemInfo is found.
  132.  
  133.   //.prs_dict begin
  134.   /.prsFile exch def
  135.   /.prsResult //.prs_empty def
  136.   /.prsDictCount countdictstack def
  137.   { //PrescanFile } stopped pop
  138.   //.prs_dict /.prsResult get
  139.   end
  140. } bind def
  141.  
  142. /GetCIDSystemInfo {     % <InstName> <CatName> GetCIDSystemInfo <CSI>
  143.   
  144.   % Retrieve CSI, using caches.
  145.   
  146.   2 copy resourcestatus {
  147.     pop 2 lt {
  148.       findresource /CIDSystemInfo .knownget not {
  149.         //.prs_empty
  150.       } if
  151.     } {                                                      
  152.       dup //.prs_dict exch get                % /InstName /CatName CSIs
  153.       dup 3 index known
  154.       //enable_cache and {                            
  155.         exch pop exch get                     % CSI
  156.       } {                                                  
  157.         3 1 roll                              % CSIs /InstName /CatName
  158.         /Category findresource begin          % CSIs /InstName
  159.         dup //path_buffer ResourceFileName    % CSIs /InstName (path)
  160.         end                                   
  161.         currentglobal exch true setglobal     % CSIs /InstName g
  162.         mark exch                             % CSIs /InstName g [ (path)
  163.         { (r) file                            % CSIs /InstName g [ file
  164.           //GetCIDSystemInfoFromFile exec     % CSIs /InstName g [ CSI
  165.         } stopped {
  166.           cleartomark //.prs_empty             
  167.         } {
  168.           exch pop
  169.         } ifelse                              % CSIs /InstName g CSI
  170.         exch setglobal                        % CSIs /InstName CSI
  171.         dup 4 1 roll                          % CSI CSIs /InstName CSI
  172.         put                                   % CSI
  173.       } ifelse
  174.     } ifelse
  175.   } {
  176.     pop pop //.prs_empty
  177.   } ifelse
  178. } bind def
  179.  
  180. /IsCompatibleCSI {  % <CSI-M> <CSI-F> IsCompatibleCSI <bool>
  181.   
  182.   % The CSI in a CIDFont may be an array, a dict, or null.
  183.   % If it is an array, it must be of 1 element, which is a dict.
  184.   % In this case the dict is used for testing the compatibility.
  185.   % Two dicts are compatible iff they contain same /Ordering and /Registry.
  186.  
  187.   exch                                  % CSI-F CSI-M
  188.   { dup type /arraytype eq {
  189.       dup length 1 ne {
  190.         pop pop false exit
  191.       } if
  192.       0 get
  193.     } if                                % CSI-F CSI-M
  194.     dup type /dicttype ne {
  195.       pop pop false exit
  196.     } if                                % CSI-F <<CSI-M>>
  197.     exch                                % <<CSI-M>> CSI-F
  198.     dup type /dicttype ne {
  199.       pop pop false exit
  200.     } if                                % <<CSI-M>> <<CSI-F>>
  201.     true                                % <<CSI-M>> <<CSI-F>> bEQ
  202.     [/Registry /Ordering] {                    
  203.       2 index 1 index .knownget not {
  204.         1234567
  205.       } if                              % <<CSI-M>> <<CSI-F>> bEQ /key vF
  206.       exch                              % <<CSI-M>> <<CSI-F>> bEQ vF /key
  207.       4 index exch .knownget not {
  208.         7654321
  209.       } if                              % <<CSI-M>> <<CSI-F>> bEQ vF vM
  210.       eq and                            % <<CSI-M>> <<CSI-F>> bEQ
  211.     } forall
  212.     exch pop exch pop                   % bEQ
  213.     exit
  214.   } loop
  215. } bind def
  216.  
  217. /IsComposedOK {     % <CIDFontName> <CMapName> IsComposedOK <bool>
  218.   
  219.   % Check if the given CIDFont and CMap have compatible CSIs.
  220.  
  221.   exch                                  % /CMapName /CIDFontName
  222.   /CIDFont //GetCIDSystemInfo exec      % /CMapName CSI-F
  223.   dup type /dicttype eq {
  224.     dup length 0 ne {                          
  225.       exch                              % CSI-F /CMapName
  226.       /CMap //GetCIDSystemInfo exec     % CSI-F CSI-M
  227.       //IsCompatibleCSI exec            % bool
  228.     } {
  229.       pop pop false
  230.     } ifelse
  231.   } {
  232.     pop pop false
  233.   } ifelse
  234. } bind def
  235.  
  236. /IsComposedFont {   % <FontName> IsComposedFont <CIDFontName> <CMapName> true
  237.                     % <FontName> IsComposedFont false
  238.   
  239.   % Check if the given font name may be decomposed into CIDFont.CMap, CIDFont-CMap
  240.   % or into CIDFont--CMap, such that CIDFont and CMap have compatible CSIs.
  241.                                         % FontName
  242.   dup type /stringtype ne {
  243.     //name_buffer cvs
  244.   } if                                  % (FontName)
  245.   { dup length 2 sub -1 1 {
  246.                                         % (FontName) i
  247.       2 copy get dup //minus eq exch //period eq or {                
  248.         2 copy 2 copy                   % (FontName) i (FontName) i (FontName) i
  249.         2 copy get //minus eq {
  250.           2 copy 1 sub get //minus eq {
  251.             1 sub
  252.           } if
  253.         } if                            % (FontName) i (FontName) i (FontName) i0
  254.         0 exch getinterval cvn          % (FontName) i (FontName) i /CIDFontName
  255.         3 1 roll                        % (FontName) i /CIDFontName (FontName) i
  256.         1 add dup                       % (FontName) i /CIDFontName (FontName) i1 i1
  257.         5 index length                  % (FontName) i /CIDFontName (FontName) i1 i1 l
  258.         exch sub getinterval cvn        % (FontName) i /CIDFontName /CMapName
  259.         2 copy //IsComposedOK exec {    % (FontName) i /CIDFontName /CMapName 
  260.           4 2 roll pop pop              % /CIDFontName /CMapName
  261.           stop
  262.         } if
  263.         pop pop pop
  264.       } {
  265.         pop
  266.       } ifelse                          % (FontName)
  267.     } for
  268.     pop
  269.   } stopped
  270. } bind def
  271.  
  272. /ComposeName { % <CIDFont> <CMap> <scr> ComposeName <CIDFont-CMap>
  273.   dup dup 5 2 roll                        % (scr) (scr) /CIDFont /CMap (scr)
  274.   3 2 roll exch cvs length dup            % (scr) (scr) /CMap l0 l0
  275.   4 -1 roll exch //minus put              % (scr) /CMap l0
  276.   1 add dup                               % (scr) /CMap l1 l1
  277.   3 index dup length                      % (scr) /CMap l1 l1 (scr) L
  278.   2 index sub                             % (scr) /CMap l1 l1 (scr) LT
  279.   3 2 roll                                % (scr) /CMap l1 (scr) LT l1
  280.   exch getinterval                        % (scr) /CMap l1 (scrT)
  281.   3 2 roll exch cvs length                % (scr) l1 l2
  282.   add 0 exch getinterval                  % (CIDFont-CMap)
  283. } bind def
  284.  
  285.  
  286. % Define a few procedure templates to be modified dynamically :
  287.  
  288. currentpacking false setpacking
  289.  
  290. /BindAux {   % <proc> BindAux <proc>
  291.   0 exec
  292. } bind def
  293.  
  294. /EnumerateFontNames { %  - EnumerateFontNames ...
  295.   
  296.   % This is a pattern for enumeration procedure to be built dynamically,
  297.   % using Bind with a temporary dictionary.
  298.   % The following names will be replaced with specific objects
  299.   % during Bind : en_local_dict, scr, proc, Fonts, Category .
  300.  
  301.   end % Category
  302.   { 
  303.     0 1 2 {
  304.       en_local_dict exch /status exch put
  305.       Fonts {                                            
  306.         en_local_dict /status get eq {            
  307.           scr cvs                           % ... (Font)
  308.           proc exec                         %
  309.         } {
  310.           pop
  311.         } ifelse                            % ...
  312.       } forall
  313.     } for                                   % ...
  314.   } stopped
  315.   Category begin
  316.   { stop } if
  317. } bind def
  318.  
  319. setpacking
  320.  
  321. /Bind {    % <proc> Bind <proc>
  322.   
  323.   % Make a copy of the given procedure, binding in the values of all names
  324.   % defined in currentdict.
  325.   % Caution : this code cannot handle procedures that were already
  326.   % bound recursively.
  327.  
  328.   dup length array copy
  329.   dup length 1 sub -1 0 {                      
  330.     2 copy get                            % {precopy} i {elem}
  331.     dup dup type /arraytype eq exch xcheck and {
  332.                                           % {precopy} i {elem}
  333.       //BindAux exec                      % {precopy} i {elem_copy}
  334.       2 index 3 1 roll put                % {precopy}
  335.     } {
  336.       dup dup type /nametype eq exch xcheck and {
  337.                                           % {precopy} i {elem}
  338.         currentdict exch .knownget {            
  339.           2 index 3 1 roll put            % {precopy}
  340.         } {                                            
  341.           pop
  342.         } ifelse
  343.       } {
  344.         pop pop
  345.       } ifelse
  346.     } ifelse                              % {precopy}
  347.   } for                                   % {copy}
  348.   cvx
  349. } bind def
  350.  
  351. //BindAux 0 //Bind put   % bind the recursive call in 'Bind'.
  352.  
  353.  
  354.  
  355. % Redefine the /Font category with CIDFont-CMap construction :
  356.  
  357. % The following code supposes that the following names are not
  358. % defined in the old /Font category dictionary :
  359. % /IsComposedFont, /Bind, /IsComposedOK, /EnumerateFontNames .
  360.  
  361.  
  362. /Font /Category findresource dup length dict copy begin
  363.  
  364. /FindResource {  % <InstName> FindResource <inst>
  365.   dup //ResourceStatus exec {
  366.     pop pop //FindResource exec
  367.   } {                                                
  368.     dup //IsComposedFont exec {          % /FontName /CIDFontName /CMapName 
  369.       exch [ exch ] composefont          % inst
  370.     } {
  371.       //FindResource exec
  372.     } ifelse
  373.   } ifelse
  374. } bind def
  375.  
  376. /ResourceStatus {  % <InstName> ResourceStatus <nStatus> <nSize> true
  377.                    % <InstName> ResourceStatus false
  378.   dup //ResourceStatus exec {                    
  379.     3 2 roll pop true                     % nStatus nSize true
  380.   } {                                                  
  381.     //IsComposedFont exec {               % /CIDFontName /CMapName 
  382.       /CMap resourcestatus {              % /CIDFontName nStatusM nSizeM 
  383.         exch pop exch                     % nSizeM /CIDFontName 
  384.         /CIDFont resourcestatus {         % nSizeM nStatusF nSizeF 
  385.           exch pop                        % nSizeF nSizeM
  386.           dup 0 ge {
  387.             exch dup 0 ge {
  388.               add
  389.             } {
  390.               exch pop
  391.             } ifelse
  392.           } {
  393.             pop
  394.           } ifelse                        % nSize
  395.           2 exch true                     % nStatus nSize true
  396.         } {                        
  397.           pop pop pop false  % work around buggy resource file
  398.         } ifelse
  399.       } {                            
  400.         pop pop pop false    % work around buggy resource file
  401.       } ifelse
  402.     } {
  403.       false
  404.     } ifelse
  405.   } ifelse
  406. } bind def
  407.  
  408. /ResourceForAll { % <template> <proc> <scratch> ResourceForAll - 
  409.  
  410.   % We suppose that the resourceforall procedure does not 
  411.   % define or install new fonts, CMaps, and/or CIDFonts.
  412.  
  413.   % First we create 3 temporary dictionaries to store temporary data
  414.   % about fonts, CMaps and CIDFonts.
  415.   % These dictionaries must be created dynamically, to allow for a possible 
  416.   % recursive call to resourceforall from the resourceforall procedure.
  417.  
  418.   currentglobal false setglobal
  419.   20 dict 20 dict 20 dict
  420.   4 -1 roll setglobal                     % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  421.  
  422.   % Store resource names into local dictionaries :
  423.  
  424.   5 index [ 2 index {exch cvn dup put} aload pop ] cvx 5 index //ResourceForAll exec
  425.   (*)     [ 3 index {exch cvn dup put} aload pop ] cvx 5 index /CMap resourceforall
  426.   (*)     [ 4 index {exch cvn dup put} aload pop ] cvx 5 index /CIDFont resourceforall
  427.  
  428.   %% Make the list of fonts in the form (/Name status) :
  429.  
  430.                                           % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  431.   dup {                                              
  432.     //ResourceStatus exec {                        
  433.       pop 2 index                         % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>> /Name nStatus <<Font>>
  434.       3 1 roll put                        % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  435.     } {
  436.       pop
  437.     } ifelse
  438.   } forall                                % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  439.  
  440.   %% Add CIDFont-CMap to it (filtering duplicates) :
  441.  
  442.   3 2 roll  {                                        
  443.     3 index {                                        
  444.       3 1 roll                            % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /CIDFont /CMap
  445.       6 index //ComposeName exec          % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap (Font)
  446.       dup 8 index .stringmatch {              
  447.         cvn                               % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /Font
  448.         dup 4 index exch known {
  449.           pop pop
  450.         } {                                            
  451.           2 index                         % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /Font /CIDFont
  452.           4 2 roll                        % (templ) proc (scr) <<CMap>> <<Font>> /Font /CIDFont /CIDFont /CMap
  453.           //IsComposedOK exec {                
  454.             exch 2 index exch 2 put       % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont
  455.           } {
  456.             exch pop
  457.           } ifelse
  458.         } ifelse
  459.       } {
  460.         pop pop
  461.       } ifelse
  462.       dup                                 % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CIDFont
  463.     } forall
  464.     pop pop                               % (templ) proc (scr) <<CMap>> <<Font>>
  465.   } forall                                % (templ) proc (scr) <<CMap>> <<Font>>
  466.   exch pop                                % (templ) proc (scr) <<Font>>
  467.  
  468.   % Build the enumeration procedure :
  469.  
  470.   % Since the resourceforall procedure may leave values on the operand stack,
  471.   % we cannot simply store the enumerator's local data on the stack.
  472.   % We also cannot use a static dictionary to store local variables,
  473.   % because of possible recursion in the resourceforall procedure.
  474.   % To work around this, we create a copy of the enumeration procedure and
  475.   % bind it dynamically with a temporary dictionary, which contains
  476.   % local variables for the currently executing instance of resourceforall.
  477.  
  478.   currentdict
  479.   6 dict begin % the temporary dictionary
  480.     /Category exch def
  481.     /Fonts exch def
  482.     /scr exch def
  483.     /proc exch def
  484.     /en_local_dict currentdict def
  485.     //EnumerateFontNames //Bind exec      % (templ) Enumerator
  486.     /status 0 def % variable for the current status to enumerate - do not Bind with it !
  487.   end
  488.   exch pop                                % Enumerator
  489.  
  490.   % Do the enumeration :
  491.  
  492.   exec
  493. } bind def
  494.  
  495.  
  496. currentdict end /Font exch /Category defineresource pop
  497. end
  498. setglobal .setlanguagelevel
  499.