home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 10 / AU_CD10.iso / Updates / GhostScript / !GhostScr / 6_01 / lib / gs_cidfn.ps < prev    next >
Text File  |  2000-03-29  |  15KB  |  465 lines
  1. %    Copyright (C) 1995, 2000 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_cidfn.ps,v 1.3 2000/03/10 04:53:25 lpd Exp $
  19. % ProcSet for implementing CIDFont and CIDMap resources.
  20. % When this is run, systemdict is still writable.
  21.  
  22. % ---------------- Defining CIDFont resources ---------------- %
  23.  
  24. % Define a CIDFont resource.  This is the defineresource implementation for
  25. % the CIDFont resource category.
  26.  
  27. /.cidfonttypes where { pop } { /.cidfonttypes 6 dict def } ifelse
  28. .cidfonttypes begin
  29.  
  30. % The key in .cidfonttypes is the CIDFontType value;
  31. % the value is a procedure that takes a font name and the CIDFont dictionary
  32. % and replaces the latter with a real font.
  33.  
  34. 0 {    % CIDFontType 0 = FontType 9
  35.   currentglobal 3 1 roll dup gcheck setglobal
  36.   dup /FontType 9 put
  37.   dup /FontMatrix known not {
  38.     dup /FontMatrix [0.001 0 0 0.001 0 0] put
  39.     dup /FDArray get {
  40.       /FontMatrix get [1000 0 0 1000 0 0] 1 index concatmatrix pop
  41.     } forall
  42.   } if
  43.   dup /FDArray get mark exch {
  44.         % Add pro forma entries
  45.     currentglobal exch dup gcheck setglobal
  46.     dup /FontType 1 put
  47.     dup /CharStrings mark /.notdef () .dicttomark put
  48.     dup /Encoding [] put
  49.         % Create a dummy Subrs array now, if there isn't one here
  50.         % already (which can only happen if we're giving another
  51.         % name to an existing font).
  52.     dup /Private get dup /Subrs known not {
  53.       dup /SubrCount .knownget {
  54.     array 1 index /Subrs 3 -1 roll put
  55.       } if readonly
  56.     } if pop
  57.     exch setglobal
  58.     dup /FontName .knownget not { () } if exch .buildfont1 exch pop
  59.   } forall ] 1 index /FDepVector 3 -1 roll put
  60.   3 -1 roll setglobal
  61.   1 index exch .buildfont9 exch pop
  62. } bind def
  63.  
  64. 1 {    % CIDFontType 1 = FontType 10
  65.   dup /FontType 10 put
  66.   1 index exch .buildfont10 exch pop
  67. } bind def
  68.  
  69. 2 {    % CIDFontType 2 = FontType 11
  70.   dup /FontType 11 put
  71.   1 index exch .buildfont11 exch pop
  72. } bind def
  73.  
  74. end        % .cidfonttypes
  75.  
  76. % ---------------- Reading CIDFontType 0 files ---------------- %
  77.  
  78. 30 dict begin
  79.  
  80. % We add the following entries to the CIDFont dictionary, in addition to
  81. % the ones documented by Adobe:
  82. %    ReadString - procedure for reading a string from the binary data
  83. %    SubrCache - dictionary for caching Subr arrays
  84. % For CIDFonts where we read the data from disk incrementally:
  85. %    DataOffset - starting position of data in file
  86. %    (if data are in hex) OffsetMap - map from logical data positions to
  87. %      physical positions in file
  88.  
  89. /StartData        % <(Binary)|(Hex)> <datalength> StartData -
  90.             %   (currentdict is CID font dict)
  91. {        % If we're loading a resource file, we can just save a
  92.         % pointer to the binary data and load it incrementally.
  93.         % Check for this by opening the resource file,
  94.         % positioning it to currentfile's position plus the
  95.         % data length, and checking for %%EndData.
  96.    mark
  97.     { currentfile fileposition
  98.       CIDFontName 100 string ResourceFileName (r) file
  99.        mark
  100.     {        % Stack: (Binary)|(Hex) length -mark- pos resfile
  101.             %   -mark-
  102.       5 index (Hex) eq
  103.        { 1 index 3 index setfileposition
  104.          1 index 5 index .skiphex
  105.             %**************** SKIP > AND WHITESPACE SOMEHOW
  106.        }
  107.        { 1 index 3 index 6 index add setfileposition
  108.        }
  109.       ifelse
  110.       1 index 9 string readstring pop (%%EndData) ne { stop } if
  111.     }
  112.        .internalstopped { cleartomark closefile stop } if
  113.        pop        % pop the mark
  114.     }
  115.    .internalstopped
  116.    {        % File is not positionable, load the data now.
  117.      cleartomark exch (Hex) eq
  118.       { { currentfile exch readhexstring pop } }
  119.       { { currentfile exch readstring pop } }
  120.      ifelse /ReadString exch def
  121.      dup 65535 le {
  122.         % readstring with a 0-length string causes a rangecheck,
  123.         % but a data length of 0 is allowed.
  124.        string dup () ne { ReadString } if
  125.      } {
  126.        mark exch
  127.      { dup 0 eq { pop exit } if
  128.        dup 65535 min dup string ReadString
  129.        3 1 roll sub
  130.      }
  131.     loop ]
  132.      } ifelse
  133.      /GlyphData exch def
  134.         % If we were reading hex data, skip past the >.
  135.      /ReadString load 2 get { readhexstring } 0 get eq {
  136.        currentfile 0 (>) /SubFileDecode filter dup flushfile closefile
  137.      } if
  138.      /.vmreadstring cvx
  139.    }
  140.    {        % File is positionable, just save a pointer.
  141.         % Stack: (Binary)|(Hex) length -mark- pos file
  142.      4 1 roll
  143.      /DataOffset exch def
  144.      pop /GlyphData exch def
  145.      exch (Hex) eq
  146.       {        % Hex data, build the offset map.
  147.     .buildoffsetmap
  148.     /.hexreadstring
  149.       }
  150.       {        % Binary data, just skip over it.
  151.     currentfile DataOffset GlyphData add setfileposition
  152.     /.binaryreadstring
  153.       }
  154.      ifelse cvx
  155.      2 packedarray cvx
  156.    }
  157.   ifelse /ReadString exch def
  158.   /SubrCache 10 dict def
  159.   CIDFontName currentdict /CIDFont defineresource pop
  160.   end            % CID font dict
  161.   end            % resource category dict
  162. } bind def
  163.  
  164. % Skip a given distance in an ASCIIHex encoded file.  We use this at
  165. % rendering time as well.
  166. /.skiphex        % <file> <count> .skiphex -
  167. { exch /ASCIIHexDecode filter dup 3 -1 roll () /SubFileDecode filter
  168.   dup flushfile closefile closefile
  169. } bind def
  170.  
  171. % Build the map from logical offsets to physical offsets in ASCIIHex
  172. % encoded data.
  173. /.buildoffsetmap
  174. { /OffsetMap GlyphData 256 idiv 8000 min array def
  175.   2 dict begin
  176.      /block GlyphData OffsetMap length idiv def
  177.      0 1 OffsetMap length 1 sub
  178.       { OffsetMap exch currentfile fileposition put
  179.     currentfile block .skiphex
  180.       }
  181.      for
  182.      GlyphData block mod dup 0 eq
  183.       { pop }
  184.       { currentfile exch .skiphex }
  185.      ifelse
  186.   end            % scratch dict
  187. } bind def
  188.  
  189. % Some Adobe fonts include the line
  190. %   /Setup /cid_Setup load def
  191. % This is apparently included only to prevent proper, conforming PostScript
  192. % interpreters (as opposed to ATM or a special Adobe font loader) from
  193. % loading the font, since Setup is not referenced anywhere else in the file.
  194. %/cid_Setup { } def
  195.  
  196. currentdict end
  197.  
  198. % ---------------- Rendering ---------------- %
  199.  
  200. % ------ Generic ------ %
  201.  
  202. % Read a string at a given offset in a "file" (binary file, ASCII hex file,
  203. % or GlyphData in RAM).
  204. /.binaryreadstring    % <pos> <string> <file> .binaryreadstring <string>
  205.  { dup 4 -1 roll DataOffset add setfileposition exch readstring pop
  206.  } bind def
  207. /.hexreadstring        % <pos> <string> <file> .hexreadstring <string>
  208. {        % Use the OffsetMap to get to the block of hex data,
  209.         % then skip to the correct position by reading.
  210.   GlyphData OffsetMap length idiv
  211.         % Stack: pos string file blocklen
  212.   3 index 1 index idiv OffsetMap exch get
  213.   2 index exch setfileposition
  214.         % Skip the next (pos % blocklen) hex bytes.
  215.   4 -1 roll exch mod 1 index exch .skiphex
  216.         % Stack: string file
  217.   exch readhexstring pop  
  218. } bind def
  219. /.vmreadstring        % <pos> <string> .vmreadstring <vmstring>
  220. { GlyphData .stringsreadstring
  221. } bind def
  222. /.stringsreadstring    % <pos> <string> <strings> .stringsreadstring
  223.             %   <vmstring>
  224. { dup type /stringtype eq
  225.    { 3 1 roll length getinterval
  226.    }
  227.    {  {        % Stack: pos string glyphdata
  228.     dup 0 get length dup 4 index gt { exit } if
  229.     4 -1 roll exch sub 3 1 roll
  230.     dup length 1 sub 1 exch getinterval
  231.       }
  232.      loop
  233.         % Stack: pos string glyphdata glyphdata[0]length
  234.         % We know no request can span more than 2 strings.
  235.      3 index 3 index length add 1 index le
  236.       {        % Request fits in a single string: just return a substring.
  237.     pop 0 get 3 1 roll length getinterval
  238.       }
  239.       {        % Request spans 2 strings.  Copy the first part.
  240.     1 index 0 get 4 index 3 -1 roll 1 index sub getinterval
  241.     2 index copy
  242.         % Copy the second part.
  243.         % Stack: pos str glyphdata str1
  244.     length exch 1 get 0 3 index length
  245.     3 index sub getinterval 2 index 3 1 roll putinterval
  246.     exch pop
  247.       }
  248.      ifelse
  249.    }
  250.   ifelse
  251. } bind def
  252.  
  253. % Interpret a byte string as a (big-endian) integer.
  254. /.cvbsi            % <bytes> .cvbsi <int>
  255. { 0 exch { exch 8 bitshift add } forall
  256. } bind def
  257.  
  258. % Read an integer from binary data.
  259. /.readint        % <pos> <nbytes> .readint <int>
  260. { string ReadString .cvbsi
  261. } bind def
  262.  
  263. % Read the glyph data for a given CID.  The CIDFont is currentdict.
  264. % Note that the data must be read into the same VM as the CharStrings
  265. % dictionary of the selected subfont.
  266. /.readglyphdata {    % <cid> .readglyphdata <subfont> <string|null>
  267.   currentdict /GlyphDirectory .knownget {
  268.     dup type /arraytype eq {
  269.       1 index get
  270.     } {
  271.       1 index .knownget not { null } if
  272.     } ifelse
  273.             % Stack: cid string|null
  274.     dup null ne { exch pop .readgdirdata } { pop .readbytedata } ifelse
  275.   } {
  276.             % Stack: cid
  277.     .readbytedata
  278.   } ifelse
  279. } bind def
  280. /.readgdirdata {    % <string|null> .readgdirdata <subfont> <string|null>
  281.   dup null eq {
  282.     FDepVector 0 get exch
  283.   } {
  284.     FDBytes 0 eq {
  285.       FDepVector 0 get exch
  286.     } {
  287.             % Note: FDBytes > 1 is not supported.
  288.       dup 0 get FDepVector exch get
  289.       exch dup length 1 sub 1 exch getinterval
  290.     }    ifelse
  291.   } ifelse
  292. } bind def
  293. /.readbytedata {    % <cid> .readbytedata <subfont> <string|null>
  294.   dup dup 0 ge exch CIDCount lt and {
  295.     FDBytes GDBytes add mul CIDMapOffset add
  296.     dup FDBytes .readint exch
  297.     FDBytes add dup GDBytes .readint
  298.     exch GDBytes add FDBytes add GDBytes .readint
  299.             % Stack: fd pos nextpos
  300.     1 index sub dup 0 eq {
  301.       pop pop pop FDepVector 0 get null
  302.     } {
  303.             % Stack: fd pos len
  304.       FDepVector 4 -1 roll get
  305.       dup /CharStrings get gcheck .currentglobal exch .setglobal
  306.             % Stack: pos len subfont global
  307.       4 2 roll string ReadString exch .setglobal
  308.     } ifelse
  309.   } {
  310.     pop FDepVector 0 get null
  311.   } ifelse
  312. } bind def
  313.  
  314. % ------ CIDFontType 0 ------ %
  315.  
  316. % Read some Subrs for the current Type 1 subfont.
  317. % The subfont's Private dict is currentdict; the CIDFont itself is the
  318. % next dictionary on the stack.
  319. /.readsubrs {        % <Subrs> <start> .readsubrs <Subrs>
  320.   1 SubrCount 1 sub {
  321.     dup SDBytes mul SubrMapOffset add
  322.     dup SDBytes .readint exch SDBytes add SDBytes .readint
  323.     1 index sub string ReadString 2 index 3 1 roll put
  324.   } for
  325. } bind def
  326.  
  327. % Ensure that all the Subrs for the current Type 1 subfont are loaded.
  328. % The subfont's Private dict is currentdict; the CIDFont itself is the
  329. % next dictionary on the stack.
  330. /.loadsubrs {
  331.   currentdict /SubrMapOffset .knownget {
  332.     Subrs length 0 eq { true } { Subrs 0 get null ne } ifelse {
  333.       pop        % We've already loaded the Subrs.
  334.     } {
  335.       currentglobal exch currentdict gcheck setglobal
  336.       SubrCache 1 index .knownget {
  337.             % We've already loaded some Subrs at this offset.
  338.             % Make sure we've got as many as we need.
  339.     dup length SubrCount lt {
  340.             % We need to load more.
  341.       SubrCount array exch 1 index copy length .readsubrs
  342.       SubrCache 3 -1 roll 2 index put
  343.     } if
  344.       } {
  345.             % We haven't loaded any Subrs at this offset yet.
  346.     SubrCount array 0 .readsubrs
  347.     SubrCache 3 -1 roll 2 index put
  348.       } ifelse
  349.       Subrs copy pop setglobal
  350.     } ifelse
  351.   } if
  352. } bind def
  353.  
  354. % BuildGlyph procedure for CIDFontType 0.
  355. % ****** WHY NOT USE .type1execchar FOR THIS? ******
  356. % The name %Type9BuildGlyph is known to the interpreter.
  357. /.cid0buildstring 10 string def
  358. (%Type9BuildGlyph) cvn {    % <cidfont> <cid> %Type9BuildGlyph -
  359.   .currentglobal 3 1 roll 1 index gcheck .setglobal
  360.   1 index begin
  361.   dup .readglyphdata dup null eq {
  362.         % Substitute CID 0. **** WRONG ****
  363.     pop pop 0 .readglyphdata
  364.   } if
  365.             % Stack: cidfont cid subfont charstring
  366. dup null eq { pop pop pop pop } {    %**** WRONG ****
  367.   4 -1 roll pop
  368.   exch dup /Private get begin .loadsubrs end
  369.   3 -1 roll //.cid0buildstring cvs cvn 3 1 roll
  370.   dup /CharStrings get 3 index 4 -1 roll put
  371.   setfont
  372.   dup .glyphwidth setcharwidth
  373.   0 0 moveto glyphshow
  374. } ifelse    %**** WRONG ****
  375.   end
  376.   .setglobal
  377. } bind def
  378.  
  379. % ------ CIDFontType 2 ------ %
  380.  
  381. % BuildGlyph procedure for CIDFontType 2.
  382. % ****** ADD THE OUTLINE STRING AS AN ARGUMENT TO .type42execchar. ******
  383. % The name %Type11BuildGlyph is known to the interpreter.
  384. (%Type11BuildGlyph) cvn {    % <cidfont> <cid> %Type11BuildGlyph -
  385.   .currentglobal 3 1 roll 1 index gcheck .setglobal
  386.   1 index begin
  387.         % We must be prepared for out-of-range CIDs.
  388.   dup GDBytes mul GDBytes string CIDMap
  389.   mark 4 1 roll { .stringsreadstring } .internalstopped {
  390.         %**** 0 IS WRONG
  391.     cleartomark 0 GDBytes string CIDMap .stringsreadstring
  392.   } {
  393.     exch pop
  394.   } ifelse .cvbsi
  395.             % Stack: cidfont cid glyphindex
  396.   1 index exch .type42execchar
  397.   end
  398.   .setglobal
  399. } bind def
  400.  
  401. % ---------------- Define resources ---------------- %
  402.  
  403. languagelevel exch 2 .setlanguagelevel
  404.  
  405. % Define the CIDInit ProcSet resource.
  406. % The ProcSet dictionary is still on the stack.
  407.  
  408. /CMap /Generic /Category findresource dup length dict .copydict
  409. /Category defineresource pop
  410.     % We might have loaded CMap support already.
  411. /CIDInit /ProcSet 2 copy resourcestatus {
  412.   pop pop findresource dup length 4 index length add dict .copydict
  413.   4 -1 roll exch .copydict
  414. } {
  415.   3 -1 roll
  416. } ifelse exch defineresource pop
  417.  
  418. % Define the CIDFont resource category.
  419. % We break out .buildcidfont because it appears that at least for
  420. % Type 32 (CIDFontType 4) fonts, the font can be registered in the Font
  421. % category with only a CIDFontType and no FontType.
  422. /.buildcidfont {        % <name> <fontdict> .buildcidfont
  423.                 %   <name> <cidfont>
  424.   dup /CIDFontType get //.cidfonttypes exch get exec
  425. } odef
  426.  
  427. /CIDFont /Generic /Category findresource dup length dict .copydict
  428. dup /InstanceType /dicttype put
  429. dup /DefineResource {
  430.   .buildcidfont
  431.   /Generic /Category findresource /DefineResource get exec
  432. } put
  433. /Category defineresource pop
  434.  
  435. % Add the new FontType resources.
  436.  
  437. 9 1 11 { dup /FontType defineresource pop } for
  438.  
  439. % Add the new FMapType resource.
  440.  
  441. 9 dup /FMapType defineresource pop
  442.  
  443. % Define the CIDMap resource category.
  444. % These aren't documented, but it's clear what they are for:
  445. % to give names to CIDMaps for CIDFontType 2 fonts.
  446.  
  447. /CIDMap /Generic /Category findresource dup length dict .copydict
  448. dup /.CheckResource {
  449.     % Allow either a string or an array of strings.
  450.   dup type dup /stringtype eq
  451.    { pop true
  452.    }
  453.    { dup /arraytype eq exch /packedarraytype eq or
  454.       { true exch { type /stringtype ne { pop false exit } if } forall
  455.       }
  456.       { false
  457.       }
  458.      ifelse
  459.    }
  460.   ifelse
  461. } bind put
  462. /Category defineresource pop
  463.  
  464. .setlanguagelevel
  465.