File: gs_fapi.ps

package info (click to toggle)
ghostscript 8.71~dfsg2-9+squeeze1
  • links: PTS, VCS
  • area: main
  • in suites: squeeze
  • size: 79,896 kB
  • ctags: 80,654
  • sloc: ansic: 501,432; sh: 25,689; python: 4,853; cpp: 3,633; perl: 3,597; tcl: 1,480; makefile: 1,187; lisp: 407; asm: 284; xml: 263; awk: 66; csh: 17; yacc: 15
file content (344 lines) | stat: -rw-r--r-- 11,469 bytes parent folder | download | duplicates (2)
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
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
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
%    Copyright (C) 2000 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.
% 
% For more information about licensing, please refer to
% http://www.ghostscript.com/licensing/. For information on
% commercial licensing, go to http://www.artifex.com/licensing/ or
% contact Artifex Software, Inc., 101 Lucas Valley Road #110,
% San Rafael, CA  94903, U.S.A., +1(415)492-9861.

% $Id: gs_fapi.ps 8954 2008-08-08 04:22:38Z ray $
% Redefine Font and CIDFont categories with FAPI-handeled fonts.

systemdict /.FAPIavailable known { .FAPIavailable } { false } ifelse not {
  (%END FAPI) .skipeof
} if

languagelevel 2 .setlanguagelevel

%====================================================================
% Redefine Font category with FAPIfontmap and CIDFont with FAPIfontmap :
15 dict begin    % a temporary dictionary for local binding.

/EmbedFontObjectsQuery mark
  /.EmbedFontObjects 0
.dicttomark def

/is_device_compatible_to_FAPI    % - is_device_compatible_to_FAPI <bool>
{ currentdevice //EmbedFontObjectsQuery .getdeviceparams               % <mark> <name> <value> ...
  dup mark eq {
    pop true
  } {
    exch pop exch pop 0 eq
  } ifelse
  % The code above assumes that only the requested parameter is rendered.
  % The commented-out code below may be useful for general case.
  % Keeping it for a while.
  % counttomark 2 idiv {
  %   exch /.EmbedFontObjects eq {
  %     counttomark 1 add 1 roll cleartomark
  %     0 eq exit
  %   } if
  % } repeat
  % dup mark eq {
  %   pop true
  % } if
} bind def

%----------------------------- Process FAPIconfig -----------------------

/Config
<<
  systemdict /FAPIconfig known {/FAPIconfig .systemvar} {(FAPIconfig)} ifelse .runlibfile
  /ServerOptions 2 dict
>> def
systemdict /.FAPIconfig //Config put

()
systemdict /UFST_SSdir .knownget {
  (UFST_SSdir=) exch concatstrings concatstrings
} if
systemdict /UFST_PlugIn .knownget {
  1 index length 0 ne {
    exch .filenamelistseparator concatstrings exch
  } if
  (UFST_PlugIn=) exch concatstrings concatstrings
} if
dup length 0 ne {
  //Config /ServerOptions get exch /UFST exch put
} { 
  pop
} ifelse

%------------------Copy the FontEmulationProcs here : -------------------

/FontEmulationProcs /ProcSet findresource {
  def
} forall

currentdict /super.complete_instance currentdict /complete_instance get put

%-----------FAPI-specific methods for category redefinition : -----------

