home *** CD-ROM | disk | FTP | other *** search
/ Mixa 155: Dogs / MIXA 155: Dogs.iso / pc / Viewer / BROWSER(W) / フィルタ / PDF / LIB / pdf_font.ps < prev    next >
Encoding:
Text File  |  2002-10-29  |  24.7 KB  |  774 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  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: pdf_font.ps,v $ $Revision: 1.14 $
  7. % pdf_font.ps
  8. % PDF font operations.
  9.  
  10. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  11. .currentglobal true .setglobal
  12. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  13. GS_PDF_ProcSet begin
  14. pdfdict begin
  15.  
  16. % We cache the PostScript font in an additional element of the
  17. % font resource dictionary, called PSFont.
  18.  
  19. % ---------------- Encodings ---------------- %
  20.  
  21. % Apply a list of differences to an Encoding.
  22. % Note that the differences may cause the array to grow.
  23. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  24.     % Calculate the length of the result.
  25.   exch 0 2 index {
  26.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  27.   } forall
  28.   1 index length .max array dup 0 4 -1 roll putinterval
  29.   exch 0 exch {
  30.         % Stack: enc' code element
  31.     dup type /nametype ne
  32.       { exch pop }
  33.       { 3 copy put pop 1 add }
  34.     ifelse
  35.   } forall pop
  36. } bdef
  37.  
  38. % Get the Encoding for a font.
  39. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  40.  { /Encoding knownoget
  41.     { dup type /nametype eq
  42.        {
  43.          % The published PDF specification says the Encoding name
  44.          % "must be" one of the 3 predefined Encodings, implying
  45.          % that an error should occur if it isn't.  However, Acrobat
  46.          % Reader simply ignores unknown names, and since there are
  47.          % some buggy applications that rely on this, we do the same.
  48.  
  49.          dup dup dup /MacRomanEncoding eq
  50.          exch /MacExpertEncoding eq or 
  51.          exch /WinAnsiEncoding eq or
  52.            { exch pop findencoding
  53.            }
  54.            { pop
  55.            }
  56.          ifelse
  57.        }
  58.        { dup /BaseEncoding knownoget
  59.       { findencoding 3 -1 roll pop exch
  60.       }
  61.      if
  62.      /Differences knownoget { updateencoding } if
  63.        }
  64.       ifelse
  65.     }
  66.    if
  67.  } bdef
  68.  
  69. % Rename a font with a generated name.
  70. /renamefont {        % <fontdict> renamefont <font'>
  71.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  72. } bind def
  73.  
  74. % Adjust a font according to the Encoding and Widths in the font resource.
  75. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  76.   getfontencoding
  77.   getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  78. } bind def
  79.  
  80. % Get the (possibly modified) encoding of a font.
  81. /getfontencoding {    % <font-resource> <font> getfontencoding
  82.             %   <font-resource> <font> <Encoding|null>
  83.   1 index /Encoding known {
  84.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  85.   } {
  86.     null
  87.   } ifelse
  88. } bdef
  89.  
  90. % Get the metrics of a font, if specified.
  91. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  92.             %   <font-resource> <font> <Encoding|null>
  93.             %   <Metrics|null>
  94.   2 index /Widths known {
  95.     dup null eq { pop dup /Encoding get } if
  96.     4 dict begin
  97.       /Encoding exch def
  98.       /Metrics Encoding length dict def
  99.       exch
  100.       dup /Widths oget /Widths exch def
  101.         % Stack: font font-res
  102.         % Note that widths are always based on a 1000-unit
  103.         % character space, but the FontMatrix may specify
  104.         % some other scale factor.  Compensate for this here,
  105.         % by scaling the Widths if necessary.
  106.       0.001 2 index /FontMatrix get 0 get div
  107.         % Stack: font font-res mscale
  108.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  109.        {    % Stack: font font-res mscale first-char index
  110.      Encoding 1 index get
  111.      Widths 2 index 4 index sub oget
  112.          % Stack: font font-res mscale first-char index charname width
  113.      4 index mul
  114.         % There is a hack here to deal with encodings where the
  115.         % same character appears more than once, because the Metrics
  116.         % dictionary works by character name, not by character code.
  117.         % Because of this, we can't deal with Width vectors that
  118.         % specify different widths for the same character name
  119.         % appearing multiple times in the Encoding.
  120.      Metrics 2 index .knownget not { 0 } if 0 ne {
  121.        pop pop
  122.      } {
  123.         % Work around a bug in pdfTeX, which can generate Encoding
  124.         % vectors containing nulls.
  125.        1 index null ne {
  126.          Metrics 3 1 roll put
  127.        } {
  128.          pop pop
  129.        } ifelse
  130.      }
  131.      ifelse pop
  132.        }
  133.       for pop
  134.         % Now fill in the MissingWidth for any encoded characters
  135.         % that aren't in Metrics already.  Note that built-in
  136.         % fonts may have Widths/FirstChar/LastChar but no
  137.         % FontDescriptor, so we must check for this.
  138.         % Stack: font font-res mscale
  139.       1 index /FontDescriptor knownoget {
  140.     Metrics exch
  141.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  142.     Encoding {
  143.         % Stack: font font-res mscale missing-width metrics charname
  144.         % Work around the abovementioned pdfTeX bug.
  145.       dup null ne {
  146.         2 copy known not { 2 copy 4 index put } if pop
  147.       } {
  148.         pop
  149.       } ifelse
  150.     } forall pop pop pop
  151.       } {
  152.     pop
  153.       } ifelse
  154.     exch Encoding Metrics end
  155.   } {
  156.     null
  157.   } ifelse
  158. } bdef
  159.  
  160. % ---------------- Descriptors ---------------- %
  161.  
  162. % Partial descriptors for the 14 built-in fonts.  Note that
  163. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  164. % object has undergone a subtle change in its meaning which has serious
  165. % consequences for searching with Acrobat:
  166. % In PDF 1.1, the flag meant: Font has StandardEncoding
  167. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  168. /standardfontdescriptors mark
  169.   /Courier mark /Flags 16#23 .dicttomark
  170.   /Courier-Oblique 1 index
  171.   /Courier-Bold 1 index
  172.   /Courier-BoldOblique 1 index
  173.   /Helvetica mark /Flags 16#20 .dicttomark
  174.   /Helvetica-Oblique 1 index
  175.   /Helvetica-Bold 1 index
  176.   /Helvetica-BoldOblique 1 index
  177.   /Times-Roman mark /Flags 16#22 .dicttomark
  178.   /Times-Bold 1 index
  179.   /Times-Italic mark /Flags 16#62 .dicttomark
  180.   /Times-BoldItalic 1 index
  181.   /Symbol mark /Flags 16#4 .dicttomark
  182.   /ZapfDingbats 1 index
  183. .dicttomark readonly def
  184.  
  185. % ---------------- Utilities ---------------- %
  186.  
  187. % Fabricate a font name by adding ?'s on the end.
  188. /genfontname        % <name> genfontname <name>
  189.  { dup length string cvs
  190.     { (?) concatstrings
  191.       dup cvn FontDirectory exch known not { cvn exit } if
  192.     }
  193.    loop
  194.  } bdef
  195.  
  196. % Find a font, and adjust its encoding if necessary.
  197. /.pdfdfndict mark
  198.   /defaultfontname /Helvetica
  199. .dicttomark readonly def
  200. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  201.         % If the font isn't available, synthesize one based on
  202.         % its descriptor.
  203.   dup /Font resourcestatus {
  204.     pop pop findfont
  205.   } {
  206.     1 index /FontDescriptor knownoget {
  207.         % Stack: font-res fontname fontdesc
  208.       dup /Flags oget
  209.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  210.       1 index 16#40000 and -17 bitshift add    % 2, bold
  211.       exch 16#2 and 2 bitshift add    % 8, serif
  212.         % We should look at the fixed flag, too.
  213.         % Stack: font-res fontname fontdesc properties
  214.       1 index /FontName oget exch
  215.         % Analyzes font name and extract "Narrow" property
  216.         % which is not described by the FontDescriptor Flags.
  217.       0 2 index .fontnameproperties 4 and or
  218.         % Rebind the default font name to Helvetica so that
  219.         % fonts with no properties are handled correctly.
  220.       //.pdfdfndict begin .substitutefontname end
  221.         % Stack: font-res fontname fontdesc substname|null
  222.       Fontmap 1 index known not {
  223.         % No available good substitution, use the standard one.
  224.     pop 1 index .substitutefont
  225.       } if
  226.       QUIET not {
  227.     (Substituting font ) print dup =only
  228.     ( for ) print 2 index =only (.) = flush
  229.       } if
  230.       3 -1 roll pop findfont
  231.         % Stack: font-res fontdesc font
  232.         % If this is a small-caps font, replace the CharString
  233.         % entries for a..z.
  234.       exch /Flags oget 16#20000 and 0 ne {
  235.     true .copyfontdict
  236.     dup /CharStrings 2 copy get dup length dict .copydict
  237.     4 index /FirstChar get 97 .max
  238.     5 index /LastChar get 122 .min 1 exch {
  239.         % Stack: font-res font' font' /CharStrings charstrings code
  240.         % Note that this only remaps a-z, not accented characters.
  241.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  242.       1 string dup 0 5 -1 roll put
  243.         % Stack: font-res font' font' /CharStrings charstrings code
  244.         %   width (x)
  245.       2 index exch dup cvn exch
  246.       dup 0 2 copy get 32 sub put 4 -1 roll {
  247.             % Stack: operand (X) width
  248.         0 setcharwidth exch pop
  249.         currentfont /FontMatrix get matrix invertmatrix concat
  250.         0.7 dup scale 0 0 moveto show
  251.       } /exec cvx 4 packedarray cvx put
  252.     } for put
  253.     renamefont
  254.       } if
  255.     } {
  256.         % No descriptor available, use the default algorithm.
  257.       findfont
  258.     } ifelse
  259.   } ifelse adjustfont
  260. } bdef
  261.  
  262. % ---------------- Type 1 fonts ---------------- %
  263.  
  264. /buildType1        % <Type1-font-resource> buildType1 <font>
  265.  { dup /BaseFont get pdffindfont
  266.  } bdef
  267.  
  268. % The state dictionary for the embedded Type 1 font reading procedure
  269. % has the following keys and values:
  270. %    data - stream (filter)
  271. %    buffer, buffer2 - string
  272. %    hexify - procedure to convert buffer to hex if needed
  273. %    leftstr - string containing (non-negative) integer
  274. %    sectionstr - string containing a character 0 .. 2
  275. %    stream - (stream) dictionary
  276. %    proc - procedure of the form {-dict- type1read}
  277. % When the procedure is executing, this dictionary is current.
  278. % leftstr and sectionstr are strings so that we can change their values
  279. % reliably in case the font executes a restore!
  280. % We also have to do something special about embedded fonts that
  281. % execute definefont more than once -- that is the function of topFontDict.
  282.  
  283. % Read an embedded Type 1 font.
  284. /readfontfilter {    % <proc> readfontfilter <filter>
  285.   0 () /SubFileDecode filter
  286. } bdef
  287. /readtype1dict 5 dict dup begin
  288.   /definefont {
  289.     dup topFontDict eq topFontDict null eq or {
  290.       dup wcheck not { dup length dict copy } if
  291.       exch pop savedFontName exch
  292.     } if
  293.     //systemdict /definefont get exec
  294.   } bdef
  295.   /eexec {
  296.         % Assume the font dictionary is on the top of the stack.
  297.     count 0 gt { /topFontDict 1 index cvlit store } if
  298.     55665 /eexecDecode filter
  299.     //systemdict begin readtype1dictcopy begin cvx stopped
  300.     currentdict readtype1dictcopy eq { end } if
  301.     currentdict //systemdict eq { end } if
  302.      { stop } if
  303.   } bdef
  304. end readonly def
  305. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  306.         % Read the definition, using a procedure-based filter
  307.         % that turns binary/hex conversion on and off
  308.         % at the right times.
  309.    1 index exch
  310.    PDFfile fileposition 3 1 roll
  311.    10 dict begin
  312.      /leftstr (          ) 10 string copy def
  313.        dup /Length1 oget leftstr cvs pop
  314.      /sectionstr <00> 1 string copy def
  315.      /stream 1 index def
  316.      true resolvestream /data exch def
  317.      /buffer 1000 string def        % arbitrary
  318.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  319.      /hexify /buf2hex load def
  320.    currentdict end
  321.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  322.    readfontfilter
  323.         % Some buggy embedded fonts leave extra junk on the stack,
  324.         % so we have to make a closure that records the stack depth
  325.         % in a fail-safe way.
  326.    //systemdict begin
  327.         % The PDF specification is somewhat muddy about whether
  328.         % an embedded font's name is supposed to be the BaseFont
  329.         % from the Font object or the FontName from the descriptor.
  330.         % Acrobat Distiller requires the former.  Save away the
  331.         % name so we can substitute it at definefont time.
  332.    //readtype1dict dup length 3 add dict copy begin
  333.    1 index /BaseFont oget /savedFontName exch def
  334.    /topFontDict null def
  335.    /readtype1dictcopy currentdict def
  336.     { run } aload pop count 1 sub 2 packedarray cvx exec
  337.    end end
  338.    count exch sub { pop } repeat
  339.    PDFfile 3 -1 roll setfileposition
  340.    /BaseFont oget findfont
  341.    adjustfont
  342.  } bdef
  343.  
  344. % Execute the appropriate reading procedure.
  345. /type1read        % <dict> type1read <string>
  346.  { begin leftstr cvi
  347.     { type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  348.    (          ) leftstr copy cvs pop end
  349.  } bdef
  350.  
  351. % Read the next block of data into the buffer.
  352. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  353.  { 0 2 index 2 index length min getinterval
  354.         % Adobe requires readstring to signal an error if given
  355.         % an empty string.  Work around this nonsense here.
  356.    dup length 0 ne { data exch readstring pop } if
  357.    dup length 3 -1 roll exch sub
  358.    DEBUG
  359.     { dup =only ( read ) print
  360.       1 index length =only (: ) print
  361.       1 index == flush
  362.     } if
  363.  } bdef
  364.  
  365. % Read the next block of the initial text portion.
  366. /type1read1 {        % <left> type1read1 <string> <left'>
  367.   DEBUG { (read1 ) print } if
  368.   dup 0 eq {
  369.     pop sectionstr 0 1 put
  370.     stream /Length2 oget
  371.             % Determine whether to hexify data for eexec.
  372.     dup 8 lt {
  373.       type1read2    % Hexify.
  374.     } {
  375.       DEBUG { (read2 ) print } if
  376.       buffer2 type1readdata exch
  377.             % The check doesn't have to be 100% accurate:
  378.             % hexifying is always OK.
  379.       dup 0 8 getinterval 0 exch { or } forall
  380.       128 ge {
  381.     /hexify { } store
  382.     /buffer2 buffer def    % We don't need an intermediate buffer.
  383.       } if hexify exch
  384.     } ifelse
  385.   } {
  386.     buffer type1readdata
  387.   } ifelse
  388. } bdef
  389.  
  390. % Convert a string from binary to hex for eexec.
  391. % Free variables: buffer.
  392. /buf2hex {        % <string> buf2hex <hexstring>
  393.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  394.   buffer (>) search pop exch pop exch pop
  395. } bdef
  396.  
  397. % Read the next block of the encrypted portion.
  398. /type1trailer
  399. (0000000000000000000000000000000000000000000000000000000000000000\n\
  400. 0000000000000000000000000000000000000000000000000000000000000000\n\
  401. 0000000000000000000000000000000000000000000000000000000000000000\n\
  402. 0000000000000000000000000000000000000000000000000000000000000000\n\
  403. 0000000000000000000000000000000000000000000000000000000000000000\n\
  404. 0000000000000000000000000000000000000000000000000000000000000000\n\
  405. 0000000000000000000000000000000000000000000000000000000000000000\n\
  406. 0000000000000000000000000000000000000000000000000000000000000000\n\
  407. cleartomark\n)
  408. readonly def
  409. /type1read2 {        % <left> type1read2 <string> <left'>
  410.   DEBUG { (read2 ) print } if
  411.    dup 0 eq
  412.     { pop sectionstr 0 2 put
  413.       stream /Length3 oget
  414.       dup 0 eq
  415.        { DEBUG { (trailer ) print } if
  416.      type1trailer exch
  417.        }
  418.        { type1read3
  419.        }
  420.       ifelse
  421.     }
  422.     { buffer2 type1readdata exch hexify exch
  423.     }
  424.    ifelse
  425. } bdef
  426.  
  427. % Read the next block of the final text portion.
  428. % When finished, this procedure returns an empty string.
  429. /type1read3        % <left> type1read3 <string> <left'>
  430.  { DEBUG { (read3 ) print } if
  431.    buffer type1readdata
  432.  } bdef
  433.  
  434. % ---------------- Type 3 fonts ---------------- %
  435.  
  436. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  437.  
  438. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  439.   8 dict begin
  440.     /FontType 3 def
  441.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  442.     /FontBBox 1 index /FontBBox get cvx def
  443.     /FontMatrix 1 index /FontMatrix oget def
  444.     /CharProcs 1 index /CharProcs oget def
  445.     1 index /Widths knownoget {
  446.       /Widths exch def
  447.       /FirstChar 1 index /FirstChar oget def
  448.       /LastChar 1 index /LastChar oget def
  449.     } if
  450.     /FontName 1 index /Name get genfontname def
  451.     /Encoding .notdefEncoding 2 index getencoding def
  452.         % We have to define BuildChar rather than BuildGlyph:
  453.         % there is no PDF equivalent of glyphshow, and we need
  454.         % the character code to access the Widths.
  455.     /BuildChar {
  456.         % Stack: font charcode
  457.       1 index begin 3 dict begin
  458.       /Font 3 -1 roll def /CharCode 1 index def
  459.       Encoding exch get CharProcs exch oget
  460.       PDFfile fileposition exch
  461.       false resolvestream
  462.         % Stack: filepos stream
  463.         % Don't let setgcolor set the color inside the BuildGlyph
  464.         % procedure, because this causes an /undefined error.
  465.       q null /FillColor gput null /StrokeColor gput
  466.       Font /Resources get exch pdfopdict .pdfruncontext
  467.       Q
  468.       PDFfile exch setfileposition
  469.       end end
  470.     } bdef
  471.     FontName currentdict end definefont exch pop
  472. } bdef
  473. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  474.   /Widths where {
  475.     begin
  476.     CharCode FirstChar ge CharCode LastChar le and {
  477.       exch pop Widths CharCode FirstChar sub get exch
  478.     } if end
  479.   } if
  480. } bdef
  481.  
  482. % ---------------- TrueType fonts ---------------- %
  483.  
  484. /TTfonts mark
  485.   /Arial /Helvetica
  486.   /Arial,Italic /Helvetica-Oblique
  487.   /Arial,Bold /Helvetica-Bold
  488.   /Arial,BoldItalic /Helvetica-BoldOblique
  489.   /CourierNew /Courier
  490.   /CourierNew,Bold /Courier-Bold
  491.   /TimesNewRoman /Times-Roman
  492.   /TimesNewRoman,Italic /Times-Italic
  493.   /TimesNewRoman,Bold /Times-Bold
  494.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  495. .dicttomark readonly def
  496.  
  497. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  498.   dup /BaseFont get
  499.   dup TTfonts exch .knownget {
  500.     exch pop
  501.         % Hack required by the PDF specification: if the
  502.         % font resource has Subtype = /TrueType but the actual
  503.         % (installed) font is not a TrueType font, ignore the
  504.         % Encoding in the font resource.  However, all current
  505.         % versions of Acrobat Reader have the 14 base TrueType
  506.         % fonts built in, so this produces incorrect output for
  507.         % badly designed PDF files that specify these file names
  508.         % with /Subtype = /TrueType but no embedded definition.
  509.         % Compensate for this by removing the /Subtype key when
  510.         % looking up the font.
  511.     exch dup length dict copy dup /Subtype null put exch
  512.   } if pdffindfont
  513. } bdef
  514.  
  515. % Read an embedded TrueType font.
  516. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  517.         % This is much simpler than readtype1, because we don't
  518.         % have to deal with the tripartite .PFB format.
  519.   1 index exch
  520.   PDFfile fileposition 3 1 roll
  521.   true resolvestream readfontfilter
  522.         % Stack: filepos fontres stream
  523.   1 index /Subtype get /CIDFontType2 eq {
  524.     .loadttcidfont
  525.         % Stack: filepos fontres cidfont
  526.     1 index /CIDToGIDMap knownoget {
  527.       dup /Identity eq {
  528.     pop
  529.       } {
  530.     true resolvestream
  531.         % The following doesn't work for CIDToGIDMaps with more
  532.         % than 32K-1 entries.  We'll fix it later if necessary.
  533.         % Stack: filepos fontres font mapstream
  534.     dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
  535.     exch dup length 5 add dict .copydict
  536.     dup /FID undef
  537.     dup /CIDMap 4 -1 roll put
  538.     dup /CIDFontName get exch /CIDFont defineresource
  539.       } ifelse
  540.     } if
  541.   } {
  542.     null 2 index getencoding .loadpdfttfont
  543.   } ifelse
  544.   exch pop
  545.   PDFfile 3 -1 roll setfileposition
  546.         % Ignore both the Encoding and the Widths.
  547.   exch pop
  548. } bdef
  549.  
  550. % ---------------- Type 0 fonts ---------------- %
  551.  
  552. % Predefine the known CMaps, but only create them on demand.
  553. /knownCMaps mark
  554.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  555.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  556. .dicttomark def
  557.  
  558. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  559.   .currentglobal true .setglobal 3 1 roll
  560.   /CIDInit /ProcSet findresource begin
  561.   12 dict begin
  562.     begincmap
  563.     /WMode exch def
  564.     /CMapName exch def
  565.     /CIDSystemInfo 3 dict dup begin
  566.       /Registry (Adobe) def
  567.       /Ordering (Japan1) def
  568.       /Supplement 0 def
  569.     end def
  570.     %/CMapName (see above)
  571.     /CMapVersion 1 def
  572.     /CMapType 1 def
  573.     %WMode (see above)
  574.     % The PDF documentation says that these CMaps map CIDs
  575.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  576.     1 begincodespacerange
  577.     % <0001> <00ff>  <0100> <ffff>
  578.       <0000> <ffff>
  579.     endcodespacerange
  580.     1 begincidrange
  581.     % <0001> <00ff> 1   <0100> <ffff> 256
  582.       <0000> <ffff> 0
  583.     endcidrange
  584.     endcmap
  585.     CMapName currentdict /CMap defineresource
  586.     knownCMaps CMapName 2 index put
  587.   end        % CMap
  588.   end        % CIDInit ProcSet
  589.   exch .setglobal
  590. } bdef
  591.  
  592. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  593.   dup /BaseFont get    % FontName
  594.   1 index /Encoding oget
  595.   dup type /nametype eq {
  596.     dup /CMap resourcestatus {
  597.     pop pop /CMap findresource
  598.     } {
  599.     knownCMaps 1 index .knownget
  600.       { exch pop exec } { /undefined signalerror } ifelse
  601.     } ifelse
  602.   } {
  603.     PDFfile fileposition exch
  604.     dup /CMapName get exch true resolvestream cvx exec
  605.     /CMap findresource
  606.     exch PDFfile exch setfileposition
  607.   } ifelse        % CMap
  608.   [
  609.     3 index /DescendantFonts oget { exec resourcefont } forall
  610.   ]            % subfonts
  611.   composefont
  612.         % Stack: fontres font
  613.   1 index /FontMatrix knownoget {
  614.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  615.       1 index exch makefont exch /FontName get exch definefont
  616.     } {
  617.       pop
  618.     } ifelse
  619.   } if exch pop
  620. } bdef
  621.  
  622. % ---------------- CIDFontType0/2 fonts ---------------- %
  623.  
  624. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  625. % arrays and using a (currently very inefficient) CDevProc.
  626. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  627.   dup length 5 add dict .copydict
  628.   dup /FID undef
  629.   dup /UniqueID undef
  630.   dup /XUID undef
  631.     % Insert the widths into the font.
  632.   {W W2 DW DW2} {
  633.     % Stack: pdfresource newfont key
  634.     2 index 1 index .knownget {
  635.       2 index 3 1 roll put
  636.     } {
  637.       pop
  638.     } ifelse
  639.   } forall
  640.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  641.   exch pop
  642. } bdef
  643.  
  644. % Apply the [D]W[2] metrics to a character before displaying.
  645. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  646.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  647.             %   <w0x'> ... <vy'>
  648.   begin
  649.     % Look up and apply [D]W
  650.   10 index
  651.   currentdict /DW .knownget { 1000 div exch pop } if
  652.   currentdict /W .knownget {
  653.     % Search the W array for the CID.
  654.     % ****** NOT IMPLEMENTED YET ******
  655.     pop
  656.   } if
  657.   0 13 2 roll 11 -2 roll pop pop
  658.     % Look up and apply [D]W2
  659.     % ****** NOT IMPLEMENTED YET ******
  660.   pop end
  661. } bdef
  662.  
  663. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  664.   dup /BaseFont get /CIDFont findresource
  665.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  666. } bdef
  667.  
  668. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  669.   dup /BaseFont get /CIDFont findresource
  670.   addCIDmetrics dup /BaseFont get exch /CIDFont defineresource
  671. } bdef
  672.  
  673. % ---------------- Other embedded fonts ---------------- %
  674.  
  675. /fontloadprocs mark
  676.   /Type1C /readType1C cvx
  677.   /CIDFontType0C /readCIDFontType0C cvx
  678. .dicttomark readonly def
  679.  
  680. % Read an embedded compressed font.
  681. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  682.   1 index exch
  683.   PDFfile fileposition 3 1 roll
  684.   dup true resolvestream dup readfontfilter
  685.         % Stack: pos resource streamdict stream filter
  686.   3 index /FontDescriptor oget /FontName oget
  687.   1 index FRD
  688.   closefile closefile pop
  689.   PDFfile 3 -1 roll setfileposition
  690.   /FontDescriptor oget /FontName oget findfont
  691.   adjustfont
  692. } bdef
  693.  
  694. % Read an embedded CFF CIDFont.
  695. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  696.   PDFfile fileposition 3 1 roll
  697.   dup true resolvestream dup readfontfilter
  698.         % Stack: pos resource streamdict stream filter
  699.   3 index /FontDescriptor oget /FontName oget
  700.   1 index FRD
  701.   closefile closefile pop
  702.   PDFfile 3 -1 roll setfileposition
  703.         % Some broken Adobe software produces PDF files in which
  704.         % the FontName of the CFF font and the FontName in the
  705.         % FontDescriptor don't match the BaseFont in the font.
  706.         % Use the FontName, rather than the BaseFont, here.
  707.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  708.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  709. } bdef
  710.  
  711. % ---------------- Font lookup ---------------- %
  712.  
  713. /fonttypeprocs mark        % <font-resource> -proc- <font>
  714.   /Type0 /buildType0 cvx
  715.   /Type1 /buildType1 cvx
  716.   /MMType1 1 index
  717.   /Type3 /buildType3 cvx
  718.   /TrueType /buildTrueType cvx
  719.   /CIDFontType0 /buildCIDType0 cvx
  720.   /CIDFontType2 /buildCIDType2 cvx
  721. .dicttomark readonly def
  722.  
  723. /resourcefont            % <font-resource> resourcefont <font>
  724.  { dup /PSFont .knownget
  725.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  726.     { false }
  727.    ifelse
  728.     { /PSFont get
  729.     }
  730.     { dup dup /FontDescriptor knownoget
  731.        {    % Stack: font-res font-res font-desc
  732.      dup /FontFile knownoget
  733.       { exch pop readtype1 true }
  734.       { dup /FontFile2 knownoget
  735.          { exch pop readtruetype true }
  736.          { /FontFile3 knownoget
  737.         { dup /Subtype get fontloadprocs exch get exec true }
  738.         { false }
  739.            ifelse
  740.          }
  741.         ifelse
  742.       }
  743.      ifelse
  744.        }
  745.        { false }
  746.       ifelse
  747.         % Stack: font-res font-res false
  748.         %  -or-: font-res font true
  749.       not
  750.        { dup /Subtype get fonttypeprocs exch get exec }
  751.       if
  752.       2 copy /PSFont exch put
  753.       exch pop
  754.     }
  755.    ifelse
  756.  } bdef
  757.  
  758. drawopdict begin
  759.   /d0 {
  760.     .adjustcharwidth setcharwidth
  761.   } bdef
  762.   /d1 {
  763.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  764.   } bdef
  765.   /Tf {
  766.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  767.     resourcefont exch Tf pop
  768.   } bdef
  769. end
  770.  
  771. end            % pdfdict
  772. end            % GS_PDF_ProcSet
  773. .setglobal
  774.