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