#define EXTERN extern
#include "mpd.h"
void zscanwithlist ( p )
halfword p ;
{/* 30 31 32 */ smallnumber t ;
halfword q ;
halfword cp, pp, dp ;
cp = 1 ;
pp = 1 ;
dp = 1 ;
while ( curcmd == 68 ) {
t = curmod ;
getxnext () ;
scanexpression () ;
if ( curtype != t )
{
disperr ( 0 , 1012 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1013 ;
helpline [ 0 ] = 1014 ;
}
if ( t == 10 )
helpline [ 1 ] = 1015 ;
else if ( t == 13 )
helpline [ 1 ] = 1016 ;
putgetflusherror ( 0 ) ;
}
else if ( t == 13 )
{
if ( cp == 1 )
{
cp = p ;
while ( cp != 0 ) {
if ( ( mem [ cp ] .hhfield .b0 < 4 ) )
goto lab30 ;
cp = mem [ cp ] .hhfield .v.RH ;
}
lab30: ;
}
if ( cp != 0 )
{
q = mem [ curexp + 1 ] .cint ;
mem [ cp + 2 ] .cint = mem [ q + 1 ] .cint ;
mem [ cp + 3 ] .cint = mem [ q + 3 ] .cint ;
mem [ cp + 4 ] .cint = mem [ q + 5 ] .cint ;
if ( mem [ cp + 2 ] .cint < 0 )
mem [ cp + 2 ] .cint = 0 ;
if ( mem [ cp + 3 ] .cint < 0 )
mem [ cp + 3 ] .cint = 0 ;
if ( mem [ cp + 4 ] .cint < 0 )
mem [ cp + 4 ] .cint = 0 ;
if ( mem [ cp + 2 ] .cint > 65536L )
mem [ cp + 2 ] .cint = 65536L ;
if ( mem [ cp + 3 ] .cint > 65536L )
mem [ cp + 3 ] .cint = 65536L ;
if ( mem [ cp + 4 ] .cint > 65536L )
mem [ cp + 4 ] .cint = 65536L ;
}
flushcurexp ( 0 ) ;
}
else if ( t == 6 )
{
if ( pp == 1 )
{
pp = p ;
while ( pp != 0 ) {
if ( ( mem [ pp ] .hhfield .b0 < 3 ) )
goto lab31 ;
pp = mem [ pp ] .hhfield .v.RH ;
}
lab31: ;
}
if ( pp != 0 )
{
if ( mem [ pp + 1 ] .hhfield .lhfield != 0 )
tossknotlist ( mem [ pp + 1 ] .hhfield .lhfield ) ;
mem [ pp + 1 ] .hhfield .lhfield = curexp ;
curtype = 1 ;
if ( mem [ pp ] .hhfield .b0 == 2 )
{
if ( ( mem [ pp + 1 ] .hhfield .lhfield == mem [ mem [ pp + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) )
mem [ pp + 7 ] .cint = getpenscale ( mem [ pp + 1 ] .hhfield .lhfield ) ;
}
}
}
else {
if ( dp == 1 )
{
dp = p ;
while ( dp != 0 ) {
if ( mem [ dp ] .hhfield .b0 == 2 )
goto lab32 ;
dp = mem [ dp ] .hhfield .v.RH ;
}
lab32: ;
}
if ( dp != 0 )
{
if ( mem [ dp + 6 ] .hhfield .v.RH != 0 )
if ( mem [ mem [ dp + 6 ] .hhfield .v.RH ] .hhfield .lhfield == 0 )
tossedges ( mem [ dp + 6 ] .hhfield .v.RH ) ;
else decr ( mem [ mem [ dp + 6 ] .hhfield .v.RH ] .hhfield .lhfield )
;
mem [ dp + 6 ] .hhfield .v.RH = makedashes ( curexp ) ;
curtype = 1 ;
}
}
}
if ( cp > 1 )
{
q = mem [ cp ] .hhfield .v.RH ;
while ( q != 0 ) {
if ( ( mem [ q ] .hhfield .b0 < 4 ) )
{
mem [ q + 2 ] .cint = mem [ cp + 2 ] .cint ;
mem [ q + 3 ] .cint = mem [ cp + 3 ] .cint ;
mem [ q + 4 ] .cint = mem [ cp + 4 ] .cint ;
}
q = mem [ q ] .hhfield .v.RH ;
}
}
if ( pp > 1 )
{
q = mem [ pp ] .hhfield .v.RH ;
while ( q != 0 ) {
if ( ( mem [ q ] .hhfield .b0 < 3 ) )
{
if ( mem [ q + 1 ] .hhfield .lhfield != 0 )
tossknotlist ( mem [ q + 1 ] .hhfield .lhfield ) ;
mem [ q + 1 ] .hhfield .lhfield = makepen ( copypath ( mem [ pp + 1 ] .hhfield .lhfield ) , false ) ;
if ( mem [ q ] .hhfield .b0 == 2 )
if ( mem [ pp ] .hhfield .b0 == 2 )
mem [ q + 7 ] .cint = mem [ pp + 7 ] .cint ;
else {
{
if ( ( mem [ q + 1 ] .hhfield .lhfield == mem [ mem [ q + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) )
mem [ q + 7 ] .cint = getpenscale ( mem [ q + 1 ] .hhfield .lhfield ) ;
}
pp = q ;
}
}
q = mem [ q ] .hhfield .v.RH ;
}
}
if ( dp > 1 )
{
q = mem [ dp ] .hhfield .v.RH ;
while ( q != 0 ) {
if ( mem [ q ] .hhfield .b0 == 2 )
{
if ( mem [ q + 6 ] .hhfield .v.RH != 0 )
if ( mem [ mem [ q + 6 ] .hhfield .v.RH ] .hhfield .lhfield == 0 )
tossedges ( mem [ q + 6 ] .hhfield .v.RH ) ;
else decr ( mem [ mem [ q + 6 ] .hhfield .v.RH ] .hhfield .lhfield ) ;
mem [ q + 6 ] .hhfield .v.RH = mem [ dp + 6 ] .hhfield .v.RH ;
if ( mem [ q + 6 ] .hhfield .v.RH != 0 )
incr ( mem [ mem [ q + 6 ] .hhfield .v.RH ] .hhfield .lhfield ) ;
}
q = mem [ q ] .hhfield .v.RH ;
}
}
}
halfword zfindedgesvar ( t )
halfword t ;
{register halfword Result; halfword p ;
halfword curedges ;
p = findvariable ( t ) ;
curedges = 0 ;
if ( p == 0 )
{
obliterated ( t ) ;
putgeterror () ;
}
else if ( mem [ p ] .hhfield .b0 != 10 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 841 ) ;
}
showtokenlist ( t , 0 , 1000 , 0 ) ;
print ( 1017 ) ;
printtype ( mem [ p ] .hhfield .b0 ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1018 ;
helpline [ 0 ] = 1019 ;
}
putgeterror () ;
}
else {
mem [ p + 1 ] .cint = privateedges ( mem [ p + 1 ] .cint ) ;
curedges = mem [ p + 1 ] .cint ;
}
flushnodelist ( t ) ;
Result = curedges ;
return(Result) ;
}
halfword zstartdrawcmd ( sep )
quarterword sep ;
{register halfword Result; halfword lhv ;
quarterword addtype ;
lhv = 0 ;
getxnext () ;
varflag = sep ;
scanprimary () ;
if ( curtype != 20 )
{
disperr ( 0 , 1022 ) ;
{
helpptr = 4 ;
helpline [ 3 ] = 1023 ;
helpline [ 2 ] = 1024 ;
helpline [ 1 ] = 1025 ;
helpline [ 0 ] = 1019 ;
}
putgetflusherror ( 0 ) ;
}
else {
lhv = curexp ;
addtype = curmod ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
}
lastaddtype = addtype ;
Result = lhv ;
return(Result) ;
}
void dobounds ( )
{halfword lhv, lhe ;
halfword p ;
integer m ;
m = curmod ;
lhv = startdrawcmd ( 71 ) ;
if ( lhv != 0 )
{
lhe = findedgesvar ( lhv ) ;
if ( lhe == 0 )
flushcurexp ( 0 ) ;
else if ( curtype != 8 )
{
disperr ( 0 , 1026 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1027 ;
helpline [ 0 ] = 1019 ;
}
putgetflusherror ( 0 ) ;
}
else if ( mem [ curexp ] .hhfield .b0 == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1028 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 1029 ;
helpline [ 0 ] = 1019 ;
}
putgeterror () ;
}
else {
p = newboundsnode ( curexp , m ) ;
mem [ p ] .hhfield .v.RH = mem [ lhe + 7 ] .hhfield .v.RH ;
mem [ lhe + 7 ] .hhfield .v.RH = p ;
if ( mem [ lhe + 7 ] .hhfield .lhfield == lhe + 7 )
mem [ lhe + 7 ] .hhfield .lhfield = p ;
p = getnode ( grobjectsize [ ( m + 2 ) ] ) ;
mem [ p ] .hhfield .b0 = ( m + 2 ) ;
mem [ mem [ lhe + 7 ] .hhfield .lhfield ] .hhfield .v.RH = p ;
mem [ lhe + 7 ] .hhfield .lhfield = p ;
initbbox ( lhe ) ;
}
}
}
void doaddto ( )
{halfword lhv, lhe ;
halfword p ;
halfword e ;
quarterword addtype ;
lhv = startdrawcmd ( 69 ) ;
addtype = lastaddtype ;
if ( lhv != 0 )
{
if ( addtype == 2 )
{
p = 0 ;
e = 0 ;
if ( curtype != 10 )
{
disperr ( 0 , 1030 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1031 ;
helpline [ 0 ] = 1019 ;
}
putgetflusherror ( 0 ) ;
}
else {
e = privateedges ( curexp ) ;
curtype = 1 ;
p = mem [ e + 7 ] .hhfield .v.RH ;
}
}
else {
e = 0 ;
p = 0 ;
if ( curtype == 14 )
pairtopath () ;
if ( curtype != 8 )
{
disperr ( 0 , 1030 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1027 ;
helpline [ 0 ] = 1019 ;
}
putgetflusherror ( 0 ) ;
}
else if ( addtype == 1 )
if ( mem [ curexp ] .hhfield .b0 == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1028 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 1029 ;
helpline [ 0 ] = 1019 ;
}
putgeterror () ;
}
else {
p = newfillnode ( curexp ) ;
curtype = 1 ;
}
else {
p = newstrokednode ( curexp ) ;
curtype = 1 ;
}
}
scanwithlist ( p ) ;
lhe = findedgesvar ( lhv ) ;
if ( lhe == 0 )
{
if ( ( e == 0 ) && ( p != 0 ) )
e = tossgrobject ( p ) ;
if ( e != 0 )
if ( mem [ e ] .hhfield .lhfield == 0 )
tossedges ( e ) ;
else decr ( mem [ e ] .hhfield .lhfield ) ;
}
else if ( addtype == 2 )
if ( e != 0 )
{
if ( mem [ e + 7 ] .hhfield .v.RH != 0 )
{
mem [ mem [ lhe + 7 ] .hhfield .lhfield ] .hhfield .v.RH = mem [ e + 7
] .hhfield .v.RH ;
mem [ lhe + 7 ] .hhfield .lhfield = mem [ e + 7 ] .hhfield .lhfield ;
mem [ e + 7 ] .hhfield .lhfield = e + 7 ;
mem [ e + 7 ] .hhfield .v.RH = 0 ;
flushdashlist ( lhe ) ;
}
tossedges ( e ) ;
}
else ;
else if ( p != 0 )
{
mem [ mem [ lhe + 7 ] .hhfield .lhfield ] .hhfield .v.RH = p ;
mem [ lhe + 7 ] .hhfield .lhfield = p ;
if ( addtype == 0 )
{
if ( mem [ p + 1 ] .hhfield .lhfield == 0 )
mem [ p + 1 ] .hhfield .lhfield = getpencircle ( 0 ) ;
{
if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) )
mem [ p + 7 ] .cint = getpenscale ( mem [ p + 1 ] .hhfield .lhfield
) ;
}
}
}
}
}
scaled ztfmcheck ( m )
smallnumber m ;
{register scaled Result; if ( abs ( internal [ m ] ) >= 134217728L )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1048 ) ;
}
print ( intname [ m ] ) ;
print ( 1049 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1050 ;
}
putgeterror () ;
if ( internal [ m ] > 0 )
Result = 134217727L ;
else Result = -134217727L ;
}
else Result = internal [ m ] ;
return(Result) ;
}
void readpsnametable ( )
{/* 50 30 */ fontnumber k ;
integer lmax ;
integer j ;
char c ;
strnumber s ;
(void) strncpy(nameoffile+1, pstabname, sizeof pstabname) ;
if ( aopenin ( pstabfile , 11 ) )
{
lmax = 0 ;
{register integer for_end; k = lastpsfnum + 1 ; for_end = lastfnum ; if (
k <= for_end) do
if ( ( strstart [ nextstr [ fontname [ k ] ] ] - strstart [ fontname [ k
] ] ) > lmax )
lmax = ( strstart [ nextstr [ fontname [ k ] ] ] - strstart [ fontname [
k ] ] ) ;
while ( k++ < for_end ) ; }
while ( ! eof ( pstabfile ) ) {
{
if ( poolptr + lmax > maxpoolptr )
if ( poolptr + lmax > poolsize )
docompaction ( lmax ) ;
else maxpoolptr = poolptr + lmax ;
}
j = lmax ;
while ( true ) {
if ( eoln ( pstabfile ) )
fatalerror ( 1113 ) ;
read ( pstabfile , c ) ;
if ( c == ' ' )
goto lab30 ;
decr ( j ) ;
if ( j >= 0 )
{
strpool [ poolptr ] = xord [ c ] ;
incr ( poolptr ) ;
}
else {
poolptr = strstart [ strptr ] ;
goto lab50 ;
}
}
lab30: s = makestring () ;
{register integer for_end; k = lastpsfnum + 1 ; for_end = lastfnum
; if ( k <= for_end) do
if ( strvsstr ( s , fontname [ k ] ) == 0 )
{
flushstring ( s ) ;
j = 32 ;
{
if ( poolptr + j > maxpoolptr )
if ( poolptr + j > poolsize )
docompaction ( j ) ;
else maxpoolptr = poolptr + j ;
}
do {
if ( eoln ( pstabfile ) )
fatalerror ( 1113 ) ;
read ( pstabfile , c ) ;
} while ( ! ( c != ' ' ) ) ;
do {
decr ( j ) ;
if ( j < 0 )
fatalerror ( 1113 ) ;
{
strpool [ poolptr ] = xord [ c ] ;
incr ( poolptr ) ;
}
if ( eoln ( pstabfile ) )
c = ' ' ;
else read ( pstabfile , c ) ;
} while ( ! ( c == ' ' ) ) ;
{
if ( strref [ fontpsname [ k ] ] < 127 )
if ( strref [ fontpsname [ k ] ] > 1 )
decr ( strref [ fontpsname [ k ] ] ) ;
else flushstring ( fontpsname [ k ] ) ;
}
fontpsname [ k ] = makestring () ;
goto lab50 ;
}
while ( k++ < for_end ) ; }
flushstring ( s ) ;
lab50: readln ( pstabfile ) ;
}
lastpsfnum = lastfnum ;
aclose ( pstabfile ) ;
}
}
void openoutputfile ( )
{integer c ;
char oldsetting ;
strnumber s ;
if ( jobname == 0 )
openlogfile () ;
c = roundunscaled ( internal [ 17 ] ) ;
if ( c < 0 )
s = 1114 ;
else {
oldsetting = selector ;
selector = 10 ;
printchar ( 46 ) ;
printint ( c ) ;
s = makestring () ;
selector = oldsetting ;
}
packjobname ( s ) ;
while ( ! aopenout ( psfile ) ) promptfilename ( 1115 , s ) ;
{
if ( strref [ s ] < 127 )
if ( strref [ s ] > 1 )
decr ( strref [ s ] ) ;
else flushstring ( s ) ;
}
if ( ( c < firstoutputcode ) && ( firstoutputcode >= 0 ) )
{
firstoutputcode = c ;
{
if ( strref [ firstfilename ] < 127 )
if ( strref [ firstfilename ] > 1 )
decr ( strref [ firstfilename ] ) ;
else flushstring ( firstfilename ) ;
}
firstfilename = amakenamestring ( psfile ) ;
}
if ( c >= lastoutputcode )
{
lastoutputcode = c ;
{
if ( strref [ lastfilename ] < 127 )
if ( strref [ lastfilename ] > 1 )
decr ( strref [ lastfilename ] ) ;
else flushstring ( lastfilename ) ;
}
lastfilename = amakenamestring ( psfile ) ;
}
if ( termoffset > maxprintline - 6 )
println () ;
else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
printchar ( 32 ) ;
printchar ( 91 ) ;
if ( c >= 0 )
printint ( c ) ;
}
void zpspairout ( x , y )
scaled x ;
scaled y ;
{if ( psoffset + 26 > maxprintline )
println () ;
printscaled ( x ) ;
printchar ( 32 ) ;
printscaled ( y ) ;
printchar ( 32 ) ;
}
void zpsprint ( s )
strnumber s ;
{if ( psoffset + ( strstart [ nextstr [ s ] ] - strstart [ s ] ) >
maxprintline )
println () ;
print ( s ) ;
}
void zpspathout ( h )
halfword h ;
{/* 10 */ halfword p, q ;
scaled d ;
boolean curved ;
if ( psoffset + 40 > maxprintline )
println () ;
if ( neednewpath )
print ( 1118 ) ;
neednewpath = true ;
pspairout ( mem [ h + 1 ] .cint , mem [ h + 2 ] .cint ) ;
print ( 1119 ) ;
p = h ;
do {
if ( mem [ p ] .hhfield .b1 == 0 )
{
if ( p == h )
psprint ( 1120 ) ;
goto lab10 ;
}
q = mem [ p ] .hhfield .v.RH ;
curved = true ;
if ( mem [ p + 5 ] .cint == mem [ p + 1 ] .cint )
if ( mem [ p + 6 ] .cint == mem [ p + 2 ] .cint )
if ( mem [ q + 3 ] .cint == mem [ q + 1 ] .cint )
if ( mem [ q + 4 ] .cint == mem [ q + 2 ] .cint )
curved = false ;
d = mem [ q + 3 ] .cint - mem [ p + 5 ] .cint ;
if ( abs ( mem [ p + 5 ] .cint - mem [ p + 1 ] .cint - d ) <= 131 )
if ( abs ( mem [ q + 1 ] .cint - mem [ q + 3 ] .cint - d ) <= 131 )
{
d = mem [ q + 4 ] .cint - mem [ p + 6 ] .cint ;
if ( abs ( mem [ p + 6 ] .cint - mem [ p + 2 ] .cint - d ) <= 131 )
if ( abs ( mem [ q + 2 ] .cint - mem [ q + 4 ] .cint - d ) <= 131 )
curved = false ;
}
println () ;
if ( curved )
{
pspairout ( mem [ p + 5 ] .cint , mem [ p + 6 ] .cint ) ;
pspairout ( mem [ q + 3 ] .cint , mem [ q + 4 ] .cint ) ;
pspairout ( mem [ q + 1 ] .cint , mem [ q + 2 ] .cint ) ;
psprint ( 1122 ) ;
}
else if ( q != h )
{
pspairout ( mem [ q + 1 ] .cint , mem [ q + 2 ] .cint ) ;
psprint ( 1123 ) ;
}
p = q ;
} while ( ! ( p == h ) ) ;
psprint ( 1121 ) ;
lab10: ;
}
void zunknowngraphicsstate ( c )
scaled c ;
{gsred = c ;
gsgreen = c ;
gsblue = c ;
gsljoin = 3 ;
gslcap = 3 ;
gsmiterlim = 0 ;
gsdashp = 1 ;
gsdashsc = 0 ;
gswidth = -1 ;
}
boolean zcoordrangeOK ( h , zoff , dz )
halfword h ;
smallnumber zoff ;
scaled dz ;
{/* 40 45 10 */ register boolean Result; halfword p ;
scaled zlo, zhi ;
scaled z ;
zlo = mem [ h + zoff ] .cint ;
zhi = zlo ;
p = h ;
while ( mem [ p ] .hhfield .b1 != 0 ) {
z = mem [ p + zoff + 4 ] .cint ;
if ( z < zlo )
zlo = z ;
else if ( z > zhi )
zhi = z ;
if ( zhi - zlo > dz )
goto lab40 ;
p = mem [ p ] .hhfield .v.RH ;
z = mem [ p + zoff + 2 ] .cint ;
if ( z < zlo )
zlo = z ;
else if ( z > zhi )
zhi = z ;
if ( zhi - zlo > dz )
goto lab40 ;
z = mem [ p + zoff ] .cint ;
if ( z < zlo )
zlo = z ;
else if ( z > zhi )
zhi = z ;
if ( zhi - zlo > dz )
goto lab40 ;
if ( p == h )
goto lab45 ;
}
lab45: Result = true ;
goto lab10 ;
lab40: Result = false ;
lab10: ;
return(Result) ;
}
boolean zsamedashes ( h , hh )
halfword h ;
halfword hh ;
{/* 30 */ register boolean Result; halfword p, pp ;
if ( h == hh )
Result = true ;
else if ( ( h <= 1 ) || ( hh <= 1 ) )
Result = false ;
else if ( mem [ h + 1 ] .cint != mem [ hh + 1 ] .cint )
Result = false ;
else {
p = mem [ h ] .hhfield .v.RH ;
pp = mem [ hh ] .hhfield .v.RH ;
while ( ( p != 2 ) && ( pp != 2 ) ) if ( ( mem [ p + 1 ] .cint != mem [ pp
+ 1 ] .cint ) || ( mem [ p + 2 ] .cint != mem [ pp + 2 ] .cint ) )
goto lab30 ;
else {
p = mem [ p ] .hhfield .v.RH ;
pp = mem [ pp ] .hhfield .v.RH ;
}
lab30: Result = p == pp ;
}
return(Result) ;
}
void zfixgraphicsstate ( p )
halfword p ;
{halfword hh, pp ;
scaled wx, wy, ww ;
boolean adjwx ;
integer tx, ty ;
scaled scf ;
if ( ( mem [ p ] .hhfield .b0 < 4 ) )
if ( ( gsred != mem [ p + 2 ] .cint ) || ( gsgreen != mem [ p + 3 ] .cint )
|| ( gsblue != mem [ p + 4 ] .cint ) )
{
gsred = mem [ p + 2 ] .cint ;
gsgreen = mem [ p + 3 ] .cint ;
gsblue = mem [ p + 4 ] .cint ;
if ( ( gsred == gsgreen ) && ( gsgreen == gsblue ) )
{
if ( psoffset + 16 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( gsred ) ;
print ( 1127 ) ;
}
else {
if ( psoffset + 36 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( gsred ) ;
printchar ( 32 ) ;
printscaled ( gsgreen ) ;
printchar ( 32 ) ;
printscaled ( gsblue ) ;
print ( 1128 ) ;
}
}
if ( ( mem [ p ] .hhfield .b0 == 1 ) || ( mem [ p ] .hhfield .b0 == 2 ) )
if ( mem [ p + 1 ] .hhfield .lhfield != 0 )
if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) )
{
pp = mem [ p + 1 ] .hhfield .lhfield ;
if ( ( mem [ pp + 5 ] .cint == mem [ pp + 1 ] .cint ) && ( mem [ pp + 4 ] .cint == mem [ pp + 2 ] .cint ) )
{
wx = abs ( mem [ pp + 3 ] .cint - mem [ pp + 1 ] .cint ) ;
wy = abs ( mem [ pp + 6 ] .cint - mem [ pp + 2 ] .cint ) ;
}
else {
wx = pythadd ( mem [ pp + 3 ] .cint - mem [ pp + 1 ] .cint , mem [ pp +
5 ] .cint - mem [ pp + 1 ] .cint ) ;
wy = pythadd ( mem [ pp + 4 ] .cint - mem [ pp + 2 ] .cint , mem [ pp +
6 ] .cint - mem [ pp + 2 ] .cint ) ;
}
tx = 1 ;
ty = 1 ;
if ( coordrangeOK ( mem [ p + 1 ] .hhfield .v.RH , 2 , wy ) )
tx = 10 ;
else if ( coordrangeOK ( mem [ p + 1 ] .hhfield .v.RH , 1 , wx ) )
ty = 10 ;
if ( wy / ty >= wx / tx )
{
ww = wy ;
adjwx = false ;
}
else {
ww = wx ;
adjwx = true ;
}
if ( ( ww != gswidth ) || ( adjwx != gsadjwx ) )
{
if ( adjwx )
{
if ( psoffset + 13 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( ww ) ;
psprint ( 1129 ) ;
}
else {
if ( psoffset + 15 > maxprintline )
println () ;
print ( 1130 ) ;
printscaled ( ww ) ;
psprint ( 1131 ) ;
}
gswidth = ww ;
gsadjwx = adjwx ;
}
if ( mem [ p ] .hhfield .b0 == 1 )
hh = 0 ;
else {
hh = mem [ p + 6 ] .hhfield .v.RH ;
if ( mem [ p + 7 ] .cint == 0 )
if ( gswidth == 0 )
scf = 65536L ;
else hh = 0 ;
else scf = makescaled ( gswidth , mem [ p + 7 ] .cint ) ;
}
if ( hh == 0 )
{
if ( gsdashp != 0 )
{
psprint ( 1132 ) ;
gsdashp = 0 ;
}
}
else if ( ( gsdashsc != scf ) || ! samedashes ( gsdashp , hh ) )
{
gsdashp = hh ;
gsdashsc = scf ;
if ( ( mem [ hh + 1 ] .cint == 0 ) || ( abs ( mem [ hh + 1 ] .cint ) /
65536L >= 2147483647L / scf ) )
psprint ( 1132 ) ;
else {
pp = mem [ hh ] .hhfield .v.RH ;
mem [ 3 ] .cint = mem [ pp + 1 ] .cint + mem [ hh + 1 ] .cint ;
if ( psoffset + 28 > maxprintline )
println () ;
print ( 1133 ) ;
while ( pp != 2 ) {
pspairout ( takescaled ( mem [ pp + 2 ] .cint - mem [ pp + 1 ] .cint
, scf ) , takescaled ( mem [ mem [ pp ] .hhfield .v.RH + 1 ] .cint -
mem [ pp + 2 ] .cint , scf ) ) ;
pp = mem [ pp ] .hhfield .v.RH ;
}
if ( psoffset + 22 > maxprintline )
println () ;
print ( 1134 ) ;
printscaled ( takescaled ( dashoffset ( hh ) , scf ) ) ;
print ( 1135 ) ;
}
}
if ( mem [ p ] .hhfield .b0 == 2 )
if ( ( mem [ mem [ p + 1 ] .hhfield .v.RH ] .hhfield .b0 == 0 ) || ( mem [
p + 6 ] .hhfield .v.RH != 0 ) )
if ( gslcap != mem [ p + 6 ] .hhfield .b0 )
{
if ( psoffset + 13 > maxprintline )
println () ;
printchar ( 32 ) ;
printchar ( 48 + mem [ p + 6 ] .hhfield .b0 ) ;
print ( 1124 ) ;
gslcap = mem [ p + 6 ] .hhfield .b0 ;
}
if ( gsljoin != mem [ p ] .hhfield .b1 )
{
if ( psoffset + 14 > maxprintline )
println () ;
printchar ( 32 ) ;
printchar ( 48 + mem [ p ] .hhfield .b1 ) ;
print ( 1125 ) ;
gsljoin = mem [ p ] .hhfield .b1 ;
}
if ( gsmiterlim != mem [ p + 5 ] .cint )
{
if ( psoffset + 27 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( mem [ p + 5 ] .cint ) ;
print ( 1126 ) ;
gsmiterlim = mem [ p + 5 ] .cint ;
}
}
if ( psoffset > 0 )
println () ;
}
void zstrokeellipse ( h , fillalso )
halfword h ;
boolean fillalso ;
{scaled txx, txy, tyx, tyy ;
halfword p ;
scaled d1, det ;
integer s ;
boolean transforming ;
transforming = false ;
p = mem [ h + 1 ] .hhfield .lhfield ;
txx = mem [ p + 3 ] .cint ;
tyx = mem [ p + 4 ] .cint ;
txy = mem [ p + 5 ] .cint ;
tyy = mem [ p + 6 ] .cint ;
if ( ( mem [ p + 1 ] .cint != 0 ) || ( mem [ p + 2 ] .cint != 0 ) )
{
printnl ( 1139 ) ;
pspairout ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ;
psprint ( 1140 ) ;
txx = txx - mem [ p + 1 ] .cint ;
tyx = tyx - mem [ p + 2 ] .cint ;
txy = txy - mem [ p + 1 ] .cint ;
tyy = tyy - mem [ p + 2 ] .cint ;
transforming = true ;
}
else printnl ( 285 ) ;
if ( gswidth != 65536L )
if ( gswidth == 0 )
{
txx = 65536L ;
tyy = 65536L ;
}
else {
txx = makescaled ( txx , gswidth ) ;
txy = makescaled ( txy , gswidth ) ;
tyx = makescaled ( tyx , gswidth ) ;
tyy = makescaled ( tyy , gswidth ) ;
}
if ( ( txy != 0 ) || ( tyx != 0 ) || ( txx != 65536L ) || ( tyy != 65536L )
)
if ( ( ! transforming ) )
{
psprint ( 1139 ) ;
transforming = true ;
}
det = takescaled ( txx , tyy ) - takescaled ( txy , tyx ) ;
d1 = 4 * 10 + 1 ;
if ( abs ( det ) < d1 )
{
if ( det >= 0 )
{
d1 = d1 - det ;
s = 1 ;
}
else {
d1 = - (integer) d1 - det ;
s = -1 ;
}
d1 = d1 * 65536L ;
if ( abs ( txx ) + abs ( tyy ) >= abs ( txy ) + abs ( tyy ) )
if ( abs ( txx ) > abs ( tyy ) )
tyy = tyy + ( d1 + s * abs ( txx ) ) / txx ;
else txx = txx + ( d1 + s * abs ( tyy ) ) / tyy ;
else if ( abs ( txy ) > abs ( tyx ) )
tyx = tyx + ( d1 + s * abs ( txy ) ) / txy ;
else txy = txy + ( d1 + s * abs ( tyx ) ) / tyx ;
}
pspathout ( mem [ h + 1 ] .hhfield .v.RH ) ;
if ( fillalso )
printnl ( 1136 ) ;
if ( ( txy != 0 ) || ( tyx != 0 ) )
{
println () ;
printchar ( 91 ) ;
pspairout ( txx , tyx ) ;
pspairout ( txy , tyy ) ;
psprint ( 1141 ) ;
}
else if ( ( txx != 65536L ) || ( tyy != 65536L ) )
{
println () ;
pspairout ( txx , tyy ) ;
print ( 1142 ) ;
}
psprint ( 1137 ) ;
if ( transforming )
psprint ( 1138 ) ;
println () ;
}
void zpsfillout ( p )
halfword p ;
{pspathout ( p ) ;
psprint ( 1143 ) ;
println () ;
}
void zdoouterenvelope ( p , h )
halfword p ;
halfword h ;
{p = makeenvelope ( p , mem [ h + 1 ] .hhfield .lhfield , mem [ h ] .hhfield .b1 , 0 , mem [ h + 5 ] .cint ) ;
psfillout ( p ) ;
tossknotlist ( p ) ;
}
scaled zchoosescale ( p )
halfword p ;
{register scaled Result; scaled a, b, c, d, ad, bc ;
a = mem [ p + 10 ] .cint ;
b = mem [ p + 11 ] .cint ;
c = mem [ p + 12 ] .cint ;
d = mem [ p + 13 ] .cint ;
if ( ( a < 0 ) )
a = - (integer) a ;
if ( ( b < 0 ) )
b = - (integer) b ;
if ( ( c < 0 ) )
c = - (integer) c ;
if ( ( d < 0 ) )
d = - (integer) d ;
ad = ( a - d ) / 2 ;
bc = ( b - c ) / 2 ;
Result = pythadd ( pythadd ( d + ad , ad ) , pythadd ( c + bc , bc ) ) ;
return(Result) ;
}
void zpsstringout ( s )
strnumber s ;
{poolpointer i ;
ASCIIcode k ;
print ( 40 ) ;
i = strstart [ s ] ;
while ( i < strstart [ nextstr [ s ] ] ) {
if ( psoffset + 5 > maxprintline )
{
printchar ( 92 ) ;
println () ;
}
k = strpool [ i ] ;
if ( ( ( k < 32 ) || ( k > 126 ) ) )
{
printchar ( 92 ) ;
printchar ( 48 + ( k / 64 ) ) ;
printchar ( 48 + ( ( k / 8 ) % 8 ) ) ;
printchar ( 48 + ( k % 8 ) ) ;
}
else {
if ( ( k == 40 ) || ( k == 41 ) || ( k == 92 ) )
printchar ( 92 ) ;
printchar ( k ) ;
}
incr ( i ) ;
}
print ( 41 ) ;
}
boolean zispsname ( s )
strnumber s ;
{/* 45 10 */ register boolean Result; poolpointer i ;
ASCIIcode k ;
i = strstart [ s ] ;
while ( i < strstart [ nextstr [ s ] ] ) {
k = strpool [ i ] ;
if ( ( k <= 32 ) || ( k > 126 ) )
goto lab45 ;
if ( ( k == 40 ) || ( k == 41 ) || ( k == 60 ) || ( k == 62 ) || ( k ==
123 ) || ( k == 125 ) || ( k == 47 ) || ( k == 37 ) )
goto lab45 ;
incr ( i ) ;
}
Result = true ;
goto lab10 ;
lab45: Result = false ;
lab10: ;
return(Result) ;
}
void zpsnameout ( s , lit )
strnumber s ;
boolean lit ;
{if ( psoffset + ( strstart [ nextstr [ s ] ] - strstart [ s ] ) + 2 >
maxprintline )
println () ;
printchar ( 32 ) ;
if ( ispsname ( s ) )
{
if ( lit )
printchar ( 47 ) ;
print ( s ) ;
}
else {
psstringout ( s ) ;
if ( ! lit )
psprint ( 1144 ) ;
psprint ( 1145 ) ;
}
}
void zunmarkfont ( f )
fontnumber f ;
{integer k ;
{register integer for_end; k = charbase [ f ] + fontbc [ f ] ; for_end =
charbase [ f ] + fontec [ f ] ; if ( k <= for_end) do
fontinfo [ k ] .qqqq .b3 = 0 ;
while ( k++ < for_end ) ; }
}
void zmarkstringchars ( f , s )
fontnumber f ;
strnumber s ;
{integer b ;
poolASCIIcode bc, ec ;
poolpointer k ;
b = charbase [ f ] ;
bc = fontbc [ f ] ;
ec = fontec [ f ] ;
k = strstart [ nextstr [ s ] ] ;
while ( k > strstart [ s ] ) {
decr ( k ) ;
if ( ( strpool [ k ] >= bc ) && ( strpool [ k ] <= ec ) )
fontinfo [ b + strpool [ k ] ] .qqqq .b3 = 1 ;
}
}
void zhexdigitout ( d )
smallnumber d ;
{if ( d < 10 )
printchar ( d + 48 ) ;
else printchar ( d + 87 ) ;
}
halfword zpsmarksout ( f , c )
fontnumber f ;
eightbits c ;
{register halfword Result; eightbits bc, ec ;
integer lim ;
integer p ;
char d, b ;
lim = 4 * ( emergencylinelength - psoffset - 4 ) ;
bc = fontbc [ f ] ;
ec = fontec [ f ] ;
if ( c > bc )
bc = c ;
p = charbase [ f ] + bc ;
while ( ( fontinfo [ p ] .qqqq .b3 == 0 ) && ( bc < ec ) ) {
incr ( p ) ;
incr ( bc ) ;
}
if ( ec >= bc + lim )
ec = bc + lim - 1 ;
p = charbase [ f ] + ec ;
while ( ( fontinfo [ p ] .qqqq .b3 == 0 ) && ( bc < ec ) ) {
decr ( p ) ;
decr ( ec ) ;
}
printchar ( 32 ) ;
hexdigitout ( bc / 16 ) ;
hexdigitout ( bc % 16 ) ;
printchar ( 58 ) ;
b = 8 ;
d = 0 ;
{register integer for_end; p = charbase [ f ] + bc ; for_end = charbase [ f
] + ec ; if ( p <= for_end) do
{
if ( b == 0 )
{
hexdigitout ( d ) ;
d = 0 ;
b = 8 ;
}
if ( fontinfo [ p ] .qqqq .b3 != 0 )
d = d + b ;
b = halfp ( b ) ;
}
while ( p++ < for_end ) ; }
hexdigitout ( d ) ;
while ( ( ec < fontec [ f ] ) && ( fontinfo [ p ] .qqqq .b3 == 0 ) ) {
incr ( p ) ;
incr ( ec ) ;
}
Result = ec + 1 ;
return(Result) ;
}
boolean zcheckpsmarks ( f , c )
fontnumber f ;
integer c ;
{/* 10 */ register boolean Result; integer p ;
{register integer for_end; p = charbase [ f ] + c ; for_end = charbase [ f
] + fontec [ f ] ; if ( p <= for_end) do
if ( fontinfo [ p ] .qqqq .b3 == 1 )
{
Result = true ;
goto lab10 ;
}
while ( p++ < for_end ) ; }
Result = false ;
lab10: ;
return(Result) ;
}
quarterword zsizeindex ( f , s )
fontnumber f ;
scaled s ;
{/* 40 */ register quarterword Result; halfword p, q ;
quarterword i ;
q = fontsizes [ f ] ;
i = 0 ;
while ( q != 0 ) {
if ( abs ( s - mem [ q + 1 ] .cint ) <= 65 )
goto lab40 ;
else {
p = q ;
q = mem [ q ] .hhfield .v.RH ;
incr ( i ) ;
}
if ( i == 255 )
overflow ( 1146 , 255 ) ;
}
q = getnode ( 2 ) ;
mem [ q + 1 ] .cint = s ;
if ( i == 0 )
fontsizes [ f ] = q ;
else mem [ p ] .hhfield .v.RH = q ;
lab40: Result = i ;
return(Result) ;
}
scaled zindexedsize ( f , j )
fontnumber f ;
quarterword j ;
{register scaled Result; halfword p ;
quarterword i ;
p = fontsizes [ f ] ;
i = 0 ;
if ( p == 0 )
confusion ( 1147 ) ;
while ( ( i != j ) ) {
incr ( i ) ;
p = mem [ p ] .hhfield .v.RH ;
if ( p == 0 )
confusion ( 1147 ) ;
}
Result = mem [ p + 1 ] .cint ;
return(Result) ;
}
void clearsizes ( )
{fontnumber f ;
halfword p ;
{register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= for_end)
do
while ( fontsizes [ f ] != 0 ) {
p = fontsizes [ f ] ;
fontsizes [ f ] = mem [ p ] .hhfield .v.RH ;
freenode ( p , 2 ) ;
}
while ( f++ < for_end ) ; }
}
void zshipout ( h )
halfword h ;
{/* 30 40 */ halfword p ;
halfword q ;
integer t ;
fontnumber f, ff ;
fontnumber ldf ;
boolean donefonts ;
quarterword nextsize ;
halfword curfsize[fontmax + 1] ;
scaled ds, scf ;
boolean transformed ;
openoutputfile () ;
if ( ( internal [ 32 ] > 0 ) && ( lastpsfnum < lastfnum ) )
readpsnametable () ;
nonpssetting = selector ;
selector = 8 ;
print ( 1156 ) ;
if ( internal [ 32 ] > 0 )
print ( 1157 ) ;
printnl ( 1158 ) ;
setbbox ( h , true ) ;
if ( mem [ h + 2 ] .cint > mem [ h + 4 ] .cint )
print ( 1159 ) ;
else {
pspairout ( floorscaled ( mem [ h + 2 ] .cint ) , floorscaled ( mem [ h +
3 ] .cint ) ) ;
pspairout ( - (integer) floorscaled ( - (integer) mem [ h + 4 ] .cint ) , - (integer) floorscaled ( - (integer) mem [ h + 5 ] .cint ) ) ;
}
printnl ( 1160 ) ;
printnl ( 1161 ) ;
printint ( roundunscaled ( internal [ 13 ] ) ) ;
printchar ( 46 ) ;
printdd ( roundunscaled ( internal [ 14 ] ) ) ;
printchar ( 46 ) ;
printdd ( roundunscaled ( internal [ 15 ] ) ) ;
printchar ( 58 ) ;
t = roundunscaled ( internal [ 16 ] ) ;
printdd ( t / 60 ) ;
printdd ( t % 60 ) ;
printnl ( 1162 ) ;
{register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= for_end)
do
fontsizes [ f ] = 0 ;
while ( f++ < for_end ) ; }
p = mem [ h + 7 ] .hhfield .v.RH ;
while ( p != 0 ) {
if ( mem [ p ] .hhfield .b0 == 3 )
if ( mem [ p + 1 ] .hhfield .lhfield != 0 )
{
f = mem [ p + 1 ] .hhfield .lhfield ;
if ( internal [ 32 ] > 0 )
fontsizes [ f ] = 1 ;
else {
if ( fontsizes [ f ] == 0 )
unmarkfont ( f ) ;
mem [ p ] .hhfield .b1 = sizeindex ( f , choosescale ( p ) ) ;
if ( mem [ p ] .hhfield .b1 == 0 )
markstringchars ( f , mem [ p + 1 ] .hhfield .v.RH ) ;
}
}
p = mem [ p ] .hhfield .v.RH ;
}
if ( internal [ 32 ] > 0 )
{
ldf = 0 ;
{register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <=
for_end) do
if ( fontsizes [ f ] != 0 )
{
if ( ldf == 0 )
printnl ( 1163 ) ;
{register integer for_end; ff = ldf ; for_end = 0 ; if ( ff >=
for_end) do
if ( fontsizes [ ff ] != 0 )
if ( strvsstr ( fontpsname [ f ] , fontpsname [ ff ] ) == 0 )
goto lab40 ;
while ( ff-- > for_end ) ; }
if ( psoffset + 1 + ( strstart [ nextstr [ fontpsname [ f ] ] ] -
strstart [ fontpsname [ f ] ] ) > maxprintline )
printnl ( 1164 ) ;
printchar ( 32 ) ;
print ( fontpsname [ f ] ) ;
ldf = f ;
lab40: ;
}
while ( f++ < for_end ) ; }
}
else {
nextsize = 0 ;
{register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <=
for_end) do
curfsize [ f ] = fontsizes [ f ] ;
while ( f++ < for_end ) ; }
do {
donefonts = true ;
{register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <=
for_end) do
{
if ( curfsize [ f ] != 0 )
{
t = 0 ;
while ( checkpsmarks ( f , t ) ) {
printnl ( 1165 ) ;
if ( psoffset + ( strstart [ nextstr [ fontname [ f ] ] ] -
strstart [ fontname [ f ] ] ) + 12 > emergencylinelength )
goto lab30 ;
print ( fontname [ f ] ) ;
printchar ( 32 ) ;
ds = ( fontdsize [ f ] + 8 ) / 16 ;
printscaled ( takescaled ( ds , mem [ curfsize [ f ] + 1 ] .cint
) ) ;
if ( psoffset + 12 > emergencylinelength )
goto lab30 ;
printchar ( 32 ) ;
printscaled ( ds ) ;
if ( psoffset + 5 > emergencylinelength )
goto lab30 ;
t = psmarksout ( f , t ) ;
}
lab30: curfsize [ f ] = mem [ curfsize [ f ] ] .hhfield .v.RH ;
}
if ( curfsize [ f ] != 0 )
{
unmarkfont ( f ) ;
donefonts = false ;
}
}
while ( f++ < for_end ) ; }
if ( ! donefonts )
{
incr ( nextsize ) ;
p = mem [ h + 7 ] .hhfield .v.RH ;
while ( p != 0 ) {
if ( mem [ p ] .hhfield .b0 == 3 )
if ( mem [ p + 1 ] .hhfield .lhfield != 0 )
if ( mem [ p ] .hhfield .b1 == nextsize )
markstringchars ( mem [ p + 1 ] .hhfield .lhfield , mem [ p + 1 ] .hhfield .v.RH ) ;
p = mem [ p ] .hhfield .v.RH ;
}
}
} while ( ! ( donefonts ) ) ;
}
println () ;
if ( internal [ 32 ] > 0 )
{
if ( ldf != 0 )
{
{register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <=
for_end) do
if ( fontsizes [ f ] != 0 )
{
psnameout ( fontname [ f ] , true ) ;
psnameout ( fontpsname [ f ] , true ) ;
psprint ( 1166 ) ;
println () ;
}
while ( f++ < for_end ) ; }
print ( 1167 ) ;
println () ;
}
}
print ( 1151 ) ;
printnl ( 1152 ) ;
println () ;
t = mem [ memtop - 3 ] .hhfield .v.RH ;
while ( t != 0 ) {
if ( ( strstart [ nextstr [ mem [ t + 1 ] .cint ] ] - strstart [ mem [ t +
1 ] .cint ] ) <= emergencylinelength )
print ( mem [ t + 1 ] .cint ) ;
else overflow ( 1150 , emergencylinelength ) ;
println () ;
t = mem [ t ] .hhfield .v.RH ;
}
flushtokenlist ( mem [ memtop - 3 ] .hhfield .v.RH ) ;
mem [ memtop - 3 ] .hhfield .v.RH = 0 ;
lastpending = memtop - 3 ;
unknowngraphicsstate ( 0 ) ;
neednewpath = true ;
p = mem [ h + 7 ] .hhfield .v.RH ;
while ( p != 0 ) {
fixgraphicsstate ( p ) ;
switch ( mem [ p ] .hhfield .b0 )
{case 4 :
{
printnl ( 1139 ) ;
pspathout ( mem [ p + 1 ] .hhfield .v.RH ) ;
psprint ( 1168 ) ;
println () ;
}
break ;
case 6 :
{
printnl ( 1169 ) ;
println () ;
unknowngraphicsstate ( -1 ) ;
}
break ;
case 1 :
if ( mem [ p + 1 ] .hhfield .lhfield == 0 )
psfillout ( mem [ p + 1 ] .hhfield .v.RH ) ;
else if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) )
strokeellipse ( p , true ) ;
else {
doouterenvelope ( copypath ( mem [ p + 1 ] .hhfield .v.RH ) , p ) ;
doouterenvelope ( htapypoc ( mem [ p + 1 ] .hhfield .v.RH ) , p ) ;
}
break ;
case 2 :
if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) )
strokeellipse ( p , false ) ;
else {
q = copypath ( mem [ p + 1 ] .hhfield .v.RH ) ;
t = mem [ p + 6 ] .hhfield .b0 ;
if ( mem [ q ] .hhfield .b0 != 0 )
{
mem [ insertknot ( q , mem [ q + 1 ] .cint , mem [ q + 2 ] .cint ) ] .hhfield .b0 = 0 ;
mem [ q ] .hhfield .b1 = 0 ;
q = mem [ q ] .hhfield .v.RH ;
t = 1 ;
}
q = makeenvelope ( q , mem [ p + 1 ] .hhfield .lhfield , mem [ p ] .hhfield .b1 , t , mem [ p + 5 ] .cint ) ;
psfillout ( q ) ;
tossknotlist ( q ) ;
}
break ;
case 3 :
if ( ( mem [ p + 1 ] .hhfield .lhfield != 0 ) && ( ( strstart [ nextstr
[ mem [ p + 1 ] .hhfield .v.RH ] ] - strstart [ mem [ p + 1 ] .hhfield .v.RH ] ) > 0 ) )
{
if ( internal [ 32 ] > 0 )
scf = choosescale ( p ) ;
else scf = indexedsize ( mem [ p + 1 ] .hhfield .lhfield , mem [ p ] .hhfield .b1 ) ;
transformed = ( mem [ p + 10 ] .cint != scf ) || ( mem [ p + 13 ] .cint != scf ) || ( mem [ p + 11 ] .cint != 0 ) || ( mem [ p + 12 ] .cint != 0 ) ;
if ( transformed )
{
print ( 1171 ) ;
pspairout ( makescaled ( mem [ p + 10 ] .cint , scf ) , makescaled (
mem [ p + 12 ] .cint , scf ) ) ;
pspairout ( makescaled ( mem [ p + 11 ] .cint , scf ) , makescaled (
mem [ p + 13 ] .cint , scf ) ) ;
pspairout ( mem [ p + 8 ] .cint , mem [ p + 9 ] .cint ) ;
psprint ( 1172 ) ;
}
else {
pspairout ( mem [ p + 8 ] .cint , mem [ p + 9 ] .cint ) ;
psprint ( 1119 ) ;
}
println () ;
psstringout ( mem [ p + 1 ] .hhfield .v.RH ) ;
psnameout ( fontname [ mem [ p + 1 ] .hhfield .lhfield ] , false ) ;
if ( psoffset + 18 > maxprintline )
println () ;
printchar ( 32 ) ;
ds = ( fontdsize [ mem [ p + 1 ] .hhfield .lhfield ] + 8 ) / 16 ;
printscaled ( takescaled ( ds , scf ) ) ;
print ( 1170 ) ;
if ( transformed )
psprint ( 1138 ) ;
println () ;
}
break ;
case 5 :
case 7 :
;
break ;
}
p = mem [ p ] .hhfield .v.RH ;
}
print ( 1153 ) ;
println () ;
print ( 1154 ) ;
println () ;
aclose ( psfile ) ;
selector = nonpssetting ;
if ( internal [ 32 ] <= 0 )
clearsizes () ;
printchar ( 93 ) ;
flush ( termout ) ;
incr ( totalshipped ) ;
if ( internal [ 9 ] > 0 )
printedges ( h , 1155 , true ) ;
}
void doshipout ( )
{integer c ;
getxnext () ;
scanexpression () ;
if ( curtype != 10 )
{
disperr ( 0 , 1032 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1033 ;
}
putgetflusherror ( 0 ) ;
}
else {
c = roundunscaled ( internal [ 17 ] ) % 256 ;
if ( c < 0 )
c = c + 256 ;
if ( c < bc )
bc = c ;
if ( c > ec )
ec = c ;
charexists [ c ] = true ;
tfmwidth [ c ] = tfmcheck ( 19 ) ;
tfmheight [ c ] = tfmcheck ( 20 ) ;
tfmdepth [ c ] = tfmcheck ( 21 ) ;
tfmitalcorr [ c ] = tfmcheck ( 22 ) ;
shipout ( curexp ) ;
flushcurexp ( 0 ) ;
}
}
void znostringerr ( s )
strnumber s ;
{disperr ( 0 , 741 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = s ;
}
putgeterror () ;
}
void domessage ( )
{char m ;
m = curmod ;
getxnext () ;
scanexpression () ;
if ( curtype != 4 )
nostringerr ( 1037 ) ;
else switch ( m )
{case 0 :
{
printnl ( 285 ) ;
slowprint ( curexp ) ;
}
break ;
case 1 :
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 285 ) ;
}
slowprint ( curexp ) ;
if ( errhelp != 0 )
useerrhelp = true ;
else if ( longhelpseen )
{
helpptr = 1 ;
helpline [ 0 ] = 1038 ;
}
else {
if ( interaction < 3 )
longhelpseen = true ;
{
helpptr = 4 ;
helpline [ 3 ] = 1039 ;
helpline [ 2 ] = 1040 ;
helpline [ 1 ] = 1041 ;
helpline [ 0 ] = 1042 ;
}
}
putgeterror () ;
useerrhelp = false ;
}
break ;
case 2 :
{
if ( errhelp != 0 )
{
if ( strref [ errhelp ] < 127 )
if ( strref [ errhelp ] > 1 )
decr ( strref [ errhelp ] ) ;
else flushstring ( errhelp ) ;
}
if ( ( strstart [ nextstr [ curexp ] ] - strstart [ curexp ] ) == 0 )
errhelp = 0 ;
else {
errhelp = curexp ;
{
if ( strref [ errhelp ] < 127 )
incr ( strref [ errhelp ] ) ;
}
}
}
break ;
}
flushcurexp ( 0 ) ;
}
void dowrite ( )
{/* 22 */ strnumber t ;
writeindex n, n0 ;
char oldsetting ;
getxnext () ;
scanexpression () ;
if ( curtype != 4 )
nostringerr ( 1043 ) ;
else if ( curcmd != 71 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1044 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 1045 ;
}
putgeterror () ;
}
else {
t = curexp ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
if ( curtype != 4 )
nostringerr ( 1046 ) ;
else {
n = writefiles ;
n0 = writefiles ;
do {
lab22: if ( n == 0 )
{
if ( n0 == writefiles )
if ( writefiles < 4 )
incr ( writefiles ) ;
else overflow ( 1047 , 4 ) ;
n = n0 ;
openwritefile ( curexp , n ) ;
}
else {
decr ( n ) ;
if ( wrfname [ n ] == 0 )
{
n0 = n ;
goto lab22 ;
}
}
} while ( ! ( strvsstr ( curexp , wrfname [ n ] ) == 0 ) ) ;
if ( eofline == 0 )
{
{
strpool [ poolptr ] = 0 ;
incr ( poolptr ) ;
}
eofline = makestring () ;
strref [ eofline ] = 127 ;
}
if ( strvsstr ( t , eofline ) == 0 )
{
aclose ( wrfile [ n ] ) ;
{
if ( strref [ wrfname [ n ] ] < 127 )
if ( strref [ wrfname [ n ] ] > 1 )
decr ( strref [ wrfname [ n ] ] ) ;
else flushstring ( wrfname [ n ] ) ;
}
wrfname [ n ] = 0 ;
if ( n == writefiles - 1 )
writefiles = n ;
}
else {
oldsetting = selector ;
selector = n ;
slowprint ( t ) ;
println () ;
selector = oldsetting ;
}
}
{
if ( strref [ t ] < 127 )
if ( strref [ t ] > 1 )
decr ( strref [ t ] ) ;
else flushstring ( t ) ;
}
}
flushcurexp ( 0 ) ;
}
eightbits getcode ( )
{/* 40 */ register eightbits Result; integer c ;
getxnext () ;
scanexpression () ;
if ( curtype == 16 )
{
c = roundunscaled ( curexp ) ;
if ( c >= 0 )
if ( c < 256 )
goto lab40 ;
}
else if ( curtype == 4 )
if ( ( strstart [ nextstr [ curexp ] ] - strstart [ curexp ] ) == 1 )
{
c = strpool [ strstart [ curexp ] ] ;
goto lab40 ;
}
disperr ( 0 , 1056 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1057 ;
helpline [ 0 ] = 1058 ;
}
putgetflusherror ( 0 ) ;
c = 0 ;
lab40: Result = c ;
return(Result) ;
}
void zsettag ( c , t , r )
halfword c ;
smallnumber t ;
halfword r ;
{if ( chartag [ c ] == 0 )
{
chartag [ c ] = t ;
charremainder [ c ] = r ;
if ( t == 1 )
{
incr ( labelptr ) ;
labelloc [ labelptr ] = r ;
labelchar [ labelptr ] = c ;
}
}
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1059 ) ;
}
if ( ( c > 32 ) && ( c < 127 ) )
print ( c ) ;
else if ( c == 256 )
print ( 1060 ) ;
else {
print ( 1061 ) ;
printint ( c ) ;
}
print ( 1062 ) ;
switch ( chartag [ c ] )
{case 1 :
print ( 1063 ) ;
break ;
case 2 :
print ( 1064 ) ;
break ;
case 3 :
print ( 1053 ) ;
break ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 1065 ;
helpline [ 0 ] = 1019 ;
}
putgeterror () ;
}
}
void dotfmcommand ( )
{/* 22 30 */ short c, cc ;
integer k ;
integer j ;
switch ( curmod )
{case 0 :
{
c = getcode () ;
while ( curcmd == 80 ) {
cc = getcode () ;
settag ( c , 2 , cc ) ;
c = cc ;
}
}
break ;
case 1 :
{
lkstarted = false ;
lab22: getxnext () ;
if ( ( curcmd == 77 ) && lkstarted )
{
c = getcode () ;
if ( nl - skiptable [ c ] > 128 )
{
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1082 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 1083 ;
}
error () ;
ll = skiptable [ c ] ;
do {
lll = ligkern [ ll ] .b0 ;
ligkern [ ll ] .b0 = 128 ;
ll = ll - lll ;
} while ( ! ( lll == 0 ) ) ;
}
skiptable [ c ] = ligtablesize ;
}
if ( skiptable [ c ] == ligtablesize )
ligkern [ nl - 1 ] .b0 = 0 ;
else ligkern [ nl - 1 ] .b0 = nl - skiptable [ c ] - 1 ;
skiptable [ c ] = nl - 1 ;
goto lab30 ;
}
if ( curcmd == 78 )
{
c = 256 ;
curcmd = 80 ;
}
else {
backinput () ;
c = getcode () ;
}
if ( ( curcmd == 80 ) || ( curcmd == 79 ) )
{
if ( curcmd == 80 )
if ( c == 256 )
bchlabel = nl ;
else settag ( c , 1 , nl ) ;
else if ( skiptable [ c ] < ligtablesize )
{
ll = skiptable [ c ] ;
skiptable [ c ] = ligtablesize ;
do {
lll = ligkern [ ll ] .b0 ;
if ( nl - ll > 128 )
{
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1082 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 1083 ;
}
error () ;
ll = ll ;
do {
lll = ligkern [ ll ] .b0 ;
ligkern [ ll ] .b0 = 128 ;
ll = ll - lll ;
} while ( ! ( lll == 0 ) ) ;
}
goto lab22 ;
}
ligkern [ ll ] .b0 = nl - ll - 1 ;
ll = ll - lll ;
} while ( ! ( lll == 0 ) ) ;
}
goto lab22 ;
}
if ( curcmd == 75 )
{
ligkern [ nl ] .b1 = c ;
ligkern [ nl ] .b0 = 0 ;
if ( curmod < 128 )
{
ligkern [ nl ] .b2 = curmod ;
ligkern [ nl ] .b3 = getcode () ;
}
else {
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 1084 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1085 ;
helpline [ 0 ] = 309 ;
}
putgetflusherror ( 0 ) ;
}
kern [ nk ] = curexp ;
k = 0 ;
while ( kern [ k ] != curexp ) incr ( k ) ;
if ( k == nk )
{
if ( nk == maxkerns )
overflow ( 1081 , maxkerns ) ;
incr ( nk ) ;
}
ligkern [ nl ] .b2 = 128 + ( k / 256 ) ;
ligkern [ nl ] .b3 = ( k % 256 ) ;
}
lkstarted = true ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 1070 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 1071 ;
}
backerror () ;
ligkern [ nl ] .b1 = 0 ;
ligkern [ nl ] .b2 = 0 ;
ligkern [ nl ] .b3 = 0 ;
ligkern [ nl ] .b0 = 129 ;
}
if ( nl == ligtablesize )
overflow ( 1072 , ligtablesize ) ;
incr ( nl ) ;
if ( curcmd == 81 )
goto lab22 ;
if ( ligkern [ nl - 1 ] .b0 < 128 )
ligkern [ nl - 1 ] .b0 = 128 ;
lab30: ;
}
break ;
case 2 :
{
if ( ne == 256 )
overflow ( 1053 , 256 ) ;
c = getcode () ;
settag ( c , 3 , ne ) ;
if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1086 ;
}
backerror () ;
}
exten [ ne ] .b0 = getcode () ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1086 ;
}
backerror () ;
}
exten [ ne ] .b1 = getcode () ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1086 ;
}
backerror () ;
}
exten [ ne ] .b2 = getcode () ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1086 ;
}
backerror () ;
}
exten [ ne ] .b3 = getcode () ;
incr ( ne ) ;
}
break ;
case 3 :
case 4 :
{
c = curmod ;
getxnext () ;
scanexpression () ;
if ( ( curtype != 16 ) || ( curexp < 32768L ) )
{
disperr ( 0 , 1066 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 1067 ;
helpline [ 0 ] = 1068 ;
}
putgeterror () ;
}
else {
j = roundunscaled ( curexp ) ;
if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 1069 ;
}
backerror () ;
}
if ( c == 3 )
do {
if ( j > headersize )
overflow ( 1054 , headersize ) ;
headerbyte [ j ] = getcode () ;
incr ( j ) ;
} while ( ! ( curcmd != 81 ) ) ;
else do {
if ( j > maxfontdimen )
overflow ( 1055 , maxfontdimen ) ;
while ( j > np ) {
incr ( np ) ;
param [ np ] = 0 ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 1087 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 309 ;
}
putgetflusherror ( 0 ) ;
}
param [ j ] = curexp ;
incr ( j ) ;
} while ( ! ( curcmd != 81 ) ) ;
}
}
break ;
}
}