/RefinePath      % <FontDict> /key RefinePath <FontDict>
{ exch begin
  //Config exch get
  /Path exch
  Path false .file_name_combine not {
    exch
    (Can't combine paths ) print print ( and ) print =
    /RefinePath cvx /configurationerror signalerror
  } if
  def
  currentdict end
} bind def

/complete_instance  % <font_name> <FontDict> <Options> complete_FAPI_Font <font_name> <FontDict>
{ //super.complete_instance exec
  dup /CIDFontName known { /CIDFontPath } { /FontPath } ifelse //RefinePath exec
} bind def

/IsMyRecord      % <raw_record> -> <raw_record> bool
{ dup type /dicttype eq { dup /FAPI known } { false } ifelse
} bind def

/IsActive       % <record> IsActive <bool>
{ pop //is_device_compatible_to_FAPI exec
} bind def

/FontRecordVirtualMethods //RecordVirtualMethodsStub dup length 2 add dict copy begin
  /IsActive //IsActive def
  /MakeInstance   % <Name> <record> MakeInstance <Name> <Instance> <size>
  { currentglobal 3 1 roll true setglobal
    //FontOptions //complete_instance exec
    2 copy //GetSize exec
    4 3 roll setglobal
  } bind def
currentdict end def

/CIDFontRecordVirtualMethods //RecordVirtualMethodsStub dup length 3 add dict copy begin
  /GetCSI //TranslateCSI def
  /IsActive //IsActive def
  /MakeInstance   % <Name> <record> MakeInstance <Name> <Instance> <size>
  { currentglobal 3 1 roll true setglobal
    //CIDFontOptions //complete_instance exec
    2 copy //GetSize exec
    4 3 roll setglobal
  } bind def
currentdict end def

/ReadFCOfontmap:   % <path> ReadFCOfontmap: name dict ...
{ /fontfile exch def
  {
    currentfile =string readline not {
      pop exit
    } if
    dup length 0 ne {
      0 () /SubFileDecode filter
      dup token not {
        % A comment line
        closefile
      } {
        dup /EndFCOfontmap cvx eq {
          pop closefile exit
        } if
        exch dup token not {
          /ReadFCOfontmap: cvx /rangecheck signalerror
        } if
        exch dup token not {
          /StandardEncoding
        } {
          dup type /nametype ne {
            /ReadFCOfontmap: cvx /rangecheck signalerror
          } if
        } ifelse
        findencoding                  
        exch dup token not {
          null
        } {
          dup type /nametype ne {
            /ReadFCOfontmap: cvx /rangecheck signalerror
          } if
          /Decoding findresource
        } ifelse                     
        exch closefile                 % index name enc dec|null
        4 3 roll                       % name enc dec|null index 
        << /Path fontfile
           /FontType 1 
           /FAPI /UFST 
           /SubfontId counttomark 2 add -1 roll 
           /Decoding  counttomark 2 add -1 roll
           dup null eq {
             pop pop
           } if
           /Encoding  counttomark 2 add -1 roll
        >> % dup { exch == = } forall
      } ifelse
    } {
      pop
    } ifelse
  } loop
  currentdict /fontfile undef
} bind def


%----------------------------------The Redefintion---------------------

/MappedCategoryRedefiner /ProcSet findresource /Redefine get /Redefine exch def

% Redefine the /Font category :
4 dict begin
  /CategoryName /Font def
  /MapFileName systemdict /FAPIfontmap known {/FAPIfontmap .systemvar} {(FAPIfontmap)} ifelse def
  /VerifyMap  { pop } bind def
  /PreprocessRecord  % <map> <Name> <raw_record> PreprocessRecord <map> <Name> <record> <bool>
  { //IsMyRecord exec dup {
      pop dup /RecordVirtualMethods //FontRecordVirtualMethods put
      true
    } if
  } bind def
currentdict end Redefine

% Redefine the /CIDFont category :
4 dict begin
  /CategoryName /CIDFont def
  /MapFileName systemdict /FAPIcidfmap known {/FAPIcidfmap .systemvar} {(FAPIcidfmap)} ifelse def
  /VerifyMap  { pop } bind def
  /PreprocessRecord  % <map> <Name> <raw_record> PreprocessRecord <map> <Name> <record> <bool>
  { //IsMyRecord exec dup {
      pop dup /RecordVirtualMethods //CIDFontRecordVirtualMethods put
      true
    } if
  } bind def
currentdict end Redefine

%==================== A hook for buildfont* operators ====================

% The procedure .FAPIhook redirects PS fonts to FAPI on necessity.
% This depends on the following conditions :
%
% 1. If font dictionary has /FAPI entry, it is a font listed in FAPIconfig.FontPath,
%    and must be build with .FAPIrebuildfont, or a copy of a font, which was
%    built with .FAPIrebuildfont .
%
% 2. If the font dictionary has /PathLoad entry, and has no /FAPI entry,
%    it is an installed PS font, which is described in lib/fontmap or
%    in GS_FONTPATH. .loadfont inserts /PathLoad entry for this case
%    (see gs_fonts.ps).
%
%    Installed fonts are being loaded with GS font loader,
%    the they are passed to FAPI is same way as embedded fonts are.
%    We do so because UFST cannot read fonts, which don't
%    follow Type 1/42 file format strongly.
%
% 3. Executing .loadfont, we place /FAPI_hook_disable in the 0th
%    element of some procedure on the execution stack - see gs_fonts.ps .
%    If FAPI_hook finds /FAPI_hook_disable in there, 
%    it knows that it is called for a disk font during 
%    its internal definefont.
%
% 4. If font dictionary has no /FAPI entry, and has no /Path entry,
%    and if we are not in .loadfont context, it is an embedded font.
%
% 5. Two entries to be defined in lib/FAPIconfig to control the hooking of PS fonts :
%    HookDiskFonts and HookEmbeddedFonts .
%    They specify arrays of font types (integers) to be redirected with FAPI.
%    HookDiskFonts controls disk PS fonts (which fall into (2) and (3) ).
%    HookEmbeddedFonts controls fonts being embedded into documents.
%
% 7. We apply the operator .passtoFAPI for checking whether FAPI can handle a font. 
%    If so, we insert /FAPI entry into the font dictionary and convert it
%    with .FAPIrebuildfont . Otherwise the font is handled with the native GS font renderer.

