197 lines
3.8 KiB
PostScript
197 lines
3.8 KiB
PostScript
%
|
|
% Redefiniton of the PostScript file output operators so results go to paper.
|
|
% Complicated and slow, but the implementation doesn't place many demands on
|
|
% included PostScript. About all that's required is gentle treatment of the
|
|
% graphics state between write calls.
|
|
%
|
|
|
|
/#copies 1 store
|
|
/aspectratio 1 def
|
|
/font /Courier def
|
|
/formsperpage 1 def
|
|
/landscape false def
|
|
/magnification 1 def
|
|
/orientation 0 def
|
|
/pointsize 10 def
|
|
/rotation 1 def
|
|
/xoffset .1 def
|
|
/yoffset .1 def
|
|
|
|
/roundpage true def
|
|
/useclippath true def
|
|
/pagebbox [0 0 612 792] def
|
|
|
|
/inch {72 mul} def
|
|
/min {2 copy gt {exch} if pop} def
|
|
|
|
/HardcopySetup {
|
|
landscape {/orientation 90 orientation add def} if
|
|
font findfont 1 1.1 div scalefont setfont
|
|
|
|
pagedimensions
|
|
xcenter ycenter translate
|
|
orientation rotation mul rotate
|
|
width 2 div neg height 2 div translate
|
|
xoffset inch yoffset inch neg translate
|
|
pointsize 1.1 mul dup scale
|
|
magnification dup aspectratio mul scale
|
|
height width div 1 min dup scale
|
|
0 -1 translate
|
|
0 0 moveto
|
|
} def
|
|
|
|
/pagedimensions {
|
|
useclippath {
|
|
/pagebbox [clippath pathbbox newpath] def
|
|
roundpage currentdict /roundpagebbox known and {roundpagebbox} if
|
|
} if
|
|
pagebbox aload pop
|
|
4 -1 roll exch 4 1 roll 4 copy
|
|
landscape {4 2 roll} if
|
|
sub /width exch def
|
|
sub /height exch def
|
|
add 2 div /xcenter exch def
|
|
add 2 div /ycenter exch def
|
|
} def
|
|
|
|
%
|
|
% Unbind the operators in an executable array or packedarray. Leaves the
|
|
% unbound array or the original object on the stack.
|
|
%
|
|
|
|
/Unbind {
|
|
0 index xcheck
|
|
1 index type /arraytype eq
|
|
2 index type /packedarraytype eq or and {
|
|
dup length array copy cvx
|
|
dup 0 exch {
|
|
dup type /operatortype eq {
|
|
( ) cvs cvn cvx
|
|
} if
|
|
|
|
dup type /dicttype eq {
|
|
dup maxlength dict exch {
|
|
Unbind
|
|
3 copy put pop pop
|
|
} forall
|
|
} if
|
|
|
|
0 index xcheck
|
|
1 index type /arraytype eq
|
|
2 index type /packedarraytype eq or and {
|
|
Unbind
|
|
} if
|
|
|
|
3 copy put pop
|
|
1 add
|
|
} forall
|
|
pop
|
|
} if
|
|
} def
|
|
|
|
%
|
|
% New write operator - don't bind the definition! Expands tabs and backspaces,
|
|
% wraps long lines, and starts a new page whenever necessary. The code that
|
|
% handles newlines assumes lines are separated by one vertical unit.
|
|
%
|
|
|
|
/write {
|
|
true exch
|
|
|
|
%%case '\b':
|
|
dup 8#10 eq {
|
|
( ) stringwidth pop neg 0 rmoveto
|
|
currentpoint pop 0 lt {
|
|
currentpoint exch pop 0 exch moveto
|
|
} if
|
|
exch pop false exch
|
|
} if
|
|
|
|
%%case '\t':
|
|
dup 8#11 eq {
|
|
currentpoint pop ( ) stringwidth pop div round cvi
|
|
8 mod 8 exch sub {
|
|
2 index 8#40 write
|
|
} repeat
|
|
exch pop false exch
|
|
} if
|
|
|
|
%%case '\n':
|
|
dup 8#12 eq {
|
|
currentpoint 0 exch 1 sub moveto pop
|
|
|
|
gsave clippath pathbbox pop pop exch pop grestore
|
|
currentpoint exch pop 1 sub ge {
|
|
2 index 8#14 write
|
|
} if
|
|
exch pop false exch
|
|
} if
|
|
|
|
%%case '\f':
|
|
dup 8#14 eq {
|
|
gsave showpage grestore
|
|
0 0 moveto
|
|
exch pop false exch
|
|
} if
|
|
|
|
%%case '\r':
|
|
dup 8#15 eq {
|
|
currentpoint 0 exch moveto pop
|
|
exch pop false exch
|
|
} if
|
|
|
|
%%case EOF:
|
|
dup -1 eq {
|
|
currentpoint 0 ne exch 0 ne or {
|
|
2 index 8#14 write
|
|
} if
|
|
exch pop false exch
|
|
} if
|
|
|
|
%%default:
|
|
exch {
|
|
dup
|
|
gsave clippath pathbbox pop 3 1 roll pop pop grestore
|
|
( ) stringwidth pop currentpoint pop add le {
|
|
2 index 8#12 write
|
|
} if
|
|
( ) dup 0 4 -1 roll put show
|
|
} if
|
|
|
|
pop % the character
|
|
pop % and file object
|
|
} def
|
|
|
|
%
|
|
% All the other file output operators call our redefined write operator.
|
|
%
|
|
|
|
/print {
|
|
(%stdout) (w) file exch {1 index exch write} forall
|
|
pop
|
|
} def
|
|
|
|
/writestring {
|
|
{1 index exch write} forall
|
|
pop
|
|
} def
|
|
|
|
/writehexstring {
|
|
(0123456789ABCDEF) 3 1 roll {
|
|
dup
|
|
3 index exch -4 bitshift 16#F and get 2 index exch write
|
|
2 index exch 16#F and get 1 index exch write
|
|
} forall
|
|
pop pop
|
|
} def
|
|
|
|
%
|
|
% Unbind and redefine the remaining file output procedures.
|
|
%
|
|
|
|
/= dup load Unbind def
|
|
/== dup load Unbind def
|
|
/stack dup load Unbind def
|
|
/pstack dup load Unbind def
|
|
|