trunk

git-svn-id: svn://tug.org/texlive/trunk@9 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 758 insertions, 0 deletions

diff --git a/Master/xemtex/gslib/gs_cff.ps b/Master/xemtex/gslib/gs_cff.ps
new file mode 100644
index 00000000000..2b9b510e7c7
--- /dev/null
+++ b/Master/xemtex/gslib/gs_cff.ps
@@ -0,0 +1,758 @@
+%    Copyright (C) 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
+% 
+% This program is free software; you can redistribute it and/or modify it
+% under the terms of the GNU General Public License as published by the
+% Free Software Foundation; either version 2 of the License, or (at your
+% option) any later version.
+%
+% This program is distributed in the hope that it will be useful, but
+% WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+% Public License for more details.
+%
+% You should have received a copy of the GNU General Public License along
+% with this program; if not, write to the Free Software Foundation, Inc.,
+% 59 Temple Place, Suite 330, Boston, MA, 02111-1307.
+
+% $Id: gs_cff.ps,v 1.10.2.1.2.1 2003/04/12 14:02:38 giles Exp $
+% Loader for CFF (compressed) fonts, including OpenType CFFs.
+% The following are not implemented yet:
+%	Deleted entries in the Name Index
+%	Embedded PostScript
+%	Multiple Master fonts
+%	Chameleon fonts
+%	Synthetic fonts
+
+% ---------------- Font loading machinery ---------------- %
+
+% Augment the FONTPATH machinery so it recognizes OpenType CFF font sets.
+
+/.scanfontheaders where {
+  pop /.scanfontheaders [
+   .scanfontheaders aload pop (OTTO*)
+  ] def
+} if
+
+% Load a font file that might be an OpenType CFF font set.
+
+% <file> .loadfontfile -
+/.loadnonottofontfile /.loadfontfile load def
+/.loadfontfile {
+  dup 4 string .peekstring pop (OTTO) eq {
+		% If this is a font at all, it's an OpenType CFF font set.
+    .loadottofontfile
+  } {
+		% Not a TrueType font.
+    .loadnonottofontfile
+  } ifelse
+} bind def
+
+% <file> .loadottofontfile -
+/.loadottofontfile {
+  /FontSetInit /ProcSet findresource begin
+  2 dict begin
+  /f exch def /cff null def
+  card32 pop card16 6 { next pop } repeat dup {
+		% Stack: numtables tablesleft
+    dup 0 eq {
+      pop pop /.loadottofontfile cvx /invalidfont signalerror
+    } if
+    f 4 string readstring pop (CFF ) eq { sub exit } if
+    1 sub
+  } loop
+		% Stack: tablesread
+  card32 pop card32 card32
+		% Stack: tablesread start length
+  exch 3 -1 roll 1 add 16 mul 12 add sub
+  f exch subfilefilter flushfile	% skip to start
+  f exch subfilefilter end
+	% Use a random FontSet resource name.  ****** WRONG ******
+  realtime rand xor =string cvs exch false
+  ReadData
+} bind def
+
+30 dict begin
+
+% ---------------- Standard strings (actually names) ---------------- %
+
+/StandardStrings mark
+	% The initial StandardStrings that that denote characters are
+	% defined as a pseudo-Encoding.
+% 0
+  /CFFStandardStrings .findencoding aload pop
+% 379
+  (001.000)
+% 380
+  (001.001) (001.002) (001.003) /Black /Bold
+  /Book /Light /Medium /Regular /Roman
+  /Semibold
+.packtomark def
+
+% ---------------- Standard encodings ---------------- %
+
+/StandardEncodings [
+
+% StandardEncoding
+mark
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
+  17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
+  33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
+  49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
+  65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
+  81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 0
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
+  0 111 112 113 114 0 115 116 117 118 119 120 121 122 0 123
+  0 124 125 126 127 128 129 130 131 0 132 133 0 134 135 136
+  137 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 138 0 139 0 0 0 0 140 141 142 143 0 0 0 0
+  0 144 0 0 0 145 0 0 146 147 148 149 0 0 0 0
+.packtomark
+
+% ExpertEncoding
+mark
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  1 229 230 0 231 232 233 234 235 236 237 238 13 14 15 99
+  239 240 241 242 243 244 245 246 247 248 27 28 249 250 251 252
+  0 253 254 255 256 257 0 0 0 258 0 0 259 260 261 262
+  0 0 263 264 265 0 266 109 110 267 268 269 0 270 271 272
+  273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
+  289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 0
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+  0 304 305 306 0 0 307 308 309 310 311 0 312 0 0 313
+  0 0 314 315 0 0 316 317 318 0 0 0 158 155 163 319
+  320 321 322 323 324 325 0 0 326 150 164 169 327 328 329 330
+  331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
+  347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
+  363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
+.packtomark
+
+] readonly def
+
+% ---------------- Standard Charsets ---------------- %
+
+% We include an explicit 0 at the beginning of each charset.
+
+/StandardCharsets [
+
+% ISOAdobe
+mark
+  0
+  1 1 228 { } for
+.packtomark
+
+% Expert
+mark
+  0
+  1 229 230 231 232 233 234 235 236 237 238 13 14 15 99 239
+  240 241 242 243 244 245 246 247 248 27 28 249 250 251 252 253
+  254 255 256 257 258 259 260 261 262 263 264 265 266 109 110 267
+  268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
+  284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
+  300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
+  316 317 318 158 155 163 319 320 321 322 323 324 325 326 150 164
+  169 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
+  342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
+  358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
+  374 375 376 377 378
+.packtomark
+
+% ExpertSubset
+mark
+  0
+  1 231 232 235 236 237 238 13 14 15 99 239 240 241 242 243
+  244 245 246 247 248 27 28 249 250 251 253 254 255 256 257 258
+  259 260 261 262 263 264 265 266 109 110 267 268 269 270 272 300
+  301 302 305 314 315 158 155 163 320 321 322 323 324 325 326 150
+  164 169 327 328 329 330 331 332 333 334 335 336 337 338 339 340
+  341 342 343 344 345 346
+.packtomark
+
+] readonly def
+
+% ---------------- Font loading ---------------- %
+
+% ------ Utilities ------ %
+
+/advance {	% <n> advance -
+  f cff eq { pos add /pos exch store } { pop } ifelse
+} bind def
+/next {		% - next <byte>
+  f read {
+    1 advance
+    DEBUG { (  ) print dup = } if
+  } if
+} bind def
+/next2 {	% - next2 <byte1> <byte2>
+  f read {
+    f read {
+      2 advance
+      DEBUG { (  ) print 1 index =only (,) print dup = } if
+    } {
+      1 advance
+      DEBUG { (  ) print dup = } if
+    } ifelse
+  } if
+} bind def
+/nextstring {	% <length> nextstring <string>
+  dup 0 eq {
+    pop ()
+  } {
+    string f exch readstring pop dup length advance
+    DEBUG { (  ) print dup == } if
+  } ifelse
+} bind def
+/card8		% - card8 <card8>
+ /next load
+def
+/card16 {	% - card16 <card16>
+  next2 exch 8 bitshift add
+} bind def
+/card32 {	% - card32 <card32>
+  card16 16 bitshift card16 add
+} bind def
+/offsetprocs [
+  /card8 load
+  /card16 load
+  { card8 16 bitshift card16 add } bind
+  /card32 load
+] readonly def
+/offsetproc {	% <offsize> offsetproc <proc>
+  1 sub //offsetprocs exch get
+} bind def
+/offset {	% <offsize> offset <offset>
+  offsetproc exec
+} bind def
+/sid		% - <sid> sid
+  /card16 load
+def
+/Index {	% - Index <array>
+  mark card16 dup 0 ne {
+    1 exch next offsetproc dup exec pop exch {
+      dup exec dup 4 -1 roll sub 3 1 roll exch
+    } repeat pop
+  } if pop .packtomark
+  [ exch { nextstring } forall ] readonly
+} bind def
+/tokens {	% - tokens <num1> ... <op#> (op# = 12 means EOF)
+  {
+    f read not { 12 exit } if
+    DEBUG { (..) print dup = } if
+    1 advance
+    dup 12 eq { pop next 32 add exit } if
+    dup 28 lt { exit } if
+    dup 32 lt {
+      28 sub {
+	{ card16 32768 xor 32768 sub }
+	{ 4 offset dup 16#7fffffff gt { -1 32 bitshift add } if }
+	{ tokenreal }
+	{ 31 exit }
+      } exch get exec
+    } {
+      dup 247 lt {
+	139 sub
+      } {
+	247 sub {
+	  { next 108 add }
+	  { next 364 add }
+	  { next 620 add }
+	  { next 876 add }
+	  { next 108 add neg }
+	  { next 364 add neg }
+	  { next 620 add neg }
+	  { next 876 add neg }
+	  % 255 is deliberately omitted and will cause a rangecheck
+	} exch get exec
+      } ifelse
+    } ifelse
+  } loop
+} bind def
+/tokenbuf 100 string def
+/tokenput {	% <index> <char> tokenput <index+1>
+  tokenbuf 2 index 3 -1 roll put 1 add
+} bind def
+/tokenrealarray [
+ (0123456789.E) { } forall
+ [(E) 0 get /tokenput cvx (-) 0 get] cvx
+ null		% will give an error
+ (-) 0 get
+ { exit }
+] readonly def
+/tokenreal {	% - tokenreal <float>
+  0 {
+    next exch 1 index -4 bitshift tokenrealarray exch get exec tokenput
+		% We must leave the byte on the stack temporarily so that
+		% the exit will see a consistent stack state.
+    1 index 15 and tokenrealarray exch get exec tokenput exch pop
+  } loop
+  tokenbuf 0 3 -1 roll getinterval cvr exch pop
+} bind def
+/Dict {		% <opsdict> Dict -
+  /opdict exch store {
+    mark tokens
+    DEBUG { (tokens: ) print ] dup === mark exch aload pop } if
+    opdict exch .knownget { exec } if cleartomark
+  } loop cleartomark
+} bind def
+/idstring {	% <sid> idstring <string|name>
+  dup 391 lt { //StandardStrings } { 391 sub strings } ifelse exch get
+} bind def
+/idname {	% <sid> idname <name>
+  idstring dup type /nametype ne { cvn } if
+} bind def
+/subfilefilter {	% <file> <length> subfilefilter <filter>
+	% SubFileDecode interprets a length of 0 as infinite.
+  dup 0 le { pop pop () 0 } if () /SubFileDecode filter
+} bind def
+
+% ------ Top dictionary ------ %
+
+/offput {	% <offset> <proc> offput -
+  DEBUG { (queued: ) print 1 index =only ( ) print dup === } if
+  currentdict exch aload length 1 add packedarray cvx
+  offsets 3 1 roll put
+} bind def
+/queueput {	% <font> <proc> queueput -
+  16#7fffffff offsets { pop .min } forall
+  pos sub nextstring
+  3 1 roll aload length 2 add packedarray cvx
+  [ queued aload pop counttomark 2 add -1 roll ]
+  /queued exch store
+} bind def
+/xxput {	% <value> <key> <dict> xxput -
+  3 1 roll exch put
+} bind def
+/putfi {	% <value> <key> putfi -
+  FontInfo xxput
+} bind def
+/xdef {		% <value> <key> xdef -
+  exch def
+} bind def
+/topdictops mark
+  12 { exit }
+  0 { idstring /version putfi }
+  1 { idstring /Notice putfi }
+  32 { idstring /Copyright putfi }
+  2 { idstring /FullName putfi }
+  3 { idstring /FamilyName putfi }
+  4 { idstring /Weight putfi }
+  33 { 0 ne /isFixedPitch putfi }
+  34 { /ItalicAngle putfi }
+  35 { /UnderlinePosition putfi }
+  36 { /UnderlineThickness putfi }
+  37 { /PaintType xdef }
+  38 { /FontType xdef }		% actually CharstringType
+  39 { counttomark array astore /FontMatrix xdef }
+  13 { /UniqueID xdef }
+  5 { counttomark array astore /FontBBox xdef }
+  40 { /StrokeWidth xdef }
+  14 { counttomark array astore /XUID xdef }
+  15 {
+    dup StandardCharsets length lt {
+      StandardCharsets exch get /charset xdef
+    } {
+      { queuecharset } offput
+    } ifelse
+  }
+  16 {
+    dup StandardEncodings length lt {
+      /Encoding xdef
+    } {
+      { queueEncoding } offput
+    } ifelse
+  }
+  17 { { readCharStrings } offput }
+  18 { exch /readPrivate cvx 2 packedarray offput }
+	% CIDFont operators
+  62 {		% ROS, must be first in a CIDFont
+    currentdict /FontType undef
+    currentdict /Encoding undef
+    currentdict /FontMatrix undef
+    /CIDFontVersion 0 def
+    /CIDFontRevision 0 def
+    /CIDFontType 0 def
+    /CIDCount 8720 def % Default value defined in CFF spec.
+    3 dict begin
+    /Supplement xdef
+    idstring /Ordering xdef
+    idstring /Registry xdef
+    /CIDSystemInfo currentdict end def
+  }
+  63 { /CIDFontVersion xdef }
+  64 { /CIDFontRevision xdef }
+  65 { /CIDFontType xdef }
+  66 { /CIDCount xdef }
+  67 { /UIDBase xdef }
+  68 { { readFDArray } offput }
+  69 { { readFDSelect } offput }
+	% This operator only appears in a FDArray element.
+  70 { idstring /FontName exch def }
+.dicttomark readonly def
+
+% readcharset and readFDSelect may require the length of CharStringArray,
+% but these structures may occur in the file before the CharStrings.
+% If that happens, use a hack: assume that all the data up to the next
+% queued read should be read.
+
+/charstringcount {	% <font> charstringcount <count> true
+			% <font> charstringcount <length> false
+  /CharStringArray .knownget {
+    length true
+  } {
+	% Hack: look for the next queued read.
+    16#7fffffff offsets { pop .min } forall
+    pos sub false
+  } ifelse
+} bind def
+
+/readCharStrings {	% <font> readCharStrings -
+  /CharStringArray Index put
+} bind def
+
+% ------ Charsets and encodings ------ %
+
+% Note: formats 1 and 2 can overflow the operand stack.
+% We'll fix this if it ever becomes necessary.
+/charsetcount {
+  charstringcount { 1 sub } { 2 idiv } ifelse
+} bind def
+/charsetformats [
+{ [ 0 3 -1 roll charsetcount { sid } repeat ]
+} bind
+{ [ 0 3 -1 roll charsetcount {
+    dup 0 eq { pop exit } if
+    sid card8 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
+  } loop ]
+} bind
+{ [ 0 3 -1 roll charsetcount {
+    dup 0 eq { pop exit } if
+    sid card16 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
+  } loop ]
+} bind
+] readonly def
+/queuecharset {		% <font> queuecharset -
+  { readcharset } queueput
+} bind def
+/readcharset {		% <data> <font> readcharset -
+  begin 0 () /SubFileDecode filter /f exch store
+  charsetformats next get currentdict exch exec /charset exch def end
+} bind def
+
+/encodingformats [
+{ 1 1 next { next exch Encoding 3 1 roll put } for
+} bind
+{ 1 next {
+    next next 1 add {
+			% Stack: gid code
+      Encoding 1 index 3 index put
+      exch 1 add exch 1 add
+    } repeat pop
+  } repeat pop
+} bind
+] readonly def
+/queueEncoding {	% <font> queueEncoding -
+  { readEncoding } queueput
+} bind def
+/readEncoding {		% <data> <font> readEncoding -
+  begin 0 () /SubFileDecode filter /f exch store
+  /Encoding [ 256 { /.notdef } repeat ] def
+  next encodingformats 1 index 127 and get exec
+  128 ge {
+			% Read supplementary encodings.
+    next {
+      Encoding next sid idname put
+    } repeat
+  } if end
+} bind def
+
+% ------ FDArray and FDSelect ------ %
+
+/readFDArray {		% <font> readFDArray -
+  Index exch
+  2 dict begin /f null def begin
+  [ exch {
+    dup length subfilefilter /f exch store
+    10 dict begin
+    /FontType 2 def
+    /PaintType 0 def
+    /FontMatrix [0.001 0 0 0.001 0 0] def
+    /Private 20 dict def
+    //topdictops Dict currentdict end
+  } forall ] /FDArray xdef end end
+} bind def
+
+% Note: this implementation can overflow the operand stack.
+% We'll fix this if it ever becomes necessary.
+/fdselectformats [
+{ [ exch charstringcount pop { card8 } repeat ] } bind
+{ /FDSelect cvx /invalidfont signalerror } bind
+dup
+{ pop [ card16 card16 exch {
+		% Stack: previndex
+    card8 card16 dup 4 1 roll 3 -1 roll sub 1 sub {
+      exch 1 index
+    } repeat exch
+  } repeat pop ]
+} bind
+] readonly def
+
+/readFDSelect {		% <font> readFDSelect -
+  begin fdselectformats next get currentdict exch exec /FDSelect exch def end
+} bind def
+
+
+% ------ Private dictionary ------ %
+
+/deltarray {		% -mark- <num1> ... deltarray <num1'> ...
+  0 counttomark 1 sub { counttomark -1 roll add dup } repeat pop
+  counttomark array astore
+} bind def
+
+/privatedictops mark
+  12 { exit }
+  6 { deltarray /BlueValues xdef }
+  7 { deltarray /OtherBlues xdef }
+  8 { deltarray /FamilyBlues xdef }
+  9 { deltarray /FamilyOtherBlues xdef }
+  41 { /BlueScale xdef }
+  42 { /BlueShift xdef }
+  43 { /BlueFuzz xdef }
+  10 { 1 array astore /StdHW xdef }
+  11 { 1 array astore /StdVW xdef }
+  44 { deltarray /StemSnapH xdef }
+  45 { deltarray /StemSnapV xdef }
+  46 { 0 ne /ForceBold xdef }
+  47 { /ForceBoldThreshold xdef }
+  48 { /lenIV xdef }
+  49 { /LanguageGroup xdef }
+  50 { /ExpansionFactor xdef }
+  51 { /initialRandomSeed xdef }
+  19 { PrivateStart add { readSubrs } offput }
+  20 { /defaultWidthX xdef }
+  21 { /nominalWidthX xdef }
+	% Multiple Master fonts only
+  59 { /NDV xdef }
+  60 { /CDV xdef }
+  61 { /lenBuildCharArray xdef }
+.dicttomark readonly def
+
+/readPrivate {		% <font> <size> readPrivate -
+  2 dict begin
+  /PrivateStart pos def
+  f 3 1 roll exch 1 index f exch subfilefilter /f exch store
+  dup /FontType get exch
+  /Private get begin
+		% Default lenIV to -1 even for Type 1 CharStrings.
+  2 ne { /lenIV -1 def } if
+  //privatedictops Dict end
+  exch /f exch store advance
+  end
+} bind def
+
+/readSubrs {		% <font> readSubrs -
+  /Subrs Index put
+} bind def
+
+% ------ Main program ------ %
+
+% Clean up after finishing a font.
+/cleanupFont {		% (currentdict) cleanupFont -
+		% Remove unwanted entries.
+  currentdict /charset undef
+  currentdict /CharStringArray undef
+} bind def
+
+% Update the Encoding and CharStrings for a real font.
+/finishFont {		% (currentdict) finishFont -
+		% Construct the real Encoding.
+		% The value of Encoding is either a number, for predefined
+		% encodings, or an array of mixed GIDs and names.
+  /Encoding mark Encoding
+  DEBUG { (Encoding: ) print dup === flush } if
+  dup type /integertype eq {
+    StandardEncodings exch get { idname } forall
+  } {
+    {
+      dup type /integertype eq { charset exch get idname } if
+    } forall
+  } ifelse .packtomark def
+		% Construct the CharStrings.
+		% Note that they may only correspond to an initial
+		% subset of the charset.
+  /CharStrings charset length CharStringArray length .min dict def
+  DEBUG {
+    charset length =only ( charset ) print
+    CharStringArray length =only ( CharStringArray) =
+    charset == flush
+  } if
+  0 1 CharStrings maxlength 1 sub {
+    dup CharStringArray exch get
+    exch charset exch get idstring CharStrings xxput
+  } for
+  cleanupFont
+} bind def
+
+% Replace CharStrings with GlyphDirectory for a CIDFont;
+% Move GlobalSubrs to descendent fonts.
+/finishCIDFont {	% (currentdict) finishCIDFont -
+		% Construct the GlyphDirectory, similar to CharStrings.
+  /FDBytes FDArray length 1 gt { 1 } { 0 } ifelse def
+  /GlyphDirectory charset length CharStringArray length .min dict def
+  DEBUG {
+    charset length =only ( charset ) print
+    CharStringArray length =only ( CharStringArray) =
+    charset == flush
+  } if
+  0 1 GlyphDirectory maxlength 1 sub {
+    dup CharStringArray exch get
+		% If there is more than one FDArray entry, add the font
+		% index to the beginning of each charstring.
+    FDBytes 1 eq {
+      FDSelect 2 index get
+      1 string dup 0 4 -1 roll put exch concatstrings
+    } if
+    exch charset exch get GlyphDirectory xxput
+  } for
+
+  Private /GlobalSubrs .knownget {
+    FDArray {
+    /Private get /GlobalSubrs 2 index put
+    } forall
+    pop
+    Private /GlobalSubrs undef
+  } if
+
+		% Clean up.
+  currentdict /FDSelect undef
+  cleanupFont
+} bind def
+% We need to pass the file as a parameter for the sake of the PDF
+% interpreter. Also for the sake of PDF, a flag forces the font
+% to be defined as <resname> instead of the name embedded in the data.
+% This is needed for subsetted fonts; it is valid if the CFF
+% contains only a single font.
+/StartData {          % <resname> <nbytes> StartData -
+  currentfile exch subfilefilter false ReadData
+} bind def
+/ReadData {           % <resname> <file> <forceresname> ReadData -
+
+	% Initialize.
+
+  30 dict begin
+  /forceresname exch def
+  /cff exch def
+  /pos 0 def
+  /resname exch cvlit def
+  /DEBUG DEBUG def	% bring the binding closer
+
+	% Read the header.
+
+  /f cff def
+  /vmajor next def
+  /vminor next def
+  /hdrsize next def
+  /aoffsize next def
+
+	% Read the Indexes.
+
+  /names Index def
+  /topdicts Index def
+  /strings Index def
+  /gsubrs Index def
+
+	% Read the top Dicts.
+
+  /offsets 50 dict def
+  /queued [] def
+  /opdict null def		% reserve a slot
+  /fonts [ topdicts {
+    0 () /SubFileDecode filter /f exch def
+    40 dict begin
+		% Preload defaults that differ from PostScript defaults,
+		% or that are required.
+      /FontType 2 def
+      /PaintType 0 def
+      /FontMatrix [0.001 0 0 0.001 0 0] def
+      /charset StandardCharsets 0 get def
+      /Encoding 0 def
+      /FontInfo 10 dict
+	dup /UnderlinePosition -100 put
+	dup /UnderlineThickness 50 put
+      def
+      /Private 20 dict
+	gsubrs length 0 ne { dup /GlobalSubrs gsubrs put } if
+      def
+      //topdictops Dict
+    currentdict end
+  } forall ] def
+
+	% Read other tables with queued offsets.
+
+  DEBUG { (offsets: ) print [ offsets { pop } forall ] == } if
+  { /f cff def
+    DEBUG { (pos=) print pos = } if
+    offsets pos 2 copy .knownget not { pop pop exit } if
+    3 1 roll undef
+    DEBUG { (exec queued: ) print dup == } if
+    exec
+  } loop
+  offsets length 0 ne {
+    (Error: missing tables at ) print [ offsets { pop } forall ] ==
+    (Current position is ) print pos ==
+    flush stop
+  } if
+
+	% Process out-of-order tables.
+
+  DEBUG { queued length =only ( queued) = flush } if
+  queued { exec } forall
+
+	% Update Encoding and CharStrings.
+
+  fonts {
+    begin
+    currentdict /CIDFontType known { finishCIDFont } { finishFont } ifelse
+    end
+  } forall
+
+	% Wrap up.
+
+  resname mark 0 1 fonts length 1 sub {
+    DEBUG { dup =only ( ) print flush } if
+    dup names exch get
+    forceresname { pop resname } if
+    DEBUG { dup == flush } if
+    exch fonts exch get
+    dup /CIDFontType known {
+		% This is a CIDFont.
+      dup /CIDFontName 3 index put
+      1 index exch /CIDFont defineresource
+    } {
+		% This is a font.
+      dup /FontName 3 index put
+      1 index exch definefont
+    } ifelse
+  } for .dicttomark
+  end		% temporary dict
+  end		% FontSetInit ProcSet
+  /FontSet defineresource pop
+
+} bind def
+
+% ---------------- Resource category definition ---------------- %
+
+currentdict end readonly
+
+languagelevel exch 2 .setlanguagelevel
+
+/FontSet /Generic /Category findresource dup length dict .copydict
+/Category defineresource pop
+
+/FontSetInit exch /ProcSet defineresource pop
+
+.setlanguagelevel