File: gs_ciddc.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 (224 lines) | stat: -rw-r--r-- 8,374 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
%    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  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_ciddc.ps 9834 2009-07-03 09:27:02Z ken $
% Define SubstCID, Decoding and CIDDecoding resource categories and related procsets.

languagelevel 2 .setlanguagelevel
currentglobal true setglobal

%----------------ParseDecoding procset----------------------------

/ParseDecoding <<

/Parse    % <resource_name> <num_tokens> Parse -
{ dict begin                                  % /ResName
  0                                           % /ResName nCode
  { currentfile token not {
      exit
    } if                                      % /ResName nCode token
    dup type /integertype eq {                % /ResName nCode
       exch pop
    } {
      1 index def                             % /ResName nCode
    } ifelse
  } loop                                      % /ResName nCode
  pop                                         % /ResName
  currentdict end /Decoding                   % /ResName <<inst>> /Decoding
  defineresource pop
} bind

>> /ProcSet defineresource pop

%----------------Decoding category----------------------------

/Generic /Category findresource dup length dict copy
dup /InstanceType /dicttype put
/Decoding exch /Category defineresource pop

%----------------ParseCMap_Inverse procset----------------------------

/ParseCMap_Inverse <<
  /findresource { pop } bind
  /defineresource { pop pop } bind
  /dict {}
  /def { pop pop } bind
  /dup null
  /begin { pop } bind
  /end {}
  /currentdict null
  /CMapName null
  /usecmap { pop } bind
  /begincmap {}
  /endcmap {}
  /begincodespacerange { pop mark } bind
  /endcodespacerange { cleartomark } bind
  /beginnotdefrange { pop mark } bind
  /endnotdefrange { cleartomark } bind
  /beginbfchar { pop mark } bind
  /endbfchar { pop mark } bind
  /beginbfrange { begincidrange }
  /endbfrange { endcidrange }
  /begincidchar { beginbfchar }
  /endcidchar { endbfchar }
  /begincidrange { pop mark } bind
  /endcidrange  { cleartomark } bind
>>  % Just keep it on stack for a while.

% Now we define another dict for local binding, than merge it with the previous one :
dup length 5 add dict begin

  /.Ranges 40 dict def % Key = CID/256, value = array of 256 integer codes.
  //.Ranges /CIDCount 0 put

  /.StringToInt     % <string> .StringToInt <integer>
  { 0 exch { exch 8 bitshift add } forall
  } bind def

  /.SetCouple    % <I> <b> .SetCouple -
  { exch                                    % b I
    dup 256 idiv                            % b I I0
    dup //.Ranges exch known not {
      dup //.Ranges exch 256 array put
    } if                                    % b I I0
    //.Ranges exch get                      % b I [Range]
    exch 256 mod                            % b [Range] I1
    2 copy get                              % b [Range] I1 e
    dup //null ne {
      % We've got char code duplicates for same CID.
      dup type /integertype eq {
        4 3 roll                            % [Range] I1 e b
        2 array astore put                  %
      } {
        dup length 1 add dup dup array dup  % b [Range] I1 D l l D' D'
        3 2 roll 0 exch getinterval         % b [Range] I1 D l D' D''
        4 3 roll exch copy pop              % b [Range] I1 l D'
        dup 3 2 roll 1 sub                  % b [Range] I1 D' D' l-1
        6 5 roll                            % [Range] I1 D' D' l-1 b
        put put                             %
      } ifelse
    } {
      pop 3 2 roll put                      %
    } ifelse
  } bind def

  /endcidrange
  { % Writes the inversed CMap to .Ranges
    counttomark 3 idiv {                    % (b) (e) I
      exch .StringToInt                     % (b) I e
      3 2 roll .StringToInt                 % I e b
      % Note : this code does't handle multidimentional CID ranges.
      % fixme : optimize below.
      dup 3 2 roll exch sub 1 add           % I b d
      { 2 copy //.SetCouple exec            % I b
        1 add exch 1 add exch
      } repeat                              % I b
      pop                                   % I
      dup //.Ranges /CIDCount get gt {      % I
        dup //.Ranges exch /CIDCount exch put
      } if                                  % I
      pop
    } repeat
    pop % mark
  } bind def

  /.GetCIDDecoding         % - .GetCIDDEcoding <dict>
  { //.Ranges dup length dict copy
    //.Ranges //.PurgeDict exec
    //.Ranges /CIDCount 0 put
  } bind def

