HOME

Mini Shell 1.0
DIR:/usr/share/ghostscript/Resource/Init/
Current File : //usr/share/ghostscript/Resource/Init/gs_type1.ps
% Copyright (C) 2001-2018 Artifex Software, Inc.
% All Rights Reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc.,  1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%

% Type 1 font support code.

% The standard representation for PostScript compatible fonts is described
% in the book "Adobe Type 1 Font Format", published by Adobe Systems Inc.

/t1_glyph_equivalence mark   % Exported for pf2afm.ps
  /Odblacute /Ohungarumlaut
  /Udblacute /Uhungarumlaut
  /odblacute /ohungarumlaut
  /udblacute /uhungarumlaut
.dicttomark def

% Define an augmented version of .buildfont1 that inserts UnderlinePosition
% and UnderlineThickness entries in FontInfo if they aren't there already,
% and FontBBox isn't degenerate.
% (This works around the incorrect assumption, made by many word processors,
% that these entries are present in the built-in fonts.)
% Also add alternative names to some glyphs.
/.buildfont1
 {
   .currentglobal 3 1 roll
   dup .gcheck .setglobal
   dup .fontbbox {
     pop pop pop pop
     dup /FontInfo known not
      { .growfontdict dup /FontInfo 2 dict put }
     if
     dup dup /FontInfo get dup dup
     /UnderlinePosition known exch /UnderlineThickness known and
      { pop pop		% entries already present
      }
      { dup length 2 add dict .copydict
        dup /UnderlinePosition known not
         { dup /UnderlinePosition 3 index /FontBBox get
           1 get 2 div put 			% 1/2 the font descent
         }
        if
        dup /UnderlineThickness known not
         { dup /UnderlineThickness 3 index /FontBBox get
           dup 3 get exch 1 get sub 20 div put 	% 1/20 the font height
         }
        if
        1 index /FontInfo get wcheck not { readonly } if
        /FontInfo exch put
      }
     ifelse
   } if

   % We want to skip this process if we've already done it, and
   % not do it for embedded fonts.
   dup /.AGLprocessed~GS known not 1 index /PathLoad known and
   {
     dup /CharStrings get
     % Provide all known aliases for each glyph if
     % substitution is allowed (pf2afm.ps has code
     % to disables it by modifying t1_glyph_equivalence).
     t1_glyph_equivalence length 0 ne
     {
         % 16 byte scratch string
         % 16 bytes is arbitrary, but should be large enough to hold any "uniXXXX" style name
         //ReverseAdobeGlyphList //AdobeGlyphList 3 -1 roll
                                                             % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict)
         dup
         {                                                   % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) gname cstring
           exch dup                                          % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname gname
           4 index exch .knownget
           { //true}
           {                                                 % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname
             dup length 16 gt
             { //false }
             {
               % if we couldn't derive the code point from the AGL, we might derive it
               % from a formatted "uniXXXX" name.
               dup <00000000000000000000000000000000> cvs dup flush (uni) anchorsearch
               {
                 % as luck would have it, we can just replace the "uni" with "16#"
                 % to get something we can convert to a number
                 pop pop dup 0 (16#) putinterval {cvi} .internalstopped
                 { pop //false}
                 {                                             % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname cpoint
                   dup 5 index exch known
                   { //true }
                   { pop //false }
                   ifelse
                 } ifelse
               }
               { pop pop //false}
               ifelse
             } ifelse
           } ifelse

           {
                                                             % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname cpoint
             % loop through the array of names for this codepoint
             % if the CharStrings dict doesn't contain an entry for the name
             % create one.
             5 index exch .knownget
             {                                                   % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname aglnames(array)
               {                                                 % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname aglname
                 dup 4 index exch known not
                 {                                               % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname aglname
                   CFFDEBUG { (\nsetting alias: ) print dup ==only
                         ( to be the same as glyph: ) print 1 index //== exec } if
                   3 index exch 3 index .forceput
                                                                 % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname
                 }executeonly
                 {pop} ifelse
               } executeonly forall
               pop pop
             } executeonly
             {
               pop pop pop
             } ifelse
           } executeonly
           {
                                                               % scratch(string) RAGL(dict) AGL(dict) CharStrings(dict) cstring gname
             pop pop
           } ifelse
         } executeonly forall
         3 1 roll pop pop
     } executeonly if
     pop
     dup /.AGLprocessed~GS //true .forceput
   } executeonly if

   %% We need to excute the C .buildfont1 in a stopped context so that, if there
   %% are errors we can put the stack back sanely and exit. Otherwise callers won't
   %% be able to execute this redefinied .buildfont1 in a stopped context and still
   %% usefully continue (because the stack will be altered, which it shold not be).
   %%
   %% Uncovered working on bug #696306 and fixed as part of that bug.
   %%
   {//.buildfont1} stopped
   4 3 roll .setglobal
   {//.buildfont1 $error /errorname get signalerror} if
 } .bind executeonly def	% hide .forceput

% If the diskfont feature isn't included, define a dummy .loadfontdict.
/.loadfontdict where
 { pop }
 { /.loadfontdict 0 dict readonly def }
ifelse
/.loadfontfile		% <file> .loadfontfile -
 { mark exch

        % In order to load fonts reliably, we should push systemdict
        % here.  However, Ed Taft says that Adobe implementations
        % push userdict and nothing else!
        % We really would just like systemdict on the stack,
        % but fonts produced by Fontographer require a writable dictionary.
        % However, we can't use any of the other well-known dictionaries
        % (such as userdict), since the whole point of pushing systemdict
        % is to make sure that nothing important has been redefined.
   /userdict .systemvar begin
        % We can't just use `run', because we want to check for .PFB files.
   currentpacking
    { //false setpacking .loadfont1 //true setpacking }
    { .loadfont1 }
   ifelse
    end
    { stop } if
   cleartomark
 } bind def
 % container for CloseSource flag (default //true to prevent buildup of file handles)
 /closesourcedict mark
   /CloseSource //true
 .dicttomark readonly def
/.loadfont1 {		% <file> .loadfont1 <errorflag>
  {	% We would like to use `false /PFBDecode filter',
        % but this occasionally produces a whitespace character as
        % the first of an eexec section, so we can't do it.
        % Also, since the real input file never reaches EOF if we are using
        % a PFBDecode filter (the filter stops just after reading the last
        % character), we must explicitly close the real file in this case.
        % Since the file might leave garbage on the operand stack,
        % we have to create a procedure to close the file reliably.
    dup read not { -1 } if
    2 copy unread 16#80 eq {
        dup //closesourcedict //true /PFBDecode filter cvx
        exch .currentresourcefile eq {
          dup /.execasresource .systemvar
        } {
          {exec}
        } ifelse
        2 index cvlit
        /closefile .systemvar 3 .execn
      } {
        cvx exec
    } ifelse
  } stopped
} bind def
% undefine a dict that is only used internally, and is immediately bound
currentdict /closesourcedict .undef

% Here are the BuildChar and BuildGlyph implementation for Type 1 fonts.
% The names %Type1BuildChar and %Type1BuildGlyph are known to the interpreter.
% The real work is done in an operator:
%	<font> <code|name> <name> <charstring> .type1execchar -

(%Type1BuildChar)  cvn {	% <font> <code> %Type1BuildChar -
  1 index /Encoding get 1 index get .type1build .type1execchar
} bind def
(%Type1BuildGlyph) cvn {	% <font> <name> %Type1BuildGlyph -
  dup .type1build .type1execchar
} bind def
% Note: this procedure is used for both Type 1 and Type 2 fonts.
/.type1build {		% <font> <code|name> <name> .type1build
                        %   <font> <code|name> <name> <charstring>
  2 index begin
    dup CharStrings exch .knownget not {
      2 copy eq { exch pop /.notdef exch } if
       QUIET not
        { (Substituting .notdef for ) print
          =string cvs print ( in the font ) print
          1 index /FontName get = flush
        }
        { pop }
       ifelse
       /.notdef CharStrings /.notdef get
    } if
  end
} bind def

1183615869 internaldict begin
% CCRun is an undocumented procedure provided for Type 4 and Type 0 fonts.
% Apparently there are two different argument lists for CCRun.
% Handling the one with the extra Private dictionary requires fabricating
% a Type 1 font on the fly, since we aren't currently prepared to parse the
% dictionary any other way.
/CCRun {	% <font> <code|name> <charstring> CCRun -
                % <font> <code|name> <charstring> <Private> CCRun -
  dup type /dicttype eq {
    dup 4 index /Private .knownget { ne } { pop //true } ifelse {
                % The Private dictionary was supplied, and is different
                % from the Private dictionary of the font.  Fabricate a
                % Type 1 font with this Private dictionary.  Most of the
                % font entries are arbitrary or not needed.
      .currentglobal //false .setglobal 10 dict exch .setglobal begin
        /Private exch def
        /FontType 1 def
        /FontMatrix 3 index /FontMatrix get def
        /Encoding 3 index /Encoding .knownget not { StandardEncoding } if def
        /FontBBox 3 index /FontBBox .knownget not { {0 0 0 0} } if def
        /PaintType 0 def
        /CharStrings 1 dict dup /.notdef () put def
      3 -1 roll pop () currentdict end .buildfont1 exch pop 3 1 roll
    } {
      pop
    } ifelse
  } if
  1 index dup type /integertype eq {
    3 index /Encoding get exch get
  } if exch .type1execchar
} bind def

% setweightvector is an undocumented procedure that force writes
% weight vector to the font. Do extra checks for safety.
/setweightvector { % <font> <vector> setweightvector -
  dup type dup /arraytype ne exch /packedarraytype ne and
  2 index type /dicttype ne or {
    /setweightvector cvx /typecheck signalerror
  } if
  1 index /FontType known not {
    /setweightvector cvx /invalidfont signalerror
  } if
  dup gcheck 2 index gcheck not and {
    /setweightvector cvx /invalidaccess signalerror
  } if
  2 copy /WeightVector exch .forceput
  .setweightvector
} .bind executeonly odef
end

% Register the font types for definefont.
buildfontdict 1 /.buildfont1 cvx put
buildfontdict 4 /.buildfont4 cvx put

% Add Type 2 support if applicable.
/.buildfont2 where not { (%END2) .skipeof } if
pop
(%Type2BuildChar)  cvn {	% <font> <code> %Type2BuildChar -
  1 index /Encoding get 1 index get .type1build .type2execchar
} bind def
(%Type2BuildGlyph) cvn {	% <font> <name> %Type2BuildGlyph -
  dup .type1build .type2execchar
} bind def
buildfontdict 2 /.buildfont2 cvx put
%END2