home *** CD-ROM | disk | FTP | other *** search
/ jppd.dyndns.org / jppd.dyndns.org.tar / jppd.dyndns.org / QUERYPRO / Impressora_PDF / converter.exe / GPLGS / gs_cff.ps < prev    next >
Text File  |  2003-04-13  |  23KB  |  773 lines
  1. %    Copyright (C) 1997, 1998, 1999, 2000 Aladdin Enterprises.  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_cff.ps,v 1.17 2003/04/12 18:08:18 ray Exp $
  17. % Loader for CFF (compressed) fonts, including OpenType CFFs.
  18. % The following are not implemented yet:
  19. %    Deleted entries in the Name Index
  20. %    Embedded PostScript
  21. %    Multiple Master fonts
  22. %    Chameleon fonts
  23. %    Synthetic fonts
  24.  
  25. % ---------------- Font loading machinery ---------------- %
  26.  
  27. % Augment the FONTPATH machinery so it recognizes OpenType CFF font sets.
  28.  
  29. /.scanfontheaders where {
  30.   pop /.scanfontheaders [
  31.    .scanfontheaders aload pop (OTTO*)
  32.   ] def
  33. } if
  34.  
  35. % Load a font file that might be an OpenType CFF font set.
  36.  
  37. % <file> .loadfontfile -
  38. /.loadnonottofontfile /.loadfontfile load def
  39. /.loadfontfile {
  40.   dup 4 string .peekstring pop (OTTO) eq {
  41.         % If this is a font at all, it's an OpenType CFF font set.
  42.     .loadottofontfile
  43.   } {
  44.         % Not a TrueType font.
  45.     .loadnonottofontfile
  46.   } ifelse
  47. } bind def
  48.  
  49. % <file> .loadottofontfile -
  50. /.loadottofontfile {
  51.   /FontSetInit /ProcSet findresource begin
  52.   2 dict begin
  53.   /f exch def /cff null def
  54.   card32 pop card16 6 { next pop } repeat dup {
  55.         % Stack: numtables tablesleft
  56.     dup 0 eq {
  57.       pop pop /.loadottofontfile cvx /invalidfont signalerror
  58.     } if
  59.     f 4 string readstring pop (CFF ) eq { sub exit } if
  60.     f 12 string readstring pop pop 1 sub    % skip to next table
  61.   } loop
  62.         % Stack: tablesread
  63.   card32 pop card32 card32
  64.         % Stack: tablesread start length
  65.   exch 3 -1 roll 1 add 16 mul 12 add sub
  66.   f exch subfilefilter flushfile    % skip to start
  67.   f exch subfilefilter end
  68.     % Use a random FontSet resource name.  ****** WRONG ******
  69.   realtime rand xor =string cvs exch false
  70.   ReadData
  71. } bind def
  72.  
  73. 30 dict begin
  74.  
  75. % ---------------- Standard strings (actually names) ---------------- %
  76.  
  77. /StandardStrings mark
  78.     % The initial StandardStrings that that denote characters are
  79.     % defined as a pseudo-Encoding.
  80. % 0
  81.   /CFFStandardStrings .findencoding aload pop
  82. % 379
  83.   (001.000)
  84. % 380
  85.   (001.001) (001.002) (001.003) /Black /Bold
  86.   /Book /Light /Medium /Regular /Roman
  87.   /Semibold
  88. .packtomark def
  89.  
  90. % ---------------- Standard encodings ---------------- %
  91.  
  92. /StandardEncodings [
  93.  
  94. % StandardEncoding
  95. mark
  96.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  97.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  98.   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  99.   17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
  100.   33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
  101.   49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
  102.   65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
  103.   81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 0
  104.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  105.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  106.   0 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
  107.   0 111 112 113 114 0 115 116 117 118 119 120 121 122 0 123
  108.   0 124 125 126 127 128 129 130 131 0 132 133 0 134 135 136
  109.   137 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  110.   0 138 0 139 0 0 0 0 140 141 142 143 0 0 0 0
  111.   0 144 0 0 0 145 0 0 146 147 148 149 0 0 0 0
  112. .packtomark
  113.  
  114. % ExpertEncoding
  115. mark
  116.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  117.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  118.   1 229 230 0 231 232 233 234 235 236 237 238 13 14 15 99
  119.   239 240 241 242 243 244 245 246 247 248 27 28 249 250 251 252
  120.   0 253 254 255 256 257 0 0 0 258 0 0 259 260 261 262
  121.   0 0 263 264 265 0 266 109 110 267 268 269 0 270 271 272
  122.   273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
  123.   289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 0
  124.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  125.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  126.   0 304 305 306 0 0 307 308 309 310 311 0 312 0 0 313
  127.   0 0 314 315 0 0 316 317 318 0 0 0 158 155 163 319
  128.   320 321 322 323 324 325 0 0 326 150 164 169 327 328 329 330
  129.   331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
  130.   347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
  131.   363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
  132. .packtomark
  133.  
  134. ] readonly def
  135.  
  136. % ---------------- Standard Charsets ---------------- %
  137.  
  138. % We include an explicit 0 at the beginning of each charset.
  139.  
  140. /StandardCharsets [
  141.  
  142. % ISOAdobe
  143. mark
  144.   0
  145.   1 1 228 { } for
  146. .packtomark
  147.  
  148. % Expert
  149. mark
  150.   0
  151.   1 229 230 231 232 233 234 235 236 237 238 13 14 15 99 239
  152.   240 241 242 243 244 245 246 247 248 27 28 249 250 251 252 253
  153.   254 255 256 257 258 259 260 261 262 263 264 265 266 109 110 267
  154.   268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
  155.   284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
  156.   300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
  157.   316 317 318 158 155 163 319 320 321 322 323 324 325 326 150 164
  158.   169 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
  159.   342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
  160.   358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
  161.   374 375 376 377 378
  162. .packtomark
  163.  
  164. % ExpertSubset
  165. mark
  166.   0
  167.   1 231 232 235 236 237 238 13 14 15 99 239 240 241 242 243
  168.   244 245 246 247 248 27 28 249 250 251 253 254 255 256 257 258
  169.   259 260 261 262 263 264 265 266 109 110 267 268 269 270 272 300
  170.   301 302 305 314 315 158 155 163 320 321 322 323 324 325 326 150
  171.   164 169 327 328 329 330 331 332 333 334 335 336 337 338 339 340
  172.   341 342 343 344 345 346
  173. .packtomark
  174.  
  175. ] readonly def
  176.  
  177. % ---------------- Font loading ---------------- %
  178.  
  179. % ------ Utilities ------ %
  180.  
  181. /advance {    % <n> advance -
  182.   f cff eq { pos add /pos exch store } { pop } ifelse
  183. } bind def
  184. /next {        % - next <byte>
  185.   f read {
  186.     1 advance
  187.     CFFDEBUG { (  ) print dup = } if
  188.   } if
  189. } bind def
  190. /next2 {    % - next2 <byte1> <byte2>
  191.   f read {
  192.     f read {
  193.       2 advance
  194.       CFFDEBUG { (  ) print 1 index =only (,) print dup = } if
  195.     } {
  196.       1 advance
  197.       CFFDEBUG { (  ) print dup = } if
  198.     } ifelse
  199.   } if
  200. } bind def
  201. /nextstring {    % <length> nextstring <string>
  202.   dup 0 eq {
  203.     pop ()
  204.   } {
  205.     string f exch readstring pop dup length advance
  206.     CFFDEBUG { (  ) print dup == } if
  207.   } ifelse
  208. } bind def
  209. /card8        % - card8 <card8>
  210.  /next load
  211. def
  212. /card16 {    % - card16 <card16>
  213.   next2 exch 8 bitshift add
  214. } bind def
  215. /card32 {    % - card32 <card32>
  216.   card16 16 bitshift card16 add
  217. } bind def
  218. /offsetprocs [
  219.   /card8 load
  220.   /card16 load
  221.   { card8 16 bitshift card16 add } bind
  222.   /card32 load
  223. ] readonly def
  224. /offsetproc {    % <offsize> offsetproc <proc>
  225.   1 sub //offsetprocs exch get
  226. } bind def
  227. /offset {    % <offsize> offset <offset>
  228.   offsetproc exec
  229. } bind def
  230. /sid        % - <sid> sid
  231.   /card16 load
  232. def
  233. /Index {    % <name> Index <name> <array>
  234.   CFFDEBUG { (% reading Index: ) print dup = } if
  235.   mark card16 dup 0 ne {
  236.     1 exch next offsetproc dup exec pop exch {
  237.       dup exec dup 4 -1 roll sub 3 1 roll exch
  238.     } repeat pop
  239.   } if pop .packtomark
  240.   CFFDEBUG { (% Index lengths = ) print dup === } if
  241.   [ exch { nextstring } forall ] readonly
  242. } bind def
  243. /tokens {    % - tokens <num1> ... <op#> (op# = 12 means EOF)
  244.   {
  245.     f read not { 12 exit } if
  246.     CFFDEBUG { (..) print dup = } if
  247.     1 advance
  248.     dup 12 eq { pop next 32 add exit } if
  249.     dup 28 lt { exit } if
  250.     dup 32 lt {
  251.       28 sub {
  252.     { card16 32768 xor 32768 sub }
  253.     { 4 offset dup 16#7fffffff gt { -1 32 bitshift add } if }
  254.     { tokenreal }
  255.     { 31 exit }
  256.       } exch get exec
  257.     } {
  258.       dup 247 lt {
  259.     139 sub
  260.       } {
  261.     247 sub {
  262.       { next 108 add }
  263.       { next 364 add }
  264.       { next 620 add }
  265.       { next 876 add }
  266.       { next 108 add neg }
  267.       { next 364 add neg }
  268.       { next 620 add neg }
  269.       { next 876 add neg }
  270.       % 255 is deliberately omitted and will cause a rangecheck
  271.     } exch get exec
  272.       } ifelse
  273.     } ifelse
  274.   } loop
  275. } bind def
  276. /tokenbuf 100 string def
  277. /tokenput {    % <index> <char> tokenput <index+1>
  278.   tokenbuf 2 index 3 -1 roll put 1 add
  279. } bind def
  280. /tokenrealarray [
  281.  (0123456789.E) { } forall
  282.  [(E) 0 get /tokenput cvx (-) 0 get] cvx
  283.  null        % will give an error
  284.  (-) 0 get
  285.  { exit }
  286. ] readonly def
  287. /tokenreal {    % - tokenreal <float>
  288.   0 {
  289.     next exch 1 index -4 bitshift tokenrealarray exch get exec tokenput
  290.         % We must leave the byte on the stack temporarily so that
  291.         % the exit will see a consistent stack state.
  292.     1 index 15 and tokenrealarray exch get exec tokenput exch pop
  293.   } loop
  294.   tokenbuf 0 3 -1 roll getinterval cvr exch pop
  295. } bind def
  296. /Dict {        % <opsdict> Dict -
  297.   /opdict exch store {
  298.     mark tokens
  299.     CFFDEBUG { (tokens: ) print ] dup === mark exch aload pop } if
  300.     opdict exch .knownget { exec } if cleartomark
  301.   } loop cleartomark
  302. } bind def
  303. /idstring {    % <sid> idstring <string|name>
  304.   dup 391 lt { //StandardStrings } { 391 sub strings } ifelse exch get
  305. } bind def
  306. /idname {    % <sid> idname <name>
  307.   idstring dup type /nametype ne { cvn } if
  308. } bind def
  309. /subfilefilter {    % <file> <length> subfilefilter <filter>
  310.     % SubFileDecode interprets a length of 0 as infinite.
  311.   dup 0 le { pop pop () 0 } if () /SubFileDecode filter
  312. } bind def
  313.  
  314. % ------ Top dictionary ------ %
  315.  
  316. /offput {    % <offset> <proc> offput -
  317.   CFFDEBUG { (queued: ) print 1 index =only ( ) print dup === } if
  318.   currentdict exch aload length 1 add packedarray cvx
  319.   offsets 3 1 roll put
  320. } bind def
  321. /queueput {    % <font> <proc> queueput -
  322.   16#7fffffff offsets { pop .min } forall
  323.   pos sub nextstring
  324.   3 1 roll aload length 2 add packedarray cvx
  325.   [ queued aload pop counttomark 2 add -1 roll ]
  326.   /queued exch store
  327. } bind def
  328. /printvk {    % <value> <key> printvk <value> <key>
  329.   CFFDEBUG { (\t% ) print dup =only ( = ) print 1 index === } if
  330. } bind def
  331. /xxput {    % <value> <key> <dict> xxput -
  332.   3 1 roll exch put
  333. } bind def
  334. /putfi {    % <value> <key> putfi -
  335.   printvk FontInfo xxput
  336. } bind def
  337. /xdef {        % <value> <key> xdef -
  338.   exch def
  339. } bind def
  340. /pxdef {    % <value> <key> pxdef -
  341.   printvk xdef
  342. } bind def
  343. /topdictops mark
  344.   12 { CFFDEBUG { (\t% EOD) = } if exit }
  345.   0 { idstring /version putfi }
  346.   1 { idstring /Notice putfi }
  347.   32 { idstring /Copyright putfi }
  348.   2 { idstring /FullName putfi }
  349.   3 { idstring /FamilyName putfi }
  350.   4 { idstring /Weight putfi }
  351.   33 { 0 ne /isFixedPitch putfi }
  352.   34 { /ItalicAngle putfi }
  353.   35 { /UnderlinePosition putfi }
  354.   36 { /UnderlineThickness putfi }
  355.   37 { /PaintType pxdef }
  356.   38 { /FontType pxdef }        % actually CharstringType
  357.   39 { counttomark array astore /FontMatrix pxdef }
  358.   13 { /UniqueID pxdef }
  359.   5 { counttomark array astore /FontBBox pxdef }
  360.   40 { /StrokeWidth pxdef }
  361.   14 { counttomark array astore /XUID pxdef }
  362.   15 {
  363.     /charset printvk pop
  364.     dup StandardCharsets length lt {
  365.       StandardCharsets exch get /charset xdef
  366.     } {
  367.       { queuecharset } offput
  368.     } ifelse
  369.   }
  370.   16 {
  371.     /Encoding printvk pop
  372.     dup StandardEncodings length lt {
  373.       /Encoding xdef
  374.     } {
  375.       { queueEncoding } offput
  376.     } ifelse
  377.   }
  378.   17 { { readCharStrings } offput }
  379.   18 { exch /readPrivate cvx 2 packedarray offput }
  380.     % CIDFont operators
  381.   62 {        % ROS, must be first in a CIDFont
  382.     currentdict /FontType undef
  383.     currentdict /Encoding undef
  384.     currentdict /FontMatrix undef
  385.     /CIDFontVersion 0 def
  386.     /CIDFontRevision 0 def
  387.     /CIDFontType 0 def
  388.     /CIDCount 8720 def % Default value defined in CFF spec.
  389.     3 dict begin
  390.     /Supplement pxdef
  391.     idstring /Ordering pxdef
  392.     idstring /Registry pxdef
  393.     /CIDSystemInfo currentdict end def
  394.   }
  395.   63 { /CIDFontVersion pxdef }
  396.   64 { /CIDFontRevision pxdef }
  397.   65 { /CIDFontType pxdef }
  398.   66 { /CIDCount pxdef }
  399.   67 { /UIDBase pxdef }
  400.   68 { { readFDArray } offput }
  401.   69 { { readFDSelect } offput }
  402.     % This operator only appears in a FDArray element.
  403.   70 { idstring /FontName pxdef }
  404. .dicttomark readonly def
  405.  
  406. % readcharset and readFDSelect may require the length of CharStringArray,
  407. % but these structures may occur in the file before the CharStrings.
  408. % If that happens, use a hack: assume that all the data up to the next
  409. % queued read should be read.
  410.  
  411. /charstringcount {    % <font> charstringcount <count> true
  412.             % <font> charstringcount <length> false
  413.   /CharStringArray .knownget {
  414.     length true
  415.   } {
  416.     % Hack: look for the next queued read.
  417.     16#7fffffff offsets { pop .min } forall
  418.     pos sub false
  419.   } ifelse
  420. } bind def
  421.  
  422. /readCharStrings {    % <font> readCharStrings -
  423.   /CharStringArray Index put
  424. } bind def
  425.  
  426. % ------ Charsets and encodings ------ %
  427.  
  428. % Note: formats 1 and 2 can overflow the operand stack.
  429. % We'll fix this if it ever becomes necessary.
  430. /charsetcount {
  431.   charstringcount { 1 sub } { 2 idiv } ifelse
  432. } bind def
  433. /charsetformats [
  434. { [ 0 3 -1 roll charsetcount { sid } repeat ]
  435. } bind
  436. { [ 0 3 -1 roll charsetcount {
  437.     dup 0 eq { pop exit } if
  438.     sid card8 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
  439.   } loop ]
  440. } bind
  441. { [ 0 3 -1 roll charsetcount {
  442.     dup 0 eq { pop exit } if
  443.     sid card16 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
  444.   } loop ]
  445. } bind
  446. ] readonly def
  447. /queuecharset {        % <font> queuecharset -
  448.   { readcharset } queueput
  449. } bind def
  450. /readcharset {        % <data> <font> readcharset -
  451.   begin 0 () /SubFileDecode filter /f exch store
  452.   charsetformats next get currentdict exch exec /charset exch def end
  453. } bind def
  454.  
  455. /encodingformats [
  456. { 1 1 next { next exch Encoding 3 1 roll put } for
  457. } bind
  458. { 1 next {
  459.     next next 1 add {
  460.             % Stack: gid code
  461.       Encoding 1 index 3 index put
  462.       exch 1 add exch 1 add
  463.     } repeat pop
  464.   } repeat pop
  465. } bind
  466. ] readonly def
  467. /queueEncoding {    % <font> queueEncoding -
  468.   { readEncoding } queueput
  469. } bind def
  470. /readEncoding {        % <data> <font> readEncoding -
  471.   begin 0 () /SubFileDecode filter /f exch store
  472.   /Encoding [ 256 { /.notdef } repeat ] def
  473.   next encodingformats 1 index 127 and get exec
  474.   128 ge {
  475.             % Read supplementary encodings.
  476.     next {
  477.       Encoding next sid idname put
  478.     } repeat
  479.   } if end
  480. } bind def
  481.  
  482. % ------ FDArray and FDSelect ------ %
  483.  
  484. /readFDArray {        % <font> readFDArray -
  485.   /FDarray Index exch pop exch
  486.   2 dict begin /f null def begin
  487.   [ exch {
  488.     dup length subfilefilter /f exch store
  489.     10 dict begin
  490.     /FontType 2 def
  491.     /PaintType 0 def
  492.     /FontMatrix [0.001 0 0 0.001 0 0] def
  493.     /Private 20 dict def
  494.     //topdictops Dict currentdict end
  495.   } forall ] /FDArray xdef end end
  496. } bind def
  497.  
  498. /fdselectformats [
  499. % Note: this procedure can overflow the operand stack.
  500. % We'll fix this if it ever becomes necessary.
  501. { [ exch charstringcount pop { card8 } repeat ] } bind    % Format 0
  502. { /FDSelect cvx /invalidfont signalerror } bind        % Format 1
  503. dup                            % Format 2
  504. % The following procedure does not use excessive op-stack space.
  505. { pop 65535 array card16 card16 exch            % Format 3
  506.   { % Stack: array previndex
  507.     card8 card16 
  508.     exch 1 index 4 -1 roll
  509.     exch 1 exch 1 sub
  510.     { 3 index exch 2 index put } for pop
  511.   } repeat
  512.   % now resize the array to the final index.
  513.   0 exch getinterval
  514. } bind
  515. ] readonly def
  516.  
  517. /readFDSelect {        % <font> readFDSelect -
  518.   begin fdselectformats next get currentdict exch exec /FDSelect exch def end
  519. } bind def
  520.  
  521.  
  522. % ------ Private dictionary ------ %
  523.  
  524. /deltarray {        % -mark- <num1> ... deltarray <num1'> ...
  525.   0 counttomark 1 sub { counttomark -1 roll add dup } repeat pop
  526.   counttomark array astore
  527. } bind def
  528.  
  529. /privatedictops mark
  530.   12 { CFFDEBUG { (\t% EOD) = } if exit }
  531.   6 { deltarray /BlueValues pxdef }
  532.   7 { deltarray /OtherBlues pxdef }
  533.   8 { deltarray /FamilyBlues pxdef }
  534.   9 { deltarray /FamilyOtherBlues pxdef }
  535.   41 { /BlueScale pxdef }
  536.   42 { /BlueShift pxdef }
  537.   43 { /BlueFuzz pxdef }
  538.   10 { 1 array astore /StdHW pxdef }
  539.   11 { 1 array astore /StdVW pxdef }
  540.   44 { deltarray /StemSnapH pxdef }
  541.   45 { deltarray /StemSnapV pxdef }
  542.   46 { 0 ne /ForceBold pxdef }
  543.   47 { /ForceBoldThreshold pxdef }
  544.   48 { /lenIV pxdef }
  545.   49 { /LanguageGroup pxdef }
  546.   50 { /ExpansionFactor pxdef }
  547.   51 { /initialRandomSeed pxdef }
  548.   19 { PrivateStart add { readSubrs } offput }
  549.   20 { /defaultWidthX pxdef }
  550.   21 { /nominalWidthX pxdef }
  551.     % Multiple Master fonts only
  552.   59 { /NDV pxdef }
  553.   60 { /CDV pxdef }
  554.   61 { /lenBuildCharArray pxdef }
  555. .dicttomark readonly def
  556.  
  557. /readPrivate {        % <font> <size> readPrivate -
  558.   2 dict begin
  559.   /PrivateStart pos def
  560.   f 3 1 roll exch 1 index f exch subfilefilter /f exch store
  561.   dup /FontType get exch
  562.   /Private get begin
  563.         % Default lenIV to -1 even for Type 1 CharStrings.
  564.   2 ne { /lenIV -1 def } if
  565.   //privatedictops Dict end
  566.   exch /f exch store advance
  567.   end
  568. } bind def
  569.  
  570. /readSubrs {        % <font> readSubrs -
  571.   /Subrs Index put
  572. } bind def
  573.  
  574. % ------ Main program ------ %
  575.  
  576. % Clean up after finishing a font.
  577. /cleanupFont {        % (currentdict) cleanupFont -
  578.         % Remove unwanted entries.
  579.   currentdict /charset undef
  580.   currentdict /CharStringArray undef
  581. } bind def
  582.  
  583. % Update the Encoding and CharStrings for a real font.
  584. /finishFont {        % (currentdict) finishFont -
  585.         % Construct the real Encoding.
  586.         % The value of Encoding is either a number, for predefined
  587.         % encodings, or an array of mixed GIDs and names.
  588.   /Encoding mark Encoding
  589.   CFFDEBUG { (Encoding: ) print dup === flush } if
  590.   dup type /integertype eq {
  591.     StandardEncodings exch get { idname } forall
  592.   } {
  593.     {
  594.       dup type /integertype eq { charset exch get idname } if
  595.     } forall
  596.   } ifelse .packtomark def
  597.         % Construct the CharStrings.
  598.         % Note that they may only correspond to an initial
  599.         % subset of the charset.
  600.   /CharStrings charset length CharStringArray length .min dict def
  601.   CFFDEBUG {
  602.     charset length =only ( charset ) print
  603.     CharStringArray length =only ( CharStringArray) =
  604.     charset == flush
  605.   } if
  606.   0 1 CharStrings maxlength 1 sub {
  607.     dup CharStringArray exch get
  608.     exch charset exch get idstring CharStrings xxput
  609.   } for
  610.   cleanupFont
  611. } bind def
  612.  
  613. % Replace CharStrings with GlyphDirectory for a CIDFont;
  614. % Move GlobalSubrs to descendent fonts.
  615. /finishCIDFont {    % (currentdict) finishCIDFont -
  616.         % Construct the GlyphDirectory, similar to CharStrings.
  617.   /FDBytes FDArray length 1 gt { 1 } { 0 } ifelse def
  618.   /GlyphDirectory charset length CharStringArray length .min dict def
  619.   CFFDEBUG {
  620.     charset length =only ( charset ) print
  621.     CharStringArray length =only ( CharStringArray) =
  622.     charset == flush
  623.   } if
  624.   0 1 GlyphDirectory maxlength 1 sub {
  625.     dup CharStringArray exch get
  626.         % If there is more than one FDArray entry, add the font
  627.         % index to the beginning of each charstring.
  628.     FDBytes 1 eq {
  629.       FDSelect 2 index get
  630.       1 string dup 0 4 -1 roll put exch concatstrings
  631.     } if
  632.     exch charset exch get GlyphDirectory xxput
  633.   } for
  634.  
  635.   Private /GlobalSubrs .knownget {
  636.     FDArray {
  637.     /Private get /GlobalSubrs 2 index put
  638.     } forall
  639.     pop
  640.     Private /GlobalSubrs undef
  641.   } if
  642.  
  643.         % Clean up.
  644.   currentdict /FDSelect undef
  645.   cleanupFont
  646. } bind def
  647. % We need to pass the file as a parameter for the sake of the PDF
  648. % interpreter. Also for the sake of PDF, a flag forces the font
  649. % to be defined as <resname> instead of the name embedded in the data.
  650. % This is needed for subsetted fonts; it is valid if the CFF
  651. % contains only a single font.
  652. /StartData {          % <resname> <nbytes> StartData -
  653.   currentfile exch subfilefilter false ReadData
  654. } bind def
  655. /ReadData {           % <resname> <file> <forceresname> ReadData -
  656.  
  657.     % Initialize.
  658.  
  659.   30 dict begin
  660.   /forceresname exch def
  661.   /cff exch def
  662.   /pos 0 def
  663.   /resname exch cvlit def
  664.   /DEBUG CFFDEBUG def    % bring the binding closer
  665.  
  666.     % Read the header.
  667.  
  668.   /f cff def
  669.   /vmajor next def
  670.   /vminor next def
  671.   /hdrsize next def
  672.   /aoffsize next def
  673.  
  674.     % Read the Indexes.
  675.  
  676.   /names Index def
  677.   /topdicts Index def
  678.   /strings Index def
  679.   /gsubrs Index def
  680.  
  681.     % Read the top Dicts.
  682.  
  683.   /offsets 50 dict def
  684.   /queued [] def
  685.   /opdict null def        % reserve a slot
  686.   /fonts [ topdicts {
  687.     0 () /SubFileDecode filter /f exch def
  688.     40 dict begin
  689.         % Preload defaults that differ from PostScript defaults,
  690.         % or that are required.
  691.       /FontType 2 def
  692.       /PaintType 0 def
  693.       /FontMatrix [0.001 0 0 0.001 0 0] def
  694.       /charset StandardCharsets 0 get def
  695.       /Encoding 0 def
  696.       /FontInfo 10 dict
  697.     dup /UnderlinePosition -100 put
  698.     dup /UnderlineThickness 50 put
  699.       def
  700.       /Private 20 dict
  701.     gsubrs length 0 ne { dup /GlobalSubrs gsubrs put } if
  702.       def
  703.       //topdictops Dict
  704.     currentdict end
  705.   } forall ] def
  706.  
  707.     % Read other tables with queued offsets.
  708.  
  709.   CFFDEBUG { (offsets: ) print [ offsets { pop } forall ] == } if
  710.   { /f cff def
  711.     CFFDEBUG { (pos=) print pos = } if
  712.     offsets pos 2 copy .knownget not { pop pop exit } if
  713.     3 1 roll undef
  714.     CFFDEBUG { (exec queued: ) print dup == } if
  715.     exec
  716.   } loop
  717.   offsets length 0 ne {
  718.     QUIET not {
  719.       (Error reading the CFF font ) print resname =string cvs print ( : missing tables at ) print [ offsets { pop } forall ] ==
  720.       (Current position is ) print pos ==
  721.     } if
  722.   } if
  723.  
  724.     % Process out-of-order tables.
  725.  
  726.   CFFDEBUG { queued length =only ( queued) = flush } if
  727.   queued { exec } forall
  728.  
  729.     % Update Encoding and CharStrings.
  730.  
  731.   fonts {
  732.     begin
  733.     currentdict /CIDFontType known { finishCIDFont } { finishFont } ifelse
  734.     end
  735.   } forall
  736.  
  737.     % Wrap up.
  738.  
  739.   resname mark 0 1 fonts length 1 sub {
  740.     CFFDEBUG { dup =only ( ) print flush } if
  741.     dup names exch get
  742.     forceresname { pop resname } if
  743.     CFFDEBUG { dup == flush } if
  744.     exch fonts exch get
  745.     dup /CIDFontType known {
  746.         % This is a CIDFont.
  747.       dup /CIDFontName 3 index put
  748.       1 index exch /CIDFont defineresource
  749.     } {
  750.         % This is a font.
  751.       dup /FontName 3 index put
  752.       1 index exch definefont
  753.     } ifelse
  754.   } for .dicttomark
  755.   end        % temporary dict
  756.   end        % FontSetInit ProcSet
  757.   /FontSet defineresource pop
  758.  
  759. } bind def
  760.  
  761. % ---------------- Resource category definition ---------------- %
  762.  
  763. currentdict end readonly
  764.  
  765. languagelevel exch 2 .setlanguagelevel
  766.  
  767. /FontSet /Generic /Category findresource dup length dict .copydict
  768. /Category defineresource pop
  769.  
  770. /FontSetInit exch /ProcSet defineresource pop
  771.  
  772. .setlanguagelevel
  773.