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