currentdict end
exch copy % Merge the dicts - see above.
/ProcSet defineresource pop

%----------------CIDDecoding category----------------------------
% Note that we put all instances in global memory - see FindResource.

/Generic /Category findresource dup length dict copy
begin
  /Category /CIDDecoding def
  /InstanceType /dicttype def

  /.CMapChooser <<
    % This lists CMaps to inverse and unite for creating a CIDDecoding.
    % Choose by FAPIcidfmap.Registry concatenated with TrueType encoding ID.
    % Font renderer must provide the glyph substitution internally.

    /CNS1.Big5       [ /ETen-B5-H /ETen-B5-V ]
    /CNS1.Unicode    [ /UniCNS-UCS2-H /UniCNS-UCS2-V]
    /GB1.GB2312      [ /GBK-EUC-H /GBK-EUC-V ]
    /GB1.Unicode     [ /UniGB-UCS2-H /UniGB-UCS2-V ]
    /Japan1.ShiftJIS [ /90ms-RKSJ-H /90ms-RKSJ-V ]
    /Japan1.Unicode  [ /UniJIS-UCS2-H  /UniJIS-UCS2-V]
    /Japan2.ShiftJIS [ /90ms-RKSJ-H /90ms-RKSJ-V ]
    /Japan2.Unicode  [ /UniHojo-UCS2-H ]
    /Korea1.Johab    [ /KSC-Johab-V /KSC-Johab-H ]
    /Korea1.Wansung  [ /KSCms-UHC-V /KSCms-UHC-H ]
    /Korea1.Unicode  [ /UniKS-UCS2-H /UniKS-UCS2-V ]
    /Identity.Symbol [ /Identity-H /Identity-V ]
    /Unicode.Unicode [ /Identity-UTF16-H ]
    /Identity.Unicode [ /Identity-UTF16-H ]
  >> def

  /.MakeInstance    % <name> .MakeInstance <inst>
  { dup                                              % /Name /Name
    //.CMapChooser exch .knownget not {
      (Can't build /) print =string cvs print ( /CIDDecoding resource. See gs_ciddc.ps . ) =
      /findresource cvx /undefinedresource signalerror
    } if                                             % /Name [CMaps]
    exch pop                                         % [CMaps]
    /CMap /Category findresource                     % [CMaps] <CMapCategory>
    /ParseCMap_Inverse /ProcSet findresource         % [CMaps] <CMapCategory> <PCI>
    3 2 roll {                                       % <CMapCategory> <PCI> /CMapName
      3 2 roll begin                                 % <PCI> /CMapName
      dup .ResourceFile not {
        (Can't find CMap ) print =string cvs print ( building a CIDDecoding resource. ) =
        /findresource cvx /undefinedresource signalerror
      } if
      currentdict end exch                           % <PCI> /CMapName <CMapCategory> file

      3 index begin
      cvx exec                                       % <PCI> /CMapName <CMapCategory>
      end
      exch pop exch                                  % <CMapCategory> <PCI>
    } forall
    exch pop begin                                   %
    .GetCIDDecoding
    end
  } bind def

  /FindResource      % <name> FindResource <dict>
  { currentglobal exch                               % bGlobal /InstName
    true setglobal
    dup //.MakeInstance exec                         % bGlobal /InstName <Inst>
    DefineResource                                   % bGlobal <Inst>
    exch setglobal                                   % <Inst>
  } bind def

currentdict end
/CIDDecoding exch /Category defineresource pop

%----------------SubstCID category----------------------------

/Generic /Category findresource dup length dict copy
begin
  /Category /SubstCID def
  /InstanceType /dicttype def
currentdict end
/SubstCID exch /Category defineresource pop

setglobal
.setlanguagelevel