summaryrefslogtreecommitdiff
path: root/Master/xemtex/gslib/ps2ai.ps
blob: 15bb6fef67523da99727dd37398144ce3a75c20d (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
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
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
%!
%    Copyright (C) 1994 , 1999 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: ps2ai.ps,v 1.2.6.1.2.1 2003/04/12 14:02:39 giles Exp $
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%
%   ps2ai.ps - a postscript to editable adobe illustrator file filter
%
/vers {2.14} def                  %                    January 31, 1999

% conditional def ( if the key is already defined before, don't 
% redefine it. This can be used by other programs to overwrite
% some settings from externally
%  
/cdef { 1 index where { pop pop pop } { def } ifelse } def
%
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%
% needs a postscript level 2 interpreter, like gnu ghostscript, to work
%
%      Usage:   gs -q -dNODISPLAY ps2ai.ps file.ps > file.aips
%                              or (see below)
%               gs -q -dNODISPLAY ps2ai.ps file.ps
%                              or
%               cat ps2ai.ps file.ps | lpr  (then look in log file)
%
% or from within gsview via:
% 	Edit->Convert to vector format
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%                            Options
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%   Output Options: directly to a file or standard out
%
/jout false cdef            % true=file  false=stdout (default=false)
/joutput (ps2ai.out.aips) cdef      % Name of Output file
%
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%
%              Other Options
%
/jtxt3 true cdef           % output text in AI3 form (false=ai88)
                          % for coreldraw/photoshop readable output
/joutln false cdef         % use font outline  instead of font
/jerr false def            % use error handling (ie die gracefully)
/jbiterr false def         % attempt to handle bitmap fonts (kludge)
/jMacGS false def         % true if using MacGS (not fully implemented yet)
/jMacfix true def         % convert filled boxes to lines (only usefull with
                          % laserwriter 8 postscript input)

%
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%                    No options below here
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%
%         - Notes -
%  ai uses cmykcolor, so level 1 interpreters don't work
%  ai doesn't use image/imagemask - so bitmaps don't work correctly
%  the output file has a header so it is viewable/printable/reconvertable
%
% Comments, suggestions, bug-fixes, etc send to:
%
%        Jason Olszewski (olszewsk@splash.princeton.edu)
%
% anonymous ftp: toby.princeton.edu /pub/olszewsk/ps2ai.ps
%       URL ftp://toby.princeton.edu/pub/olszewsk
%
%         - Fix History -
%  2.14 added cdef to allow overwriting of certain values from externally
%  2.13 check for bitmap fonts, work better with TeX,WinPS,etc
%  2.12 fixed initclip to US letter size page
%  2.11 added header support for *u/*U compound paths
%  2.1  option of font outline instead of text(gwhite@trevnx.bio.dfo.ca)
%  2.0  major change to complex path handling
%  1.9  fixed text leaking ascii (,),\
%  1.85 added default font to handle no setfont (Courier)
%  1.84 added even-odd fill/clip (D)
%  1.83 undefined PPD PageSize printer specific info
%  1.82 added kludge to save clipping status through a restore
%  1.81 added custom color/gray support to header (x/X, g/G)
%  1.8  added newpath if clippath is not consumed correctly(amiga)
%  1.79 eliminated scientific notation of numbers less than 0.0001
%  1.78 fixed transposed h & H
%  1.77 made laserwriter 8 fixes optional
%  1.76 added margin fix for unix AI (brown@wi.extrel.com)
%  1.75 added kludge to handle bitmap font errors (TeX, Windows.ps)
%  1.74 made grestore a little smarter
%  1.73 included header handle encoded fontname (/_fontname)
%  1.72 fixed problem with restore/clip info - (not enough Qs problem)
%  1.71 filter font names to remove previous encoding (|,_,etc)
%  1.7  change text format to AI3, works better with PS & CD
%  1.67 deal with weird makefonts 
%  1.66 handle to many bad stroke/fills (s s s w/o paths)
%  1.65 more useable with non-gs interpreters (defaultmatrix fix)
%  1.64 fixed "smart grestore" repeat bug
%  1.63 fixed ashow/awidthshow bug
%  1.62 check if cmykcolor is understood otherwise rgb
%  1.61 made grestore smarter (only print if different)
%  1.6  add better compatibility to CorelDraw and PhotoShop
%  1.53 make it more gs-backward compatible (clarke@lsl.co.uk)
%  1.52 handle clipping paths a little better (Posted)
%  1.51 improve mac lw8 output (lines instead of filled boxes)
%  1.5 handle some level 2 stuff (mac lw8)
%  1.4 fixed scaling of linewidth and dash
%  1.31 made trailer more AI88 friendly
%  1.3 add ablity to output to file directly
%  1.21 print matrix cleaner
%  1.2 fix rotated fonts, thanks to G.Cameron (g.cameron@biomed.abdn.ac.uk)
%  1.1 fix stroke/fill color difference (k vs K)
%  1.0 posted to comp.lang.postscript
%
%         - To Do List -
%  find real %%BoundingBox: llx lly urx ury
%  make MacGS friendly (line-endings)
%  handle eps w/o showpage:(append to end)
%  write out image data to external file
%
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
%                  Nothing of Interest below here
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
matrix identmatrix setmatrix %   make ctm [1 0 0 1 0 0]
/oldgsave {} def /oldgrestore {} def
/initgraphics {} def /initmatrix {} def 
% undefine PPD PageSizes to be more printer independant
/letter {} def /legal {} def /a4 {} def /b5 {} def /lettersmall {} def
/setpagedevice { pop } def % for level 2 PPD PageSizes
/Courier findfont 12 scalefont setfont % handle no setfont
/initclip {0 0 moveto 0 792 lineto 612 792 lineto 612 0 lineto closepath
           clip newpath } def
/xdef {exch def} def
/trx {transform exch} def
/cbdef {cvx bind def} def
/jltz {dup abs 0.0001 lt {pop 0} if} def % get rid of scientific notation bug
/clstate false def        % closepath state
/dpth false def           % destroy path (ie newpath)
/fclp false def           % first paint after clip
/kscl {1.0} def           % default current scale X-factor
/gcnt {1} def             % graphics state counter
/spth {1} def             % multiple paths on stack
/jeol (\n) def            % default end-of-line
/jnump {0} def            % number of paths on stack
/jx {0} def /jy {0} def /j_ax {0} def
/j3ftxt true def
/clarry 10 array def
0 1 9 {clarry exch false put} for % initilize no clipping path
%
% handle cmyk color on level 1 interpreters
/setcmykcolor where {pop}
 {/setcmykcolor {
   /blk exch def /yel exch def /mag exch def /cyan exch def
   /ccomp {add dup 1 gt {pop 1} if} def
   /red {1 cyan blk ccomp sub} def
   /green {1 mag blk ccomp sub} def
   /blue {1 yel blk ccomp sub} def
   red green blue setrgbcolor
  } def
} ifelse
/currentcmykcolor where {pop}
 {/currentcmykcolor {
   currentrgbcolor /bval xdef /gval xdef /rval xdef
   /rawC 1 rval sub def /rawM 1 gval sub def /rawY 1 bval sub def
   rawC rawM ge { rawY rawM ge { /blk rawM def} if } if
   rawC rawY ge { rawM rawY ge { /blk rawY def} if } if
   rawY rawC ge { rawM rawC ge { /blk rawC def} if } if
   rawY rawC eq { rawM rawC eq { /blk rawC def} if } if
   /cyan  rawC blk sub  def
   /mag  rawM blk sub  def
   /yel  rawY blk sub  def
   /blk blk def
   cyan mag yel blk
  } def
} ifelse
% If using Mac Ghostscript 
jMacGS { 
%        /jeol {(\r) jp} def
        /jout true def
        (%%Note: Loading ps2ai.ps\n) print
       } if
/jstr 40 string def
jout {joutput (w) file /joutput xdef} if
%
%              Output
%
jout {/jp { joutput exch writestring } bind def }{/jp {print}bind def} ifelse
/jpnum {jltz ( ) jp =string cvs jp } bind def
/jpmat { dup /jarry exch def length 1 sub /j_num exch def
 (\[) jp 0 1 j_num {jarry exch get jpnum} for (\]) jp } def
%
%              Stack to Paths converters
%
/ckpnt { % check which paint and clipping to use
   dpth {  % if there are multiple paths on the stack
  clarry gcnt get fclp and {clstate {(h W\n) jp }{(H W\n) jp } ifelse} if
  spth 0 eq {clstate {(n\n) jp }{(N\n) jp } ifelse} if
  spth 1 eq {clstate {(s\n) jp }{(S\n) jp } ifelse} if
  spth 2 eq {clstate {(f\n) jp }{(F\n) jp } ifelse} if
     } if
} def
/jpm {
  ckpnt
  /dpth true def
  transform 2 copy /yst xdef /xst xdef exch jpnum jpnum ( m\n) jp } bind def
/jpl { trx jpnum jpnum ( l\n) jp } bind def
/jpc {  6 4 roll trx jpnum jpnum 4 2 roll trx jpnum jpnum trx
    jpnum jpnum ( c\n) jp } bind def
/jpp {xst jpnum yst jpnum ( l\n) jp /clstate true def} def
/cntpaths { % count paths on stack
  oldgsave
  {pop pop /jnump jnump 1 add def} {pop pop} {6 {pop} repeat}{} pathforall
  oldgrestore
} def
/ppforall {
 cntpaths % find out how many paths are on the stack
 jnump 1 gt { (*u\n) jp } if
 {jpm}{jpl}{jpc}{jpp} pathforall 
  ckpnt
 jnump 1 gt { (*U\n) jp } if
 /jnump 0 def /clstate false def /dpth false def /fclp false def
  oldnewpath
} bind def
%
%              Painting Operators
%
/oldnewpath [/newpath load] cbdef
/newpath { (\n) jp /spth 0 def ppforall} def 
/stroke { (\n) jp /spth 1 def ppforall } def 
/fill   {(\n) jp /spth 2 def ppforall } def 
/eofill {(1 D\n) jp fill (0 D\n) jp} def
/clip {clarry gcnt get {(Q\nq\n) jp}{(q\n) jp} ifelse 
                   /fclp true def clarry gcnt true put} def
/eoclip {(1 D\n) jp clip (0 D\n) jp} def
%
%               Text Operators
%
/oldshow [/show load] cbdef
/curpt {stringwidth pop jx add jy} def 
/jNN {dup 0 eq {pop oldgsave currentfont /FontMatrix get setmatrix kscl
                oldgrestore} if
} def
/curftmatrix {
 currentfont /FontMatrix get dup 0 get jNN abs /norm exch def 
 dup 0 get norm div exch dup
 1 get norm div exch dup 2 get norm div exch dup 3 get norm div exch dup
 4 get exch 5 get 6 array astore matrix currentmatrix matrix concatmatrix
} def
% AI does not support negitive font sizes
/curftsize {currentfont /FontMatrix get 0 get jNN abs 1000 mul} def
/hstr (X) def
/vbar (|) 0 get def /undsc (_) 0 get def
/ftnamefix { % handle font names with |,_ (previously encoded)
jstr cvs
{ %forall
        dup vbar eq {pop}{ %ifelse
            dup undsc eq {pop}{ %ifelse
                    hstr exch 0 exch put hstr jp
            } ifelse
        } ifelse
   } forall   flush
} bind def
%/curftname {currentfont /FontName get ftnamefix}def
/curftname { currentfont /FontName known {currentfont /FontName get}
           { (Times-Roman)} ifelse ftnamefix } def
/lftpar (\() 0 get def
/rhtpar (\)) 0 get def
/bckslsh (\\) 0 get def
/handft { % handle strings with (,),\
   (\() jp
   { %forall
        dup lftpar eq { (\\\() jp }{ %ifelse
            dup rhtpar eq { (\\\)) jp }{ %ifelse
                dup bckslsh eq { (\\\\) jp }{ %ifelse
                    hstr exch 0 exch put hstr jp
                } ifelse
            } ifelse
        } ifelse
   } forall (\)) jp flush
} bind def
% AI 3 text format pieces
jtxt3 {
/j3txt { j3ftxt {(0 Ts 100 Tz 0 Tt 0 TA 0 0 5 TC 100 100 200 TW 0 0 0 Ti\n) jp
                (0 Ta 0 Tq 0 0 TI 0 Tc 0 Tw\n) jp} if } def
/show {oldgsave  (0 To\n) jp 
  currentpoint 2 copy /jy exch def /jx exch def translate 
  curftmatrix /jitm exch def
  0 1 5 {jitm exch get jpnum} for ( 0 Tp\n) jp (TP\n) jp
  (0 Tr\n) jp (\/_) jp curftname  curftsize jpnum ( Tf\n) jp
  (0) jp j_ax  curftsize div 100 mul jpnum ( 100 TC\n) jp %  percent(?)
  dup curpt moveto mark exch handft ( Tx\n) jp (TO\n) jp /j3ftxt false def
  cleartomark currentpoint oldgrestore moveto
} def  
/ashow {exch pop exch /j_ax exch def show /j_ax {0} def } def
} 
 {
/show {oldgsave (u\n) jp currentpoint 2 copy /jy exch def /jx exch def translate
  (\/) jp curftname jstr cvs jp
  curftsize dup jpnum  jpnum ( 0 0 z\n) jp
  curftmatrix jpmat ( e\n) jp
  dup curpt moveto mark exch handft ( t T U\n) jp
  cleartomark currentpoint oldgrestore moveto} def
/ashow {oldgsave (u\n) jp currentpoint translate (\/) jp curftname jstr cvs jp
  curftsize dup jpnum jpnum  exch kscl mul jpnum ( 0 z\n) jp
  curftmatrix jpmat ( e\n) jp dup curpt moveto mark exch handft
  ( t T U\n) jp cleartomark currentpoint oldgrestore moveto} def
} ifelse
/widthshow { show pop pop pop} def
/awidthshow {ashow pop pop pop} def
/kshow {show pop} def
%/show {true charpath fill} bind def   % get outline of charactor
joutln {/show { true charpath currentpoint 
     /jy exch def /jx exch def fill jx jy moveto} bind def} if
%/show {oldshow} def    % do nothing different
%
%               Color Operators
%
/oldsetcmykcolor [/setcmykcolor load] cbdef
/setcmykcolor {oldsetcmykcolor 
currentcmykcolor 4 -1 roll jpnum 3 -1 roll jpnum 2 -1 roll jpnum jpnum ( k\n) jp
currentcmykcolor 4 -1 roll jpnum 3 -1 roll jpnum 2 -1 roll jpnum jpnum ( K\n) jp
 } def
/oldsetgray [/setgray load] cbdef
/setgray {0 0 0 4 -1 roll 1 exch sub setcmykcolor} def
/oldsethsbcolor [/sethsbcolor load] cbdef
/sethsbcolor {oldsethsbcolor currentcmykcolor setcmykcolor} def
/oldsetrgbcolor [/setrgbcolor load] cbdef
/setrgbcolor {oldsetrgbcolor currentrgbcolor /bval xdef /gval xdef /rval xdef
 /rawC 1 rval sub def /rawM 1 gval sub def /rawY 1 bval sub def
 rawC rawM ge { rawY rawM ge { /blk rawM def} if } if
 rawC rawY ge { rawM rawY ge { /blk rawY def} if } if
 rawY rawC ge { rawM rawC ge { /blk rawC def} if } if
 rawY rawC eq { rawM rawC eq { /blk rawC def} if } if
 /cyan  rawC blk sub  def
 /mag  rawM blk sub  def
 /yel  rawY blk sub  def
 /blk blk def
 cyan mag yel blk setcmykcolor } def
%
%                State Operators
%
/oldsetlinewidth [/setlinewidth load] cbdef
/setlinewidth {kscl abs mul jltz  oldsetlinewidth
 currentlinewidth jpnum ( w\n) jp } def
/oldsetlinecap [/setlinecap load] cbdef
/setlinecap {dup oldsetlinecap jpnum ( J\n) jp} def
/oldsetlinejoin [/setlinejoin load] cbdef
/setlinejoin {dup oldsetlinejoin jpnum ( j\n) jp} def
/oldsetmiterlimit [/setmiterlimit load] cbdef
/setmiterlimit {dup oldsetmiterlimit jpnum ( M\n) jp}def
/oldsetdash [/setdash load] cbdef
/setdash {exch [ exch {kscl abs mul} forall ] exch kscl abs mul oldsetdash
  currentdash exch jpmat jpnum ( d\n) jp } def
/oldsetflat [/setflat load] cbdef
/setflat {dup oldsetflat jpnum ( i\n) jp } def
%
%                More State Operators
%
/kscl { % use just the x scale factor
 oldgsave
 matrix currentmatrix /jctm exch def
 jctm 4 0 put jctm 5 0 put jctm setmatrix
 1 0 moveto currentpoint transform
 dup mul exch dup mul add sqrt 10000 mul round 10000 div
 oldgrestore
} def
/currentstate {currentcmykcolor setcmykcolor
 currentflat jpnum ( i) jp currentlinecap jpnum ( J) jp
 currentlinejoin jpnum ( j) jp currentlinewidth jpnum ( w) jp
 currentmiterlimit jpnum ( M ) jp currentdash exch jpmat jpnum ( d\n) jp 
} def
/jdifG {
 currentcmykcolor /jok xdef /joy xdef /jom xdef /joc xdef
 currentflat /jof xdef currentlinecap /jolc xdef currentlinejoin /jolj xdef
 currentlinewidth /jolw xdef currentmiterlimit /joml xdef
 currentdash /jood xdef /joad xdef
 oldgrestore
 currentcmykcolor /jnk xdef /jny xdef /jnm xdef /jnc xdef
 currentflat /jnf xdef currentlinecap /jnlc xdef currentlinejoin /jnlj xdef
 currentlinewidth /jnlw xdef currentmiterlimit /jnml xdef
 currentdash /jnod xdef /jnad xdef
 % compare old gstate to new gstate
 joc jnc ne jom jnm ne joy jny ne jok jnk ne
 jof jnf ne jolc jnlc ne jolj jnlj ne jolw jnlw ne joml jnml ne 
 false joad {true exit} forall {pop pop true}{false} ifelse
 false jnad {true exit} forall {pop pop true}{false} ifelse ne
 jood jnod ne 10 {or} repeat {currentstate} if
} def
/oldgsave [/gsave load] cbdef
/gsave {oldgsave /gcnt gcnt 1 add def } def % clarry gcnt false put} def
%  (%%Note:gsave ) jp gcnt jpnum (\n) jp} def
/oldgrestore [/grestore load] cbdef
/grestore {dpth {newpath} if clarry gcnt get {(Q\n) jp clarry gcnt false put} if 
 jdifG /gcnt gcnt 1 sub def } def
% oldgrestore currentstate } def
% (%%Note:grestore ) jp gcnt 1 add jpnum (\n) jp} def
/oldrestore [/restore load] cbdef
% a kludgy way of saving the clipping path status information
/restore {clarry aload pop 11 -1 roll oldrestore clarry astore pop} def
/showpage {  0 1 9 {clarry exch get {(Q\n) jp} if } for
 (%%Note: If Error, make sure there are matched pairs of 'q's and 'Q's\n) jp
 (%%Note: in the file. Add 'Q's before '%%Trailer' until equal\n) jp
 (%%Trailer\n) jp
 jtxt3 {(Adobe_IllustratorA_AI3 /terminate get exec\n) jp
        (Adobe_typography_AI3 /terminate get exec\n) jp
        (Adobe_customcolor /terminate get exec\n) jp
        (Adobe_cshow /terminate get exec\n) jp
        (Adobe_cmykcolor /terminate get exec\n) jp
        (Adobe_packedarray /terminate get exec\n) jp
}{
        (Adobe_Illustrator881 /terminate get exec\n) jp
        (Adobe_customcolor /terminate get exec\n) jp
        (Adobe_cshow /terminate get exec\n) jp
        (Adobe_cmykcolor /terminate get exec\n) jp
        (Adobe_packedarray /terminate get exec\n) jp 
       } ifelse
( showpage\n%EOF\n%%EndDocument\n) jp
 jout {joutput closefile} if jMacGS not {quit} if /j3ftxt true def } def 
%
%                Error handling
%
errordict begin
% Attempt to handle the error caused by bitmap fonts (TeX,Windows.ps,etc)
% this is a big-time kludge
jbiterr {
 /undefined {pop pop (Times-Roman)} def
 /typecheck {pop pop} def
} if
jerr {
 /handleerror {
  (%%Note: ps2ai error, aborting rest of conversion\n) jp showpage
 } def
} if
end
%
%                Mac LW 8 improvements
%
/jmacimp { % stroked line instead of thin filled boxes
 /@a {  3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll add exch moveto
      3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll exch sub exch lineto
      abs setlinewidth  stroke pop pop} def
 /@b { 3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll add exch moveto
      pop
      3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll add exch lineto
      abs setlinewidth  stroke} def
 /endp {showpage pm restore} def % because the restore stops clean up
} def
%
%                Handle (some) PS Level 2
%
/rectstroke { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto
  closepath stroke} def
/rectfill { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto
  fill } def
/rectclip { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto
  closepath clip newpath jMacfix {jmacimp} if } def
%
% Add a header prolog to the output file so it is still view/print-able
%
(%!PS-Adobe-2.0 EPSF-1.2\n%%BoundingBox: 0 0 612 792\n) jp
(%%Title: Adobe Illustator 3 Editable Document\n) jp
(%%Creator: ps2ai.ps vers.) jp vers jpnum ( \(C\) 1993-94 Jason Olszewski\n) jp
(%%TemplateBox: 0 0 612 792\n) jp
jtxt3 {(%%AI3_Margin:0 0 0 0\n) jp } if
(%%EndComments\n) jp
(%%BeginProlog\n) jp
(/m {moveto} def /l {lineto} def /c {curveto} def\n) jp
(/S {stroke} def /F {fill} def\n) jp
(/s {closepath S} def /f {closepath F} def\n) jp
(/q {gsave} def /Q {grestore} def /W {clip} def /k {setcmykcolor} def\n) jp
(/i {setflat} def /J {setlinecap} def /j {setlinejoin} def\n) jp
(/w {setlinewidth} def /M {setmiterlimit} def /d {setdash} def\n) jp
(/u {gsave} def /U {grestore} def /K {k} def\n) jp
(/N {newpath} def /n {closepath N} def\n) jp
(/g {setgray} def /G {g} def\n) jp
(/x {pop pop k} def /X {x} def\n) jp
(/H {} def /h {H closepath} def /D {pop} def\n) jp
(/*u { /N {/spth 0 def}def /S{/spth 1 def}def /F {/spth 2 def} def} def\n) jp
(/*U { spth 0 eq {newpath} if spth 1 eq {stroke} if spth 2 eq {fill} if\n) jp
(     /N {newpath} def /S {stroke} def /F {fill} def  } def\n) jp
%(\n) jp
jtxt3 {
 (/TC {pop pop pop} def /Tr {pop} def\n) jp
 (/To {pop gsave} def /TO {grestore} def\n) jp
 (/Tp {pop matrix astore concat} def  /TP {0 0 moveto} def\n) jp
 (/a_str 40 string def /cnt 0 def /h_str (X) def /undsc (_) 0 get def\n) jp
 (/fntfix {a_str cvs dup length 1 sub /f_str exch string def\n) jp
 (  {dup undsc eq {pop}{f_str cnt 3 -1 roll put /cnt cnt 1 add def\n) jp
 (  } ifelse } forall flush /cnt 0 def f_str cvn } bind def\n) jp

 (/Tf {exch fntfix findfont exch scalefont setfont} def /Tx {show} def\n) jp
}{
 (/z {pop pop pop exch findfont exch scalefont setfont} def\n) jp
 (/e {concat 0 0 m} def /t {show} def /T {} def\n) jp
} ifelse
(\n) jp
jtxt3 {
 (userdict /Adobe_packedarray 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_cmykcolor 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_cshow 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_customcolor 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_typography_AI3 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_IllustratorA_AI3 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
}{
 (userdict /Adobe_packedarray 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_cmykcolor 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_cshow 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_customcolor 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
 (userdict /Adobe_Illustrator881 2 dict dup begin put\n) jp
 (/initialize {} def /terminate {} def\n) jp
} ifelse
(%%EndProlog\n) jp
(%%BeginSetup\n) jp
jtxt3 {
 (Adobe_packedarray /initialize get exec\n) jp
 (Adobe_cmykcolor /initialize get exec\n) jp
 (Adobe_cshow /initialize get exec\n) jp
 (Adobe_customcolor /initialize get exec\n) jp
 (Adobe_typography_AI3 /initialize get exec\n) jp
 (Adobe_IllustratorA_AI3 /initialize get exec\n) jp
}{
 (Adobe_packedarray /initialize get exec\n) jp
 (Adobe_cmykcolor /initialize get exec\n) jp
 (Adobe_cshow /initialize get exec\n) jp
 (Adobe_customcolor /initialize get exec\n) jp
 (Adobe_Illustrator881 /initialize get exec\n) jp
} ifelse
(%%EndSetup\n) jp
0 0 0 1 oldsetcmykcolor
currentstate

jout {(%%Note: Load Postscript file to be converted now\n) print} if