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