/FAPI_hook_debug   % <proc> FAPI_hook_debug -
FAPIDEBUG { {exec} } { {pop} } ifelse
bind def
 
/FAPI_hook_warn   % <proc> FAPI_hook_debug -
QUIET { {pop} } { {exec} } ifelse
bind def
 
/FAPI_is_hook_disabled     % - FAPI_is_hook_disabled <bool>
{ % checks whether execution stack contains packedarray started with /FAPI_hook_disable .
  /FAPI_hook_disable /MappedCategoryRedefiner /ProcSet findresource /execstack_lookup get exec
  null ne
} bind def

/FAPIhook_aux  %      <string|name> <font_dict> .FAPIhook <string|name> <font>
{                                                     % name <<font>>
  { (FAPIhook ) print 1 index = } //FAPI_hook_debug exec
  dup /FAPI known {
    { //PrintFontRef exec ( is mapped to FAPI=) print dup /FAPI get = } //FAPI_hook_warn exec
    true //.FAPIrebuildfont //ChooseDecoding exec
  } {
    dup /PathLoad known dup {
      { (PathLoad known for the font ) print //PrintFontRef exec (.) = } //FAPI_hook_debug exec
    } {
      pop //FAPI_is_hook_disabled exec dup
      { pop
        { (FAPIhook is in .loadfont context for the font ) print //PrintFontRef exec (.) = } //FAPI_hook_debug exec
        true
      } if
    } ifelse
    { /HookDiskFonts } { /HookEmbeddedFonts } ifelse
    //Config exch get                                  % name <<font>> [types]
    1 index //GetFontType exec //FindInArray exec      % name <<font>> bHook
    { { (Trying to render the font ) print //PrintFontRef exec ( with FAPI...) = } //FAPI_hook_debug exec
      //.FAPIpassfont {
        { //PrintFontRef exec ( is being rendered with FAPI=) print dup /FAPI get = } //FAPI_hook_warn exec
        false //.FAPIrebuildfont //ChooseDecoding exec
      } {
        { (Can't render ) print //PrintFontRef exec ( with FAPI, will do with native GS renderer.) = } //FAPI_hook_warn exec
      } ifelse
    } {
      { (The font ) print //PrintFontRef exec ( doesn't need to render with FAPI.) = } //FAPI_hook_debug exec
    } ifelse
  } ifelse
} bind def

/FAPIhook  %      <string|name> <font_dict> .FAPIhook <string|name> <font>
{ //is_device_compatible_to_FAPI exec
  { //FAPIhook_aux exec
  } {
    { (FAPIhook is disabled for the current device.) = } //FAPI_hook_debug exec
  } ifelse
} bind def

% ------------------ Redefine .buildfont* with FAPI : -----------------------

/.buildfont1
{ //.buildfont1 exec //FAPIhook exec
} bind % 'odef' is below.

/.buildfont2
{ //.buildfont2 exec //FAPIhook exec
} bind % 'odef' is below.

/.buildfont42
{ //.buildfont42 exec //FAPIhook exec
} bind % 'odef' is below.

/.buildfont9
{ //.buildfont9 exec //FAPIhook exec
} bind % 'odef' is below.

/.buildfont10
{ //.buildfont10 exec //FAPIhook exec
} bind % 'odef' is below.

/.buildfont11
{ //.buildfont11 exec //FAPIhook exec
} bind % 'odef' is below.

end % the temporary dictionary for local binding.
odef odef odef odef odef odef

.setlanguagelevel

%END FAPI