summaryrefslogtreecommitdiff
path: root/Master/xemtex/gslib/pdfwrite.ps
blob: 922bfaafd1a1484125a6b99d810f79e9fd04b6e9 (plain)
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
%    Copyright (C) 1999, 2000, 2001 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: pdfwrite.ps,v 1.7.2.1.2.1 2003/04/12 14:02:39 giles Exp $
% Writer for transmuting PDF files.

% NOTES:
% We do editing by replacing objects (in the cache) and then doing a
%   simple recursive walk with object renumbering.
% Free variables:
%   RMap [per input file] (dict): input_obj# => output_obj#
%   PDFfile (file): current input file
%   OFile (file): current output file
%   XRef (dict): output_obj# => output_file_pos
%   ToWrite: 0..N-1 => [obj# gen#]

/.setlanguagelevel where { pop 2 .setlanguagelevel } if
.currentglobal true .setglobal

/PDEBUG where { pop } { /PDEBUG false def } ifelse

% ================ Object mapping ================ %

% Initialize the object number and location map.
/omapinit {		% - omapinit -
  /RMap 100 dict def
  /XRef 100 dict def
  PDEBUG { (omapinit) = } if
} def

% Map an object number.
/omapnew {		% <oldobj#> omap <newobj#> <isnew>
  RMap 1 index .knownget {
    exch pop false
  } {
    PDEBUG { (omap\() print dup =only } if
    RMap dup length 1 add 2 index exch dup 5 1 roll put pop true
    PDEBUG { (\) = ) print 1 index = } if
  } ifelse
} def
/omap {			% <oldobj#> omap <newobj#>
  omapnew pop
} bind def

% Save and restore the object map.
% Note that currentomap either returns a copy or calls omapinit.
/currentomap {		% <copy> currentomap <omap>
  {
    [RMap dup length dict copy XRef dup length dict copy]
  } {
    [RMap XRef] omapinit
  } ifelse
} bind def
/setomap {		% <omap> setomap -
  aload pop /XRef exch def /RMap exch def
  PDEBUG {
    (setomap: #Xref = ) print XRef length =only
    (, #RMap = ) print RMap length =
  } if
} bind def

% ================ Writing ================ %

% ---------------- Low-level output ---------------- %

% Write a string on the output file.
/ows {			% <string> ows -
  OFile exch writestring
} def

% ---------------- Scalars ---------------- %

% Note that the '#' character isn't legal in a name unless it is a prefix
% for a hex encoded character (for PDF 1.2 and later). The following assumes
% that the names are already valid PDF 1.2+ names so that  we can treat the
% '#' as a legal character. The next two hex characters are already in the
% set of valid name characters. PDF 1.1 and earlier allowed spaces in names
% which probably wouldn't make it past the tokenizer anyway.
/pdfnamechars
  (!"#$&'*+,-.0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\\^_`abcdefghijklmnopqrstuvwxyz|~)
readonly def
/pdfwritename {		% <name> pdfwritename -
  (/) ows .namestring {
    ( ) dup 0 4 -1 roll put
    //pdfnamechars 1 index search {
      pop pop pop
    } {
      pop 0 get 256 add 16 =string cvrs
      dup 0 (#) 0 get put
    } ifelse ows
  } forall
} def

% ---------------- Composite objects ---------------- %

/pdfwriteprocs mark
  /resolveR { pdfwriteref }
  /O { pdfwritenewref }
.dicttomark readonly def
/pdfwritearray {	% <array> pdfwritearray -
  dup xcheck {
    aload pop //pdfwriteprocs exch get exec
  } {
	% Because of a bug in Acrobat's parser for linearization parameters,
	% we have to include some whitespace after the opening [ (!).
    ([ ) ows { pdfwritevalue (\n) ows } forall (]) ows
  } ifelse
} def

/pdfwritedict {		% <dict> pdfwritedict -
  dup xcheck {
    pdfwritestream
  } {
    (<<) ows {
      exch pdfwritevalue ( ) ows pdfwritevalue (\n) ows
    } forall (>>) ows
  } ifelse
} def

% ---------------- References ---------------- %

/pdfwritenewref {	% <newobj#> pdfwritenewref -
  OFile exch write=only ( 0 R) ows
} def

/pdfwriteref {		% <obj#> <gen#> pdfwriteref -
  1 index omapnew {
    ToWrite dup length 5 -2 roll 2 packedarray put
  } {
    exch pop exch pop
  } ifelse
  pdfwritenewref
} def

/pdfcopystring 200 string def
/pdfwritestream {	% <streamdict> pdfwritestream -
	% Remove File, FilePosition, and StreamKey;
	% optimize by replacing an indirect Length.
  dup dup length dict copy
	% Stack: origdict dict
  dup /File undef dup /FilePosition undef dup /StreamKey undef
  dup /Length get dup oforce ne {
    dup /Length 2 copy oget put
  } if
  exch dup /File get dup 3 -1 roll /FilePosition get setfileposition
  pdfcopystream
} def

% We put copying the stream contents in separate procedures so that we
% can replace this function if desired.
/pdfcopybytes {		% <fromfile> <tofile> <length> pdfcopybytes -
  {
    dup 0 eq { exit } if
    //pdfcopystring 0 2 index 2 index length .min getinterval
    3 index exch readstring 3 1 roll
    3 index 1 index writestring length sub exch not { exit } if
  } loop pop pop pop
} def
/pdfcopystream {	% <newstreamdict> <file> pdfcopystream -
			%   (file has been positioned)
  1 index pdfwritevalue (stream\n) ows
  exch /Length get OFile exch pdfcopybytes
  (endstream) ows
} def

% ---------------- General values/objects ---------------- %

/pdfwritetypes mark
	% Scalars
  /nulltype { pop (null) ows }
  /integertype { =string cvs ows }
  /booleantype 1 index
  /realtype { OFile exch write===only }
  /stringtype 1 index
  /nametype { pdfwritename }
	% Composite/reference objects
  /arraytype { pdfwritearray }
  /packedarraytype 1 index
  /dicttype { pdfwritedict }
.dicttomark readonly def

/pdfwritevalue {	% <obj> pdfwritevalue -
  PDEBUG { (****Writing: ) print dup === flush } if
  //pdfwritetypes 1 index type get exec
} def

% We make pdfwriteobjdef a separate procedure for external use.
/pdfwriteobjheader {	% <newobj#> pdfwriteobjheader -
  XRef 1 index OFile .fileposition put
  PDEBUG { (XRef\() print dup =only (\) = ) print XRef 1 index get = } if
  OFile exch write=only ( 0 obj\n) ows
} def
/pdfwriteobjdef {	% <newobj#> <value> pdfwriteobjdef -
  exch pdfwriteobjheader
  pdfwritevalue (\nendobj\n) ows
} def
/pdfwriteobj {		% <obj#> <gen#> pdfwriteobj -
  1 index exch resolveR exch omap exch pdfwriteobjdef
} def

% ---------------- File-level entities ---------------- %

% Write a PDF file header.
% Free variables: OFile, PDFversion.
/pdfwriteheader {	% - pdfwriteheader -
  (%PDF-) ows OFile PDFversion write=
  (%\347\363\317\323\n) ows
} bind def

% Write a cross-reference table and trailer.
/pdfwritexref {		% <firstobj#> <#objs> pdfwritexref -
  (xref\n) ows
  OFile 2 index write=only ( ) ows OFile 1 index write=
  1 index add 1 sub 1 exch {
    dup 0 eq {
      pop (0000000000 65535 f \n) ows
    } {
      XRef exch get 1000000000 add =string cvs
      dup 0 (0) 0 get put
      ows ( 00000 n \n) ows
    } ifelse
  } for
} bind def
/pdfwritetrailer {	% <trailer> pdfwritetrailer -
  (trailer\n) ows pdfwritevalue (\n) ows
} bind def
/pdfwritestartxref {	% <startpos> pdfwritestartxref -
  (startxref\n) ows OFile exch write=
  (%%EOF\n) ows
} bind def

% ================ Top-level control ================ %

/pdfwrite {		% <file> <trailer> pdfwrite -
  10 dict begin
  /trailer exch def
  /OFile exch def
  /ToWrite 100 dict def
  omapinit

	% Write the PDF file header.

  pdfwriteheader

	% Write the objects.

  trailer {
    exch pop dup xcheck {	% The only executable objects are references.
      aload pop pop pdfwriteobj
    } {
      pop
    } ifelse
  } forall
	% Walk the object graph.
  {
    ToWrite dup length dup 0 eq { pop pop exit } if
    1 sub 2 copy get 3 1 roll undef aload pop pdfwriteobj
  } loop

	% Write the xref table and trailer.

  /xref OFile fileposition def
  0 XRef length 1 add pdfwritexref
  trailer dup length 1 add dict copy
  dup /Size XRef length 1 add put pdfwritetrailer
  xref pdfwritestartxref

  end
} def

.setglobal