#define EXTERN extern
#include "mfd.h"
void
#ifdef HAVE_PROTOTYPES
zsplitforoffset ( halfword p , fraction t )
#else
zsplitforoffset ( p , t )
halfword p ;
fraction t ;
#endif
{
halfword q ;
halfword r ;
q = mem [p ].hhfield .v.RH ;
splitcubic ( p , t , mem [q + 1 ].cint , mem [q + 2 ].cint ) ;
r = mem [p ].hhfield .v.RH ;
if ( mem [r + 2 ].cint < mem [p + 2 ].cint )
mem [r + 2 ].cint = mem [p + 2 ].cint ;
else if ( mem [r + 2 ].cint > mem [q + 2 ].cint )
mem [r + 2 ].cint = mem [q + 2 ].cint ;
if ( mem [r + 1 ].cint < mem [p + 1 ].cint )
mem [r + 1 ].cint = mem [p + 1 ].cint ;
else if ( mem [r + 1 ].cint > mem [q + 1 ].cint )
mem [r + 1 ].cint = mem [q + 1 ].cint ;
}
void
#ifdef HAVE_PROTOTYPES
zfinoffsetprep ( halfword p , halfword k , halfword w , integer x0 , integer
x1 , integer x2 , integer y0 , integer y1 , integer y2 , boolean rising ,
integer n )
#else
zfinoffsetprep ( p , k , w , x0 , x1 , x2 , y0 , y1 , y2 , rising , n )
halfword p ;
halfword k ;
halfword w ;
integer x0 ;
integer x1 ;
integer x2 ;
integer y0 ;
integer y1 ;
integer y2 ;
boolean rising ;
integer n ;
#endif
{
/* 10 */ halfword ww ;
scaled du, dv ;
integer t0, t1, t2 ;
fraction t ;
fraction s ;
integer v ;
while ( true ) {
mem [p ].hhfield .b1 = k ;
if ( rising )
if ( k == n )
goto lab10 ;
else ww = mem [w ].hhfield .v.RH ;
else if ( k == 1 )
goto lab10 ;
else ww = mem [w ].hhfield .lhfield ;
du = mem [ww + 1 ].cint - mem [w + 1 ].cint ;
dv = mem [ww + 2 ].cint - mem [w + 2 ].cint ;
if ( abs ( du ) >= abs ( dv ) )
{
s = makefraction ( dv , du ) ;
t0 = takefraction ( x0 , s ) - y0 ;
t1 = takefraction ( x1 , s ) - y1 ;
t2 = takefraction ( x2 , s ) - y2 ;
}
else {
s = makefraction ( du , dv ) ;
t0 = x0 - takefraction ( y0 , s ) ;
t1 = x1 - takefraction ( y1 , s ) ;
t2 = x2 - takefraction ( y2 , s ) ;
}
t = crossingpoint ( t0 , t1 , t2 ) ;
if ( t >= 268435456L )
goto lab10 ;
{
splitforoffset ( p , t ) ;
mem [p ].hhfield .b1 = k ;
p = mem [p ].hhfield .v.RH ;
v = x0 - takefraction ( x0 - x1 , t ) ;
x1 = x1 - takefraction ( x1 - x2 , t ) ;
x0 = v - takefraction ( v - x1 , t ) ;
v = y0 - takefraction ( y0 - y1 , t ) ;
y1 = y1 - takefraction ( y1 - y2 , t ) ;
y0 = v - takefraction ( v - y1 , t ) ;
t1 = t1 - takefraction ( t1 - t2 , t ) ;
if ( t1 > 0 )
t1 = 0 ;
t = crossingpoint ( 0 , - (integer) t1 , - (integer) t2 ) ;
if ( t < 268435456L )
{
splitforoffset ( p , t ) ;
mem [mem [p ].hhfield .v.RH ].hhfield .b1 = k ;
v = x1 - takefraction ( x1 - x2 , t ) ;
x1 = x0 - takefraction ( x0 - x1 , t ) ;
x2 = x1 - takefraction ( x1 - v , t ) ;
v = y1 - takefraction ( y1 - y2 , t ) ;
y1 = y0 - takefraction ( y0 - y1 , t ) ;
y2 = y1 - takefraction ( y1 - v , t ) ;
}
}
if ( rising )
incr ( k ) ;
else decr ( k ) ;
w = ww ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zoffsetprep ( halfword c , halfword h )
#else
zoffsetprep ( c , h )
halfword c ;
halfword h ;
#endif
{
/* 30 45 */ halfword n ;
halfword p, q, r, lh, ww ;
halfword k ;
halfword w ;
integer x0, x1, x2, y0, y1, y2 ;
integer t0, t1, t2 ;
integer du, dv, dx, dy ;
integer lmaxcoef ;
integer x0a, x1a, x2a, y0a, y1a, y2a ;
fraction t ;
fraction s ;
p = c ;
n = mem [h ].hhfield .lhfield ;
lh = mem [h ].hhfield .v.RH ;
while ( mem [p ].hhfield .b1 != 0 ) {
q = mem [p ].hhfield .v.RH ;
if ( n <= 1 )
mem [p ].hhfield .b1 = 1 ;
else {
x0 = mem [p + 5 ].cint - mem [p + 1 ].cint ;
x2 = mem [q + 1 ].cint - mem [q + 3 ].cint ;
x1 = mem [q + 3 ].cint - mem [p + 5 ].cint ;
y0 = mem [p + 6 ].cint - mem [p + 2 ].cint ;
y2 = mem [q + 2 ].cint - mem [q + 4 ].cint ;
y1 = mem [q + 4 ].cint - mem [p + 6 ].cint ;
lmaxcoef = abs ( x0 ) ;
if ( abs ( x1 ) > lmaxcoef )
lmaxcoef = abs ( x1 ) ;
if ( abs ( x2 ) > lmaxcoef )
lmaxcoef = abs ( x2 ) ;
if ( abs ( y0 ) > lmaxcoef )
lmaxcoef = abs ( y0 ) ;
if ( abs ( y1 ) > lmaxcoef )
lmaxcoef = abs ( y1 ) ;
if ( abs ( y2 ) > lmaxcoef )
lmaxcoef = abs ( y2 ) ;
if ( lmaxcoef == 0 )
goto lab45 ;
while ( lmaxcoef < 134217728L ) {
lmaxcoef = lmaxcoef + lmaxcoef ;
x0 = x0 + x0 ;
x1 = x1 + x1 ;
x2 = x2 + x2 ;
y0 = y0 + y0 ;
y1 = y1 + y1 ;
y2 = y2 + y2 ;
}
dx = x0 ;
dy = y0 ;
if ( dx == 0 )
if ( dy == 0 )
{
dx = x1 ;
dy = y1 ;
if ( dx == 0 )
if ( dy == 0 )
{
dx = x2 ;
dy = y2 ;
}
}
if ( dx == 0 )
finoffsetprep ( p , n , mem [mem [lh ].hhfield .lhfield ].hhfield
.lhfield , - (integer) x0 , - (integer) x1 , - (integer) x2 ,
- (integer) y0 , - (integer) y1 , - (integer) y2 , false , n ) ;
else {
k = 1 ;
w = mem [lh ].hhfield .v.RH ;
while ( true ) {
if ( k == n )
goto lab30 ;
ww = mem [w ].hhfield .v.RH ;
if ( abvscd ( dy , abs ( mem [ww + 1 ].cint - mem [w + 1 ].cint
) , dx , abs ( mem [ww + 2 ].cint - mem [w + 2 ].cint ) ) >= 0 )
{
incr ( k ) ;
w = ww ;
}
else goto lab30 ;
}
lab30: ;
if ( k == 1 )
t = 268435457L ;
else {
ww = mem [w ].hhfield .lhfield ;
du = mem [ww + 1 ].cint - mem [w + 1 ].cint ;
dv = mem [ww + 2 ].cint - mem [w + 2 ].cint ;
if ( abs ( du ) >= abs ( dv ) )
{
s = makefraction ( dv , du ) ;
t0 = takefraction ( x0 , s ) - y0 ;
t1 = takefraction ( x1 , s ) - y1 ;
t2 = takefraction ( x2 , s ) - y2 ;
}
else {
s = makefraction ( du , dv ) ;
t0 = x0 - takefraction ( y0 , s ) ;
t1 = x1 - takefraction ( y1 , s ) ;
t2 = x2 - takefraction ( y2 , s ) ;
}
t = crossingpoint ( - (integer) t0 , - (integer) t1 , - (integer) t2
) ;
}
if ( t >= 268435456L )
finoffsetprep ( p , k , w , x0 , x1 , x2 , y0 , y1 , y2 , true , n ) ;
else {
splitforoffset ( p , t ) ;
r = mem [p ].hhfield .v.RH ;
x1a = x0 - takefraction ( x0 - x1 , t ) ;
x1 = x1 - takefraction ( x1 - x2 , t ) ;
x2a = x1a - takefraction ( x1a - x1 , t ) ;
y1a = y0 - takefraction ( y0 - y1 , t ) ;
y1 = y1 - takefraction ( y1 - y2 , t ) ;
y2a = y1a - takefraction ( y1a - y1 , t ) ;
finoffsetprep ( p , k , w , x0 , x1a , x2a , y0 , y1a , y2a , true ,
n ) ;
x0 = x2a ;
y0 = y2a ;
t1 = t1 - takefraction ( t1 - t2 , t ) ;
if ( t1 < 0 )
t1 = 0 ;
t = crossingpoint ( 0 , t1 , t2 ) ;
if ( t < 268435456L )
{
splitforoffset ( r , t ) ;
x1a = x1 - takefraction ( x1 - x2 , t ) ;
x1 = x0 - takefraction ( x0 - x1 , t ) ;
x0a = x1 - takefraction ( x1 - x1a , t ) ;
y1a = y1 - takefraction ( y1 - y2 , t ) ;
y1 = y0 - takefraction ( y0 - y1 , t ) ;
y0a = y1 - takefraction ( y1 - y1a , t ) ;
finoffsetprep ( mem [r ].hhfield .v.RH , k , w , x0a , x1a , x2
, y0a , y1a , y2 , true , n ) ;
x2 = x0a ;
y2 = y0a ;
}
finoffsetprep ( r , k - 1 , ww , - (integer) x0 , - (integer) x1 ,
- (integer) x2 , - (integer) y0 , - (integer) y1 , - (integer) y2 ,
false , n ) ;
}
}
lab45: ;
}
do {
r = mem [p ].hhfield .v.RH ;
if ( mem [p + 1 ].cint == mem [p + 5 ].cint )
if ( mem [p + 2 ].cint == mem [p + 6 ].cint )
if ( mem [p + 1 ].cint == mem [r + 3 ].cint )
if ( mem [p + 2 ].cint == mem [r + 4 ].cint )
if ( mem [p + 1 ].cint == mem [r + 1 ].cint )
if ( mem [p + 2 ].cint == mem [r + 2 ].cint )
{
removecubic ( p ) ;
if ( r == q )
q = p ;
r = p ;
}
p = r ;
} while ( ! ( p == q ) ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zskewlineedges ( halfword p , halfword w , halfword ww )
#else
zskewlineedges ( p , w , ww )
halfword p ;
halfword w ;
halfword ww ;
#endif
{
scaled x0, y0, x1, y1 ;
if ( ( mem [w + 1 ].cint != mem [ww + 1 ].cint ) || ( mem [w + 2 ]
.cint != mem [ww + 2 ].cint ) )
{
x0 = mem [p + 1 ].cint + mem [w + 1 ].cint ;
y0 = mem [p + 2 ].cint + mem [w + 2 ].cint ;
x1 = mem [p + 1 ].cint + mem [ww + 1 ].cint ;
y1 = mem [p + 2 ].cint + mem [ww + 2 ].cint ;
unskew ( x0 , y0 , octant ) ;
x0 = curx ;
y0 = cury ;
unskew ( x1 , y1 , octant ) ;
;
#ifdef STAT
if ( internal [10 ]> 65536L )
{
printnl ( 583 ) ;
printtwo ( x0 , y0 ) ;
print ( 582 ) ;
printtwo ( curx , cury ) ;
printnl ( 283 ) ;
}
#endif /* STAT */
lineedges ( x0 , y0 , curx , cury ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zdualmoves ( halfword h , halfword p , halfword q )
#else
zdualmoves ( h , p , q )
halfword h ;
halfword p ;
halfword q ;
#endif
{
/* 30 31 */ halfword r, s ;
integer m, n ;
integer mm0, mm1 ;
integer k ;
halfword w, ww ;
integer smoothbot, smoothtop ;
scaled xx, yy, xp, yp, delx, dely, tx, ty ;
k = mem [h ].hhfield .lhfield + 1 ;
ww = mem [h ].hhfield .v.RH ;
w = mem [ww ].hhfield .lhfield ;
mm0 = floorunscaled ( mem [p + 1 ].cint + mem [w + 1 ].cint - xycorr [
octant ]) ;
mm1 = floorunscaled ( mem [q + 1 ].cint + mem [ww + 1 ].cint - xycorr [
octant ]) ;
{register integer for_end; n = 1 ;for_end = n1 - n0 + 1 ; if ( n <=
for_end) do
envmove [n ]= mm1 ;
while ( n++ < for_end ) ;}
envmove [0 ]= mm0 ;
moveptr = 0 ;
m = mm0 ;
r = p ;
while ( true ) {
if ( r == q )
smoothtop = moveptr ;
while ( mem [r ].hhfield .b1 != k ) {
xx = mem [r + 1 ].cint + mem [w + 1 ].cint ;
yy = mem [r + 2 ].cint + mem [w + 2 ].cint + 32768L ;
;
#ifdef STAT
if ( internal [10 ]> 65536L )
{
printnl ( 584 ) ;
printint ( k ) ;
print ( 585 ) ;
unskew ( xx , yy - 32768L , octant ) ;
printtwo ( curx , cury ) ;
}
#endif /* STAT */
if ( mem [r ].hhfield .b1 < k )
{
decr ( k ) ;
w = mem [w ].hhfield .lhfield ;
xp = mem [r + 1 ].cint + mem [w + 1 ].cint ;
yp = mem [r + 2 ].cint + mem [w + 2 ].cint + 32768L ;
if ( yp != yy )
{
ty = floorscaled ( yy - ycorr [octant ]) ;
dely = yp - yy ;
yy = yy - ty ;
ty = yp - ycorr [octant ]- ty ;
if ( ty >= 65536L )
{
delx = xp - xx ;
yy = 65536L - yy ;
while ( true ) {
if ( m < envmove [moveptr ])
envmove [moveptr ]= m ;
tx = takefraction ( delx , makefraction ( yy , dely ) ) ;
if ( abvscd ( tx , dely , delx , yy ) + xycorr [octant ]> 0 )
decr ( tx ) ;
m = floorunscaled ( xx + tx ) ;
ty = ty - 65536L ;
incr ( moveptr ) ;
if ( ty < 65536L )
goto lab31 ;
yy = yy + 65536L ;
}
lab31: if ( m < envmove [moveptr ])
envmove [moveptr ]= m ;
}
}
}
else {
incr ( k ) ;
w = mem [w ].hhfield .v.RH ;
xp = mem [r + 1 ].cint + mem [w + 1 ].cint ;
yp = mem [r + 2 ].cint + mem [w + 2 ].cint + 32768L ;
}
;
#ifdef STAT
if ( internal [10 ]> 65536L )
{
print ( 582 ) ;
unskew ( xp , yp - 32768L , octant ) ;
printtwo ( curx , cury ) ;
printnl ( 283 ) ;
}
#endif /* STAT */
m = floorunscaled ( xp - xycorr [octant ]) ;
moveptr = floorunscaled ( yp - ycorr [octant ]) - n0 ;
if ( m < envmove [moveptr ])
envmove [moveptr ]= m ;
}
if ( r == p )
smoothbot = moveptr ;
if ( r == q )
goto lab30 ;
move [moveptr ]= 1 ;
n = moveptr ;
s = mem [r ].hhfield .v.RH ;
makemoves ( mem [r + 1 ].cint + mem [w + 1 ].cint , mem [r + 5 ]
.cint + mem [w + 1 ].cint , mem [s + 3 ].cint + mem [w + 1 ].cint ,
mem [s + 1 ].cint + mem [w + 1 ].cint , mem [r + 2 ].cint + mem [w
+ 2 ].cint + 32768L , mem [r + 6 ].cint + mem [w + 2 ].cint + 32768L
, mem [s + 4 ].cint + mem [w + 2 ].cint + 32768L , mem [s + 2 ].cint
+ mem [w + 2 ].cint + 32768L , xycorr [octant ], ycorr [octant ]) ;
do {
if ( m < envmove [n ])
envmove [n ]= m ;
m = m + move [n ]- 1 ;
incr ( n ) ;
} while ( ! ( n > moveptr ) ) ;
r = s ;
}
lab30:
;
#ifdef TEXMF_DEBUG
if ( ( m != mm1 ) || ( moveptr != n1 - n0 ) )
confusion ( 50 ) ;
#endif /* TEXMF_DEBUG */
move [0 ]= d0 + envmove [1 ]- mm0 ;
{register integer for_end; n = 1 ;for_end = moveptr ; if ( n <= for_end)
do
move [n ]= envmove [n + 1 ]- envmove [n ]+ 1 ;
while ( n++ < for_end ) ;}
move [moveptr ]= move [moveptr ]- d1 ;
if ( internal [35 ]> 0 )
smoothmoves ( smoothbot , smoothtop ) ;
movetoedges ( m0 , n0 , m1 , n1 ) ;
if ( mem [q + 6 ].cint == 1 )
{
w = mem [h ].hhfield .v.RH ;
skewlineedges ( q , w , mem [w ].hhfield .lhfield ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zfillenvelope ( halfword spechead )
#else
zfillenvelope ( spechead )
halfword spechead ;
#endif
{
/* 30 31 */ halfword p, q, r, s ;
halfword h ;
halfword www ;
integer m, n ;
integer mm0, mm1 ;
integer k ;
halfword w, ww ;
integer smoothbot, smoothtop ;
scaled xx, yy, xp, yp, delx, dely, tx, ty ;
if ( internal [10 ]> 0 )
beginedgetracing () ;
p = spechead ;
do {
octant = mem [p + 3 ].cint ;
h = curpen + octant ;
q = p ;
while ( mem [q ].hhfield .b1 != 0 ) q = mem [q ].hhfield .v.RH ;
w = mem [h ].hhfield .v.RH ;
if ( mem [p + 4 ].cint == 1 )
w = mem [w ].hhfield .lhfield ;
;
#ifdef STAT
if ( internal [10 ]> 65536L )
{
printnl ( 579 ) ;
print ( octantdir [octant ]) ;
print ( 557 ) ;
printint ( mem [h ].hhfield .lhfield ) ;
print ( 580 ) ;
if ( mem [h ].hhfield .lhfield != 1 )
printchar ( 115 ) ;
print ( 581 ) ;
unskew ( mem [p + 1 ].cint + mem [w + 1 ].cint , mem [p + 2 ].cint
+ mem [w + 2 ].cint , octant ) ;
printtwo ( curx , cury ) ;
ww = mem [h ].hhfield .v.RH ;
if ( mem [q + 6 ].cint == 1 )
ww = mem [ww ].hhfield .lhfield ;
print ( 582 ) ;
unskew ( mem [q + 1 ].cint + mem [ww + 1 ].cint , mem [q + 2 ]
.cint + mem [ww + 2 ].cint , octant ) ;
printtwo ( curx , cury ) ;
}
#endif /* STAT */
ww = mem [h ].hhfield .v.RH ;
www = ww ;
if ( odd ( octantnumber [octant ]) )
www = mem [www ].hhfield .lhfield ;
else ww = mem [ww ].hhfield .lhfield ;
if ( w != ww )
skewlineedges ( p , w , ww ) ;
endround ( mem [p + 1 ].cint + mem [ww + 1 ].cint , mem [p + 2 ]
.cint + mem [ww + 2 ].cint ) ;
m0 = m1 ;
n0 = n1 ;
d0 = d1 ;
endround ( mem [q + 1 ].cint + mem [www + 1 ].cint , mem [q + 2 ]
.cint + mem [www + 2 ].cint ) ;
if ( n1 - n0 >= movesize )
overflow ( 539 , movesize ) ;
offsetprep ( p , h ) ;
q = p ;
while ( mem [q ].hhfield .b1 != 0 ) q = mem [q ].hhfield .v.RH ;
if ( odd ( octantnumber [octant ]) )
{
k = 0 ;
w = mem [h ].hhfield .v.RH ;
ww = mem [w ].hhfield .lhfield ;
mm0 = floorunscaled ( mem [p + 1 ].cint + mem [w + 1 ].cint - xycorr
[octant ]) ;
mm1 = floorunscaled ( mem [q + 1 ].cint + mem [ww + 1 ].cint -
xycorr [octant ]) ;
{register integer for_end; n = 0 ;for_end = n1 - n0 ; if ( n <=
for_end) do
envmove [n ]= mm0 ;
while ( n++ < for_end ) ;}
envmove [n1 - n0 ]= mm1 ;
moveptr = 0 ;
m = mm0 ;
r = p ;
mem [q ].hhfield .b1 = mem [h ].hhfield .lhfield + 1 ;
while ( true ) {
if ( r == q )
smoothtop = moveptr ;
while ( mem [r ].hhfield .b1 != k ) {
xx = mem [r + 1 ].cint + mem [w + 1 ].cint ;
yy = mem [r + 2 ].cint + mem [w + 2 ].cint + 32768L ;
;
#ifdef STAT
if ( internal [10 ]> 65536L )
{
printnl ( 584 ) ;
printint ( k ) ;
print ( 585 ) ;
unskew ( xx , yy - 32768L , octant ) ;
printtwo ( curx , cury ) ;
}
#endif /* STAT */
if ( mem [r ].hhfield .b1 > k )
{
incr ( k ) ;
w = mem [w ].hhfield .v.RH ;
xp = mem [r + 1 ].cint + mem [w + 1 ].cint ;
yp = mem [r + 2 ].cint + mem [w + 2 ].cint + 32768L ;
if ( yp != yy )
{
ty = floorscaled ( yy - ycorr [octant ]) ;
dely = yp - yy ;
yy = yy - ty ;
ty = yp - ycorr [octant ]- ty ;
if ( ty >= 65536L )
{
delx = xp - xx ;
yy = 65536L - yy ;
while ( true ) {
tx = takefraction ( delx , makefraction ( yy , dely ) ) ;
if ( abvscd ( tx , dely , delx , yy ) + xycorr [octant ]>
0 )
decr ( tx ) ;
m = floorunscaled ( xx + tx ) ;
if ( m > envmove [moveptr ])
envmove [moveptr ]= m ;
ty = ty - 65536L ;
if ( ty < 65536L )
goto lab31 ;
yy = yy + 65536L ;
incr ( moveptr ) ;
}
lab31: ;
}
}
}
else {
decr ( k ) ;
w = mem [w ].hhfield .lhfield ;
xp = mem [r + 1 ].cint + mem [w + 1 ].cint ;
yp = mem [r + 2 ].cint + mem [w + 2 ].cint + 32768L ;
}
;
#ifdef STAT
if ( internal [10 ]> 65536L )
{
print ( 582 ) ;
unskew ( xp , yp - 32768L , octant ) ;
printtwo ( curx , cury ) ;
printnl ( 283 ) ;
}
#endif /* STAT */
m = floorunscaled ( xp - xycorr [octant ]) ;
moveptr = floorunscaled ( yp - ycorr [octant ]) - n0 ;
if ( m > envmove [moveptr ])
envmove [moveptr ]= m ;
}
if ( r == p )
smoothbot = moveptr ;
if ( r == q )
goto lab30 ;
move [moveptr ]= 1 ;
n = moveptr ;
s = mem [r ].hhfield .v.RH ;
makemoves ( mem [r + 1 ].cint + mem [w + 1 ].cint , mem [r + 5 ]
.cint + mem [w + 1 ].cint , mem [s + 3 ].cint + mem [w + 1 ]
.cint , mem [s + 1 ].cint + mem [w + 1 ].cint , mem [r + 2 ]
.cint + mem [w + 2 ].cint + 32768L , mem [r + 6 ].cint + mem [w +
2 ].cint + 32768L , mem [s + 4 ].cint + mem [w + 2 ].cint +
32768L , mem [s + 2 ].cint + mem [w + 2 ].cint + 32768L , xycorr [
octant ], ycorr [octant ]) ;
do {
m = m + move [n ]- 1 ;
if ( m > envmove [n ])
envmove [n ]= m ;
incr ( n ) ;
} while ( ! ( n > moveptr ) ) ;
r = s ;
}
lab30:
;
#ifdef TEXMF_DEBUG
if ( ( m != mm1 ) || ( moveptr != n1 - n0 ) )
confusion ( 49 ) ;
#endif /* TEXMF_DEBUG */
move [0 ]= d0 + envmove [0 ]- mm0 ;
{register integer for_end; n = 1 ;for_end = moveptr ; if ( n <=
for_end) do
move [n ]= envmove [n ]- envmove [n - 1 ]+ 1 ;
while ( n++ < for_end ) ;}
move [moveptr ]= move [moveptr ]- d1 ;
if ( internal [35 ]> 0 )
smoothmoves ( smoothbot , smoothtop ) ;
movetoedges ( m0 , n0 , m1 , n1 ) ;
if ( mem [q + 6 ].cint == 0 )
{
w = mem [h ].hhfield .v.RH ;
skewlineedges ( q , mem [w ].hhfield .lhfield , w ) ;
}
}
else dualmoves ( h , p , q ) ;
mem [q ].hhfield .b1 = 0 ;
p = mem [q ].hhfield .v.RH ;
} while ( ! ( p == spechead ) ) ;
if ( internal [10 ]> 0 )
endedgetracing () ;
tossknotlist ( spechead ) ;
}
halfword
#ifdef HAVE_PROTOTYPES
zmakeellipse ( scaled majoraxis , scaled minoraxis , angle theta )
#else
zmakeellipse ( majoraxis , minoraxis , theta )
scaled majoraxis ;
scaled minoraxis ;
angle theta ;
#endif
{
/* 30 31 40 */ register halfword Result; halfword p, q, r, s ;
halfword h ;
integer alpha, beta, gamma, delta ;
integer c, d ;
integer u, v ;
boolean symmetric ;
if ( ( majoraxis == minoraxis ) || ( theta % 94371840L == 0 ) )
{
symmetric = true ;
alpha = 0 ;
if ( odd ( theta / 94371840L ) )
{
beta = majoraxis ;
gamma = minoraxis ;
nsin = 268435456L ;
ncos = 0 ;
}
else {
beta = minoraxis ;
gamma = majoraxis ;
}
}
else {
symmetric = false ;
nsincos ( theta ) ;
gamma = takefraction ( majoraxis , nsin ) ;
delta = takefraction ( minoraxis , ncos ) ;
beta = pythadd ( gamma , delta ) ;
alpha = makefraction ( gamma , beta ) ;
alpha = takefraction ( majoraxis , alpha ) ;
alpha = takefraction ( alpha , ncos ) ;
alpha = ( alpha + 32768L ) / 65536L ;
gamma = takefraction ( minoraxis , nsin ) ;
gamma = pythadd ( takefraction ( majoraxis , ncos ) , gamma ) ;
}
beta = ( beta + 32768L ) / 65536L ;
gamma = ( gamma + 32768L ) / 65536L ;
p = getnode ( 7 ) ;
q = getnode ( 7 ) ;
r = getnode ( 7 ) ;
if ( symmetric )
s = 0 ;
else s = getnode ( 7 ) ;
h = p ;
mem [p ].hhfield .v.RH = q ;
mem [q ].hhfield .v.RH = r ;
mem [r ].hhfield .v.RH = s ;
if ( beta == 0 )
beta = 1 ;
if ( gamma == 0 )
gamma = 1 ;
if ( gamma <= abs ( alpha ) )
if ( alpha > 0 )
alpha = gamma - 1 ;
else alpha = 1 - gamma ;
mem [p + 1 ].cint = - (integer) alpha * 32768L ;
mem [p + 2 ].cint = - (integer) beta * 32768L ;
mem [q + 1 ].cint = gamma * 32768L ;
mem [q + 2 ].cint = mem [p + 2 ].cint ;
mem [r + 1 ].cint = mem [q + 1 ].cint ;
mem [p + 5 ].cint = 0 ;
mem [q + 3 ].cint = -32768L ;
mem [q + 5 ].cint = 32768L ;
mem [r + 3 ].cint = 0 ;
mem [r + 5 ].cint = 0 ;
mem [p + 6 ].cint = beta ;
mem [q + 6 ].cint = gamma ;
mem [r + 6 ].cint = beta ;
mem [q + 4 ].cint = gamma + alpha ;
if ( symmetric )
{
mem [r + 2 ].cint = 0 ;
mem [r + 4 ].cint = beta ;
}
else {
mem [r + 2 ].cint = - (integer) mem [p + 2 ].cint ;
mem [r + 4 ].cint = beta + beta ;
mem [s + 1 ].cint = - (integer) mem [p + 1 ].cint ;
mem [s + 2 ].cint = mem [r + 2 ].cint ;
mem [s + 3 ].cint = 32768L ;
mem [s + 4 ].cint = gamma - alpha ;
}
while ( true ) {
u = mem [p + 5 ].cint + mem [q + 5 ].cint ;
v = mem [q + 3 ].cint + mem [r + 3 ].cint ;
c = mem [p + 6 ].cint + mem [q + 6 ].cint ;
delta = pythadd ( u , v ) ;
if ( majoraxis == minoraxis )
d = majoraxis ;
else {
if ( theta == 0 )
{
alpha = u ;
beta = v ;
}
else {
alpha = takefraction ( u , ncos ) + takefraction ( v , nsin ) ;
beta = takefraction ( v , ncos ) - takefraction ( u , nsin ) ;
}
alpha = makefraction ( alpha , delta ) ;
beta = makefraction ( beta , delta ) ;
d = pythadd ( takefraction ( majoraxis , alpha ) , takefraction (
minoraxis , beta ) ) ;
}
alpha = abs ( u ) ;
beta = abs ( v ) ;
if ( alpha < beta )
{
alpha = abs ( v ) ;
beta = abs ( u ) ;
}
if ( internal [38 ]!= 0 )
d = d - takefraction ( internal [38 ], makefraction ( beta + beta ,
delta ) ) ;
d = takefraction ( ( d + 4 ) / 8 , delta ) ;
alpha = alpha / 32768L ;
if ( d < alpha )
d = alpha ;
delta = c - d ;
if ( delta > 0 )
{
if ( delta > mem [r + 4 ].cint )
delta = mem [r + 4 ].cint ;
if ( delta >= mem [q + 4 ].cint )
{
delta = mem [q + 4 ].cint ;
mem [p + 6 ].cint = c - delta ;
mem [p + 5 ].cint = u ;
mem [q + 3 ].cint = v ;
mem [q + 1 ].cint = mem [q + 1 ].cint - delta * mem [r + 3 ]
.cint ;
mem [q + 2 ].cint = mem [q + 2 ].cint + delta * mem [q + 5 ]
.cint ;
mem [r + 4 ].cint = mem [r + 4 ].cint - delta ;
}
else {
s = getnode ( 7 ) ;
mem [p ].hhfield .v.RH = s ;
mem [s ].hhfield .v.RH = q ;
mem [s + 1 ].cint = mem [q + 1 ].cint + delta * mem [q + 3 ]
.cint ;
mem [s + 2 ].cint = mem [q + 2 ].cint - delta * mem [p + 5 ]
.cint ;
mem [q + 1 ].cint = mem [q + 1 ].cint - delta * mem [r + 3 ]
.cint ;
mem [q + 2 ].cint = mem [q + 2 ].cint + delta * mem [q + 5 ]
.cint ;
mem [s + 3 ].cint = mem [q + 3 ].cint ;
mem [s + 5 ].cint = u ;
mem [q + 3 ].cint = v ;
mem [s + 6 ].cint = c - delta ;
mem [s + 4 ].cint = mem [q + 4 ].cint - delta ;
mem [q + 4 ].cint = delta ;
mem [r + 4 ].cint = mem [r + 4 ].cint - delta ;
}
}
else p = q ;
while ( true ) {
q = mem [p ].hhfield .v.RH ;
if ( q == 0 )
goto lab30 ;
if ( mem [q + 4 ].cint == 0 )
{
mem [p ].hhfield .v.RH = mem [q ].hhfield .v.RH ;
mem [p + 6 ].cint = mem [q + 6 ].cint ;
mem [p + 5 ].cint = mem [q + 5 ].cint ;
freenode ( q , 7 ) ;
}
else {
r = mem [q ].hhfield .v.RH ;
if ( r == 0 )
goto lab30 ;
if ( mem [r + 4 ].cint == 0 )
{
mem [p ].hhfield .v.RH = r ;
freenode ( q , 7 ) ;
p = r ;
}
else goto lab40 ;
}
}
lab40: ;
}
lab30: ;
if ( symmetric )
{
s = 0 ;
q = h ;
while ( true ) {
r = getnode ( 7 ) ;
mem [r ].hhfield .v.RH = s ;
s = r ;
mem [s + 1 ].cint = mem [q + 1 ].cint ;
mem [s + 2 ].cint = - (integer) mem [q + 2 ].cint ;
if ( q == p )
goto lab31 ;
q = mem [q ].hhfield .v.RH ;
if ( mem [q + 2 ].cint == 0 )
goto lab31 ;
}
lab31: mem [p ].hhfield .v.RH = s ;
beta = - (integer) mem [h + 2 ].cint ;
while ( mem [p + 2 ].cint != beta ) p = mem [p ].hhfield .v.RH ;
q = mem [p ].hhfield .v.RH ;
}
if ( q != 0 )
{
if ( mem [h + 5 ].cint == 0 )
{
p = h ;
h = mem [h ].hhfield .v.RH ;
freenode ( p , 7 ) ;
mem [q + 1 ].cint = - (integer) mem [h + 1 ].cint ;
}
p = q ;
}
else q = p ;
r = mem [h ].hhfield .v.RH ;
do {
s = getnode ( 7 ) ;
mem [p ].hhfield .v.RH = s ;
p = s ;
mem [p + 1 ].cint = - (integer) mem [r + 1 ].cint ;
mem [p + 2 ].cint = - (integer) mem [r + 2 ].cint ;
r = mem [r ].hhfield .v.RH ;
} while ( ! ( r == q ) ) ;
mem [p ].hhfield .v.RH = h ;
Result = h ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zfinddirectiontime ( scaled x , scaled y , halfword h )
#else
zfinddirectiontime ( x , y , h )
scaled x ;
scaled y ;
halfword h ;
#endif
{
/* 10 40 45 30 */ register scaled Result; scaled max ;
halfword p, q ;
scaled n ;
scaled tt ;
scaled x1, x2, x3, y1, y2, y3 ;
angle theta, phi ;
fraction t ;
if ( abs ( x ) < abs ( y ) )
{
x = makefraction ( x , abs ( y ) ) ;
if ( y > 0 )
y = 268435456L ;
else y = -268435456L ;
}
else if ( x == 0 )
{
Result = 0 ;
goto lab10 ;
}
else {
y = makefraction ( y , abs ( x ) ) ;
if ( x > 0 )
x = 268435456L ;
else x = -268435456L ;
}
n = 0 ;
p = h ;
while ( true ) {
if ( mem [p ].hhfield .b1 == 0 )
goto lab45 ;
q = mem [p ].hhfield .v.RH ;
tt = 0 ;
x1 = mem [p + 5 ].cint - mem [p + 1 ].cint ;
x2 = mem [q + 3 ].cint - mem [p + 5 ].cint ;
x3 = mem [q + 1 ].cint - mem [q + 3 ].cint ;
y1 = mem [p + 6 ].cint - mem [p + 2 ].cint ;
y2 = mem [q + 4 ].cint - mem [p + 6 ].cint ;
y3 = mem [q + 2 ].cint - mem [q + 4 ].cint ;
max = abs ( x1 ) ;
if ( abs ( x2 ) > max )
max = abs ( x2 ) ;
if ( abs ( x3 ) > max )
max = abs ( x3 ) ;
if ( abs ( y1 ) > max )
max = abs ( y1 ) ;
if ( abs ( y2 ) > max )
max = abs ( y2 ) ;
if ( abs ( y3 ) > max )
max = abs ( y3 ) ;
if ( max == 0 )
goto lab40 ;
while ( max < 134217728L ) {
max = max + max ;
x1 = x1 + x1 ;
x2 = x2 + x2 ;
x3 = x3 + x3 ;
y1 = y1 + y1 ;
y2 = y2 + y2 ;
y3 = y3 + y3 ;
}
t = x1 ;
x1 = takefraction ( x1 , x ) + takefraction ( y1 , y ) ;
y1 = takefraction ( y1 , x ) - takefraction ( t , y ) ;
t = x2 ;
x2 = takefraction ( x2 , x ) + takefraction ( y2 , y ) ;
y2 = takefraction ( y2 , x ) - takefraction ( t , y ) ;
t = x3 ;
x3 = takefraction ( x3 , x ) + takefraction ( y3 , y ) ;
y3 = takefraction ( y3 , x ) - takefraction ( t , y ) ;
if ( y1 == 0 )
if ( x1 >= 0 )
goto lab40 ;
if ( n > 0 )
{
theta = narg ( x1 , y1 ) ;
if ( theta >= 0 )
if ( phi <= 0 )
if ( phi >= theta - 188743680L )
goto lab40 ;
if ( theta <= 0 )
if ( phi >= 0 )
if ( phi <= theta + 188743680L )
goto lab40 ;
if ( p == h )
goto lab45 ;
}
if ( ( x3 != 0 ) || ( y3 != 0 ) )
phi = narg ( x3 , y3 ) ;
if ( x1 < 0 )
if ( x2 < 0 )
if ( x3 < 0 )
goto lab30 ;
if ( abvscd ( y1 , y3 , y2 , y2 ) == 0 )
{
if ( abvscd ( y1 , y2 , 0 , 0 ) < 0 )
{
t = makefraction ( y1 , y1 - y2 ) ;
x1 = x1 - takefraction ( x1 - x2 , t ) ;
x2 = x2 - takefraction ( x2 - x3 , t ) ;
if ( x1 - takefraction ( x1 - x2 , t ) >= 0 )
{
tt = ( t + 2048 ) / 4096 ;
goto lab40 ;
}
}
else if ( y3 == 0 )
if ( y1 == 0 )
{
t = crossingpoint ( - (integer) x1 , - (integer) x2 , - (integer) x3 )
;
if ( t <= 268435456L )
{
tt = ( t + 2048 ) / 4096 ;
goto lab40 ;
}
if ( abvscd ( x1 , x3 , x2 , x2 ) <= 0 )
{
t = makefraction ( x1 , x1 - x2 ) ;
{
tt = ( t + 2048 ) / 4096 ;
goto lab40 ;
}
}
}
else if ( x3 >= 0 )
{
tt = 65536L ;
goto lab40 ;
}
goto lab30 ;
}
if ( y1 <= 0 )
if ( y1 < 0 )
{
y1 = - (integer) y1 ;
y2 = - (integer) y2 ;
y3 = - (integer) y3 ;
}
else if ( y2 > 0 )
{
y2 = - (integer) y2 ;
y3 = - (integer) y3 ;
}
t = crossingpoint ( y1 , y2 , y3 ) ;
if ( t > 268435456L )
goto lab30 ;
y2 = y2 - takefraction ( y2 - y3 , t ) ;
x1 = x1 - takefraction ( x1 - x2 , t ) ;
x2 = x2 - takefraction ( x2 - x3 , t ) ;
x1 = x1 - takefraction ( x1 - x2 , t ) ;
if ( x1 >= 0 )
{
tt = ( t + 2048 ) / 4096 ;
goto lab40 ;
}
if ( y2 > 0 )
y2 = 0 ;
tt = t ;
t = crossingpoint ( 0 , - (integer) y2 , - (integer) y3 ) ;
if ( t > 268435456L )
goto lab30 ;
x1 = x1 - takefraction ( x1 - x2 , t ) ;
x2 = x2 - takefraction ( x2 - x3 , t ) ;
if ( x1 - takefraction ( x1 - x2 , t ) >= 0 )
{
t = tt - takefraction ( tt - 268435456L , t ) ;
{
tt = ( t + 2048 ) / 4096 ;
goto lab40 ;
}
}
lab30: ;
p = q ;
n = n + 65536L ;
}
lab45: Result = -65536L ;
goto lab10 ;
lab40: Result = n + tt ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zcubicintersection ( halfword p , halfword pp )
#else
zcubicintersection ( p , pp )
halfword p ;
halfword pp ;
#endif
{
/* 22 45 10 */ halfword q, qq ;
timetogo = 5000 ;
maxt = 2 ;
q = mem [p ].hhfield .v.RH ;
qq = mem [pp ].hhfield .v.RH ;
bisectptr = 20 ;
bisectstack [bisectptr - 5 ]= mem [p + 5 ].cint - mem [p + 1 ].cint ;
bisectstack [bisectptr - 4 ]= mem [q + 3 ].cint - mem [p + 5 ].cint ;
bisectstack [bisectptr - 3 ]= mem [q + 1 ].cint - mem [q + 3 ].cint ;
if ( bisectstack [bisectptr - 5 ]< 0 )
if ( bisectstack [bisectptr - 3 ]>= 0 )
{
if ( bisectstack [bisectptr - 4 ]< 0 )
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
else bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 1 ]< 0 )
bisectstack [bisectptr - 1 ]= 0 ;
}
else {
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 2 ]> bisectstack [bisectptr - 5 ])
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
if ( bisectstack [bisectptr - 1 ]< 0 )
bisectstack [bisectptr - 1 ]= 0 ;
}
else if ( bisectstack [bisectptr - 3 ]<= 0 )
{
if ( bisectstack [bisectptr - 4 ]> 0 )
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
else bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 2 ]> 0 )
bisectstack [bisectptr - 2 ]= 0 ;
}
else {
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 1 ]< bisectstack [bisectptr - 5 ])
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
if ( bisectstack [bisectptr - 2 ]> 0 )
bisectstack [bisectptr - 2 ]= 0 ;
}
bisectstack [bisectptr - 10 ]= mem [p + 6 ].cint - mem [p + 2 ].cint ;
bisectstack [bisectptr - 9 ]= mem [q + 4 ].cint - mem [p + 6 ].cint ;
bisectstack [bisectptr - 8 ]= mem [q + 2 ].cint - mem [q + 4 ].cint ;
if ( bisectstack [bisectptr - 10 ]< 0 )
if ( bisectstack [bisectptr - 8 ]>= 0 )
{
if ( bisectstack [bisectptr - 9 ]< 0 )
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
else bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 6 ]< 0 )
bisectstack [bisectptr - 6 ]= 0 ;
}
else {
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 7 ]> bisectstack [bisectptr - 10 ])
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
if ( bisectstack [bisectptr - 6 ]< 0 )
bisectstack [bisectptr - 6 ]= 0 ;
}
else if ( bisectstack [bisectptr - 8 ]<= 0 )
{
if ( bisectstack [bisectptr - 9 ]> 0 )
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
else bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 7 ]> 0 )
bisectstack [bisectptr - 7 ]= 0 ;
}
else {
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 6 ]< bisectstack [bisectptr - 10 ])
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
if ( bisectstack [bisectptr - 7 ]> 0 )
bisectstack [bisectptr - 7 ]= 0 ;
}
bisectstack [bisectptr - 15 ]= mem [pp + 5 ].cint - mem [pp + 1 ].cint
;
bisectstack [bisectptr - 14 ]= mem [qq + 3 ].cint - mem [pp + 5 ].cint
;
bisectstack [bisectptr - 13 ]= mem [qq + 1 ].cint - mem [qq + 3 ].cint
;
if ( bisectstack [bisectptr - 15 ]< 0 )
if ( bisectstack [bisectptr - 13 ]>= 0 )
{
if ( bisectstack [bisectptr - 14 ]< 0 )
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
else bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 11 ]< 0 )
bisectstack [bisectptr - 11 ]= 0 ;
}
else {
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 12 ]> bisectstack [bisectptr - 15 ])
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
if ( bisectstack [bisectptr - 11 ]< 0 )
bisectstack [bisectptr - 11 ]= 0 ;
}
else if ( bisectstack [bisectptr - 13 ]<= 0 )
{
if ( bisectstack [bisectptr - 14 ]> 0 )
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
else bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 12 ]> 0 )
bisectstack [bisectptr - 12 ]= 0 ;
}
else {
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 11 ]< bisectstack [bisectptr - 15 ])
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
if ( bisectstack [bisectptr - 12 ]> 0 )
bisectstack [bisectptr - 12 ]= 0 ;
}
bisectstack [bisectptr - 20 ]= mem [pp + 6 ].cint - mem [pp + 2 ].cint
;
bisectstack [bisectptr - 19 ]= mem [qq + 4 ].cint - mem [pp + 6 ].cint
;
bisectstack [bisectptr - 18 ]= mem [qq + 2 ].cint - mem [qq + 4 ].cint
;
if ( bisectstack [bisectptr - 20 ]< 0 )
if ( bisectstack [bisectptr - 18 ]>= 0 )
{
if ( bisectstack [bisectptr - 19 ]< 0 )
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
else bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 16 ]< 0 )
bisectstack [bisectptr - 16 ]= 0 ;
}
else {
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 17 ]> bisectstack [bisectptr - 20 ])
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
if ( bisectstack [bisectptr - 16 ]< 0 )
bisectstack [bisectptr - 16 ]= 0 ;
}
else if ( bisectstack [bisectptr - 18 ]<= 0 )
{
if ( bisectstack [bisectptr - 19 ]> 0 )
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
else bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 17 ]> 0 )
bisectstack [bisectptr - 17 ]= 0 ;
}
else {
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 16 ]< bisectstack [bisectptr - 20 ])
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
if ( bisectstack [bisectptr - 17 ]> 0 )
bisectstack [bisectptr - 17 ]= 0 ;
}
delx = mem [p + 1 ].cint - mem [pp + 1 ].cint ;
dely = mem [p + 2 ].cint - mem [pp + 2 ].cint ;
tol = 0 ;
uv = bisectptr ;
xy = bisectptr ;
threel = 0 ;
curt = 1 ;
curtt = 1 ;
while ( true ) {
lab22: if ( delx - tol <= bisectstack [xy - 11 ]- bisectstack [uv - 2 ]
)
if ( delx + tol >= bisectstack [xy - 12 ]- bisectstack [uv - 1 ])
if ( dely - tol <= bisectstack [xy - 16 ]- bisectstack [uv - 7 ])
if ( dely + tol >= bisectstack [xy - 17 ]- bisectstack [uv - 6 ])
{
if ( curt >= maxt )
{
if ( maxt == 131072L )
{
curt = halfp ( curt + 1 ) ;
curtt = halfp ( curtt + 1 ) ;
goto lab10 ;
}
maxt = maxt + maxt ;
apprt = curt ;
apprtt = curtt ;
}
bisectstack [bisectptr ]= delx ;
bisectstack [bisectptr + 1 ]= dely ;
bisectstack [bisectptr + 2 ]= tol ;
bisectstack [bisectptr + 3 ]= uv ;
bisectstack [bisectptr + 4 ]= xy ;
bisectptr = bisectptr + 45 ;
curt = curt + curt ;
curtt = curtt + curtt ;
bisectstack [bisectptr - 25 ]= bisectstack [uv - 5 ];
bisectstack [bisectptr - 3 ]= bisectstack [uv - 3 ];
bisectstack [bisectptr - 24 ]= half ( bisectstack [bisectptr - 25 ]+
bisectstack [uv - 4 ]) ;
bisectstack [bisectptr - 4 ]= half ( bisectstack [bisectptr - 3 ]+
bisectstack [uv - 4 ]) ;
bisectstack [bisectptr - 23 ]= half ( bisectstack [bisectptr - 24 ]+
bisectstack [bisectptr - 4 ]) ;
bisectstack [bisectptr - 5 ]= bisectstack [bisectptr - 23 ];
if ( bisectstack [bisectptr - 25 ]< 0 )
if ( bisectstack [bisectptr - 23 ]>= 0 )
{
if ( bisectstack [bisectptr - 24 ]< 0 )
bisectstack [bisectptr - 22 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ];
else bisectstack [bisectptr - 22 ]= bisectstack [bisectptr - 25 ];
bisectstack [bisectptr - 21 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ]+ bisectstack [bisectptr - 23 ];
if ( bisectstack [bisectptr - 21 ]< 0 )
bisectstack [bisectptr - 21 ]= 0 ;
}
else {
bisectstack [bisectptr - 22 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ]+ bisectstack [bisectptr - 23 ];
if ( bisectstack [bisectptr - 22 ]> bisectstack [bisectptr - 25 ])
bisectstack [bisectptr - 22 ]= bisectstack [bisectptr - 25 ];
bisectstack [bisectptr - 21 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ];
if ( bisectstack [bisectptr - 21 ]< 0 )
bisectstack [bisectptr - 21 ]= 0 ;
}
else if ( bisectstack [bisectptr - 23 ]<= 0 )
{
if ( bisectstack [bisectptr - 24 ]> 0 )
bisectstack [bisectptr - 21 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ];
else bisectstack [bisectptr - 21 ]= bisectstack [bisectptr - 25 ];
bisectstack [bisectptr - 22 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ]+ bisectstack [bisectptr - 23 ];
if ( bisectstack [bisectptr - 22 ]> 0 )
bisectstack [bisectptr - 22 ]= 0 ;
}
else {
bisectstack [bisectptr - 21 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ]+ bisectstack [bisectptr - 23 ];
if ( bisectstack [bisectptr - 21 ]< bisectstack [bisectptr - 25 ])
bisectstack [bisectptr - 21 ]= bisectstack [bisectptr - 25 ];
bisectstack [bisectptr - 22 ]= bisectstack [bisectptr - 25 ]+
bisectstack [bisectptr - 24 ];
if ( bisectstack [bisectptr - 22 ]> 0 )
bisectstack [bisectptr - 22 ]= 0 ;
}
if ( bisectstack [bisectptr - 5 ]< 0 )
if ( bisectstack [bisectptr - 3 ]>= 0 )
{
if ( bisectstack [bisectptr - 4 ]< 0 )
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
else bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 1 ]< 0 )
bisectstack [bisectptr - 1 ]= 0 ;
}
else {
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 2 ]> bisectstack [bisectptr - 5 ])
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
if ( bisectstack [bisectptr - 1 ]< 0 )
bisectstack [bisectptr - 1 ]= 0 ;
}
else if ( bisectstack [bisectptr - 3 ]<= 0 )
{
if ( bisectstack [bisectptr - 4 ]> 0 )
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
else bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 2 ]> 0 )
bisectstack [bisectptr - 2 ]= 0 ;
}
else {
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ]+ bisectstack [bisectptr - 3 ];
if ( bisectstack [bisectptr - 1 ]< bisectstack [bisectptr - 5 ])
bisectstack [bisectptr - 1 ]= bisectstack [bisectptr - 5 ];
bisectstack [bisectptr - 2 ]= bisectstack [bisectptr - 5 ]+
bisectstack [bisectptr - 4 ];
if ( bisectstack [bisectptr - 2 ]> 0 )
bisectstack [bisectptr - 2 ]= 0 ;
}
bisectstack [bisectptr - 30 ]= bisectstack [uv - 10 ];
bisectstack [bisectptr - 8 ]= bisectstack [uv - 8 ];
bisectstack [bisectptr - 29 ]= half ( bisectstack [bisectptr - 30 ]+
bisectstack [uv - 9 ]) ;
bisectstack [bisectptr - 9 ]= half ( bisectstack [bisectptr - 8 ]+
bisectstack [uv - 9 ]) ;
bisectstack [bisectptr - 28 ]= half ( bisectstack [bisectptr - 29 ]+
bisectstack [bisectptr - 9 ]) ;
bisectstack [bisectptr - 10 ]= bisectstack [bisectptr - 28 ];
if ( bisectstack [bisectptr - 30 ]< 0 )
if ( bisectstack [bisectptr - 28 ]>= 0 )
{
if ( bisectstack [bisectptr - 29 ]< 0 )
bisectstack [bisectptr - 27 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ];
else bisectstack [bisectptr - 27 ]= bisectstack [bisectptr - 30 ];
bisectstack [bisectptr - 26 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ]+ bisectstack [bisectptr - 28 ];
if ( bisectstack [bisectptr - 26 ]< 0 )
bisectstack [bisectptr - 26 ]= 0 ;
}
else {
bisectstack [bisectptr - 27 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ]+ bisectstack [bisectptr - 28 ];
if ( bisectstack [bisectptr - 27 ]> bisectstack [bisectptr - 30 ])
bisectstack [bisectptr - 27 ]= bisectstack [bisectptr - 30 ];
bisectstack [bisectptr - 26 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ];
if ( bisectstack [bisectptr - 26 ]< 0 )
bisectstack [bisectptr - 26 ]= 0 ;
}
else if ( bisectstack [bisectptr - 28 ]<= 0 )
{
if ( bisectstack [bisectptr - 29 ]> 0 )
bisectstack [bisectptr - 26 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ];
else bisectstack [bisectptr - 26 ]= bisectstack [bisectptr - 30 ];
bisectstack [bisectptr - 27 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ]+ bisectstack [bisectptr - 28 ];
if ( bisectstack [bisectptr - 27 ]> 0 )
bisectstack [bisectptr - 27 ]= 0 ;
}
else {
bisectstack [bisectptr - 26 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ]+ bisectstack [bisectptr - 28 ];
if ( bisectstack [bisectptr - 26 ]< bisectstack [bisectptr - 30 ])
bisectstack [bisectptr - 26 ]= bisectstack [bisectptr - 30 ];
bisectstack [bisectptr - 27 ]= bisectstack [bisectptr - 30 ]+
bisectstack [bisectptr - 29 ];
if ( bisectstack [bisectptr - 27 ]> 0 )
bisectstack [bisectptr - 27 ]= 0 ;
}
if ( bisectstack [bisectptr - 10 ]< 0 )
if ( bisectstack [bisectptr - 8 ]>= 0 )
{
if ( bisectstack [bisectptr - 9 ]< 0 )
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
else bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 6 ]< 0 )
bisectstack [bisectptr - 6 ]= 0 ;
}
else {
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 7 ]> bisectstack [bisectptr - 10 ])
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
if ( bisectstack [bisectptr - 6 ]< 0 )
bisectstack [bisectptr - 6 ]= 0 ;
}
else if ( bisectstack [bisectptr - 8 ]<= 0 )
{
if ( bisectstack [bisectptr - 9 ]> 0 )
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
else bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 7 ]> 0 )
bisectstack [bisectptr - 7 ]= 0 ;
}
else {
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ]+ bisectstack [bisectptr - 8 ];
if ( bisectstack [bisectptr - 6 ]< bisectstack [bisectptr - 10 ])
bisectstack [bisectptr - 6 ]= bisectstack [bisectptr - 10 ];
bisectstack [bisectptr - 7 ]= bisectstack [bisectptr - 10 ]+
bisectstack [bisectptr - 9 ];
if ( bisectstack [bisectptr - 7 ]> 0 )
bisectstack [bisectptr - 7 ]= 0 ;
}
bisectstack [bisectptr - 35 ]= bisectstack [xy - 15 ];
bisectstack [bisectptr - 13 ]= bisectstack [xy - 13 ];
bisectstack [bisectptr - 34 ]= half ( bisectstack [bisectptr - 35 ]+
bisectstack [xy - 14 ]) ;
bisectstack [bisectptr - 14 ]= half ( bisectstack [bisectptr - 13 ]+
bisectstack [xy - 14 ]) ;
bisectstack [bisectptr - 33 ]= half ( bisectstack [bisectptr - 34 ]+
bisectstack [bisectptr - 14 ]) ;
bisectstack [bisectptr - 15 ]= bisectstack [bisectptr - 33 ];
if ( bisectstack [bisectptr - 35 ]< 0 )
if ( bisectstack [bisectptr - 33 ]>= 0 )
{
if ( bisectstack [bisectptr - 34 ]< 0 )
bisectstack [bisectptr - 32 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ];
else bisectstack [bisectptr - 32 ]= bisectstack [bisectptr - 35 ];
bisectstack [bisectptr - 31 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ]+ bisectstack [bisectptr - 33 ];
if ( bisectstack [bisectptr - 31 ]< 0 )
bisectstack [bisectptr - 31 ]= 0 ;
}
else {
bisectstack [bisectptr - 32 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ]+ bisectstack [bisectptr - 33 ];
if ( bisectstack [bisectptr - 32 ]> bisectstack [bisectptr - 35 ])
bisectstack [bisectptr - 32 ]= bisectstack [bisectptr - 35 ];
bisectstack [bisectptr - 31 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ];
if ( bisectstack [bisectptr - 31 ]< 0 )
bisectstack [bisectptr - 31 ]= 0 ;
}
else if ( bisectstack [bisectptr - 33 ]<= 0 )
{
if ( bisectstack [bisectptr - 34 ]> 0 )
bisectstack [bisectptr - 31 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ];
else bisectstack [bisectptr - 31 ]= bisectstack [bisectptr - 35 ];
bisectstack [bisectptr - 32 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ]+ bisectstack [bisectptr - 33 ];
if ( bisectstack [bisectptr - 32 ]> 0 )
bisectstack [bisectptr - 32 ]= 0 ;
}
else {
bisectstack [bisectptr - 31 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ]+ bisectstack [bisectptr - 33 ];
if ( bisectstack [bisectptr - 31 ]< bisectstack [bisectptr - 35 ])
bisectstack [bisectptr - 31 ]= bisectstack [bisectptr - 35 ];
bisectstack [bisectptr - 32 ]= bisectstack [bisectptr - 35 ]+
bisectstack [bisectptr - 34 ];
if ( bisectstack [bisectptr - 32 ]> 0 )
bisectstack [bisectptr - 32 ]= 0 ;
}
if ( bisectstack [bisectptr - 15 ]< 0 )
if ( bisectstack [bisectptr - 13 ]>= 0 )
{
if ( bisectstack [bisectptr - 14 ]< 0 )
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
else bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 11 ]< 0 )
bisectstack [bisectptr - 11 ]= 0 ;
}
else {
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 12 ]> bisectstack [bisectptr - 15 ])
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
if ( bisectstack [bisectptr - 11 ]< 0 )
bisectstack [bisectptr - 11 ]= 0 ;
}
else if ( bisectstack [bisectptr - 13 ]<= 0 )
{
if ( bisectstack [bisectptr - 14 ]> 0 )
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
else bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 12 ]> 0 )
bisectstack [bisectptr - 12 ]= 0 ;
}
else {
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ]+ bisectstack [bisectptr - 13 ];
if ( bisectstack [bisectptr - 11 ]< bisectstack [bisectptr - 15 ])
bisectstack [bisectptr - 11 ]= bisectstack [bisectptr - 15 ];
bisectstack [bisectptr - 12 ]= bisectstack [bisectptr - 15 ]+
bisectstack [bisectptr - 14 ];
if ( bisectstack [bisectptr - 12 ]> 0 )
bisectstack [bisectptr - 12 ]= 0 ;
}
bisectstack [bisectptr - 40 ]= bisectstack [xy - 20 ];
bisectstack [bisectptr - 18 ]= bisectstack [xy - 18 ];
bisectstack [bisectptr - 39 ]= half ( bisectstack [bisectptr - 40 ]+
bisectstack [xy - 19 ]) ;
bisectstack [bisectptr - 19 ]= half ( bisectstack [bisectptr - 18 ]+
bisectstack [xy - 19 ]) ;
bisectstack [bisectptr - 38 ]= half ( bisectstack [bisectptr - 39 ]+
bisectstack [bisectptr - 19 ]) ;
bisectstack [bisectptr - 20 ]= bisectstack [bisectptr - 38 ];
if ( bisectstack [bisectptr - 40 ]< 0 )
if ( bisectstack [bisectptr - 38 ]>= 0 )
{
if ( bisectstack [bisectptr - 39 ]< 0 )
bisectstack [bisectptr - 37 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ];
else bisectstack [bisectptr - 37 ]= bisectstack [bisectptr - 40 ];
bisectstack [bisectptr - 36 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ]+ bisectstack [bisectptr - 38 ];
if ( bisectstack [bisectptr - 36 ]< 0 )
bisectstack [bisectptr - 36 ]= 0 ;
}
else {
bisectstack [bisectptr - 37 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ]+ bisectstack [bisectptr - 38 ];
if ( bisectstack [bisectptr - 37 ]> bisectstack [bisectptr - 40 ])
bisectstack [bisectptr - 37 ]= bisectstack [bisectptr - 40 ];
bisectstack [bisectptr - 36 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ];
if ( bisectstack [bisectptr - 36 ]< 0 )
bisectstack [bisectptr - 36 ]= 0 ;
}
else if ( bisectstack [bisectptr - 38 ]<= 0 )
{
if ( bisectstack [bisectptr - 39 ]> 0 )
bisectstack [bisectptr - 36 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ];
else bisectstack [bisectptr - 36 ]= bisectstack [bisectptr - 40 ];
bisectstack [bisectptr - 37 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ]+ bisectstack [bisectptr - 38 ];
if ( bisectstack [bisectptr - 37 ]> 0 )
bisectstack [bisectptr - 37 ]= 0 ;
}
else {
bisectstack [bisectptr - 36 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ]+ bisectstack [bisectptr - 38 ];
if ( bisectstack [bisectptr - 36 ]< bisectstack [bisectptr - 40 ])
bisectstack [bisectptr - 36 ]= bisectstack [bisectptr - 40 ];
bisectstack [bisectptr - 37 ]= bisectstack [bisectptr - 40 ]+
bisectstack [bisectptr - 39 ];
if ( bisectstack [bisectptr - 37 ]> 0 )
bisectstack [bisectptr - 37 ]= 0 ;
}
if ( bisectstack [bisectptr - 20 ]< 0 )
if ( bisectstack [bisectptr - 18 ]>= 0 )
{
if ( bisectstack [bisectptr - 19 ]< 0 )
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
else bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 16 ]< 0 )
bisectstack [bisectptr - 16 ]= 0 ;
}
else {
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 17 ]> bisectstack [bisectptr - 20 ])
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
if ( bisectstack [bisectptr - 16 ]< 0 )
bisectstack [bisectptr - 16 ]= 0 ;
}
else if ( bisectstack [bisectptr - 18 ]<= 0 )
{
if ( bisectstack [bisectptr - 19 ]> 0 )
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
else bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 17 ]> 0 )
bisectstack [bisectptr - 17 ]= 0 ;
}
else {
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ]+ bisectstack [bisectptr - 18 ];
if ( bisectstack [bisectptr - 16 ]< bisectstack [bisectptr - 20 ])
bisectstack [bisectptr - 16 ]= bisectstack [bisectptr - 20 ];
bisectstack [bisectptr - 17 ]= bisectstack [bisectptr - 20 ]+
bisectstack [bisectptr - 19 ];
if ( bisectstack [bisectptr - 17 ]> 0 )
bisectstack [bisectptr - 17 ]= 0 ;
}
uv = bisectptr - 20 ;
xy = bisectptr - 20 ;
delx = delx + delx ;
dely = dely + dely ;
tol = tol - threel + tolstep ;
tol = tol + tol ;
threel = threel + tolstep ;
goto lab22 ;
}
if ( timetogo > 0 )
decr ( timetogo ) ;
else {
while ( apprt < 65536L ) {
apprt = apprt + apprt ;
apprtt = apprtt + apprtt ;
}
curt = apprt ;
curtt = apprtt ;
goto lab10 ;
}
lab45: if ( odd ( curtt ) )
if ( odd ( curt ) )
{
curt = halfp ( curt ) ;
curtt = halfp ( curtt ) ;
if ( curt == 0 )
goto lab10 ;
bisectptr = bisectptr - 45 ;
threel = threel - tolstep ;
delx = bisectstack [bisectptr ];
dely = bisectstack [bisectptr + 1 ];
tol = bisectstack [bisectptr + 2 ];
uv = bisectstack [bisectptr + 3 ];
xy = bisectstack [bisectptr + 4 ];
goto lab45 ;
}
else {
incr ( curt ) ;
delx = delx + bisectstack [uv - 5 ]+ bisectstack [uv - 4 ]+
bisectstack [uv - 3 ];
dely = dely + bisectstack [uv - 10 ]+ bisectstack [uv - 9 ]+
bisectstack [uv - 8 ];
uv = uv + 20 ;
decr ( curtt ) ;
xy = xy - 20 ;
delx = delx + bisectstack [xy - 15 ]+ bisectstack [xy - 14 ]+
bisectstack [xy - 13 ];
dely = dely + bisectstack [xy - 20 ]+ bisectstack [xy - 19 ]+
bisectstack [xy - 18 ];
}
else {
incr ( curtt ) ;
tol = tol + threel ;
delx = delx - bisectstack [xy - 15 ]- bisectstack [xy - 14 ]-
bisectstack [xy - 13 ];
dely = dely - bisectstack [xy - 20 ]- bisectstack [xy - 19 ]-
bisectstack [xy - 18 ];
xy = xy + 20 ;
}
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zpathintersection ( halfword h , halfword hh )
#else
zpathintersection ( h , hh )
halfword h ;
halfword hh ;
#endif
{
/* 10 */ halfword p, pp ;
integer n, nn ;
if ( mem [h ].hhfield .b1 == 0 )
{
mem [h + 5 ].cint = mem [h + 1 ].cint ;
mem [h + 3 ].cint = mem [h + 1 ].cint ;
mem [h + 6 ].cint = mem [h + 2 ].cint ;
mem [h + 4 ].cint = mem [h + 2 ].cint ;
mem [h ].hhfield .b1 = 1 ;
}
if ( mem [hh ].hhfield .b1 == 0 )
{
mem [hh + 5 ].cint = mem [hh + 1 ].cint ;
mem [hh + 3 ].cint = mem [hh + 1 ].cint ;
mem [hh + 6 ].cint = mem [hh + 2 ].cint ;
mem [hh + 4 ].cint = mem [hh + 2 ].cint ;
mem [hh ].hhfield .b1 = 1 ;
}
tolstep = 0 ;
do {
n = -65536L ;
p = h ;
do {
if ( mem [p ].hhfield .b1 != 0 )
{
nn = -65536L ;
pp = hh ;
do {
if ( mem [pp ].hhfield .b1 != 0 )
{
cubicintersection ( p , pp ) ;
if ( curt > 0 )
{
curt = curt + n ;
curtt = curtt + nn ;
goto lab10 ;
}
}
nn = nn + 65536L ;
pp = mem [pp ].hhfield .v.RH ;
} while ( ! ( pp == hh ) ) ;
}
n = n + 65536L ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == h ) ) ;
tolstep = tolstep + 3 ;
} while ( ! ( tolstep > 3 ) ) ;
curt = -65536L ;
curtt = -65536L ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zopenawindow ( windownumber k , scaled r0 , scaled c0 , scaled r1 , scaled c1
, scaled x , scaled y )
#else
zopenawindow ( k , r0 , c0 , r1 , c1 , x , y )
windownumber k ;
scaled r0 ;
scaled c0 ;
scaled r1 ;
scaled c1 ;
scaled x ;
scaled y ;
#endif
{
integer m, n ;
if ( r0 < 0 )
r0 = 0 ;
else r0 = roundunscaled ( r0 ) ;
r1 = roundunscaled ( r1 ) ;
if ( r1 > screendepth )
r1 = screendepth ;
if ( r1 < r0 )
if ( r0 > screendepth )
r0 = r1 ;
else r1 = r0 ;
if ( c0 < 0 )
c0 = 0 ;
else c0 = roundunscaled ( c0 ) ;
c1 = roundunscaled ( c1 ) ;
if ( c1 > screenwidth )
c1 = screenwidth ;
if ( c1 < c0 )
if ( c0 > screenwidth )
c0 = c1 ;
else c1 = c0 ;
windowopen [k ]= true ;
incr ( windowtime [k ]) ;
leftcol [k ]= c0 ;
rightcol [k ]= c1 ;
toprow [k ]= r0 ;
botrow [k ]= r1 ;
m = roundunscaled ( x ) ;
n = roundunscaled ( y ) - 1 ;
mwindow [k ]= c0 - m ;
nwindow [k ]= r0 + n ;
{
if ( ! screenstarted )
{
screenOK = initscreen () ;
screenstarted = true ;
}
}
if ( screenOK )
{
blankrectangle ( c0 , c1 , r0 , r1 ) ;
updatescreen () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zdispedges ( windownumber k )
#else
zdispedges ( k )
windownumber k ;
#endif
{
/* 30 40 */ halfword p, q ;
boolean alreadythere ;
integer r ;
screencol n ;
integer w, ww ;
pixelcolor b ;
integer m, mm ;
integer d ;
integer madjustment ;
integer rightedge ;
screencol mincol ;
if ( screenOK )
if ( leftcol [k ]< rightcol [k ])
if ( toprow [k ]< botrow [k ])
{
alreadythere = false ;
if ( mem [curedges + 3 ].hhfield .v.RH == k )
if ( mem [curedges + 4 ].cint == windowtime [k ])
alreadythere = true ;
if ( ! alreadythere )
blankrectangle ( leftcol [k ], rightcol [k ], toprow [k ], botrow [
k ]) ;
madjustment = mwindow [k ]- mem [curedges + 3 ].hhfield .lhfield ;
rightedge = 8 * ( rightcol [k ]- madjustment ) ;
mincol = leftcol [k ];
p = mem [curedges ].hhfield .v.RH ;
r = nwindow [k ]- ( mem [curedges + 1 ].hhfield .lhfield - 4096 ) ;
while ( ( p != curedges ) && ( r >= toprow [k ]) ) {
if ( r < botrow [k ])
{
if ( mem [p + 1 ].hhfield .lhfield > 1 )
sortedges ( p ) ;
else if ( mem [p + 1 ].hhfield .lhfield == 1 )
if ( alreadythere )
goto lab30 ;
mem [p + 1 ].hhfield .lhfield = 1 ;
n = 0 ;
ww = 0 ;
m = -1 ;
w = 0 ;
q = mem [p + 1 ].hhfield .v.RH ;
rowtransition [0 ]= mincol ;
while ( true ) {
if ( q == memtop )
d = rightedge ;
else d = mem [q ].hhfield .lhfield ;
mm = ( d / 8 ) + madjustment ;
if ( mm != m )
{
if ( w <= 0 )
{
if ( ww > 0 )
if ( m > mincol )
{
if ( n == 0 )
if ( alreadythere )
{
b = 0 ;
incr ( n ) ;
}
else b = 1 ;
else incr ( n ) ;
rowtransition [n ]= m ;
}
}
else if ( ww <= 0 )
if ( m > mincol )
{
if ( n == 0 )
b = 1 ;
incr ( n ) ;
rowtransition [n ]= m ;
}
m = mm ;
w = ww ;
}
if ( d >= rightedge )
goto lab40 ;
ww = ww + ( d % 8 ) - 4 ;
q = mem [q ].hhfield .v.RH ;
}
lab40: if ( alreadythere || ( ww > 0 ) )
{
if ( n == 0 )
if ( ww > 0 )
b = 1 ;
else b = 0 ;
incr ( n ) ;
rowtransition [n ]= rightcol [k ];
}
else if ( n == 0 )
goto lab30 ;
paintrow ( r , b , rowtransition , n ) ;
lab30: ;
}
p = mem [p ].hhfield .v.RH ;
decr ( r ) ;
}
updatescreen () ;
incr ( windowtime [k ]) ;
mem [curedges + 3 ].hhfield .v.RH = k ;
mem [curedges + 4 ].cint = windowtime [k ];
}
}
fraction
#ifdef HAVE_PROTOTYPES
zmaxcoef ( halfword p )
#else
zmaxcoef ( p )
halfword p ;
#endif
{
register fraction Result; fraction x ;
x = 0 ;
while ( mem [p ].hhfield .lhfield != 0 ) {
if ( abs ( mem [p + 1 ].cint ) > x )
x = abs ( mem [p + 1 ].cint ) ;
p = mem [p ].hhfield .v.RH ;
}
Result = x ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zpplusq ( halfword p , halfword q , smallnumber t )
#else
zpplusq ( p , q , t )
halfword p ;
halfword q ;
smallnumber t ;
#endif
{
/* 30 */ register halfword Result; halfword pp, qq ;
halfword r, s ;
integer threshold ;
integer v ;
if ( t == 17 )
threshold = 2685 ;
else threshold = 8 ;
r = memtop - 1 ;
pp = mem [p ].hhfield .lhfield ;
qq = mem [q ].hhfield .lhfield ;
while ( true ) if ( pp == qq )
if ( pp == 0 )
goto lab30 ;
else {
v = mem [p + 1 ].cint + mem [q + 1 ].cint ;
mem [p + 1 ].cint = v ;
s = p ;
p = mem [p ].hhfield .v.RH ;
pp = mem [p ].hhfield .lhfield ;
if ( abs ( v ) < threshold )
freenode ( s , 2 ) ;
else {
if ( abs ( v ) >= 626349397L )
if ( watchcoefs )
{
mem [qq ].hhfield .b0 = 0 ;
fixneeded = true ;
}
mem [r ].hhfield .v.RH = s ;
r = s ;
}
q = mem [q ].hhfield .v.RH ;
qq = mem [q ].hhfield .lhfield ;
}
else if ( mem [pp + 1 ].cint < mem [qq + 1 ].cint )
{
s = getnode ( 2 ) ;
mem [s ].hhfield .lhfield = qq ;
mem [s + 1 ].cint = mem [q + 1 ].cint ;
q = mem [q ].hhfield .v.RH ;
qq = mem [q ].hhfield .lhfield ;
mem [r ].hhfield .v.RH = s ;
r = s ;
}
else {
mem [r ].hhfield .v.RH = p ;
r = p ;
p = mem [p ].hhfield .v.RH ;
pp = mem [p ].hhfield .lhfield ;
}
lab30: mem [p + 1 ].cint = slowadd ( mem [p + 1 ].cint , mem [q + 1 ]
.cint ) ;
mem [r ].hhfield .v.RH = p ;
depfinal = p ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zptimesv ( halfword p , integer v , smallnumber t0 , smallnumber t1 , boolean
visscaled )
#else
zptimesv ( p , v , t0 , t1 , visscaled )
halfword p ;
integer v ;
smallnumber t0 ;
smallnumber t1 ;
boolean visscaled ;
#endif
{
register halfword Result; halfword r, s ;
integer w ;
integer threshold ;
boolean scalingdown ;
if ( t0 != t1 )
scalingdown = true ;
else scalingdown = ! visscaled ;
if ( t1 == 17 )
threshold = 1342 ;
else threshold = 4 ;
r = memtop - 1 ;
while ( mem [p ].hhfield .lhfield != 0 ) {
if ( scalingdown )
w = takefraction ( v , mem [p + 1 ].cint ) ;
else w = takescaled ( v , mem [p + 1 ].cint ) ;
if ( abs ( w ) <= threshold )
{
s = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
p = s ;
}
else {
if ( abs ( w ) >= 626349397L )
{
fixneeded = true ;
mem [mem [p ].hhfield .lhfield ].hhfield .b0 = 0 ;
}
mem [r ].hhfield .v.RH = p ;
r = p ;
mem [p + 1 ].cint = w ;
p = mem [p ].hhfield .v.RH ;
}
}
mem [r ].hhfield .v.RH = p ;
if ( visscaled )
mem [p + 1 ].cint = takescaled ( mem [p + 1 ].cint , v ) ;
else mem [p + 1 ].cint = takefraction ( mem [p + 1 ].cint , v ) ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zpwithxbecomingq ( halfword p , halfword x , halfword q , smallnumber t )
#else
zpwithxbecomingq ( p , x , q , t )
halfword p ;
halfword x ;
halfword q ;
smallnumber t ;
#endif
{
register halfword Result; halfword r, s ;
integer v ;
integer sx ;
s = p ;
r = memtop - 1 ;
sx = mem [x + 1 ].cint ;
while ( mem [mem [s ].hhfield .lhfield + 1 ].cint > sx ) {
r = s ;
s = mem [s ].hhfield .v.RH ;
}
if ( mem [s ].hhfield .lhfield != x )
Result = p ;
else {
mem [memtop - 1 ].hhfield .v.RH = p ;
mem [r ].hhfield .v.RH = mem [s ].hhfield .v.RH ;
v = mem [s + 1 ].cint ;
freenode ( s , 2 ) ;
Result = pplusfq ( mem [memtop - 1 ].hhfield .v.RH , v , q , t , 17 ) ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
znewdep ( halfword q , halfword p )
#else
znewdep ( q , p )
halfword q ;
halfword p ;
#endif
{
halfword r ;
mem [q + 1 ].hhfield .v.RH = p ;
mem [q + 1 ].hhfield .lhfield = 13 ;
r = mem [13 ].hhfield .v.RH ;
mem [depfinal ].hhfield .v.RH = r ;
mem [r + 1 ].hhfield .lhfield = depfinal ;
mem [13 ].hhfield .v.RH = q ;
}
halfword
#ifdef HAVE_PROTOTYPES
zconstdependency ( scaled v )
#else
zconstdependency ( v )
scaled v ;
#endif
{
register halfword Result; depfinal = getnode ( 2 ) ;
mem [depfinal + 1 ].cint = v ;
mem [depfinal ].hhfield .lhfield = 0 ;
Result = depfinal ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zsingledependency ( halfword p )
#else
zsingledependency ( p )
halfword p ;
#endif
{
register halfword Result; halfword q ;
integer m ;
m = mem [p + 1 ].cint % 64 ;
if ( m > 28 )
Result = constdependency ( 0 ) ;
else {
q = getnode ( 2 ) ;
mem [q + 1 ].cint = twotothe [28 - m ];
mem [q ].hhfield .lhfield = p ;
mem [q ].hhfield .v.RH = constdependency ( 0 ) ;
Result = q ;
}
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zcopydeplist ( halfword p )
#else
zcopydeplist ( p )
halfword p ;
#endif
{
/* 30 */ register halfword Result; halfword q ;
q = getnode ( 2 ) ;
depfinal = q ;
while ( true ) {
mem [depfinal ].hhfield .lhfield = mem [p ].hhfield .lhfield ;
mem [depfinal + 1 ].cint = mem [p + 1 ].cint ;
if ( mem [depfinal ].hhfield .lhfield == 0 )
goto lab30 ;
mem [depfinal ].hhfield .v.RH = getnode ( 2 ) ;
depfinal = mem [depfinal ].hhfield .v.RH ;
p = mem [p ].hhfield .v.RH ;
}
lab30: Result = q ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zlineareq ( halfword p , smallnumber t )
#else
zlineareq ( p , t )
halfword p ;
smallnumber t ;
#endif
{
halfword q, r, s ;
halfword x ;
integer n ;
integer v ;
halfword prevr ;
halfword finalnode ;
integer w ;
q = p ;
r = mem [p ].hhfield .v.RH ;
v = mem [q + 1 ].cint ;
while ( mem [r ].hhfield .lhfield != 0 ) {
if ( abs ( mem [r + 1 ].cint ) > abs ( v ) )
{
q = r ;
v = mem [r + 1 ].cint ;
}
r = mem [r ].hhfield .v.RH ;
}
x = mem [q ].hhfield .lhfield ;
n = mem [x + 1 ].cint % 64 ;
s = memtop - 1 ;
mem [s ].hhfield .v.RH = p ;
r = p ;
do {
if ( r == q )
{
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
freenode ( r , 2 ) ;
}
else {
w = makefraction ( mem [r + 1 ].cint , v ) ;
if ( abs ( w ) <= 1342 )
{
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
freenode ( r , 2 ) ;
}
else {
mem [r + 1 ].cint = - (integer) w ;
s = r ;
}
}
r = mem [s ].hhfield .v.RH ;
} while ( ! ( mem [r ].hhfield .lhfield == 0 ) ) ;
if ( t == 18 )
mem [r + 1 ].cint = - (integer) makescaled ( mem [r + 1 ].cint , v ) ;
else if ( v != -268435456L )
mem [r + 1 ].cint = - (integer) makefraction ( mem [r + 1 ].cint , v ) ;
finalnode = r ;
p = mem [memtop - 1 ].hhfield .v.RH ;
if ( internal [2 ]> 0 )
if ( interesting ( x ) )
{
begindiagnostic () ;
printnl ( 594 ) ;
printvariablename ( x ) ;
w = n ;
while ( w > 0 ) {
print ( 587 ) ;
w = w - 2 ;
}
printchar ( 61 ) ;
printdependency ( p , 17 ) ;
enddiagnostic ( false ) ;
}
prevr = 13 ;
r = mem [13 ].hhfield .v.RH ;
while ( r != 13 ) {
s = mem [r + 1 ].hhfield .v.RH ;
q = pwithxbecomingq ( s , x , p , mem [r ].hhfield .b0 ) ;
if ( mem [q ].hhfield .lhfield == 0 )
makeknown ( r , q ) ;
else {
mem [r + 1 ].hhfield .v.RH = q ;
do {
q = mem [q ].hhfield .v.RH ;
} while ( ! ( mem [q ].hhfield .lhfield == 0 ) ) ;
prevr = q ;
}
r = mem [prevr ].hhfield .v.RH ;
}
if ( n > 0 )
{
s = memtop - 1 ;
mem [memtop - 1 ].hhfield .v.RH = p ;
r = p ;
do {
if ( n > 30 )
w = 0 ;
else w = mem [r + 1 ].cint / twotothe [n ];
if ( ( abs ( w ) <= 1342 ) && ( mem [r ].hhfield .lhfield != 0 ) )
{
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
freenode ( r , 2 ) ;
}
else {
mem [r + 1 ].cint = w ;
s = r ;
}
r = mem [s ].hhfield .v.RH ;
} while ( ! ( mem [s ].hhfield .lhfield == 0 ) ) ;
p = mem [memtop - 1 ].hhfield .v.RH ;
}
if ( mem [p ].hhfield .lhfield == 0 )
{
mem [x ].hhfield .b0 = 16 ;
mem [x + 1 ].cint = mem [p + 1 ].cint ;
if ( abs ( mem [x + 1 ].cint ) >= 268435456L )
valtoobig ( mem [x + 1 ].cint ) ;
freenode ( p , 2 ) ;
if ( curexp == x )
if ( curtype == 19 )
{
curexp = mem [x + 1 ].cint ;
curtype = 16 ;
freenode ( x , 2 ) ;
}
}
else {
mem [x ].hhfield .b0 = 17 ;
depfinal = finalnode ;
newdep ( x , p ) ;
if ( curexp == x )
if ( curtype == 19 )
curtype = 17 ;
}
if ( fixneeded )
fixdependencies () ;
}
halfword
#ifdef HAVE_PROTOTYPES
znewringentry ( halfword p )
#else
znewringentry ( p )
halfword p ;
#endif
{
register halfword Result; halfword q ;
q = getnode ( 2 ) ;
mem [q ].hhfield .b1 = 11 ;
mem [q ].hhfield .b0 = mem [p ].hhfield .b0 ;
if ( mem [p + 1 ].cint == 0 )
mem [q + 1 ].cint = p ;
else mem [q + 1 ].cint = mem [p + 1 ].cint ;
mem [p + 1 ].cint = q ;
Result = q ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
znonlineareq ( integer v , halfword p , boolean flushp )
#else
znonlineareq ( v , p , flushp )
integer v ;
halfword p ;
boolean flushp ;
#endif
{
smallnumber t ;
halfword q, r ;
t = mem [p ].hhfield .b0 - 1 ;
q = mem [p + 1 ].cint ;
if ( flushp )
mem [p ].hhfield .b0 = 1 ;
else p = q ;
do {
r = mem [q + 1 ].cint ;
mem [q ].hhfield .b0 = t ;
switch ( t )
{case 2 :
mem [q + 1 ].cint = v ;
break ;
case 4 :
{
mem [q + 1 ].cint = v ;
{
if ( strref [v ]< 127 )
incr ( strref [v ]) ;
}
}
break ;
case 6 :
{
mem [q + 1 ].cint = v ;
incr ( mem [v ].hhfield .lhfield ) ;
}
break ;
case 9 :
mem [q + 1 ].cint = copypath ( v ) ;
break ;
case 11 :
mem [q + 1 ].cint = copyedges ( v ) ;
break ;
}
q = r ;
} while ( ! ( q == p ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
zringmerge ( halfword p , halfword q )
#else
zringmerge ( p , q )
halfword p ;
halfword q ;
#endif
{
/* 10 */ halfword r ;
r = mem [p + 1 ].cint ;
while ( r != p ) {
if ( r == q )
{
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 597 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 598 ;
helpline [0 ]= 599 ;
}
putgeterror () ;
}
goto lab10 ;
}
r = mem [r + 1 ].cint ;
}
r = mem [p + 1 ].cint ;
mem [p + 1 ].cint = mem [q + 1 ].cint ;
mem [q + 1 ].cint = r ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zshowcmdmod ( integer c , integer m )
#else
zshowcmdmod ( c , m )
integer c ;
integer m ;
#endif
{
begindiagnostic () ;
printnl ( 123 ) ;
printcmdmod ( c , m ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
void
#ifdef HAVE_PROTOTYPES
showcontext ( void )
#else
showcontext ( )
#endif
{
/* 30 */ char oldsetting ;
integer i ;
integer l ;
integer m ;
integer n ;
integer p ;
integer q ;
fileptr = inputptr ;
inputstack [fileptr ]= curinput ;
while ( true ) {
curinput = inputstack [fileptr ];
if ( ( fileptr == inputptr ) || ( curinput .indexfield <= 15 ) || (
curinput .indexfield != 19 ) || ( curinput .locfield != 0 ) )
{
tally = 0 ;
oldsetting = selector ;
if ( ( curinput .indexfield <= 15 ) )
{
if ( curinput .namefield <= 1 )
if ( ( curinput .namefield == 0 ) && ( fileptr == 0 ) )
printnl ( 601 ) ;
else printnl ( 602 ) ;
else if ( curinput .namefield == 2 )
printnl ( 603 ) ;
else {
printnl ( curinput .namefield ) ;
print ( 58 ) ;
printint ( line ) ;
print ( 58 ) ;
}
printchar ( 32 ) ;
{
l = tally ;
tally = 0 ;
selector = 4 ;
trickcount = 1000000L ;
}
if ( curinput .limitfield > 0 )
{register integer for_end; i = curinput .startfield ;for_end =
curinput .limitfield - 1 ; if ( i <= for_end) do
{
if ( i == curinput .locfield )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
print ( buffer [i ]) ;
}
while ( i++ < for_end ) ;}
}
else {
switch ( curinput .indexfield )
{case 16 :
printnl ( 604 ) ;
break ;
case 17 :
{
printnl ( 609 ) ;
p = paramstack [curinput .limitfield ];
if ( p != 0 )
if ( mem [p ].hhfield .v.RH == 1 )
printexp ( p , 0 ) ;
else showtokenlist ( p , 0 , 20 , tally ) ;
print ( 610 ) ;
}
break ;
case 18 :
printnl ( 605 ) ;
break ;
case 19 :
if ( curinput .locfield == 0 )
printnl ( 606 ) ;
else printnl ( 607 ) ;
break ;
case 20 :
printnl ( 608 ) ;
break ;
case 21 :
{
println () ;
if ( curinput .namefield != 0 )
print ( hash [curinput .namefield ].v.RH ) ;
else {
p = paramstack [curinput .limitfield ];
if ( p == 0 )
showtokenlist ( paramstack [curinput .limitfield + 1 ], 0 , 20
, tally ) ;
else {
q = p ;
while ( mem [q ].hhfield .v.RH != 0 ) q = mem [q ].hhfield
.v.RH ;
mem [q ].hhfield .v.RH = paramstack [curinput .limitfield +
1 ];
showtokenlist ( p , 0 , 20 , tally ) ;
mem [q ].hhfield .v.RH = 0 ;
}
}
print ( 500 ) ;
}
break ;
default:
printnl ( 63 ) ;
break ;
}
{
l = tally ;
tally = 0 ;
selector = 4 ;
trickcount = 1000000L ;
}
if ( curinput .indexfield != 21 )
showtokenlist ( curinput .startfield , curinput .locfield , 100000L ,
0 ) ;
else showmacro ( curinput .startfield , curinput .locfield , 100000L )
;
}
selector = oldsetting ;
if ( trickcount == 1000000L )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
if ( tally < trickcount )
m = tally - firstcount ;
else m = trickcount - firstcount ;
if ( l + firstcount <= halferrorline )
{
p = 0 ;
n = l + firstcount ;
}
else {
print ( 274 ) ;
p = l + firstcount - halferrorline + 3 ;
n = halferrorline ;
}
{register integer for_end; q = p ;for_end = firstcount - 1 ; if ( q <=
for_end) do
printchar ( trickbuf [q % errorline ]) ;
while ( q++ < for_end ) ;}
println () ;
{register integer for_end; q = 1 ;for_end = n ; if ( q <= for_end) do
printchar ( 32 ) ;
while ( q++ < for_end ) ;}
if ( m + n <= errorline )
p = firstcount + m ;
else p = firstcount + ( errorline - n - 3 ) ;
{register integer for_end; q = firstcount ;for_end = p - 1 ; if ( q <=
for_end) do
printchar ( trickbuf [q % errorline ]) ;
while ( q++ < for_end ) ;}
if ( m + n > errorline )
print ( 274 ) ;
}
if ( ( curinput .indexfield <= 15 ) )
if ( ( curinput .namefield > 2 ) || ( fileptr == 0 ) )
goto lab30 ;
decr ( fileptr ) ;
}
lab30: curinput = inputstack [inputptr ];
}
void
#ifdef HAVE_PROTOTYPES
zbegintokenlist ( halfword p , quarterword t )
#else
zbegintokenlist ( p , t )
halfword p ;
quarterword t ;
#endif
{
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 611 , stacksize ) ;
}
inputstack [inputptr ]= curinput ;
incr ( inputptr ) ;
}
curinput .startfield = p ;
curinput .indexfield = t ;
curinput .limitfield = paramptr ;
curinput .locfield = p ;
}
void
#ifdef HAVE_PROTOTYPES
endtokenlist ( void )
#else
endtokenlist ( )
#endif
{
/* 30 */ halfword p ;
if ( curinput .indexfield >= 19 )
if ( curinput .indexfield <= 20 )
{
flushtokenlist ( curinput .startfield ) ;
goto lab30 ;
}
else deletemacref ( curinput .startfield ) ;
while ( paramptr > curinput .limitfield ) {
decr ( paramptr ) ;
p = paramstack [paramptr ];
if ( p != 0 )
if ( mem [p ].hhfield .v.RH == 1 )
{
recyclevalue ( p ) ;
freenode ( p , 2 ) ;
}
else flushtokenlist ( p ) ;
}
lab30: {
decr ( inputptr ) ;
curinput = inputstack [inputptr ];
}
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zencapsulate ( halfword p )
#else
zencapsulate ( p )
halfword p ;
#endif
{
curexp = getnode ( 2 ) ;
mem [curexp ].hhfield .b0 = curtype ;
mem [curexp ].hhfield .b1 = 11 ;
newdep ( curexp , p ) ;
}
void
#ifdef HAVE_PROTOTYPES
zinstall ( halfword r , halfword q )
#else
zinstall ( r , q )
halfword r ;
halfword q ;
#endif
{
halfword p ;
if ( mem [q ].hhfield .b0 == 16 )
{
mem [r + 1 ].cint = mem [q + 1 ].cint ;
mem [r ].hhfield .b0 = 16 ;
}
else if ( mem [q ].hhfield .b0 == 19 )
{
p = singledependency ( q ) ;
if ( p == depfinal )
{
mem [r ].hhfield .b0 = 16 ;
mem [r + 1 ].cint = 0 ;
freenode ( p , 2 ) ;
}
else {
mem [r ].hhfield .b0 = 17 ;
newdep ( r , p ) ;
}
}
else {
mem [r ].hhfield .b0 = mem [q ].hhfield .b0 ;
newdep ( r , copydeplist ( mem [q + 1 ].hhfield .v.RH ) ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmakeexpcopy ( halfword p )
#else
zmakeexpcopy ( p )
halfword p ;
#endif
{
/* 20 */ halfword q, r, t ;
lab20: curtype = mem [p ].hhfield .b0 ;
switch ( curtype )
{case 1 :
case 2 :
case 16 :
curexp = mem [p + 1 ].cint ;
break ;
case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
curexp = newringentry ( p ) ;
break ;
case 4 :
{
curexp = mem [p + 1 ].cint ;
{
if ( strref [curexp ]< 127 )
incr ( strref [curexp ]) ;
}
}
break ;
case 6 :
{
curexp = mem [p + 1 ].cint ;
incr ( mem [curexp ].hhfield .lhfield ) ;
}
break ;
case 11 :
curexp = copyedges ( mem [p + 1 ].cint ) ;
break ;
case 9 :
case 8 :
curexp = copypath ( mem [p + 1 ].cint ) ;
break ;
case 13 :
case 14 :
{
if ( mem [p + 1 ].cint == 0 )
initbignode ( p ) ;
t = getnode ( 2 ) ;
mem [t ].hhfield .b1 = 11 ;
mem [t ].hhfield .b0 = curtype ;
initbignode ( t ) ;
q = mem [p + 1 ].cint + bignodesize [curtype ];
r = mem [t + 1 ].cint + bignodesize [curtype ];
do {
q = q - 2 ;
r = r - 2 ;
install ( r , q ) ;
} while ( ! ( q == mem [p + 1 ].cint ) ) ;
curexp = t ;
}
break ;
case 17 :
case 18 :
encapsulate ( copydeplist ( mem [p + 1 ].hhfield .v.RH ) ) ;
break ;
case 15 :
{
{
mem [p ].hhfield .b0 = 19 ;
serialno = serialno + 64 ;
mem [p + 1 ].cint = serialno ;
}
goto lab20 ;
}
break ;
case 19 :
{
q = singledependency ( p ) ;
if ( q == depfinal )
{
curtype = 16 ;
curexp = 0 ;
freenode ( q , 2 ) ;
}
else {
curtype = 17 ;
encapsulate ( q ) ;
}
}
break ;
default:
confusion ( 796 ) ;
break ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
curtok ( void )
#else
curtok ( )
#endif
{
register halfword Result; halfword p ;
smallnumber savetype ;
integer saveexp ;
if ( cursym == 0 )
if ( curcmd == 38 )
{
savetype = curtype ;
saveexp = curexp ;
makeexpcopy ( curmod ) ;
p = stashcurexp () ;
mem [p ].hhfield .v.RH = 0 ;
curtype = savetype ;
curexp = saveexp ;
}
else {
p = getnode ( 2 ) ;
mem [p + 1 ].cint = curmod ;
mem [p ].hhfield .b1 = 12 ;
if ( curcmd == 42 )
mem [p ].hhfield .b0 = 16 ;
else mem [p ].hhfield .b0 = 4 ;
}
else {
{
p = avail ;
if ( p == 0 )
p = getavail () ;
else {
avail = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
}
}
mem [p ].hhfield .lhfield = cursym ;
}
Result = p ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
backinput ( void )
#else
backinput ( )
#endif
{
halfword p ;
p = curtok () ;
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
begintokenlist ( p , 19 ) ;
}
void
#ifdef HAVE_PROTOTYPES
backerror ( void )
#else
backerror ( )
#endif
{
OKtointerrupt = false ;
backinput () ;
OKtointerrupt = true ;
error () ;
}
void
#ifdef HAVE_PROTOTYPES
inserror ( void )
#else
inserror ( )
#endif
{
OKtointerrupt = false ;
backinput () ;
curinput .indexfield = 20 ;
OKtointerrupt = true ;
error () ;
}
void
#ifdef HAVE_PROTOTYPES
beginfilereading ( void )
#else
beginfilereading ( )
#endif
{
if ( inopen == 15 )
overflow ( 612 , 15 ) ;
if ( first == bufsize )
overflow ( 256 , bufsize ) ;
incr ( inopen ) ;
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 611 , stacksize ) ;
}
inputstack [inputptr ]= curinput ;
incr ( inputptr ) ;
}
curinput .indexfield = inopen ;
linestack [curinput .indexfield ]= line ;
curinput .startfield = first ;
curinput .namefield = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
endfilereading ( void )
#else
endfilereading ( )
#endif
{
first = curinput .startfield ;
line = linestack [curinput .indexfield ];
if ( curinput .indexfield != inopen )
confusion ( 613 ) ;
if ( curinput .namefield > 2 )
aclose ( inputfile [curinput .indexfield ]) ;
{
decr ( inputptr ) ;
curinput = inputstack [inputptr ];
}
decr ( inopen ) ;
}
void
#ifdef HAVE_PROTOTYPES
clearforerrorprompt ( void )
#else
clearforerrorprompt ( )
#endif
{
while ( ( curinput .indexfield <= 15 ) && ( curinput .namefield == 0 ) &&
( inputptr > 0 ) && ( curinput .locfield == curinput .limitfield ) )
endfilereading () ;
println () ;
}
boolean
#ifdef HAVE_PROTOTYPES
checkoutervalidity ( void )
#else
checkoutervalidity ( )
#endif
{
register boolean Result; halfword p ;
if ( scannerstatus == 0 )
Result = true ;
else {
deletionsallowed = false ;
if ( cursym != 0 )
{
p = getavail () ;
mem [p ].hhfield .lhfield = cursym ;
begintokenlist ( p , 19 ) ;
}
if ( scannerstatus > 1 )
{
runaway () ;
if ( cursym == 0 )
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 619 ) ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 620 ) ;
}
}
print ( 621 ) ;
{
helpptr = 4 ;
helpline [3 ]= 622 ;
helpline [2 ]= 623 ;
helpline [1 ]= 624 ;
helpline [0 ]= 625 ;
}
switch ( scannerstatus )
{case 2 :
{
print ( 626 ) ;
helpline [3 ]= 627 ;
cursym = 9763 ;
}
break ;
case 3 :
{
print ( 628 ) ;
helpline [3 ]= 629 ;
if ( warninginfo == 0 )
cursym = 9767 ;
else {
cursym = 9759 ;
eqtb [9759 ].v.RH = warninginfo ;
}
}
break ;
case 4 :
case 5 :
{
print ( 630 ) ;
if ( scannerstatus == 5 )
print ( hash [warninginfo ].v.RH ) ;
else printvariablename ( warninginfo ) ;
cursym = 9765 ;
}
break ;
case 6 :
{
print ( 631 ) ;
print ( hash [warninginfo ].v.RH ) ;
print ( 632 ) ;
helpline [3 ]= 633 ;
cursym = 9764 ;
}
break ;
}
inserror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 614 ) ;
}
printint ( warninginfo ) ;
{
helpptr = 3 ;
helpline [2 ]= 615 ;
helpline [1 ]= 616 ;
helpline [0 ]= 617 ;
}
if ( cursym == 0 )
helpline [2 ]= 618 ;
cursym = 9766 ;
inserror () ;
}
deletionsallowed = true ;
Result = false ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
getnext ( void )
#else
getnext ( )
#endif
{
/* 20 10 40 25 85 86 87 30 */ integer k ;
ASCIIcode c ;
ASCIIcode class ;
integer n, f ;
lab20: cursym = 0 ;
if ( ( curinput .indexfield <= 15 ) )
{
lab25: c = buffer [curinput .locfield ];
incr ( curinput .locfield ) ;
class = charclass [c ];
switch ( class )
{case 0 :
goto lab85 ;
break ;
case 1 :
{
class = charclass [buffer [curinput .locfield ]];
if ( class > 1 )
goto lab25 ;
else if ( class < 1 )
{
n = 0 ;
goto lab86 ;
}
}
break ;
case 2 :
goto lab25 ;
break ;
case 3 :
{
if ( curinput .namefield > 2 )
{
incr ( line ) ;
first = curinput .startfield ;
if ( ! forceeof )
{
if ( inputln ( inputfile [curinput .indexfield ], true ) )
firmuptheline () ;
else forceeof = true ;
}
if ( forceeof )
{
printchar ( 41 ) ;
decr ( openparens ) ;
fflush ( stdout ) ;
forceeof = false ;
endfilereading () ;
if ( checkoutervalidity () )
goto lab20 ;
else goto lab20 ;
}
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
else {
if ( inputptr > 0 )
{
endfilereading () ;
goto lab20 ;
}
if ( selector < 2 )
openlogfile () ;
if ( interaction > 1 )
{
if ( curinput .limitfield == curinput .startfield )
printnl ( 648 ) ;
println () ;
first = curinput .startfield ;
{
;
print ( 42 ) ;
terminput () ;
}
curinput .limitfield = last ;
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
else fatalerror ( 649 ) ;
}
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
goto lab25 ;
}
break ;
case 4 :
{
if ( buffer [curinput .locfield ]== 34 )
curmod = 283 ;
else {
k = curinput .locfield ;
buffer [curinput .limitfield + 1 ]= 34 ;
do {
incr ( curinput .locfield ) ;
} while ( ! ( buffer [curinput .locfield ]== 34 ) ) ;
if ( curinput .locfield > curinput .limitfield )
{
curinput .locfield = curinput .limitfield ;
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 641 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 642 ;
helpline [1 ]= 643 ;
helpline [0 ]= 644 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
goto lab20 ;
}
if ( ( curinput .locfield == k + 1 ) && ( ( strstart [buffer [k ]
+ 1 ]- strstart [buffer [k ]]) == 1 ) )
curmod = buffer [k ];
else {
{
if ( poolptr + curinput .locfield - k > maxpoolptr )
{
if ( poolptr + curinput .locfield - k > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + curinput .locfield - k ;
}
}
do {
{
strpool [poolptr ]= buffer [k ];
incr ( poolptr ) ;
}
incr ( k ) ;
} while ( ! ( k == curinput .locfield ) ) ;
curmod = makestring () ;
}
}
incr ( curinput .locfield ) ;
curcmd = 39 ;
goto lab10 ;
}
break ;
case 5 :
case 6 :
case 7 :
case 8 :
{
k = curinput .locfield - 1 ;
goto lab40 ;
}
break ;
case 20 :
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 638 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 639 ;
helpline [0 ]= 640 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
goto lab20 ;
}
break ;
default:
;
break ;
}
k = curinput .locfield - 1 ;
while ( charclass [buffer [curinput .locfield ]]== class ) incr (
curinput .locfield ) ;
goto lab40 ;
lab85: n = c - 48 ;
while ( charclass [buffer [curinput .locfield ]]== 0 ) {
if ( n < 4096 )
n = 10 * n + buffer [curinput .locfield ]- 48 ;
incr ( curinput .locfield ) ;
}
if ( buffer [curinput .locfield ]== 46 )
if ( charclass [buffer [curinput .locfield + 1 ]]== 0 )
goto lab30 ;
f = 0 ;
goto lab87 ;
lab30: incr ( curinput .locfield ) ;
lab86: k = 0 ;
do {
if ( k < 17 )
{
dig [k ]= buffer [curinput .locfield ]- 48 ;
incr ( k ) ;
}
incr ( curinput .locfield ) ;
} while ( ! ( charclass [buffer [curinput .locfield ]]!= 0 ) ) ;
f = rounddecimals ( k ) ;
if ( f == 65536L )
{
incr ( n ) ;
f = 0 ;
}
lab87: if ( n < 4096 )
curmod = n * 65536L + f ;
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 645 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 646 ;
helpline [0 ]= 647 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
curmod = 268435455L ;
}
curcmd = 42 ;
goto lab10 ;
lab40: cursym = idlookup ( k , curinput .locfield - k ) ;
}
else if ( curinput .locfield >= himemmin )
{
cursym = mem [curinput .locfield ].hhfield .lhfield ;
curinput .locfield = mem [curinput .locfield ].hhfield .v.RH ;
if ( cursym >= 9770 )
if ( cursym >= 9920 )
{
if ( cursym >= 10070 )
cursym = cursym - 150 ;
begintokenlist ( paramstack [curinput .limitfield + cursym - ( 9920 ) ]
, 18 ) ;
goto lab20 ;
}
else {
curcmd = 38 ;
curmod = paramstack [curinput .limitfield + cursym - ( 9770 ) ];
cursym = 0 ;
goto lab10 ;
}
}
else if ( curinput .locfield > 0 )
{
if ( mem [curinput .locfield ].hhfield .b1 == 12 )
{
curmod = mem [curinput .locfield + 1 ].cint ;
if ( mem [curinput .locfield ].hhfield .b0 == 16 )
curcmd = 42 ;
else {
curcmd = 39 ;
{
if ( strref [curmod ]< 127 )
incr ( strref [curmod ]) ;
}
}
}
else {
curmod = curinput .locfield ;
curcmd = 38 ;
}
curinput .locfield = mem [curinput .locfield ].hhfield .v.RH ;
goto lab10 ;
}
else {
endtokenlist () ;
goto lab20 ;
}
curcmd = eqtb [cursym ].lhfield ;
curmod = eqtb [cursym ].v.RH ;
if ( curcmd >= 86 )
if ( checkoutervalidity () )
curcmd = curcmd - 86 ;
else goto lab20 ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
firmuptheline ( void )
#else
firmuptheline ( )
#endif
{
integer k ;
curinput .limitfield = last ;
if ( internal [31 ]> 0 )
if ( interaction > 1 )
{
;
println () ;
if ( curinput .startfield < curinput .limitfield )
{register integer for_end; k = curinput .startfield ;for_end = curinput
.limitfield - 1 ; if ( k <= for_end) do
print ( buffer [k ]) ;
while ( k++ < for_end ) ;}
first = curinput .limitfield ;
{
;
print ( 650 ) ;
terminput () ;
}
if ( last > first )
{
{register integer for_end; k = first ;for_end = last - 1 ; if ( k <=
for_end) do
buffer [k + curinput .startfield - first ]= buffer [k ];
while ( k++ < for_end ) ;}
curinput .limitfield = curinput .startfield + last - first ;
}
}
}
halfword
#ifdef HAVE_PROTOTYPES
zscantoks ( commandcode terminator , halfword substlist , halfword tailend ,
smallnumber suffixcount )
#else
zscantoks ( terminator , substlist , tailend , suffixcount )
commandcode terminator ;
halfword substlist ;
halfword tailend ;
smallnumber suffixcount ;
#endif
{
/* 30 40 */ register halfword Result; halfword p ;
halfword q ;
integer balance ;
p = memtop - 2 ;
balance = 1 ;
mem [memtop - 2 ].hhfield .v.RH = 0 ;
while ( true ) {
getnext () ;
if ( cursym > 0 )
{
{
q = substlist ;
while ( q != 0 ) {
if ( mem [q ].hhfield .lhfield == cursym )
{
cursym = mem [q + 1 ].cint ;
curcmd = 7 ;
goto lab40 ;
}
q = mem [q ].hhfield .v.RH ;
}
lab40: ;
}
if ( curcmd == terminator )
if ( curmod > 0 )
incr ( balance ) ;
else {
decr ( balance ) ;
if ( balance == 0 )
goto lab30 ;
}
else if ( curcmd == 61 )
{
if ( curmod == 0 )
getnext () ;
else if ( curmod <= suffixcount )
cursym = 9919 + curmod ;
}
}
mem [p ].hhfield .v.RH = curtok () ;
p = mem [p ].hhfield .v.RH ;
}
lab30: mem [p ].hhfield .v.RH = tailend ;
flushnodelist ( substlist ) ;
Result = mem [memtop - 2 ].hhfield .v.RH ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
getsymbol ( void )
#else
getsymbol ( )
#endif
{
/* 20 */ lab20: getnext () ;
if ( ( cursym == 0 ) || ( cursym > 9757 ) )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 662 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 663 ;
helpline [1 ]= 664 ;
helpline [0 ]= 665 ;
}
if ( cursym > 0 )
helpline [2 ]= 666 ;
else if ( curcmd == 39 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
cursym = 9757 ;
inserror () ;
goto lab20 ;
}
}
void
#ifdef HAVE_PROTOTYPES
getclearsymbol ( void )
#else
getclearsymbol ( )
#endif
{
getsymbol () ;
clearsymbol ( cursym , false ) ;
}
void
#ifdef HAVE_PROTOTYPES
checkequals ( void )
#else
checkequals ( )
#endif
{
if ( curcmd != 51 )
if ( curcmd != 77 )
{
missingerr ( 61 ) ;
{
helpptr = 5 ;
helpline [4 ]= 667 ;
helpline [3 ]= 668 ;
helpline [2 ]= 669 ;
helpline [1 ]= 670 ;
helpline [0 ]= 671 ;
}
backerror () ;
}
}
void
#ifdef HAVE_PROTOTYPES
makeopdef ( void )
#else
makeopdef ( )
#endif
{
commandcode m ;
halfword p, q, r ;
m = curmod ;
getsymbol () ;
q = getnode ( 2 ) ;
mem [q ].hhfield .lhfield = cursym ;
mem [q + 1 ].cint = 9770 ;
getclearsymbol () ;
warninginfo = cursym ;
getsymbol () ;
p = getnode ( 2 ) ;
mem [p ].hhfield .lhfield = cursym ;
mem [p + 1 ].cint = 9771 ;
mem [p ].hhfield .v.RH = q ;
getnext () ;
checkequals () ;
scannerstatus = 5 ;
q = getavail () ;
mem [q ].hhfield .lhfield = 0 ;
r = getavail () ;
mem [q ].hhfield .v.RH = r ;
mem [r ].hhfield .lhfield = 0 ;
mem [r ].hhfield .v.RH = scantoks ( 16 , p , 0 , 0 ) ;
scannerstatus = 0 ;
eqtb [warninginfo ].lhfield = m ;
eqtb [warninginfo ].v.RH = q ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zcheckdelimiter ( halfword ldelim , halfword rdelim )
#else
zcheckdelimiter ( ldelim , rdelim )
halfword ldelim ;
halfword rdelim ;
#endif
{
/* 10 */ if ( curcmd == 62 )
if ( curmod == ldelim )
goto lab10 ;
if ( cursym != rdelim )
{
missingerr ( hash [rdelim ].v.RH ) ;
{
helpptr = 2 ;
helpline [1 ]= 918 ;
helpline [0 ]= 919 ;
}
backerror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 920 ) ;
}
print ( hash [rdelim ].v.RH ) ;
print ( 921 ) ;
{
helpptr = 3 ;
helpline [2 ]= 922 ;
helpline [1 ]= 923 ;
helpline [0 ]= 924 ;
}
error () ;
}
lab10: ;
}
halfword
#ifdef HAVE_PROTOTYPES
scandeclaredvariable ( void )
#else
scandeclaredvariable ( )
#endif
{
/* 30 */ register halfword Result; halfword x ;
halfword h, t ;
halfword l ;
getsymbol () ;
x = cursym ;
if ( curcmd != 41 )
clearsymbol ( x , false ) ;
h = getavail () ;
mem [h ].hhfield .lhfield = x ;
t = h ;
while ( true ) {
getxnext () ;
if ( cursym == 0 )
goto lab30 ;
if ( curcmd != 41 )
if ( curcmd != 40 )
if ( curcmd == 63 )
{
l = cursym ;
getxnext () ;
if ( curcmd != 64 )
{
backinput () ;
cursym = l ;
curcmd = 63 ;
goto lab30 ;
}
else cursym = 0 ;
}
else goto lab30 ;
mem [t ].hhfield .v.RH = getavail () ;
t = mem [t ].hhfield .v.RH ;
mem [t ].hhfield .lhfield = cursym ;
}
lab30: if ( eqtb [x ].lhfield != 41 )
clearsymbol ( x , false ) ;
if ( eqtb [x ].v.RH == 0 )
newroot ( x ) ;
Result = h ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
scandef ( void )
#else
scandef ( )
#endif
{
char m ;
char n ;
unsigned char k ;
char c ;
halfword r ;
halfword q ;
halfword p ;
halfword base ;
halfword ldelim, rdelim ;
m = curmod ;
c = 0 ;
mem [memtop - 2 ].hhfield .v.RH = 0 ;
q = getavail () ;
mem [q ].hhfield .lhfield = 0 ;
r = 0 ;
if ( m == 1 )
{
getclearsymbol () ;
warninginfo = cursym ;
getnext () ;
scannerstatus = 5 ;
n = 0 ;
eqtb [warninginfo ].lhfield = 10 ;
eqtb [warninginfo ].v.RH = q ;
}
else {
p = scandeclaredvariable () ;
flushvariable ( eqtb [mem [p ].hhfield .lhfield ].v.RH , mem [p ]
.hhfield .v.RH , true ) ;
warninginfo = findvariable ( p ) ;
flushlist ( p ) ;
if ( warninginfo == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 678 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 679 ;
helpline [0 ]= 680 ;
}
error () ;
warninginfo = 21 ;
}
scannerstatus = 4 ;
n = 2 ;
if ( curcmd == 61 )
if ( curmod == 3 )
{
n = 3 ;
getnext () ;
}
mem [warninginfo ].hhfield .b0 = 20 + n ;
mem [warninginfo + 1 ].cint = q ;
}
k = n ;
if ( curcmd == 31 )
do {
ldelim = cursym ;
rdelim = curmod ;
getnext () ;
if ( ( curcmd == 56 ) && ( curmod >= 9770 ) )
base = curmod ;
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 681 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 682 ;
}
backerror () ;
base = 9770 ;
}
do {
mem [q ].hhfield .v.RH = getavail () ;
q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .lhfield = base + k ;
getsymbol () ;
p = getnode ( 2 ) ;
mem [p + 1 ].cint = base + k ;
mem [p ].hhfield .lhfield = cursym ;
if ( k == 150 )
overflow ( 683 , 150 ) ;
incr ( k ) ;
mem [p ].hhfield .v.RH = r ;
r = p ;
getnext () ;
} while ( ! ( curcmd != 82 ) ) ;
checkdelimiter ( ldelim , rdelim ) ;
getnext () ;
} while ( ! ( curcmd != 31 ) ) ;
if ( curcmd == 56 )
{
p = getnode ( 2 ) ;
if ( curmod < 9770 )
{
c = curmod ;
mem [p + 1 ].cint = 9770 + k ;
}
else {
mem [p + 1 ].cint = curmod + k ;
if ( curmod == 9770 )
c = 4 ;
else if ( curmod == 9920 )
c = 6 ;
else c = 7 ;
}
if ( k == 150 )
overflow ( 683 , 150 ) ;
incr ( k ) ;
getsymbol () ;
mem [p ].hhfield .lhfield = cursym ;
mem [p ].hhfield .v.RH = r ;
r = p ;
getnext () ;
if ( c == 4 )
if ( curcmd == 69 )
{
c = 5 ;
p = getnode ( 2 ) ;
if ( k == 150 )
overflow ( 683 , 150 ) ;
mem [p + 1 ].cint = 9770 + k ;
getsymbol () ;
mem [p ].hhfield .lhfield = cursym ;
mem [p ].hhfield .v.RH = r ;
r = p ;
getnext () ;
}
}
checkequals () ;
p = getavail () ;
mem [p ].hhfield .lhfield = c ;
mem [q ].hhfield .v.RH = p ;
if ( m == 1 )
mem [p ].hhfield .v.RH = scantoks ( 16 , r , 0 , n ) ;
else {
q = getavail () ;
mem [q ].hhfield .lhfield = bgloc ;
mem [p ].hhfield .v.RH = q ;
p = getavail () ;
mem [p ].hhfield .lhfield = egloc ;
mem [q ].hhfield .v.RH = scantoks ( 16 , r , p , n ) ;
}
if ( warninginfo == 21 )
flushtokenlist ( mem [22 ].cint ) ;
scannerstatus = 0 ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zprintmacroname ( halfword a , halfword n )
#else
zprintmacroname ( a , n )
halfword a ;
halfword n ;
#endif
{
halfword p, q ;
if ( n != 0 )
print ( hash [n ].v.RH ) ;
else {
p = mem [a ].hhfield .lhfield ;
if ( p == 0 )
print ( hash [mem [mem [mem [a ].hhfield .v.RH ].hhfield .lhfield ]
.hhfield .lhfield ].v.RH ) ;
else {
q = p ;
while ( mem [q ].hhfield .v.RH != 0 ) q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .v.RH = mem [mem [a ].hhfield .v.RH ].hhfield
.lhfield ;
showtokenlist ( p , 0 , 1000 , 0 ) ;
mem [q ].hhfield .v.RH = 0 ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
zprintarg ( halfword q , integer n , halfword b )
#else
zprintarg ( q , n , b )
halfword q ;
integer n ;
halfword b ;
#endif
{
if ( mem [q ].hhfield .v.RH == 1 )
printnl ( 497 ) ;
else if ( ( b < 10070 ) && ( b != 7 ) )
printnl ( 498 ) ;
else printnl ( 499 ) ;
printint ( n ) ;
print ( 699 ) ;
if ( mem [q ].hhfield .v.RH == 1 )
printexp ( q , 1 ) ;
else showtokenlist ( q , 0 , 1000 , 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zscantextarg ( halfword ldelim , halfword rdelim )
#else
zscantextarg ( ldelim , rdelim )
halfword ldelim ;
halfword rdelim ;
#endif
{
/* 30 */ integer balance ;
halfword p ;
warninginfo = ldelim ;
scannerstatus = 3 ;
p = memtop - 2 ;
balance = 1 ;
mem [memtop - 2 ].hhfield .v.RH = 0 ;
while ( true ) {
getnext () ;
if ( ldelim == 0 )
{
if ( curcmd > 82 )
{
if ( balance == 1 )
goto lab30 ;
else if ( curcmd == 84 )
decr ( balance ) ;
}
else if ( curcmd == 32 )
incr ( balance ) ;
}
else {
if ( curcmd == 62 )
{
if ( curmod == ldelim )
{
decr ( balance ) ;
if ( balance == 0 )
goto lab30 ;
}
}
else if ( curcmd == 31 )
if ( curmod == rdelim )
incr ( balance ) ;
}
mem [p ].hhfield .v.RH = curtok () ;
p = mem [p ].hhfield .v.RH ;
}
lab30: curexp = mem [memtop - 2 ].hhfield .v.RH ;
curtype = 20 ;
scannerstatus = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zmacrocall ( halfword defref , halfword arglist , halfword macroname )
#else
zmacrocall ( defref , arglist , macroname )
halfword defref ;
halfword arglist ;
halfword macroname ;
#endif
{
/* 40 */ halfword r ;
halfword p, q ;
integer n ;
halfword ldelim, rdelim ;
halfword tail ;
r = mem [defref ].hhfield .v.RH ;
incr ( mem [defref ].hhfield .lhfield ) ;
if ( arglist == 0 )
n = 0 ;
else {
n = 1 ;
tail = arglist ;
while ( mem [tail ].hhfield .v.RH != 0 ) {
incr ( n ) ;
tail = mem [tail ].hhfield .v.RH ;
}
}
if ( internal [9 ]> 0 )
{
begindiagnostic () ;
println () ;
printmacroname ( arglist , macroname ) ;
if ( n == 3 )
print ( 661 ) ;
showmacro ( defref , 0 , 100000L ) ;
if ( arglist != 0 )
{
n = 0 ;
p = arglist ;
do {
q = mem [p ].hhfield .lhfield ;
printarg ( q , n , 0 ) ;
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == 0 ) ) ;
}
enddiagnostic ( false ) ;
}
curcmd = 83 ;
while ( mem [r ].hhfield .lhfield >= 9770 ) {
if ( curcmd != 82 )
{
getxnext () ;
if ( curcmd != 31 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 705 ) ;
}
printmacroname ( arglist , macroname ) ;
{
helpptr = 3 ;
helpline [2 ]= 706 ;
helpline [1 ]= 707 ;
helpline [0 ]= 708 ;
}
if ( mem [r ].hhfield .lhfield >= 9920 )
{
curexp = 0 ;
curtype = 20 ;
}
else {
curexp = 0 ;
curtype = 16 ;
}
backerror () ;
curcmd = 62 ;
goto lab40 ;
}
ldelim = cursym ;
rdelim = curmod ;
}
if ( mem [r ].hhfield .lhfield >= 10070 )
scantextarg ( ldelim , rdelim ) ;
else {
getxnext () ;
if ( mem [r ].hhfield .lhfield >= 9920 )
scansuffix () ;
else scanexpression () ;
}
if ( curcmd != 82 )
if ( ( curcmd != 62 ) || ( curmod != ldelim ) )
if ( mem [mem [r ].hhfield .v.RH ].hhfield .lhfield >= 9770 )
{
missingerr ( 44 ) ;
{
helpptr = 3 ;
helpline [2 ]= 709 ;
helpline [1 ]= 710 ;
helpline [0 ]= 704 ;
}
backerror () ;
curcmd = 82 ;
}
else {
missingerr ( hash [rdelim ].v.RH ) ;
{
helpptr = 2 ;
helpline [1 ]= 711 ;
helpline [0 ]= 704 ;
}
backerror () ;
}
lab40: {
p = getavail () ;
if ( curtype == 20 )
mem [p ].hhfield .lhfield = curexp ;
else mem [p ].hhfield .lhfield = stashcurexp () ;
if ( internal [9 ]> 0 )
{
begindiagnostic () ;
printarg ( mem [p ].hhfield .lhfield , n , mem [r ].hhfield
.lhfield ) ;
enddiagnostic ( false ) ;
}
if ( arglist == 0 )
arglist = p ;
else mem [tail ].hhfield .v.RH = p ;
tail = p ;
incr ( n ) ;
}
r = mem [r ].hhfield .v.RH ;
}
if ( curcmd == 82 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 700 ) ;
}
printmacroname ( arglist , macroname ) ;
printchar ( 59 ) ;
printnl ( 701 ) ;
print ( hash [rdelim ].v.RH ) ;
print ( 298 ) ;
{
helpptr = 3 ;
helpline [2 ]= 702 ;
helpline [1 ]= 703 ;
helpline [0 ]= 704 ;
}
error () ;
}
if ( mem [r ].hhfield .lhfield != 0 )
{
if ( mem [r ].hhfield .lhfield < 7 )
{
getxnext () ;
if ( mem [r ].hhfield .lhfield != 6 )
if ( ( curcmd == 51 ) || ( curcmd == 77 ) )
getxnext () ;
}
switch ( mem [r ].hhfield .lhfield )
{case 1 :
scanprimary () ;
break ;
case 2 :
scansecondary () ;
break ;
case 3 :
scantertiary () ;
break ;
case 4 :
scanexpression () ;
break ;
case 5 :
{
scanexpression () ;
p = getavail () ;
mem [p ].hhfield .lhfield = stashcurexp () ;
if ( internal [9 ]> 0 )
{
begindiagnostic () ;
printarg ( mem [p ].hhfield .lhfield , n , 0 ) ;
enddiagnostic ( false ) ;
}
if ( arglist == 0 )
arglist = p ;
else mem [tail ].hhfield .v.RH = p ;
tail = p ;
incr ( n ) ;
if ( curcmd != 69 )
{
missingerr ( 478 ) ;
print ( 712 ) ;
printmacroname ( arglist , macroname ) ;
{
helpptr = 1 ;
helpline [0 ]= 713 ;
}
backerror () ;
}
getxnext () ;
scanprimary () ;
}
break ;
case 6 :
{
if ( curcmd != 31 )
ldelim = 0 ;
else {
ldelim = cursym ;
rdelim = curmod ;
getxnext () ;
}
scansuffix () ;
if ( ldelim != 0 )
{
if ( ( curcmd != 62 ) || ( curmod != ldelim ) )
{
missingerr ( hash [rdelim ].v.RH ) ;
{
helpptr = 2 ;
helpline [1 ]= 711 ;
helpline [0 ]= 704 ;
}
backerror () ;
}
getxnext () ;
}
}
break ;
case 7 :
scantextarg ( 0 , 0 ) ;
break ;
}
backinput () ;
{
p = getavail () ;
if ( curtype == 20 )
mem [p ].hhfield .lhfield = curexp ;
else mem [p ].hhfield .lhfield = stashcurexp () ;
if ( internal [9 ]> 0 )
{
begindiagnostic () ;
printarg ( mem [p ].hhfield .lhfield , n , mem [r ].hhfield
.lhfield ) ;
enddiagnostic ( false ) ;
}
if ( arglist == 0 )
arglist = p ;
else mem [tail ].hhfield .v.RH = p ;
tail = p ;
incr ( n ) ;
}
}
r = mem [r ].hhfield .v.RH ;
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
if ( paramptr + n > maxparamstack )
{
maxparamstack = paramptr + n ;
if ( maxparamstack > 150 )
overflow ( 683 , 150 ) ;
}
begintokenlist ( defref , 21 ) ;
curinput .namefield = macroname ;
curinput .locfield = r ;
if ( n > 0 )
{
p = arglist ;
do {
paramstack [paramptr ]= mem [p ].hhfield .lhfield ;
incr ( paramptr ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == 0 ) ) ;
flushlist ( arglist ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
expand ( void )
#else
expand ( )
#endif
{
halfword p ;
integer k ;
poolpointer j ;
if ( internal [7 ]> 65536L )
if ( curcmd != 10 )
showcmdmod ( curcmd , curmod ) ;
switch ( curcmd )
{case 1 :
conditional () ;
break ;
case 2 :
if ( curmod > iflimit )
if ( iflimit == 1 )
{
missingerr ( 58 ) ;
backinput () ;
cursym = 9762 ;
inserror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 720 ) ;
}
printcmdmod ( 2 , curmod ) ;
{
helpptr = 1 ;
helpline [0 ]= 721 ;
}
error () ;
}
else {
while ( curmod != 2 ) passtext () ;
{
p = condptr ;
ifline = mem [p + 1 ].cint ;
curif = mem [p ].hhfield .b1 ;
iflimit = mem [p ].hhfield .b0 ;
condptr = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
}
break ;
case 3 :
if ( curmod > 0 )
forceeof = true ;
else startinput () ;
break ;
case 4 :
if ( curmod == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 684 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 685 ;
helpline [0 ]= 686 ;
}
error () ;
}
else beginiteration () ;
break ;
case 5 :
{
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
if ( loopptr == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 688 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 689 ;
helpline [0 ]= 690 ;
}
error () ;
}
else resumeiteration () ;
}
break ;
case 6 :
{
getboolean () ;
if ( internal [7 ]> 65536L )
showcmdmod ( 33 , curexp ) ;
if ( curexp == 30 )
if ( loopptr == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 691 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 692 ;
}
if ( curcmd == 83 )
error () ;
else backerror () ;
}
else {
p = 0 ;
do {
if ( ( curinput .indexfield <= 15 ) )
endfilereading () ;
else {
if ( curinput .indexfield <= 17 )
p = curinput .startfield ;
endtokenlist () ;
}
} while ( ! ( p != 0 ) ) ;
if ( p != mem [loopptr ].hhfield .lhfield )
fatalerror ( 695 ) ;
stopiteration () ;
}
else if ( curcmd != 83 )
{
missingerr ( 59 ) ;
{
helpptr = 2 ;
helpline [1 ]= 693 ;
helpline [0 ]= 694 ;
}
backerror () ;
}
}
break ;
case 7 :
;
break ;
case 9 :
{
getnext () ;
p = curtok () ;
getnext () ;
if ( curcmd < 11 )
expand () ;
else backinput () ;
begintokenlist ( p , 19 ) ;
}
break ;
case 8 :
{
getxnext () ;
scanprimary () ;
if ( curtype != 4 )
{
disperr ( 0 , 696 ) ;
{
helpptr = 2 ;
helpline [1 ]= 697 ;
helpline [0 ]= 698 ;
}
putgetflusherror ( 0 ) ;
}
else {
backinput () ;
if ( ( strstart [curexp + 1 ]- strstart [curexp ]) > 0 )
{
beginfilereading () ;
curinput .namefield = 2 ;
k = first + ( strstart [curexp + 1 ]- strstart [curexp ]) ;
if ( k >= maxbufstack )
{
if ( k >= bufsize )
{
maxbufstack = bufsize ;
overflow ( 256 , bufsize ) ;
}
maxbufstack = k + 1 ;
}
j = strstart [curexp ];
curinput .limitfield = k ;
while ( first < curinput .limitfield ) {
buffer [first ]= strpool [j ];
incr ( j ) ;
incr ( first ) ;
}
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
flushcurexp ( 0 ) ;
}
}
}
break ;
case 10 :
macrocall ( curmod , 0 , cursym ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
getxnext ( void )
#else
getxnext ( )
#endif
{
halfword saveexp ;
getnext () ;
if ( curcmd < 11 )
{
saveexp = stashcurexp () ;
do {
if ( curcmd == 10 )
macrocall ( curmod , 0 , cursym ) ;
else expand () ;
getnext () ;
} while ( ! ( curcmd >= 11 ) ) ;
unstashcurexp ( saveexp ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zstackargument ( halfword p )
#else
zstackargument ( p )
halfword p ;
#endif
{
if ( paramptr == maxparamstack )
{
incr ( maxparamstack ) ;
if ( maxparamstack > 150 )
overflow ( 683 , 150 ) ;
}
paramstack [paramptr ]= p ;
incr ( paramptr ) ;
}
void
#ifdef HAVE_PROTOTYPES
passtext ( void )
#else
passtext ( )
#endif
{
/* 30 */ integer l ;
scannerstatus = 1 ;
l = 0 ;
warninginfo = line ;
while ( true ) {
getnext () ;
if ( curcmd <= 2 )
if ( curcmd < 2 )
incr ( l ) ;
else {
if ( l == 0 )
goto lab30 ;
if ( curmod == 2 )
decr ( l ) ;
}
else if ( curcmd == 39 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
}
lab30: scannerstatus = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zchangeiflimit ( smallnumber l , halfword p )
#else
zchangeiflimit ( l , p )
smallnumber l ;
halfword p ;
#endif
{
/* 10 */ halfword q ;
if ( p == condptr )
iflimit = l ;
else {
q = condptr ;
while ( true ) {
if ( q == 0 )
confusion ( 714 ) ;
if ( mem [q ].hhfield .v.RH == p )
{
mem [q ].hhfield .b0 = l ;
goto lab10 ;
}
q = mem [q ].hhfield .v.RH ;
}
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
checkcolon ( void )
#else
checkcolon ( )
#endif
{
if ( curcmd != 81 )
{
missingerr ( 58 ) ;
{
helpptr = 2 ;
helpline [1 ]= 717 ;
helpline [0 ]= 694 ;
}
backerror () ;
}
}
void
#ifdef HAVE_PROTOTYPES
conditional ( void )
#else
conditional ( )
#endif
{
/* 10 30 21 40 */ halfword savecondptr ;
char newiflimit ;
halfword p ;
{
p = getnode ( 2 ) ;
mem [p ].hhfield .v.RH = condptr ;
mem [p ].hhfield .b0 = iflimit ;
mem [p ].hhfield .b1 = curif ;
mem [p + 1 ].cint = ifline ;
condptr = p ;
iflimit = 1 ;
ifline = line ;
curif = 1 ;
}
savecondptr = condptr ;
lab21: getboolean () ;
newiflimit = 4 ;
if ( internal [7 ]> 65536L )
{
begindiagnostic () ;
if ( curexp == 30 )
print ( 718 ) ;
else print ( 719 ) ;
enddiagnostic ( false ) ;
}
lab40: checkcolon () ;
if ( curexp == 30 )
{
changeiflimit ( newiflimit , savecondptr ) ;
goto lab10 ;
}
while ( true ) {
passtext () ;
if ( condptr == savecondptr )
goto lab30 ;
else if ( curmod == 2 )
{
p = condptr ;
ifline = mem [p + 1 ].cint ;
curif = mem [p ].hhfield .b1 ;
iflimit = mem [p ].hhfield .b0 ;
condptr = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
}
lab30: curif = curmod ;
ifline = line ;
if ( curmod == 2 )
{
p = condptr ;
ifline = mem [p + 1 ].cint ;
curif = mem [p ].hhfield .b1 ;
iflimit = mem [p ].hhfield .b0 ;
condptr = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
else if ( curmod == 4 )
goto lab21 ;
else {
curexp = 30 ;
newiflimit = 2 ;
getxnext () ;
goto lab40 ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zbadfor ( strnumber s )
#else
zbadfor ( s )
strnumber s ;
#endif
{
disperr ( 0 , 722 ) ;
print ( s ) ;
print ( 305 ) ;
{
helpptr = 4 ;
helpline [3 ]= 723 ;
helpline [2 ]= 724 ;
helpline [1 ]= 725 ;
helpline [0 ]= 307 ;
}
putgetflusherror ( 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
beginiteration ( void )
#else
beginiteration ( )
#endif
{
/* 22 30 40 */ halfword m ;
halfword n ;
halfword p, q, s, pp ;
m = curmod ;
n = cursym ;
s = getnode ( 2 ) ;
if ( m == 1 )
{
mem [s + 1 ].hhfield .lhfield = 1 ;
p = 0 ;
getxnext () ;
goto lab40 ;
}
getsymbol () ;
p = getnode ( 2 ) ;
mem [p ].hhfield .lhfield = cursym ;
mem [p + 1 ].cint = m ;
getxnext () ;
if ( ( curcmd != 51 ) && ( curcmd != 77 ) )
{
missingerr ( 61 ) ;
{
helpptr = 3 ;
helpline [2 ]= 726 ;
helpline [1 ]= 669 ;
helpline [0 ]= 727 ;
}
backerror () ;
}
mem [s + 1 ].hhfield .lhfield = 0 ;
q = s + 1 ;
mem [q ].hhfield .v.RH = 0 ;
do {
getxnext () ;
if ( m != 9770 )
scansuffix () ;
else {
if ( curcmd >= 81 )
if ( curcmd <= 82 )
goto lab22 ;
scanexpression () ;
if ( curcmd == 74 )
if ( q == s + 1 )
{
if ( curtype != 16 )
badfor ( 733 ) ;
pp = getnode ( 4 ) ;
mem [pp + 1 ].cint = curexp ;
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
badfor ( 734 ) ;
mem [pp + 2 ].cint = curexp ;
if ( curcmd != 75 )
{
missingerr ( 489 ) ;
{
helpptr = 2 ;
helpline [1 ]= 735 ;
helpline [0 ]= 736 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
badfor ( 737 ) ;
mem [pp + 3 ].cint = curexp ;
mem [s + 1 ].hhfield .lhfield = pp ;
goto lab30 ;
}
curexp = stashcurexp () ;
}
mem [q ].hhfield .v.RH = getavail () ;
q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .lhfield = curexp ;
curtype = 1 ;
lab22: ;
} while ( ! ( curcmd != 82 ) ) ;
lab30: ;
lab40: if ( curcmd != 81 )
{
missingerr ( 58 ) ;
{
helpptr = 3 ;
helpline [2 ]= 728 ;
helpline [1 ]= 729 ;
helpline [0 ]= 730 ;
}
backerror () ;
}
q = getavail () ;
mem [q ].hhfield .lhfield = 9758 ;
scannerstatus = 6 ;
warninginfo = n ;
mem [s ].hhfield .lhfield = scantoks ( 4 , p , q , 0 ) ;
scannerstatus = 0 ;
mem [s ].hhfield .v.RH = loopptr ;
loopptr = s ;
resumeiteration () ;
}
void
#ifdef HAVE_PROTOTYPES
resumeiteration ( void )
#else
resumeiteration ( )
#endif
{
/* 45 10 */ halfword p, q ;
p = mem [loopptr + 1 ].hhfield .lhfield ;
if ( p > 1 )
{
curexp = mem [p + 1 ].cint ;
if ( ( ( mem [p + 2 ].cint > 0 ) && ( curexp > mem [p + 3 ].cint ) )
|| ( ( mem [p + 2 ].cint < 0 ) && ( curexp < mem [p + 3 ].cint ) ) )
goto lab45 ;
curtype = 16 ;
q = stashcurexp () ;
mem [p + 1 ].cint = curexp + mem [p + 2 ].cint ;
}
else if ( p < 1 )
{
p = mem [loopptr + 1 ].hhfield .v.RH ;
if ( p == 0 )
goto lab45 ;
mem [loopptr + 1 ].hhfield .v.RH = mem [p ].hhfield .v.RH ;
q = mem [p ].hhfield .lhfield ;
{
mem [p ].hhfield .v.RH = avail ;
avail = p ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
else {
begintokenlist ( mem [loopptr ].hhfield .lhfield , 16 ) ;
goto lab10 ;
}
begintokenlist ( mem [loopptr ].hhfield .lhfield , 17 ) ;
stackargument ( q ) ;
if ( internal [7 ]> 65536L )
{
begindiagnostic () ;
printnl ( 732 ) ;
if ( ( q != 0 ) && ( mem [q ].hhfield .v.RH == 1 ) )
printexp ( q , 1 ) ;
else showtokenlist ( q , 0 , 50 , 0 ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
goto lab10 ;
lab45: stopiteration () ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
stopiteration ( void )
#else
stopiteration ( )
#endif
{
halfword p, q ;
p = mem [loopptr + 1 ].hhfield .lhfield ;
if ( p > 1 )
freenode ( p , 4 ) ;
else if ( p < 1 )
{
q = mem [loopptr + 1 ].hhfield .v.RH ;
while ( q != 0 ) {
p = mem [q ].hhfield .lhfield ;
if ( p != 0 )
if ( mem [p ].hhfield .v.RH == 1 )
{
recyclevalue ( p ) ;
freenode ( p , 2 ) ;
}
else flushtokenlist ( p ) ;
p = q ;
q = mem [q ].hhfield .v.RH ;
{
mem [p ].hhfield .v.RH = avail ;
avail = p ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
}
p = loopptr ;
loopptr = mem [p ].hhfield .v.RH ;
flushtokenlist ( mem [p ].hhfield .lhfield ) ;
freenode ( p , 2 ) ;
}
void
#ifdef HAVE_PROTOTYPES
beginname ( void )
#else
beginname ( )
#endif
{
areadelimiter = 0 ;
extdelimiter = 0 ;
}
boolean
#ifdef HAVE_PROTOTYPES
zmorename ( ASCIIcode c )
#else
zmorename ( c )
ASCIIcode c ;
#endif
{
register boolean Result; if ( ( c == 32 ) || ( c == 9 ) )
Result = false ;
else {
if ( ISDIRSEP ( c ) )
{
areadelimiter = poolptr ;
extdelimiter = 0 ;
}
else if ( c == 46 )
extdelimiter = poolptr ;
{
if ( poolptr + 1 > maxpoolptr )
{
if ( poolptr + 1 > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + 1 ;
}
}
{
strpool [poolptr ]= c ;
incr ( poolptr ) ;
}
Result = true ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
endname ( void )
#else
endname ( )
#endif
{
if ( strptr + 3 > maxstrptr )
{
if ( strptr + 3 > maxstrings )
overflow ( 258 , maxstrings - initstrptr ) ;
maxstrptr = strptr + 3 ;
}
if ( areadelimiter == 0 )
curarea = 283 ;
else {
curarea = strptr ;
incr ( strptr ) ;
strstart [strptr ]= areadelimiter + 1 ;
}
if ( extdelimiter == 0 )
{
curext = 283 ;
curname = makestring () ;
}
else {
curname = strptr ;
incr ( strptr ) ;
strstart [strptr ]= extdelimiter ;
curext = makestring () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zpackfilename ( strnumber n , strnumber a , strnumber e )
#else
zpackfilename ( n , a , e )
strnumber n ;
strnumber a ;
strnumber e ;
#endif
{
integer k ;
ASCIIcode c ;
poolpointer j ;
k = 0 ;
if ( (char*) nameoffile )
libcfree ( (char*) nameoffile ) ;
nameoffile = xmalloc ( 1 + ( strstart [a + 1 ]- strstart [a ]) + (
strstart [n + 1 ]- strstart [n ]) + ( strstart [e + 1 ]- strstart [e
]) + 1 ) ;
{register integer for_end; j = strstart [a ];for_end = strstart [a + 1
]- 1 ; if ( j <= for_end) do
{
c = strpool [j ];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
{register integer for_end; j = strstart [n ];for_end = strstart [n + 1
]- 1 ; if ( j <= for_end) do
{
c = strpool [j ];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
{register integer for_end; j = strstart [e ];for_end = strstart [e + 1
]- 1 ; if ( j <= for_end) do
{
c = strpool [j ];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
if ( k <= maxint )
namelength = k ;
else namelength = maxint ;
nameoffile [namelength + 1 ]= 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zpackbufferedname ( smallnumber n , integer a , integer b )
#else
zpackbufferedname ( n , a , b )
smallnumber n ;
integer a ;
integer b ;
#endif
{
integer k ;
ASCIIcode c ;
integer j ;
if ( n + b - a + 6 > maxint )
b = a + maxint - n - 6 ;
k = 0 ;
if ( (char*) nameoffile )
libcfree ( (char*) nameoffile ) ;
nameoffile = xmalloc ( 1 + n + ( b - a + 1 ) + 6 ) ;
{register integer for_end; j = 1 ;for_end = n ; if ( j <= for_end) do
{
c = xord [MFbasedefault [j ]];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
{register integer for_end; j = a ;for_end = b ; if ( j <= for_end) do
{
c = buffer [j ];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
{register integer for_end; j = basedefaultlength - 4 ;for_end =
basedefaultlength ; if ( j <= for_end) do
{
c = xord [MFbasedefault [j ]];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
if ( k <= maxint )
namelength = k ;
else namelength = maxint ;
nameoffile [namelength + 1 ]= 0 ;
}
strnumber
#ifdef HAVE_PROTOTYPES
makenamestring ( void )
#else
makenamestring ( )
#endif
{
register strnumber Result; integer k ;
if ( ( poolptr + namelength > poolsize ) || ( strptr == maxstrings ) )
Result = 63 ;
else {
{register integer for_end; k = 1 ;for_end = namelength ; if ( k <=
for_end) do
{
strpool [poolptr ]= xord [nameoffile [k ]];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
Result = makestring () ;
}
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
zamakenamestring ( alphafile f )
#else
zamakenamestring ( f )
alphafile f ;
#endif
{
register strnumber Result; Result = makenamestring () ;
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
zbmakenamestring ( bytefile f )
#else
zbmakenamestring ( f )
bytefile f ;
#endif
{
register strnumber Result; Result = makenamestring () ;
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
zwmakenamestring ( wordfile f )
#else
zwmakenamestring ( f )
wordfile f ;
#endif
{
register strnumber Result; Result = makenamestring () ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
scanfilename ( void )
#else
scanfilename ( )
#endif
{
/* 30 */ beginname () ;
while ( ( buffer [curinput .locfield ]== 32 ) || ( buffer [curinput
.locfield ]== 9 ) ) incr ( curinput .locfield ) ;
while ( true ) {
if ( ( buffer [curinput .locfield ]== 59 ) || ( buffer [curinput
.locfield ]== 37 ) )
goto lab30 ;
if ( ! morename ( buffer [curinput .locfield ]) )
goto lab30 ;
incr ( curinput .locfield ) ;
}
lab30: endname () ;
}
void
#ifdef HAVE_PROTOTYPES
zpackjobname ( strnumber s )
#else
zpackjobname ( s )
strnumber s ;
#endif
{
curarea = 283 ;
curext = s ;
curname = jobname ;
packfilename ( curname , curarea , curext ) ;
}
void
#ifdef HAVE_PROTOTYPES
zpromptfilename ( strnumber s , strnumber e )
#else
zpromptfilename ( s , e )
strnumber s ;
strnumber e ;
#endif
{
/* 30 */ integer k ;
if ( interaction == 2 )
;
if ( s == 739 )
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 740 ) ;
}
else {
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 741 ) ;
}
printfilename ( curname , curarea , curext ) ;
print ( 742 ) ;
if ( e == 743 )
showcontext () ;
printnl ( 744 ) ;
print ( s ) ;
if ( interaction < 2 )
fatalerror ( 745 ) ;
{
;
print ( 746 ) ;
terminput () ;
}
{
beginname () ;
k = first ;
while ( ( ( buffer [k ]== 32 ) || ( buffer [k ]== 9 ) ) && ( k < last
) ) incr ( k ) ;
while ( true ) {
if ( k == last )
goto lab30 ;
if ( ! morename ( buffer [k ]) )
goto lab30 ;
incr ( k ) ;
}
lab30: endname () ;
}
if ( curext == 283 )
curext = e ;
packfilename ( curname , curarea , curext ) ;
}
void
#ifdef HAVE_PROTOTYPES
openlogfile ( void )
#else
openlogfile ( )
#endif
{
char oldsetting ;
integer k ;
integer l ;
integer m ;
char * months ;
oldsetting = selector ;
if ( jobname == 0 )
jobname = 747 ;
packjobname ( 748 ) ;
while ( ! aopenout ( logfile ) ) {
selector = 1 ;
promptfilename ( 750 , 748 ) ;
}
texmflogname = amakenamestring ( logfile ) ;
selector = 2 ;
logopened = true ;
{
Fputs( logfile , "This is METAFONT, Version 2.7182" ) ;
Fputs( logfile , versionstring ) ;
print ( baseident ) ;
print ( 751 ) ;
printint ( roundunscaled ( internal [16 ]) ) ;
printchar ( 32 ) ;
months = " JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" ;
m = roundunscaled ( internal [15 ]) ;
{register integer for_end; k = 3 * m - 2 ;for_end = 3 * m ; if ( k <=
for_end) do
putc ( months [k ], logfile );
while ( k++ < for_end ) ;}
printchar ( 32 ) ;
printint ( roundunscaled ( internal [14 ]) ) ;
printchar ( 32 ) ;
m = roundunscaled ( internal [17 ]) ;
printdd ( m / 60 ) ;
printchar ( 58 ) ;
printdd ( m % 60 ) ;
}
inputstack [inputptr ]= curinput ;
printnl ( 749 ) ;
l = inputstack [0 ].limitfield - 1 ;
{register integer for_end; k = 1 ;for_end = l ; if ( k <= for_end) do
print ( buffer [k ]) ;
while ( k++ < for_end ) ;}
println () ;
selector = oldsetting + 2 ;
}
void
#ifdef HAVE_PROTOTYPES
zbadexp ( strnumber s )
#else
zbadexp ( s )
strnumber s ;
#endif
{
char saveflag ;
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( s ) ;
}
print ( 766 ) ;
printcmdmod ( curcmd , curmod ) ;
printchar ( 39 ) ;
{
helpptr = 4 ;
helpline [3 ]= 767 ;
helpline [2 ]= 768 ;
helpline [1 ]= 769 ;
helpline [0 ]= 770 ;
}
backinput () ;
cursym = 0 ;
curcmd = 42 ;
curmod = 0 ;
inserror () ;
saveflag = varflag ;
varflag = 0 ;
getxnext () ;
varflag = saveflag ;
}
void
#ifdef HAVE_PROTOTYPES
zstashin ( halfword p )
#else
zstashin ( p )
halfword p ;
#endif
{
halfword q ;
mem [p ].hhfield .b0 = curtype ;
if ( curtype == 16 )
mem [p + 1 ].cint = curexp ;
else {
if ( curtype == 19 )
{
q = singledependency ( curexp ) ;
if ( q == depfinal )
{
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = 0 ;
freenode ( q , 2 ) ;
}
else {
mem [p ].hhfield .b0 = 17 ;
newdep ( p , q ) ;
}
recyclevalue ( curexp ) ;
}
else {
mem [p + 1 ]= mem [curexp + 1 ];
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = p ;
}
freenode ( curexp , 2 ) ;
}
curtype = 1 ;
}
void
#ifdef HAVE_PROTOTYPES
backexpr ( void )
#else
backexpr ( )
#endif
{
halfword p ;
p = stashcurexp () ;
mem [p ].hhfield .v.RH = 0 ;
begintokenlist ( p , 19 ) ;
}
void
#ifdef HAVE_PROTOTYPES
badsubscript ( void )
#else
badsubscript ( )
#endif
{
disperr ( 0 , 782 ) ;
{
helpptr = 3 ;
helpline [2 ]= 783 ;
helpline [1 ]= 784 ;
helpline [0 ]= 785 ;
}
flusherror ( 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zobliterated ( halfword q )
#else
zobliterated ( q )
halfword q ;
#endif
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 786 ) ;
}
showtokenlist ( q , 0 , 1000 , 0 ) ;
print ( 787 ) ;
{
helpptr = 5 ;
helpline [4 ]= 788 ;
helpline [3 ]= 789 ;
helpline [2 ]= 790 ;
helpline [1 ]= 791 ;
helpline [0 ]= 792 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbinarymac ( halfword p , halfword c , halfword n )
#else
zbinarymac ( p , c , n )
halfword p ;
halfword c ;
halfword n ;
#endif
{
halfword q, r ;
q = getavail () ;
r = getavail () ;
mem [q ].hhfield .v.RH = r ;
mem [q ].hhfield .lhfield = p ;
mem [r ].hhfield .lhfield = stashcurexp () ;
macrocall ( c , q , n ) ;
}
void
#ifdef HAVE_PROTOTYPES
materializepen ( void )
#else
materializepen ( )
#endif
{
/* 50 */ scaled aminusb, aplusb, majoraxis, minoraxis ;
angle theta ;
halfword p ;
halfword q ;
q = curexp ;
if ( mem [q ].hhfield .b0 == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 802 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 803 ;
helpline [0 ]= 574 ;
}
putgeterror () ;
curexp = 3 ;
goto lab50 ;
}
else if ( mem [q ].hhfield .b0 == 4 )
{
tx = mem [q + 1 ].cint ;
ty = mem [q + 2 ].cint ;
txx = mem [q + 3 ].cint - tx ;
tyx = mem [q + 4 ].cint - ty ;
txy = mem [q + 5 ].cint - tx ;
tyy = mem [q + 6 ].cint - ty ;
aminusb = pythadd ( txx - tyy , tyx + txy ) ;
aplusb = pythadd ( txx + tyy , tyx - txy ) ;
majoraxis = halfp ( aminusb + aplusb ) ;
minoraxis = halfp ( abs ( aplusb - aminusb ) ) ;
if ( majoraxis == minoraxis )
theta = 0 ;
else theta = half ( narg ( txx - tyy , tyx + txy ) + narg ( txx + tyy ,
tyx - txy ) ) ;
freenode ( q , 7 ) ;
q = makeellipse ( majoraxis , minoraxis , theta ) ;
if ( ( tx != 0 ) || ( ty != 0 ) )
{
p = q ;
do {
mem [p + 1 ].cint = mem [p + 1 ].cint + tx ;
mem [p + 2 ].cint = mem [p + 2 ].cint + ty ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == q ) ) ;
}
}
curexp = makepen ( q ) ;
lab50: tossknotlist ( q ) ;
curtype = 6 ;
}
void
#ifdef HAVE_PROTOTYPES
knownpair ( void )
#else
knownpair ( )
#endif
{
halfword p ;
if ( curtype != 14 )
{
disperr ( 0 , 805 ) ;
{
helpptr = 5 ;
helpline [4 ]= 806 ;
helpline [3 ]= 807 ;
helpline [2 ]= 808 ;
helpline [1 ]= 809 ;
helpline [0 ]= 810 ;
}
putgetflusherror ( 0 ) ;
curx = 0 ;
cury = 0 ;
}
else {
p = mem [curexp + 1 ].cint ;
if ( mem [p ].hhfield .b0 == 16 )
curx = mem [p + 1 ].cint ;
else {
disperr ( p , 811 ) ;
{
helpptr = 5 ;
helpline [4 ]= 812 ;
helpline [3 ]= 807 ;
helpline [2 ]= 808 ;
helpline [1 ]= 809 ;
helpline [0 ]= 810 ;
}
putgeterror () ;
recyclevalue ( p ) ;
curx = 0 ;
}
if ( mem [p + 2 ].hhfield .b0 == 16 )
cury = mem [p + 3 ].cint ;
else {
disperr ( p + 2 , 813 ) ;
{
helpptr = 5 ;
helpline [4 ]= 814 ;
helpline [3 ]= 807 ;
helpline [2 ]= 808 ;
helpline [1 ]= 809 ;
helpline [0 ]= 810 ;
}
putgeterror () ;
recyclevalue ( p + 2 ) ;
cury = 0 ;
}
flushcurexp ( 0 ) ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
newknot ( void )
#else
newknot ( )
#endif
{
register halfword Result; halfword q ;
q = getnode ( 7 ) ;
mem [q ].hhfield .b0 = 0 ;
mem [q ].hhfield .b1 = 0 ;
mem [q ].hhfield .v.RH = q ;
knownpair () ;
mem [q + 1 ].cint = curx ;
mem [q + 2 ].cint = cury ;
Result = q ;
return Result ;
}
smallnumber
#ifdef HAVE_PROTOTYPES
scandirection ( void )
#else
scandirection ( )
#endif
{
register smallnumber Result; char t ;
scaled x ;
getxnext () ;
if ( curcmd == 60 )
{
getxnext () ;
scanexpression () ;
if ( ( curtype != 16 ) || ( curexp < 0 ) )
{
disperr ( 0 , 817 ) ;
{
helpptr = 1 ;
helpline [0 ]= 818 ;
}
putgetflusherror ( 65536L ) ;
}
t = 3 ;
}
else {
scanexpression () ;
if ( curtype > 14 )
{
if ( curtype != 16 )
{
disperr ( 0 , 811 ) ;
{
helpptr = 5 ;
helpline [4 ]= 812 ;
helpline [3 ]= 807 ;
helpline [2 ]= 808 ;
helpline [1 ]= 809 ;
helpline [0 ]= 810 ;
}
putgetflusherror ( 0 ) ;
}
x = curexp ;
if ( curcmd != 82 )
{
missingerr ( 44 ) ;
{
helpptr = 2 ;
helpline [1 ]= 819 ;
helpline [0 ]= 820 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 813 ) ;
{
helpptr = 5 ;
helpline [4 ]= 814 ;
helpline [3 ]= 807 ;
helpline [2 ]= 808 ;
helpline [1 ]= 809 ;
helpline [0 ]= 810 ;
}
putgetflusherror ( 0 ) ;
}
cury = curexp ;
curx = x ;
}
else knownpair () ;
if ( ( curx == 0 ) && ( cury == 0 ) )
t = 4 ;
else {
t = 2 ;
curexp = narg ( curx , cury ) ;
}
}
if ( curcmd != 65 )
{
missingerr ( 125 ) ;
{
helpptr = 3 ;
helpline [2 ]= 815 ;
helpline [1 ]= 816 ;
helpline [0 ]= 694 ;
}
backerror () ;
}
getxnext () ;
Result = t ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zdonullary ( quarterword c )
#else
zdonullary ( c )
quarterword c ;
#endif
{
integer k ;
{
if ( aritherror )
cleararith () ;
}
if ( internal [7 ]> 131072L )
showcmdmod ( 33 , c ) ;
switch ( c )
{case 30 :
case 31 :
{
curtype = 2 ;
curexp = c ;
}
break ;
case 32 :
{
curtype = 11 ;
curexp = getnode ( 6 ) ;
initedges ( curexp ) ;
}
break ;
case 33 :
{
curtype = 6 ;
curexp = 3 ;
}
break ;
case 37 :
{
curtype = 16 ;
curexp = normrand () ;
}
break ;
case 36 :
{
curtype = 8 ;
curexp = getnode ( 7 ) ;
mem [curexp ].hhfield .b0 = 4 ;
mem [curexp ].hhfield .b1 = 4 ;
mem [curexp ].hhfield .v.RH = curexp ;
mem [curexp + 1 ].cint = 0 ;
mem [curexp + 2 ].cint = 0 ;
mem [curexp + 3 ].cint = 65536L ;
mem [curexp + 4 ].cint = 0 ;
mem [curexp + 5 ].cint = 0 ;
mem [curexp + 6 ].cint = 65536L ;
}
break ;
case 34 :
{
if ( jobname == 0 )
openlogfile () ;
curtype = 4 ;
curexp = jobname ;
}
break ;
case 35 :
{
if ( interaction <= 1 )
fatalerror ( 831 ) ;
beginfilereading () ;
curinput .namefield = 1 ;
{
;
print ( 283 ) ;
terminput () ;
}
{
if ( poolptr + last - curinput .startfield > maxpoolptr )
{
if ( poolptr + last - curinput .startfield > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + last - curinput .startfield ;
}
}
{register integer for_end; k = curinput .startfield ;for_end = last -
1 ; if ( k <= for_end) do
{
strpool [poolptr ]= buffer [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
endfilereading () ;
curtype = 4 ;
curexp = makestring () ;
}
break ;
}
{
if ( aritherror )
cleararith () ;
}
}
boolean
#ifdef HAVE_PROTOTYPES
znicepair ( integer p , quarterword t )
#else
znicepair ( p , t )
integer p ;
quarterword t ;
#endif
{
/* 10 */ register boolean Result; if ( t == 14 )
{
p = mem [p + 1 ].cint ;
if ( mem [p ].hhfield .b0 == 16 )
if ( mem [p + 2 ].hhfield .b0 == 16 )
{
Result = true ;
goto lab10 ;
}
}
Result = false ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zprintknownorunknowntype ( smallnumber t , integer v )
#else
zprintknownorunknowntype ( t , v )
smallnumber t ;
integer v ;
#endif
{
printchar ( 40 ) ;
if ( t < 17 )
if ( t != 14 )
printtype ( t ) ;
else if ( nicepair ( v , 14 ) )
print ( 335 ) ;
else print ( 832 ) ;
else print ( 833 ) ;
printchar ( 41 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zbadunary ( quarterword c )
#else
zbadunary ( c )
quarterword c ;
#endif
{
disperr ( 0 , 834 ) ;
printop ( c ) ;
printknownorunknowntype ( curtype , curexp ) ;
{
helpptr = 3 ;
helpline [2 ]= 835 ;
helpline [1 ]= 836 ;
helpline [0 ]= 837 ;
}
putgeterror () ;
}
void
#ifdef HAVE_PROTOTYPES
znegatedeplist ( halfword p )
#else
znegatedeplist ( p )
halfword p ;
#endif
{
/* 10 */ while ( true ) {
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
if ( mem [p ].hhfield .lhfield == 0 )
goto lab10 ;
p = mem [p ].hhfield .v.RH ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
pairtopath ( void )
#else
pairtopath ( )
#endif
{
curexp = newknot () ;
curtype = 9 ;
}
void
#ifdef HAVE_PROTOTYPES
ztakepart ( quarterword c )
#else
ztakepart ( c )
quarterword c ;
#endif
{
halfword p ;
p = mem [curexp + 1 ].cint ;
mem [18 ].cint = p ;
mem [17 ].hhfield .b0 = curtype ;
mem [p ].hhfield .v.RH = 17 ;
freenode ( curexp , 2 ) ;
makeexpcopy ( p + 2 * ( c - 53 ) ) ;
recyclevalue ( 17 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zstrtonum ( quarterword c )
#else
zstrtonum ( c )
quarterword c ;
#endif
{
integer n ;
ASCIIcode m ;
poolpointer k ;
char b ;
boolean badchar ;
if ( c == 49 )
if ( ( strstart [curexp + 1 ]- strstart [curexp ]) == 0 )
n = -1 ;
else n = strpool [strstart [curexp ]];
else {
if ( c == 47 )
b = 8 ;
else b = 16 ;
n = 0 ;
badchar = false ;
{register integer for_end; k = strstart [curexp ];for_end = strstart [
curexp + 1 ]- 1 ; if ( k <= for_end) do
{
m = strpool [k ];
if ( ( m >= 48 ) && ( m <= 57 ) )
m = m - 48 ;
else if ( ( m >= 65 ) && ( m <= 70 ) )
m = m - 55 ;
else if ( ( m >= 97 ) && ( m <= 102 ) )
m = m - 87 ;
else {
badchar = true ;
m = 0 ;
}
if ( m >= b )
{
badchar = true ;
m = 0 ;
}
if ( n < 32768L / b )
n = n * b + m ;
else n = 32767 ;
}
while ( k++ < for_end ) ;}
if ( badchar )
{
disperr ( 0 , 839 ) ;
if ( c == 47 )
{
helpptr = 1 ;
helpline [0 ]= 840 ;
}
else {
helpptr = 1 ;
helpline [0 ]= 841 ;
}
putgeterror () ;
}
if ( n > 4095 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 842 ) ;
}
printint ( n ) ;
printchar ( 41 ) ;
{
helpptr = 1 ;
helpline [0 ]= 843 ;
}
putgeterror () ;
}
}
flushcurexp ( n * 65536L ) ;
}
scaled
#ifdef HAVE_PROTOTYPES
pathlength ( void )
#else
pathlength ( )
#endif
{
register scaled Result; scaled n ;
halfword p ;
p = curexp ;
if ( mem [p ].hhfield .b0 == 0 )
n = -65536L ;
else n = 0 ;
do {
p = mem [p ].hhfield .v.RH ;
n = n + 65536L ;
} while ( ! ( p == curexp ) ) ;
Result = n ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
ztestknown ( quarterword c )
#else
ztestknown ( c )
quarterword c ;
#endif
{
/* 30 */ char b ;
halfword p, q ;
b = 31 ;
switch ( curtype )
{case 1 :
case 2 :
case 4 :
case 6 :
case 8 :
case 9 :
case 11 :
case 16 :
b = 30 ;
break ;
case 13 :
case 14 :
{
p = mem [curexp + 1 ].cint ;
q = p + bignodesize [curtype ];
do {
q = q - 2 ;
if ( mem [q ].hhfield .b0 != 16 )
goto lab30 ;
} while ( ! ( q == p ) ) ;
b = 30 ;
lab30: ;
}
break ;
default:
;
break ;
}
if ( c == 39 )
flushcurexp ( b ) ;
else flushcurexp ( 61 - b ) ;
curtype = 2 ;
}
void
#ifdef HAVE_PROTOTYPES
zdounary ( quarterword c )
#else
zdounary ( c )
quarterword c ;
#endif
{
halfword p, q ;
integer x ;
{
if ( aritherror )
cleararith () ;
}
if ( internal [7 ]> 131072L )
{
begindiagnostic () ;
printnl ( 123 ) ;
printop ( c ) ;
printchar ( 40 ) ;
printexp ( 0 , 0 ) ;
print ( 838 ) ;
enddiagnostic ( false ) ;
}
switch ( c )
{case 69 :
if ( curtype < 14 )
if ( curtype != 11 )
badunary ( 69 ) ;
break ;
case 70 :
switch ( curtype )
{case 14 :
case 19 :
{
q = curexp ;
makeexpcopy ( q ) ;
if ( curtype == 17 )
negatedeplist ( mem [curexp + 1 ].hhfield .v.RH ) ;
else if ( curtype == 14 )
{
p = mem [curexp + 1 ].cint ;
if ( mem [p ].hhfield .b0 == 16 )
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
else negatedeplist ( mem [p + 1 ].hhfield .v.RH ) ;
if ( mem [p + 2 ].hhfield .b0 == 16 )
mem [p + 3 ].cint = - (integer) mem [p + 3 ].cint ;
else negatedeplist ( mem [p + 3 ].hhfield .v.RH ) ;
}
recyclevalue ( q ) ;
freenode ( q , 2 ) ;
}
break ;
case 17 :
case 18 :
negatedeplist ( mem [curexp + 1 ].hhfield .v.RH ) ;
break ;
case 16 :
curexp = - (integer) curexp ;
break ;
case 11 :
negateedges ( curexp ) ;
break ;
default:
badunary ( 70 ) ;
break ;
}
break ;
case 41 :
if ( curtype != 2 )
badunary ( 41 ) ;
else curexp = 61 - curexp ;
break ;
case 59 :
case 60 :
case 61 :
case 62 :
case 63 :
case 64 :
case 65 :
case 38 :
case 66 :
if ( curtype != 16 )
badunary ( c ) ;
else switch ( c )
{case 59 :
curexp = squarert ( curexp ) ;
break ;
case 60 :
curexp = mexp ( curexp ) ;
break ;
case 61 :
curexp = mlog ( curexp ) ;
break ;
case 62 :
case 63 :
{
nsincos ( ( curexp % 23592960L ) * 16 ) ;
if ( c == 62 )
curexp = roundfraction ( nsin ) ;
else curexp = roundfraction ( ncos ) ;
}
break ;
case 64 :
curexp = floorscaled ( curexp ) ;
break ;
case 65 :
curexp = unifrand ( curexp ) ;
break ;
case 38 :
{
if ( odd ( roundunscaled ( curexp ) ) )
curexp = 30 ;
else curexp = 31 ;
curtype = 2 ;
}
break ;
case 66 :
{
curexp = roundunscaled ( curexp ) % 256 ;
if ( curexp < 0 )
curexp = curexp + 256 ;
if ( charexists [curexp ])
curexp = 30 ;
else curexp = 31 ;
curtype = 2 ;
}
break ;
}
break ;
case 67 :
if ( nicepair ( curexp , curtype ) )
{
p = mem [curexp + 1 ].cint ;
x = narg ( mem [p + 1 ].cint , mem [p + 3 ].cint ) ;
if ( x >= 0 )
flushcurexp ( ( x + 8 ) / 16 ) ;
else flushcurexp ( - (integer) ( ( - (integer) x + 8 ) / 16 ) ) ;
}
else badunary ( 67 ) ;
break ;
case 53 :
case 54 :
if ( ( curtype <= 14 ) && ( curtype >= 13 ) )
takepart ( c ) ;
else badunary ( c ) ;
break ;
case 55 :
case 56 :
case 57 :
case 58 :
if ( curtype == 13 )
takepart ( c ) ;
else badunary ( c ) ;
break ;
case 50 :
if ( curtype != 16 )
badunary ( 50 ) ;
else {
curexp = roundunscaled ( curexp ) % 256 ;
curtype = 4 ;
if ( curexp < 0 )
curexp = curexp + 256 ;
}
break ;
case 42 :
if ( curtype != 16 )
badunary ( 42 ) ;
else {
oldsetting = selector ;
selector = 5 ;
printscaled ( curexp ) ;
curexp = makestring () ;
selector = oldsetting ;
curtype = 4 ;
}
break ;
case 47 :
case 48 :
case 49 :
if ( curtype != 4 )
badunary ( c ) ;
else strtonum ( c ) ;
break ;
case 51 :
if ( curtype == 4 )
flushcurexp ( ( strstart [curexp + 1 ]- strstart [curexp ]) * 65536L )
;
else if ( curtype == 9 )
flushcurexp ( pathlength () ) ;
else if ( curtype == 16 )
curexp = abs ( curexp ) ;
else if ( nicepair ( curexp , curtype ) )
flushcurexp ( pythadd ( mem [mem [curexp + 1 ].cint + 1 ].cint , mem [
mem [curexp + 1 ].cint + 3 ].cint ) ) ;
else badunary ( c ) ;
break ;
case 52 :
if ( curtype == 14 )
flushcurexp ( 0 ) ;
else if ( curtype != 9 )
badunary ( 52 ) ;
else if ( mem [curexp ].hhfield .b0 == 0 )
flushcurexp ( 0 ) ;
else {
curpen = 3 ;
curpathtype = 1 ;
curexp = makespec ( curexp , -1879080960L , 0 ) ;
flushcurexp ( turningnumber * 65536L ) ;
}
break ;
case 2 :
{
if ( ( curtype >= 2 ) && ( curtype <= 3 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 4 :
{
if ( ( curtype >= 4 ) && ( curtype <= 5 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 6 :
{
if ( ( curtype >= 6 ) && ( curtype <= 8 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 9 :
{
if ( ( curtype >= 9 ) && ( curtype <= 10 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 11 :
{
if ( ( curtype >= 11 ) && ( curtype <= 12 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 13 :
case 14 :
{
if ( curtype == c )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 15 :
{
if ( ( curtype >= 16 ) && ( curtype <= 19 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 39 :
case 40 :
testknown ( c ) ;
break ;
case 68 :
{
if ( curtype != 9 )
flushcurexp ( 31 ) ;
else if ( mem [curexp ].hhfield .b0 != 0 )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 45 :
{
if ( curtype == 14 )
pairtopath () ;
if ( curtype == 9 )
curtype = 8 ;
else badunary ( 45 ) ;
}
break ;
case 44 :
{
if ( curtype == 8 )
materializepen () ;
if ( curtype != 6 )
badunary ( 44 ) ;
else {
flushcurexp ( makepath ( curexp ) ) ;
curtype = 9 ;
}
}
break ;
case 46 :
if ( curtype != 11 )
badunary ( 46 ) ;
else flushcurexp ( totalweight ( curexp ) ) ;
break ;
case 43 :
if ( curtype == 9 )
{
p = htapypoc ( curexp ) ;
if ( mem [p ].hhfield .b1 == 0 )
p = mem [p ].hhfield .v.RH ;
tossknotlist ( curexp ) ;
curexp = p ;
}
else if ( curtype == 14 )
pairtopath () ;
else badunary ( 43 ) ;
break ;
}
{
if ( aritherror )
cleararith () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbadbinary ( halfword p , quarterword c )
#else
zbadbinary ( p , c )
halfword p ;
quarterword c ;
#endif
{
disperr ( p , 283 ) ;
disperr ( 0 , 834 ) ;
if ( c >= 94 )
printop ( c ) ;
printknownorunknowntype ( mem [p ].hhfield .b0 , p ) ;
if ( c >= 94 )
print ( 478 ) ;
else printop ( c ) ;
printknownorunknowntype ( curtype , curexp ) ;
{
helpptr = 3 ;
helpline [2 ]= 835 ;
helpline [1 ]= 844 ;
helpline [0 ]= 845 ;
}
putgeterror () ;
}
halfword
#ifdef HAVE_PROTOTYPES
ztarnished ( halfword p )
#else
ztarnished ( p )
halfword p ;
#endif
{
/* 10 */ register halfword Result; halfword q ;
halfword r ;
q = mem [p + 1 ].cint ;
r = q + bignodesize [mem [p ].hhfield .b0 ];
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 == 19 )
{
Result = 1 ;
goto lab10 ;
}
} while ( ! ( r == q ) ) ;
Result = 0 ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zdepfinish ( halfword v , halfword q , smallnumber t )
#else
zdepfinish ( v , q , t )
halfword v ;
halfword q ;
smallnumber t ;
#endif
{
halfword p ;
scaled vv ;
if ( q == 0 )
p = curexp ;
else p = q ;
mem [p + 1 ].hhfield .v.RH = v ;
mem [p ].hhfield .b0 = t ;
if ( mem [v ].hhfield .lhfield == 0 )
{
vv = mem [v + 1 ].cint ;
if ( q == 0 )
flushcurexp ( vv ) ;
else {
recyclevalue ( p ) ;
mem [q ].hhfield .b0 = 16 ;
mem [q + 1 ].cint = vv ;
}
}
else if ( q == 0 )
curtype = t ;
if ( fixneeded )
fixdependencies () ;
}
void
#ifdef HAVE_PROTOTYPES
zaddorsubtract ( halfword p , halfword q , quarterword c )
#else
zaddorsubtract ( p , q , c )
halfword p ;
halfword q ;
quarterword c ;
#endif
{
/* 30 10 */ smallnumber s, t ;
halfword r ;
integer v ;
if ( q == 0 )
{
t = curtype ;
if ( t < 17 )
v = curexp ;
else v = mem [curexp + 1 ].hhfield .v.RH ;
}
else {
t = mem [q ].hhfield .b0 ;
if ( t < 17 )
v = mem [q + 1 ].cint ;
else v = mem [q + 1 ].hhfield .v.RH ;
}
if ( t == 16 )
{
if ( c == 70 )
v = - (integer) v ;
if ( mem [p ].hhfield .b0 == 16 )
{
v = slowadd ( mem [p + 1 ].cint , v ) ;
if ( q == 0 )
curexp = v ;
else mem [q + 1 ].cint = v ;
goto lab10 ;
}
r = mem [p + 1 ].hhfield .v.RH ;
while ( mem [r ].hhfield .lhfield != 0 ) r = mem [r ].hhfield .v.RH ;
mem [r + 1 ].cint = slowadd ( mem [r + 1 ].cint , v ) ;
if ( q == 0 )
{
q = getnode ( 2 ) ;
curexp = q ;
curtype = mem [p ].hhfield .b0 ;
mem [q ].hhfield .b1 = 11 ;
}
mem [q + 1 ].hhfield .v.RH = mem [p + 1 ].hhfield .v.RH ;
mem [q ].hhfield .b0 = mem [p ].hhfield .b0 ;
mem [q + 1 ].hhfield .lhfield = mem [p + 1 ].hhfield .lhfield ;
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = q ;
mem [p ].hhfield .b0 = 16 ;
}
else {
if ( c == 70 )
negatedeplist ( v ) ;
if ( mem [p ].hhfield .b0 == 16 )
{
while ( mem [v ].hhfield .lhfield != 0 ) v = mem [v ].hhfield .v.RH
;
mem [v + 1 ].cint = slowadd ( mem [p + 1 ].cint , mem [v + 1 ]
.cint ) ;
}
else {
s = mem [p ].hhfield .b0 ;
r = mem [p + 1 ].hhfield .v.RH ;
if ( t == 17 )
{
if ( s == 17 )
if ( maxcoef ( r ) + maxcoef ( v ) < 626349397L )
{
v = pplusq ( v , r , 17 ) ;
goto lab30 ;
}
t = 18 ;
v = poverv ( v , 65536L , 17 , 18 ) ;
}
if ( s == 18 )
v = pplusq ( v , r , 18 ) ;
else v = pplusfq ( v , 65536L , r , 18 , 17 ) ;
lab30: if ( q != 0 )
depfinish ( v , q , t ) ;
else {
curtype = t ;
depfinish ( v , 0 , t ) ;
}
}
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zdepmult ( halfword p , integer v , boolean visscaled )
#else
zdepmult ( p , v , visscaled )
halfword p ;
integer v ;
boolean visscaled ;
#endif
{
/* 10 */ halfword q ;
smallnumber s, t ;
if ( p == 0 )
q = curexp ;
else if ( mem [p ].hhfield .b0 != 16 )
q = p ;
else {
if ( visscaled )
mem [p + 1 ].cint = takescaled ( mem [p + 1 ].cint , v ) ;
else mem [p + 1 ].cint = takefraction ( mem [p + 1 ].cint , v ) ;
goto lab10 ;
}
t = mem [q ].hhfield .b0 ;
q = mem [q + 1 ].hhfield .v.RH ;
s = t ;
if ( t == 17 )
if ( visscaled )
if ( abvscd ( maxcoef ( q ) , abs ( v ) , 626349396L , 65536L ) >= 0 )
t = 18 ;
q = ptimesv ( q , v , s , t , visscaled ) ;
depfinish ( q , p , t ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zhardtimes ( halfword p )
#else
zhardtimes ( p )
halfword p ;
#endif
{
halfword q ;
halfword r ;
scaled u, v ;
if ( mem [p ].hhfield .b0 == 14 )
{
q = stashcurexp () ;
unstashcurexp ( p ) ;
p = q ;
}
r = mem [curexp + 1 ].cint ;
u = mem [r + 1 ].cint ;
v = mem [r + 3 ].cint ;
mem [r + 2 ].hhfield .b0 = mem [p ].hhfield .b0 ;
newdep ( r + 2 , copydeplist ( mem [p + 1 ].hhfield .v.RH ) ) ;
mem [r ].hhfield .b0 = mem [p ].hhfield .b0 ;
mem [r + 1 ]= mem [p + 1 ];
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = r ;
freenode ( p , 2 ) ;
depmult ( r , u , true ) ;
depmult ( r + 2 , v , true ) ;
}
void
#ifdef HAVE_PROTOTYPES
zdepdiv ( halfword p , scaled v )
#else
zdepdiv ( p , v )
halfword p ;
scaled v ;
#endif
{
/* 10 */ halfword q ;
smallnumber s, t ;
if ( p == 0 )
q = curexp ;
else if ( mem [p ].hhfield .b0 != 16 )
q = p ;
else {
mem [p + 1 ].cint = makescaled ( mem [p + 1 ].cint , v ) ;
goto lab10 ;
}
t = mem [q ].hhfield .b0 ;
q = mem [q + 1 ].hhfield .v.RH ;
s = t ;
if ( t == 17 )
if ( abvscd ( maxcoef ( q ) , 65536L , 626349396L , abs ( v ) ) >= 0 )
t = 18 ;
q = poverv ( q , v , s , t ) ;
depfinish ( q , p , t ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zsetuptrans ( quarterword c )
#else
zsetuptrans ( c )
quarterword c ;
#endif
{
/* 30 10 */ halfword p, q, r ;
if ( ( c != 88 ) || ( curtype != 13 ) )
{
p = stashcurexp () ;
curexp = idtransform () ;
curtype = 13 ;
q = mem [curexp + 1 ].cint ;
switch ( c )
{case 84 :
if ( mem [p ].hhfield .b0 == 16 )
{
nsincos ( ( mem [p + 1 ].cint % 23592960L ) * 16 ) ;
mem [q + 5 ].cint = roundfraction ( ncos ) ;
mem [q + 9 ].cint = roundfraction ( nsin ) ;
mem [q + 7 ].cint = - (integer) mem [q + 9 ].cint ;
mem [q + 11 ].cint = mem [q + 5 ].cint ;
goto lab30 ;
}
break ;
case 85 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 6 , p ) ;
goto lab30 ;
}
break ;
case 86 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 4 , p ) ;
install ( q + 10 , p ) ;
goto lab30 ;
}
break ;
case 87 :
if ( mem [p ].hhfield .b0 == 14 )
{
r = mem [p + 1 ].cint ;
install ( q , r ) ;
install ( q + 2 , r + 2 ) ;
goto lab30 ;
}
break ;
case 89 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 4 , p ) ;
goto lab30 ;
}
break ;
case 90 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 10 , p ) ;
goto lab30 ;
}
break ;
case 91 :
if ( mem [p ].hhfield .b0 == 14 )
{
r = mem [p + 1 ].cint ;
install ( q + 4 , r ) ;
install ( q + 10 , r ) ;
install ( q + 8 , r + 2 ) ;
if ( mem [r + 2 ].hhfield .b0 == 16 )
mem [r + 3 ].cint = - (integer) mem [r + 3 ].cint ;
else negatedeplist ( mem [r + 3 ].hhfield .v.RH ) ;
install ( q + 6 , r + 2 ) ;
goto lab30 ;
}
break ;
case 88 :
;
break ;
}
disperr ( p , 854 ) ;
{
helpptr = 3 ;
helpline [2 ]= 855 ;
helpline [1 ]= 856 ;
helpline [0 ]= 537 ;
}
putgeterror () ;
lab30: recyclevalue ( p ) ;
freenode ( p , 2 ) ;
}
q = mem [curexp + 1 ].cint ;
r = q + 12 ;
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 != 16 )
goto lab10 ;
} while ( ! ( r == q ) ) ;
txx = mem [q + 5 ].cint ;
txy = mem [q + 7 ].cint ;
tyx = mem [q + 9 ].cint ;
tyy = mem [q + 11 ].cint ;
tx = mem [q + 1 ].cint ;
ty = mem [q + 3 ].cint ;
flushcurexp ( 0 ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zsetupknowntrans ( quarterword c )
#else
zsetupknowntrans ( c )
quarterword c ;
#endif
{
setuptrans ( c ) ;
if ( curtype != 16 )
{
disperr ( 0 , 857 ) ;
{
helpptr = 3 ;
helpline [2 ]= 858 ;
helpline [1 ]= 859 ;
helpline [0 ]= 537 ;
}
putgetflusherror ( 0 ) ;
txx = 65536L ;
txy = 0 ;
tyx = 0 ;
tyy = 65536L ;
tx = 0 ;
ty = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
ztrans ( halfword p , halfword q )
#else
ztrans ( p , q )
halfword p ;
halfword q ;
#endif
{
scaled v ;
v = takescaled ( mem [p ].cint , txx ) + takescaled ( mem [q ].cint ,
txy ) + tx ;
mem [q ].cint = takescaled ( mem [p ].cint , tyx ) + takescaled ( mem [
q ].cint , tyy ) + ty ;
mem [p ].cint = v ;
}
void
#ifdef HAVE_PROTOTYPES
zpathtrans ( halfword p , quarterword c )
#else
zpathtrans ( p , c )
halfword p ;
quarterword c ;
#endif
{
/* 10 */ halfword q ;
setupknowntrans ( c ) ;
unstashcurexp ( p ) ;
if ( curtype == 6 )
{
if ( mem [curexp + 9 ].cint == 0 )
if ( tx == 0 )
if ( ty == 0 )
goto lab10 ;
flushcurexp ( makepath ( curexp ) ) ;
curtype = 8 ;
}
q = curexp ;
do {
if ( mem [q ].hhfield .b0 != 0 )
trans ( q + 3 , q + 4 ) ;
trans ( q + 1 , q + 2 ) ;
if ( mem [q ].hhfield .b1 != 0 )
trans ( q + 5 , q + 6 ) ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == curexp ) ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zedgestrans ( halfword p , quarterword c )
#else
zedgestrans ( p , c )
halfword p ;
quarterword c ;
#endif
{
/* 10 */ setupknowntrans ( c ) ;
unstashcurexp ( p ) ;
curedges = curexp ;
if ( mem [curedges ].hhfield .v.RH == curedges )
goto lab10 ;
if ( txx == 0 )
if ( tyy == 0 )
if ( txy % 65536L == 0 )
if ( tyx % 65536L == 0 )
{
xyswapedges () ;
txx = txy ;
tyy = tyx ;
txy = 0 ;
tyx = 0 ;
if ( mem [curedges ].hhfield .v.RH == curedges )
goto lab10 ;
}
if ( txy == 0 )
if ( tyx == 0 )
if ( txx % 65536L == 0 )
if ( tyy % 65536L == 0 )
{
if ( ( txx == 0 ) || ( tyy == 0 ) )
{
tossedges ( curedges ) ;
curexp = getnode ( 6 ) ;
initedges ( curexp ) ;
}
else {
if ( txx < 0 )
{
xreflectedges () ;
txx = - (integer) txx ;
}
if ( tyy < 0 )
{
yreflectedges () ;
tyy = - (integer) tyy ;
}
if ( txx != 65536L )
xscaleedges ( txx / 65536L ) ;
if ( tyy != 65536L )
yscaleedges ( tyy / 65536L ) ;
tx = roundunscaled ( tx ) ;
ty = roundunscaled ( ty ) ;
if ( ( toint ( mem [curedges + 2 ].hhfield .lhfield ) + tx <= 0 ) || (
mem [curedges + 2 ].hhfield .v.RH + tx >= 8192 ) || ( toint ( mem [
curedges + 1 ].hhfield .lhfield ) + ty <= 0 ) || ( mem [curedges + 1 ]
.hhfield .v.RH + ty >= 8191 ) || ( abs ( tx ) >= 4096 ) || ( abs ( ty )
>= 4096 ) )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 863 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 864 ;
helpline [1 ]= 536 ;
helpline [0 ]= 537 ;
}
putgeterror () ;
}
else {
if ( tx != 0 )
{
if ( ! ( abs ( mem [curedges + 3 ].hhfield .lhfield - tx - 4096 )
< 4096 ) )
fixoffset () ;
mem [curedges + 2 ].hhfield .lhfield = mem [curedges + 2 ]
.hhfield .lhfield + tx ;
mem [curedges + 2 ].hhfield .v.RH = mem [curedges + 2 ].hhfield
.v.RH + tx ;
mem [curedges + 3 ].hhfield .lhfield = mem [curedges + 3 ]
.hhfield .lhfield - tx ;
mem [curedges + 4 ].cint = 0 ;
}
if ( ty != 0 )
{
mem [curedges + 1 ].hhfield .lhfield = mem [curedges + 1 ]
.hhfield .lhfield + ty ;
mem [curedges + 1 ].hhfield .v.RH = mem [curedges + 1 ].hhfield
.v.RH + ty ;
mem [curedges + 5 ].hhfield .lhfield = mem [curedges + 5 ]
.hhfield .lhfield + ty ;
mem [curedges + 4 ].cint = 0 ;
}
}
}
goto lab10 ;
}
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 860 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 861 ;
helpline [1 ]= 862 ;
helpline [0 ]= 537 ;
}
putgeterror () ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zbilin1 ( halfword p , scaled t , halfword q , scaled u , scaled delta )
#else
zbilin1 ( p , t , q , u , delta )
halfword p ;
scaled t ;
halfword q ;
scaled u ;
scaled delta ;
#endif
{
halfword r ;
if ( t != 65536L )
depmult ( p , t , true ) ;
if ( u != 0 )
if ( mem [q ].hhfield .b0 == 16 )
delta = delta + takescaled ( mem [q + 1 ].cint , u ) ;
else {
if ( mem [p ].hhfield .b0 != 18 )
{
if ( mem [p ].hhfield .b0 == 16 )
newdep ( p , constdependency ( mem [p + 1 ].cint ) ) ;
else mem [p + 1 ].hhfield .v.RH = ptimesv ( mem [p + 1 ].hhfield
.v.RH , 65536L , 17 , 18 , true ) ;
mem [p ].hhfield .b0 = 18 ;
}
mem [p + 1 ].hhfield .v.RH = pplusfq ( mem [p + 1 ].hhfield .v.RH , u
, mem [q + 1 ].hhfield .v.RH , 18 , mem [q ].hhfield .b0 ) ;
}
if ( mem [p ].hhfield .b0 == 16 )
mem [p + 1 ].cint = mem [p + 1 ].cint + delta ;
else {
r = mem [p + 1 ].hhfield .v.RH ;
while ( mem [r ].hhfield .lhfield != 0 ) r = mem [r ].hhfield .v.RH ;
delta = mem [r + 1 ].cint + delta ;
if ( r != mem [p + 1 ].hhfield .v.RH )
mem [r + 1 ].cint = delta ;
else {
recyclevalue ( p ) ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = delta ;
}
}
if ( fixneeded )
fixdependencies () ;
}
void
#ifdef HAVE_PROTOTYPES
zaddmultdep ( halfword p , scaled v , halfword r )
#else
zaddmultdep ( p , v , r )
halfword p ;
scaled v ;
halfword r ;
#endif
{
if ( mem [r ].hhfield .b0 == 16 )
mem [depfinal + 1 ].cint = mem [depfinal + 1 ].cint + takescaled ( mem [
r + 1 ].cint , v ) ;
else {
mem [p + 1 ].hhfield .v.RH = pplusfq ( mem [p + 1 ].hhfield .v.RH , v
, mem [r + 1 ].hhfield .v.RH , 18 , mem [r ].hhfield .b0 ) ;
if ( fixneeded )
fixdependencies () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbilin2 ( halfword p , halfword t , scaled v , halfword u , halfword q )
#else
zbilin2 ( p , t , v , u , q )
halfword p ;
halfword t ;
scaled v ;
halfword u ;
halfword q ;
#endif
{
scaled vv ;
vv = mem [p + 1 ].cint ;
mem [p ].hhfield .b0 = 18 ;
newdep ( p , constdependency ( 0 ) ) ;
if ( vv != 0 )
addmultdep ( p , vv , t ) ;
if ( v != 0 )
addmultdep ( p , v , u ) ;
if ( q != 0 )
addmultdep ( p , 65536L , q ) ;
if ( mem [p + 1 ].hhfield .v.RH == depfinal )
{
vv = mem [depfinal + 1 ].cint ;
recyclevalue ( p ) ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = vv ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbilin3 ( halfword p , scaled t , scaled v , scaled u , scaled delta )
#else
zbilin3 ( p , t , v , u , delta )
halfword p ;
scaled t ;
scaled v ;
scaled u ;
scaled delta ;
#endif
{
if ( t != 65536L )
delta = delta + takescaled ( mem [p + 1 ].cint , t ) ;
else delta = delta + mem [p + 1 ].cint ;
if ( u != 0 )
mem [p + 1 ].cint = delta + takescaled ( v , u ) ;
else mem [p + 1 ].cint = delta ;
}
void
#ifdef HAVE_PROTOTYPES
zbigtrans ( halfword p , quarterword c )
#else
zbigtrans ( p , c )
halfword p ;
quarterword c ;
#endif
{
/* 10 */ halfword q, r, pp, qq ;
smallnumber s ;
s = bignodesize [mem [p ].hhfield .b0 ];
q = mem [p + 1 ].cint ;
r = q + s ;
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 != 16 )
{
setupknowntrans ( c ) ;
makeexpcopy ( p ) ;
r = mem [curexp + 1 ].cint ;
if ( curtype == 13 )
{
bilin1 ( r + 10 , tyy , q + 6 , tyx , 0 ) ;
bilin1 ( r + 8 , tyy , q + 4 , tyx , 0 ) ;
bilin1 ( r + 6 , txx , q + 10 , txy , 0 ) ;
bilin1 ( r + 4 , txx , q + 8 , txy , 0 ) ;
}
bilin1 ( r + 2 , tyy , q , tyx , ty ) ;
bilin1 ( r , txx , q + 2 , txy , tx ) ;
goto lab10 ;
}
} while ( ! ( r == q ) ) ;
setuptrans ( c ) ;
if ( curtype == 16 )
{
makeexpcopy ( p ) ;
r = mem [curexp + 1 ].cint ;
if ( curtype == 13 )
{
bilin3 ( r + 10 , tyy , mem [q + 7 ].cint , tyx , 0 ) ;
bilin3 ( r + 8 , tyy , mem [q + 5 ].cint , tyx , 0 ) ;
bilin3 ( r + 6 , txx , mem [q + 11 ].cint , txy , 0 ) ;
bilin3 ( r + 4 , txx , mem [q + 9 ].cint , txy , 0 ) ;
}
bilin3 ( r + 2 , tyy , mem [q + 1 ].cint , tyx , ty ) ;
bilin3 ( r , txx , mem [q + 3 ].cint , txy , tx ) ;
}
else {
pp = stashcurexp () ;
qq = mem [pp + 1 ].cint ;
makeexpcopy ( p ) ;
r = mem [curexp + 1 ].cint ;
if ( curtype == 13 )
{
bilin2 ( r + 10 , qq + 10 , mem [q + 7 ].cint , qq + 8 , 0 ) ;
bilin2 ( r + 8 , qq + 10 , mem [q + 5 ].cint , qq + 8 , 0 ) ;
bilin2 ( r + 6 , qq + 4 , mem [q + 11 ].cint , qq + 6 , 0 ) ;
bilin2 ( r + 4 , qq + 4 , mem [q + 9 ].cint , qq + 6 , 0 ) ;
}
bilin2 ( r + 2 , qq + 10 , mem [q + 1 ].cint , qq + 8 , qq + 2 ) ;
bilin2 ( r , qq + 4 , mem [q + 3 ].cint , qq + 6 , qq ) ;
recyclevalue ( pp ) ;
freenode ( pp , 2 ) ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zcat ( halfword p )
#else
zcat ( p )
halfword p ;
#endif
{
strnumber a, b ;
poolpointer k ;
a = mem [p + 1 ].cint ;
b = curexp ;
{
if ( poolptr + ( strstart [a + 1 ]- strstart [a ]) + ( strstart [b +
1 ]- strstart [b ]) > maxpoolptr )
{
if ( poolptr + ( strstart [a + 1 ]- strstart [a ]) + ( strstart [b
+ 1 ]- strstart [b ]) > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + ( strstart [a + 1 ]- strstart [a ]) + (
strstart [b + 1 ]- strstart [b ]) ;
}
}
{register integer for_end; k = strstart [a ];for_end = strstart [a + 1
]- 1 ; if ( k <= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
{register integer for_end; k = strstart [b ];for_end = strstart [b + 1
]- 1 ; if ( k <= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
curexp = makestring () ;
{
if ( strref [b ]< 127 )
if ( strref [b ]> 1 )
decr ( strref [b ]) ;
else flushstring ( b ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zchopstring ( halfword p )
#else
zchopstring ( p )
halfword p ;
#endif
{
integer a, b ;
integer l ;
integer k ;
strnumber s ;
boolean reversed ;
a = roundunscaled ( mem [p + 1 ].cint ) ;
b = roundunscaled ( mem [p + 3 ].cint ) ;
if ( a <= b )
reversed = false ;
else {
reversed = true ;
k = a ;
a = b ;
b = k ;
}
s = curexp ;
l = ( strstart [s + 1 ]- strstart [s ]) ;
if ( a < 0 )
{
a = 0 ;
if ( b < 0 )
b = 0 ;
}
if ( b > l )
{
b = l ;
if ( a > l )
a = l ;
}
{
if ( poolptr + b - a > maxpoolptr )
{
if ( poolptr + b - a > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + b - a ;
}
}
if ( reversed )
{register integer for_end; k = strstart [s ]+ b - 1 ;for_end = strstart
[s ]+ a ; if ( k >= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k-- > for_end ) ;}
else {
register integer for_end; k = strstart [s ]+ a ;for_end = strstart
[s ]+ b - 1 ; if ( k <= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
curexp = makestring () ;
{
if ( strref [s ]< 127 )
if ( strref [s ]> 1 )
decr ( strref [s ]) ;
else flushstring ( s ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zchoppath ( halfword p )
#else
zchoppath ( p )
halfword p ;
#endif
{
halfword q ;
halfword pp, qq, rr, ss ;
scaled a, b, k, l ;
boolean reversed ;
l = pathlength () ;
a = mem [p + 1 ].cint ;
b = mem [p + 3 ].cint ;
if ( a <= b )
reversed = false ;
else {
reversed = true ;
k = a ;
a = b ;
b = k ;
}
if ( a < 0 )
if ( mem [curexp ].hhfield .b0 == 0 )
{
a = 0 ;
if ( b < 0 )
b = 0 ;
}
else do {
a = a + l ;
b = b + l ;
} while ( ! ( a >= 0 ) ) ;
if ( b > l )
if ( mem [curexp ].hhfield .b0 == 0 )
{
b = l ;
if ( a > l )
a = l ;
}
else while ( a >= l ) {
a = a - l ;
b = b - l ;
}
q = curexp ;
while ( a >= 65536L ) {
q = mem [q ].hhfield .v.RH ;
a = a - 65536L ;
b = b - 65536L ;
}
if ( b == a )
{
if ( a > 0 )
{
qq = mem [q ].hhfield .v.RH ;
splitcubic ( q , a * 4096 , mem [qq + 1 ].cint , mem [qq + 2 ].cint
) ;
q = mem [q ].hhfield .v.RH ;
}
pp = copyknot ( q ) ;
qq = pp ;
}
else {
pp = copyknot ( q ) ;
qq = pp ;
do {
q = mem [q ].hhfield .v.RH ;
rr = qq ;
qq = copyknot ( q ) ;
mem [rr ].hhfield .v.RH = qq ;
b = b - 65536L ;
} while ( ! ( b <= 0 ) ) ;
if ( a > 0 )
{
ss = pp ;
pp = mem [pp ].hhfield .v.RH ;
splitcubic ( ss , a * 4096 , mem [pp + 1 ].cint , mem [pp + 2 ].cint
) ;
pp = mem [ss ].hhfield .v.RH ;
freenode ( ss , 7 ) ;
if ( rr == ss )
{
b = makescaled ( b , 65536L - a ) ;
rr = pp ;
}
}
if ( b < 0 )
{
splitcubic ( rr , ( b + 65536L ) * 4096 , mem [qq + 1 ].cint , mem [
qq + 2 ].cint ) ;
freenode ( qq , 7 ) ;
qq = mem [rr ].hhfield .v.RH ;
}
}
mem [pp ].hhfield .b0 = 0 ;
mem [qq ].hhfield .b1 = 0 ;
mem [qq ].hhfield .v.RH = pp ;
tossknotlist ( curexp ) ;
if ( reversed )
{
curexp = mem [htapypoc ( pp ) ].hhfield .v.RH ;
tossknotlist ( pp ) ;
}
else curexp = pp ;
}
void
#ifdef HAVE_PROTOTYPES
zpairvalue ( scaled x , scaled y )
#else
zpairvalue ( x , y )
scaled x ;
scaled y ;
#endif
{
halfword p ;
p = getnode ( 2 ) ;
flushcurexp ( p ) ;
curtype = 14 ;
mem [p ].hhfield .b0 = 14 ;
mem [p ].hhfield .b1 = 11 ;
initbignode ( p ) ;
p = mem [p + 1 ].cint ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = x ;
mem [p + 2 ].hhfield .b0 = 16 ;
mem [p + 3 ].cint = y ;
}
void
#ifdef HAVE_PROTOTYPES
zsetupoffset ( halfword p )
#else
zsetupoffset ( p )
halfword p ;
#endif
{
findoffset ( mem [p + 1 ].cint , mem [p + 3 ].cint , curexp ) ;
pairvalue ( curx , cury ) ;
}
void
#ifdef HAVE_PROTOTYPES
zsetupdirectiontime ( halfword p )
#else
zsetupdirectiontime ( p )
halfword p ;
#endif
{
flushcurexp ( finddirectiontime ( mem [p + 1 ].cint , mem [p + 3 ]
.cint , curexp ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
zfindpoint ( scaled v , quarterword c )
#else
zfindpoint ( v , c )
scaled v ;
quarterword c ;
#endif
{
halfword p ;
scaled n ;
halfword q ;
p = curexp ;
if ( mem [p ].hhfield .b0 == 0 )
n = -65536L ;
else n = 0 ;
do {
p = mem [p ].hhfield .v.RH ;
n = n + 65536L ;
} while ( ! ( p == curexp ) ) ;
if ( n == 0 )
v = 0 ;
else if ( v < 0 )
if ( mem [p ].hhfield .b0 == 0 )
v = 0 ;
else v = n - 1 - ( ( - (integer) v - 1 ) % n ) ;
else if ( v > n )
if ( mem [p ].hhfield .b0 == 0 )
v = n ;
else v = v % n ;
p = curexp ;
while ( v >= 65536L ) {
p = mem [p ].hhfield .v.RH ;
v = v - 65536L ;
}
if ( v != 0 )
{
q = mem [p ].hhfield .v.RH ;
splitcubic ( p , v * 4096 , mem [q + 1 ].cint , mem [q + 2 ].cint ) ;
p = mem [p ].hhfield .v.RH ;
}
switch ( c )
{case 97 :
pairvalue ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
break ;
case 98 :
if ( mem [p ].hhfield .b0 == 0 )
pairvalue ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
else pairvalue ( mem [p + 3 ].cint , mem [p + 4 ].cint ) ;
break ;
case 99 :
if ( mem [p ].hhfield .b1 == 0 )
pairvalue ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
else pairvalue ( mem [p + 5 ].cint , mem [p + 6 ].cint ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zdobinary ( halfword p , quarterword c )
#else
zdobinary ( p , c )
halfword p ;
quarterword c ;
#endif
{
/* 30 31 10 */ halfword q, r, rr ;
halfword oldp, oldexp ;
integer v ;
{
if ( aritherror )
cleararith () ;
}
if ( internal [7 ]> 131072L )
{
begindiagnostic () ;
printnl ( 846 ) ;
printexp ( p , 0 ) ;
printchar ( 41 ) ;
printop ( c ) ;
printchar ( 40 ) ;
printexp ( 0 , 0 ) ;
print ( 838 ) ;
enddiagnostic ( false ) ;
}
switch ( mem [p ].hhfield .b0 )
{case 13 :
case 14 :
oldp = tarnished ( p ) ;
break ;
case 19 :
oldp = 1 ;
break ;
default:
oldp = 0 ;
break ;
}
if ( oldp != 0 )
{
q = stashcurexp () ;
oldp = p ;
makeexpcopy ( oldp ) ;
p = stashcurexp () ;
unstashcurexp ( q ) ;
}
switch ( curtype )
{case 13 :
case 14 :
oldexp = tarnished ( curexp ) ;
break ;
case 19 :
oldexp = 1 ;
break ;
default:
oldexp = 0 ;
break ;
}
if ( oldexp != 0 )
{
oldexp = curexp ;
makeexpcopy ( oldexp ) ;
}
switch ( c )
{case 69 :
case 70 :
if ( ( curtype < 14 ) || ( mem [p ].hhfield .b0 < 14 ) )
if ( ( curtype == 11 ) && ( mem [p ].hhfield .b0 == 11 ) )
{
if ( c == 70 )
negateedges ( curexp ) ;
curedges = curexp ;
mergeedges ( mem [p + 1 ].cint ) ;
}
else badbinary ( p , c ) ;
else if ( curtype == 14 )
if ( mem [p ].hhfield .b0 != 14 )
badbinary ( p , c ) ;
else {
q = mem [p + 1 ].cint ;
r = mem [curexp + 1 ].cint ;
addorsubtract ( q , r , c ) ;
addorsubtract ( q + 2 , r + 2 , c ) ;
}
else if ( mem [p ].hhfield .b0 == 14 )
badbinary ( p , c ) ;
else addorsubtract ( p , 0 , c ) ;
break ;
case 77 :
case 78 :
case 79 :
case 80 :
case 81 :
case 82 :
{
if ( ( curtype > 14 ) && ( mem [p ].hhfield .b0 > 14 ) )
addorsubtract ( p , 0 , 70 ) ;
else if ( curtype != mem [p ].hhfield .b0 )
{
badbinary ( p , c ) ;
goto lab30 ;
}
else if ( curtype == 4 )
flushcurexp ( strvsstr ( mem [p + 1 ].cint , curexp ) ) ;
else if ( ( curtype == 5 ) || ( curtype == 3 ) )
{
q = mem [curexp + 1 ].cint ;
while ( ( q != curexp ) && ( q != p ) ) q = mem [q + 1 ].cint ;
if ( q == p )
flushcurexp ( 0 ) ;
}
else if ( ( curtype == 14 ) || ( curtype == 13 ) )
{
q = mem [p + 1 ].cint ;
r = mem [curexp + 1 ].cint ;
rr = r + bignodesize [curtype ]- 2 ;
while ( true ) {
addorsubtract ( q , r , 70 ) ;
if ( mem [r ].hhfield .b0 != 16 )
goto lab31 ;
if ( mem [r + 1 ].cint != 0 )
goto lab31 ;
if ( r == rr )
goto lab31 ;
q = q + 2 ;
r = r + 2 ;
}
lab31: takepart ( 53 + half ( r - mem [curexp + 1 ].cint ) ) ;
}
else if ( curtype == 2 )
flushcurexp ( curexp - mem [p + 1 ].cint ) ;
else {
badbinary ( p , c ) ;
goto lab30 ;
}
if ( curtype != 16 )
{
if ( curtype < 16 )
{
disperr ( p , 283 ) ;
{
helpptr = 1 ;
helpline [0 ]= 847 ;
}
}
else {
helpptr = 2 ;
helpline [1 ]= 848 ;
helpline [0 ]= 849 ;
}
disperr ( 0 , 850 ) ;
putgetflusherror ( 31 ) ;
}
else switch ( c )
{case 77 :
if ( curexp < 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 78 :
if ( curexp <= 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 79 :
if ( curexp > 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 80 :
if ( curexp >= 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 81 :
if ( curexp == 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 82 :
if ( curexp != 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
}
curtype = 2 ;
lab30: ;
}
break ;
case 76 :
case 75 :
if ( ( mem [p ].hhfield .b0 != 2 ) || ( curtype != 2 ) )
badbinary ( p , c ) ;
else if ( mem [p + 1 ].cint == c - 45 )
curexp = mem [p + 1 ].cint ;
break ;
case 71 :
if ( ( curtype < 14 ) || ( mem [p ].hhfield .b0 < 14 ) )
badbinary ( p , 71 ) ;
else if ( ( curtype == 16 ) || ( mem [p ].hhfield .b0 == 16 ) )
{
if ( mem [p ].hhfield .b0 == 16 )
{
v = mem [p + 1 ].cint ;
freenode ( p , 2 ) ;
}
else {
v = curexp ;
unstashcurexp ( p ) ;
}
if ( curtype == 16 )
curexp = takescaled ( curexp , v ) ;
else if ( curtype == 14 )
{
p = mem [curexp + 1 ].cint ;
depmult ( p , v , true ) ;
depmult ( p + 2 , v , true ) ;
}
else depmult ( 0 , v , true ) ;
goto lab10 ;
}
else if ( ( nicepair ( p , mem [p ].hhfield .b0 ) && ( curtype > 14 ) )
|| ( nicepair ( curexp , curtype ) && ( mem [p ].hhfield .b0 > 14 ) ) )
{
hardtimes ( p ) ;
goto lab10 ;
}
else badbinary ( p , 71 ) ;
break ;
case 72 :
if ( ( curtype != 16 ) || ( mem [p ].hhfield .b0 < 14 ) )
badbinary ( p , 72 ) ;
else {
v = curexp ;
unstashcurexp ( p ) ;
if ( v == 0 )
{
disperr ( 0 , 780 ) ;
{
helpptr = 2 ;
helpline [1 ]= 852 ;
helpline [0 ]= 853 ;
}
putgeterror () ;
}
else {
if ( curtype == 16 )
curexp = makescaled ( curexp , v ) ;
else if ( curtype == 14 )
{
p = mem [curexp + 1 ].cint ;
depdiv ( p , v ) ;
depdiv ( p + 2 , v ) ;
}
else depdiv ( 0 , v ) ;
}
goto lab10 ;
}
break ;
case 73 :
case 74 :
if ( ( curtype == 16 ) && ( mem [p ].hhfield .b0 == 16 ) )
if ( c == 73 )
curexp = pythadd ( mem [p + 1 ].cint , curexp ) ;
else curexp = pythsub ( mem [p + 1 ].cint , curexp ) ;
else badbinary ( p , c ) ;
break ;
case 84 :
case 85 :
case 86 :
case 87 :
case 88 :
case 89 :
case 90 :
case 91 :
if ( ( mem [p ].hhfield .b0 == 9 ) || ( mem [p ].hhfield .b0 == 8 ) ||
( mem [p ].hhfield .b0 == 6 ) )
{
pathtrans ( p , c ) ;
goto lab10 ;
}
else if ( ( mem [p ].hhfield .b0 == 14 ) || ( mem [p ].hhfield .b0 ==
13 ) )
bigtrans ( p , c ) ;
else if ( mem [p ].hhfield .b0 == 11 )
{
edgestrans ( p , c ) ;
goto lab10 ;
}
else badbinary ( p , c ) ;
break ;
case 83 :
if ( ( curtype == 4 ) && ( mem [p ].hhfield .b0 == 4 ) )
cat ( p ) ;
else badbinary ( p , 83 ) ;
break ;
case 94 :
if ( nicepair ( p , mem [p ].hhfield .b0 ) && ( curtype == 4 ) )
chopstring ( mem [p + 1 ].cint ) ;
else badbinary ( p , 94 ) ;
break ;
case 95 :
{
if ( curtype == 14 )
pairtopath () ;
if ( nicepair ( p , mem [p ].hhfield .b0 ) && ( curtype == 9 ) )
choppath ( mem [p + 1 ].cint ) ;
else badbinary ( p , 95 ) ;
}
break ;
case 97 :
case 98 :
case 99 :
{
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 9 ) && ( mem [p ].hhfield .b0 == 16 ) )
findpoint ( mem [p + 1 ].cint , c ) ;
else badbinary ( p , c ) ;
}
break ;
case 100 :
{
if ( curtype == 8 )
materializepen () ;
if ( ( curtype == 6 ) && nicepair ( p , mem [p ].hhfield .b0 ) )
setupoffset ( mem [p + 1 ].cint ) ;
else badbinary ( p , 100 ) ;
}
break ;
case 96 :
{
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 9 ) && nicepair ( p , mem [p ].hhfield .b0 ) )
setupdirectiontime ( mem [p + 1 ].cint ) ;
else badbinary ( p , 96 ) ;
}
break ;
case 92 :
{
if ( mem [p ].hhfield .b0 == 14 )
{
q = stashcurexp () ;
unstashcurexp ( p ) ;
pairtopath () ;
p = stashcurexp () ;
unstashcurexp ( q ) ;
}
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 9 ) && ( mem [p ].hhfield .b0 == 9 ) )
{
pathintersection ( mem [p + 1 ].cint , curexp ) ;
pairvalue ( curt , curtt ) ;
}
else badbinary ( p , 92 ) ;
}
break ;
}
recyclevalue ( p ) ;
freenode ( p , 2 ) ;
lab10: {
if ( aritherror )
cleararith () ;
}
if ( oldp != 0 )
{
recyclevalue ( oldp ) ;
freenode ( oldp , 2 ) ;
}
if ( oldexp != 0 )
{
recyclevalue ( oldexp ) ;
freenode ( oldexp , 2 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zfracmult ( scaled n , scaled d )
#else
zfracmult ( n , d )
scaled n ;
scaled d ;
#endif
{
halfword p ;
halfword oldexp ;
fraction v ;
if ( internal [7 ]> 131072L )
{
begindiagnostic () ;
printnl ( 846 ) ;
printscaled ( n ) ;
printchar ( 47 ) ;
printscaled ( d ) ;
print ( 851 ) ;
printexp ( 0 , 0 ) ;
print ( 838 ) ;
enddiagnostic ( false ) ;
}
switch ( curtype )
{case 13 :
case 14 :
oldexp = tarnished ( curexp ) ;
break ;
case 19 :
oldexp = 1 ;
break ;
default:
oldexp = 0 ;
break ;
}
if ( oldexp != 0 )
{
oldexp = curexp ;
makeexpcopy ( oldexp ) ;
}
v = makefraction ( n , d ) ;
if ( curtype == 16 )
curexp = takefraction ( curexp , v ) ;
else if ( curtype == 14 )
{
p = mem [curexp + 1 ].cint ;
depmult ( p , v , false ) ;
depmult ( p + 2 , v , false ) ;
}
else depmult ( 0 , v , false ) ;
if ( oldexp != 0 )
{
recyclevalue ( oldexp ) ;
freenode ( oldexp , 2 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
gfswap ( void )
#else
gfswap ( )
#endif
{
if ( gflimit == gfbufsize )
{
writegf ( 0 , halfbuf - 1 ) ;
gflimit = halfbuf ;
gfoffset = gfoffset + gfbufsize ;
gfptr = 0 ;
}
else {
writegf ( halfbuf , gfbufsize - 1 ) ;
gflimit = gfbufsize ;
}
}
void
#ifdef HAVE_PROTOTYPES
zgffour ( integer x )
#else
zgffour ( x )
integer x ;
#endif
{
if ( x >= 0 )
{
gfbuf [gfptr ]= x / 16777216L ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
else {
x = x + 1073741824L ;
x = x + 1073741824L ;
{
gfbuf [gfptr ]= ( x / 16777216L ) + 128 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
x = x % 16777216L ;
{
gfbuf [gfptr ]= x / 65536L ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
x = x % 65536L ;
{
gfbuf [gfptr ]= x / 256 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= x % 256 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zgftwo ( integer x )
#else
zgftwo ( x )
integer x ;
#endif
{
{
gfbuf [gfptr ]= x / 256 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= x % 256 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zgfthree ( integer x )
#else
zgfthree ( x )
integer x ;
#endif
{
{
gfbuf [gfptr ]= x / 65536L ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= ( x % 65536L ) / 256 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= x % 256 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zgfpaint ( integer d )
#else
zgfpaint ( d )
integer d ;
#endif
{
if ( d < 64 )
{
gfbuf [gfptr ]= 0 + d ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
else if ( d < 256 )
{
{
gfbuf [gfptr ]= 64 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= d ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
else {
{
gfbuf [gfptr ]= 65 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gftwo ( d ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zgfstring ( strnumber s , strnumber t )
#else
zgfstring ( s , t )
strnumber s ;
strnumber t ;
#endif
{
poolpointer k ;
integer l ;
if ( s != 0 )
{
l = ( strstart [s + 1 ]- strstart [s ]) ;
if ( t != 0 )
l = l + ( strstart [t + 1 ]- strstart [t ]) ;
if ( l <= 255 )
{
{
gfbuf [gfptr ]= 239 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= l ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
else {
{
gfbuf [gfptr ]= 241 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gfthree ( l ) ;
}
{register integer for_end; k = strstart [s ];for_end = strstart [s +
1 ]- 1 ; if ( k <= for_end) do
{
gfbuf [gfptr ]= strpool [k ];
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
while ( k++ < for_end ) ;}
}
if ( t != 0 )
{register integer for_end; k = strstart [t ];for_end = strstart [t + 1
]- 1 ; if ( k <= for_end) do
{
gfbuf [gfptr ]= strpool [k ];
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
while ( k++ < for_end ) ;}
}
void
#ifdef HAVE_PROTOTYPES
zgfboc ( integer minm , integer maxm , integer minn , integer maxn )
#else
zgfboc ( minm , maxm , minn , maxn )
integer minm ;
integer maxm ;
integer minn ;
integer maxn ;
#endif
{
/* 10 */ if ( minm < gfminm )
gfminm = minm ;
if ( maxn > gfmaxn )
gfmaxn = maxn ;
if ( bocp == -1 )
if ( bocc >= 0 )
if ( bocc < 256 )
if ( maxm - minm >= 0 )
if ( maxm - minm < 256 )
if ( maxm >= 0 )
if ( maxm < 256 )
if ( maxn - minn >= 0 )
if ( maxn - minn < 256 )
if ( maxn >= 0 )
if ( maxn < 256 )
{
{
gfbuf [gfptr ]= 68 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= bocc ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= maxm - minm ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= maxm ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= maxn - minn ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= maxn ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
goto lab10 ;
}
{
gfbuf [gfptr ]= 67 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gffour ( bocc ) ;
gffour ( bocp ) ;
gffour ( minm ) ;
gffour ( maxm ) ;
gffour ( minn ) ;
gffour ( maxn ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
initgf ( void )
#else
initgf ( )
#endif
{
short k ;
integer t ;
gfminm = 4096 ;
gfmaxm = -4096 ;
gfminn = 4096 ;
gfmaxn = -4096 ;
{register integer for_end; k = 0 ;for_end = 255 ; if ( k <= for_end) do
charptr [k ]= -1 ;
while ( k++ < for_end ) ;}
if ( internal [27 ]<= 0 )
gfext = 1050 ;
else {
oldsetting = selector ;
selector = 5 ;
printchar ( 46 ) ;
printint ( makescaled ( internal [27 ], 59429463L ) ) ;
print ( 1051 ) ;
gfext = makestring () ;
selector = oldsetting ;
}
{
if ( jobname == 0 )
openlogfile () ;
packjobname ( gfext ) ;
while ( ! bopenout ( gffile ) ) promptfilename ( 752 , gfext ) ;
outputfilename = bmakenamestring ( gffile ) ;
}
{
gfbuf [gfptr ]= 247 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= 131 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
oldsetting = selector ;
selector = 5 ;
print ( 1049 ) ;
printint ( roundunscaled ( internal [14 ]) ) ;
printchar ( 46 ) ;
printdd ( roundunscaled ( internal [15 ]) ) ;
printchar ( 46 ) ;
printdd ( roundunscaled ( internal [16 ]) ) ;
printchar ( 58 ) ;
t = roundunscaled ( internal [17 ]) ;
printdd ( t / 60 ) ;
printdd ( t % 60 ) ;
selector = oldsetting ;
{
gfbuf [gfptr ]= ( poolptr - strstart [strptr ]) ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
strstart [strptr + 1 ]= poolptr ;
gfstring ( 0 , strptr ) ;
poolptr = strstart [strptr ];
gfprevptr = gfoffset + gfptr ;
}
void
#ifdef HAVE_PROTOTYPES
zshipout ( eightbits c )
#else
zshipout ( c )
eightbits c ;
#endif
{
/* 30 */ integer f ;
integer prevm, m, mm ;
integer prevn, n ;
halfword p, q ;
integer prevw, w, ww ;
integer d ;
integer delta ;
integer curminm ;
integer xoff, yoff ;
if ( outputfilename == 0 )
initgf () ;
f = roundunscaled ( internal [19 ]) ;
xoff = roundunscaled ( internal [29 ]) ;
yoff = roundunscaled ( internal [30 ]) ;
if ( termoffset > maxprintline - 9 )
println () ;
else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
printchar ( 32 ) ;
printchar ( 91 ) ;
printint ( c ) ;
if ( f != 0 )
{
printchar ( 46 ) ;
printint ( f ) ;
}
fflush ( stdout ) ;
bocc = 256 * f + c ;
bocp = charptr [c ];
charptr [c ]= gfprevptr ;
if ( internal [34 ]> 0 )
{
if ( xoff != 0 )
{
gfstring ( 436 , 0 ) ;
{
gfbuf [gfptr ]= 243 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gffour ( xoff * 65536L ) ;
}
if ( yoff != 0 )
{
gfstring ( 437 , 0 ) ;
{
gfbuf [gfptr ]= 243 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gffour ( yoff * 65536L ) ;
}
}
prevn = 4096 ;
p = mem [curedges ].hhfield .lhfield ;
n = mem [curedges + 1 ].hhfield .v.RH - 4096 ;
while ( p != curedges ) {
if ( mem [p + 1 ].hhfield .lhfield > 1 )
sortedges ( p ) ;
q = mem [p + 1 ].hhfield .v.RH ;
w = 0 ;
prevm = -268435456L ;
ww = 0 ;
prevw = 0 ;
m = prevm ;
do {
if ( q == memtop )
mm = 268435456L ;
else {
d = mem [q ].hhfield .lhfield ;
mm = d / 8 ;
ww = ww + ( d % 8 ) - 4 ;
}
if ( mm != m )
{
if ( prevw <= 0 )
{
if ( w > 0 )
{
if ( prevm == -268435456L )
{
if ( prevn == 4096 )
{
gfboc ( mem [curedges + 2 ].hhfield .lhfield + xoff - 4096 ,
mem [curedges + 2 ].hhfield .v.RH + xoff - 4096 , mem [
curedges + 1 ].hhfield .lhfield + yoff - 4096 , n + yoff ) ;
curminm = mem [curedges + 2 ].hhfield .lhfield - 4096 + mem
[curedges + 3 ].hhfield .lhfield ;
}
else if ( prevn > n + 1 )
{
delta = prevn - n - 1 ;
if ( delta < 256 )
{
{
gfbuf [gfptr ]= 71 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
{
gfbuf [gfptr ]= delta ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
}
else {
{
gfbuf [gfptr ]= 72 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gftwo ( delta ) ;
}
}
else {
delta = m - curminm ;
if ( delta > 164 )
{
gfbuf [gfptr ]= 70 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
else {
{
gfbuf [gfptr ]= 74 + delta ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
goto lab30 ;
}
}
gfpaint ( m - curminm ) ;
lab30: prevn = n ;
}
else gfpaint ( m - prevm ) ;
prevm = m ;
prevw = w ;
}
}
else if ( w <= 0 )
{
gfpaint ( m - prevm ) ;
prevm = m ;
prevw = w ;
}
m = mm ;
}
w = ww ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( mm == 268435456L ) ) ;
if ( w != 0 )
printnl ( 1053 ) ;
if ( prevm - toint ( mem [curedges + 3 ].hhfield .lhfield ) + xoff >
gfmaxm )
gfmaxm = prevm - mem [curedges + 3 ].hhfield .lhfield + xoff ;
p = mem [p ].hhfield .lhfield ;
decr ( n ) ;
}
if ( prevn == 4096 )
{
gfboc ( 0 , 0 , 0 , 0 ) ;
if ( gfmaxm < 0 )
gfmaxm = 0 ;
if ( gfminn > 0 )
gfminn = 0 ;
}
else if ( prevn + yoff < gfminn )
gfminn = prevn + yoff ;
{
gfbuf [gfptr ]= 69 ;
incr ( gfptr ) ;
if ( gfptr == gflimit )
gfswap () ;
}
gfprevptr = gfoffset + gfptr ;
incr ( totalchars ) ;
printchar ( 93 ) ;
fflush ( stdout ) ;
if ( internal [11 ]> 0 )
printedges ( 1052 , true , xoff , yoff ) ;
}
void
#ifdef HAVE_PROTOTYPES
ztryeq ( halfword l , halfword r )
#else
ztryeq ( l , r )
halfword l ;
halfword r ;
#endif
{
/* 30 31 */ halfword p ;
char t ;
halfword q ;
halfword pp ;
char tt ;
boolean copied ;
t = mem [l ].hhfield .b0 ;
if ( t == 16 )
{
t = 17 ;
p = constdependency ( - (integer) mem [l + 1 ].cint ) ;
q = p ;
}
else if ( t == 19 )
{
t = 17 ;
p = singledependency ( l ) ;
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
q = depfinal ;
}
else {
p = mem [l + 1 ].hhfield .v.RH ;
q = p ;
while ( true ) {
mem [q + 1 ].cint = - (integer) mem [q + 1 ].cint ;
if ( mem [q ].hhfield .lhfield == 0 )
goto lab30 ;
q = mem [q ].hhfield .v.RH ;
}
lab30: mem [mem [l + 1 ].hhfield .lhfield ].hhfield .v.RH = mem [q ]
.hhfield .v.RH ;
mem [mem [q ].hhfield .v.RH + 1 ].hhfield .lhfield = mem [l + 1 ]
.hhfield .lhfield ;
mem [l ].hhfield .b0 = 16 ;
}
if ( r == 0 )
if ( curtype == 16 )
{
mem [q + 1 ].cint = mem [q + 1 ].cint + curexp ;
goto lab31 ;
}
else {
tt = curtype ;
if ( tt == 19 )
pp = singledependency ( curexp ) ;
else pp = mem [curexp + 1 ].hhfield .v.RH ;
}
else if ( mem [r ].hhfield .b0 == 16 )
{
mem [q + 1 ].cint = mem [q + 1 ].cint + mem [r + 1 ].cint ;
goto lab31 ;
}
else {
tt = mem [r ].hhfield .b0 ;
if ( tt == 19 )
pp = singledependency ( r ) ;
else pp = mem [r + 1 ].hhfield .v.RH ;
}
if ( tt != 19 )
copied = false ;
else {
copied = true ;
tt = 17 ;
}
watchcoefs = false ;
if ( t == tt )
p = pplusq ( p , pp , t ) ;
else if ( t == 18 )
p = pplusfq ( p , 65536L , pp , 18 , 17 ) ;
else {
q = p ;
while ( mem [q ].hhfield .lhfield != 0 ) {
mem [q + 1 ].cint = roundfraction ( mem [q + 1 ].cint ) ;
q = mem [q ].hhfield .v.RH ;
}
t = 18 ;
p = pplusq ( p , pp , t ) ;
}
watchcoefs = true ;
if ( copied )
flushnodelist ( pp ) ;
lab31: ;
if ( mem [p ].hhfield .lhfield == 0 )
{
if ( abs ( mem [p + 1 ].cint ) > 64 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 893 ) ;
}
print ( 895 ) ;
printscaled ( mem [p + 1 ].cint ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 894 ;
helpline [0 ]= 892 ;
}
putgeterror () ;
}
else if ( r == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 597 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 598 ;
helpline [0 ]= 599 ;
}
putgeterror () ;
}
freenode ( p , 2 ) ;
}
else {
lineareq ( p , t ) ;
if ( r == 0 )
if ( curtype != 16 )
if ( mem [curexp ].hhfield .b0 == 16 )
{
pp = curexp ;
curexp = mem [curexp + 1 ].cint ;
curtype = 16 ;
freenode ( pp , 2 ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
zmakeeq ( halfword lhs )
#else
zmakeeq ( lhs )
halfword lhs ;
#endif
{
/* 20 30 45 */ smallnumber t ;
integer v ;
halfword p, q ;
lab20: t = mem [lhs ].hhfield .b0 ;
if ( t <= 14 )
v = mem [lhs + 1 ].cint ;
switch ( t )
{case 2 :
case 4 :
case 6 :
case 9 :
case 11 :
if ( curtype == t + 1 )
{
nonlineareq ( v , curexp , false ) ;
goto lab30 ;
}
else if ( curtype == t )
{
if ( curtype <= 4 )
{
if ( curtype == 4 )
{
if ( strvsstr ( v , curexp ) != 0 )
goto lab45 ;
}
else if ( v != curexp )
goto lab45 ;
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 597 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 598 ;
helpline [0 ]= 599 ;
}
putgeterror () ;
}
goto lab30 ;
}
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 890 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 891 ;
helpline [0 ]= 892 ;
}
putgeterror () ;
goto lab30 ;
lab45: {
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 893 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 894 ;
helpline [0 ]= 892 ;
}
putgeterror () ;
goto lab30 ;
}
break ;
case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
if ( curtype == t - 1 )
{
nonlineareq ( curexp , lhs , true ) ;
goto lab30 ;
}
else if ( curtype == t )
{
ringmerge ( lhs , curexp ) ;
goto lab30 ;
}
else if ( curtype == 14 )
if ( t == 10 )
{
pairtopath () ;
goto lab20 ;
}
break ;
case 13 :
case 14 :
if ( curtype == t )
{
p = v + bignodesize [t ];
q = mem [curexp + 1 ].cint + bignodesize [t ];
do {
p = p - 2 ;
q = q - 2 ;
tryeq ( p , q ) ;
} while ( ! ( p == v ) ) ;
goto lab30 ;
}
break ;
case 16 :
case 17 :
case 18 :
case 19 :
if ( curtype >= 16 )
{
tryeq ( lhs , 0 ) ;
goto lab30 ;
}
break ;
case 1 :
;
break ;
}
disperr ( lhs , 283 ) ;
disperr ( 0 , 887 ) ;
if ( mem [lhs ].hhfield .b0 <= 14 )
printtype ( mem [lhs ].hhfield .b0 ) ;
else print ( 339 ) ;
printchar ( 61 ) ;
if ( curtype <= 14 )
printtype ( curtype ) ;
else print ( 339 ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 888 ;
helpline [0 ]= 889 ;
}
putgeterror () ;
lab30: {
if ( aritherror )
cleararith () ;
}
recyclevalue ( lhs ) ;
freenode ( lhs , 2 ) ;
}
void
#ifdef HAVE_PROTOTYPES
doequation ( void )
#else
doequation ( )
#endif
{
halfword lhs ;
halfword p ;
lhs = stashcurexp () ;
getxnext () ;
varflag = 77 ;
scanexpression () ;
if ( curcmd == 51 )
doequation () ;
else if ( curcmd == 77 )
doassignment () ;
if ( internal [7 ]> 131072L )
{
begindiagnostic () ;
printnl ( 846 ) ;
printexp ( lhs , 0 ) ;
print ( 882 ) ;
printexp ( 0 , 0 ) ;
print ( 838 ) ;
enddiagnostic ( false ) ;
}
if ( curtype == 10 )
if ( mem [lhs ].hhfield .b0 == 14 )
{
p = stashcurexp () ;
unstashcurexp ( lhs ) ;
lhs = p ;
}
makeeq ( lhs ) ;
}
void
#ifdef HAVE_PROTOTYPES
doassignment ( void )
#else
doassignment ( )
#endif
{
halfword lhs ;
halfword p ;
halfword q ;
if ( curtype != 20 )
{
disperr ( 0 , 879 ) ;
{
helpptr = 2 ;
helpline [1 ]= 880 ;
helpline [0 ]= 881 ;
}
error () ;
doequation () ;
}
else {
lhs = curexp ;
curtype = 1 ;
getxnext () ;
varflag = 77 ;
scanexpression () ;
if ( curcmd == 51 )
doequation () ;
else if ( curcmd == 77 )
doassignment () ;
if ( internal [7 ]> 131072L )
{
begindiagnostic () ;
printnl ( 123 ) ;
if ( mem [lhs ].hhfield .lhfield > 9769 )
print ( intname [mem [lhs ].hhfield .lhfield - ( 9769 ) ]) ;
else showtokenlist ( lhs , 0 , 1000 , 0 ) ;
print ( 460 ) ;
printexp ( 0 , 0 ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
if ( mem [lhs ].hhfield .lhfield > 9769 )
if ( curtype == 16 )
internal [mem [lhs ].hhfield .lhfield - ( 9769 ) ]= curexp ;
else {
disperr ( 0 , 883 ) ;
print ( intname [mem [lhs ].hhfield .lhfield - ( 9769 ) ]) ;
print ( 884 ) ;
{
helpptr = 2 ;
helpline [1 ]= 885 ;
helpline [0 ]= 886 ;
}
putgeterror () ;
}
else {
p = findvariable ( lhs ) ;
if ( p != 0 )
{
q = stashcurexp () ;
curtype = undtype ( p ) ;
recyclevalue ( p ) ;
mem [p ].hhfield .b0 = curtype ;
mem [p + 1 ].cint = 0 ;
makeexpcopy ( p ) ;
p = stashcurexp () ;
unstashcurexp ( q ) ;
makeeq ( p ) ;
}
else {
obliterated ( lhs ) ;
putgeterror () ;
}
}
flushnodelist ( lhs ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
dotypedeclaration ( void )
#else
dotypedeclaration ( )
#endif
{
smallnumber t ;
halfword p ;
halfword q ;
if ( curmod >= 13 )
t = curmod ;
else t = curmod + 1 ;
do {
p = scandeclaredvariable () ;
flushvariable ( eqtb [mem [p ].hhfield .lhfield ].v.RH , mem [p ]
.hhfield .v.RH , false ) ;
q = findvariable ( p ) ;
if ( q != 0 )
{
mem [q ].hhfield .b0 = t ;
mem [q + 1 ].cint = 0 ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 896 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 897 ;
helpline [0 ]= 898 ;
}
putgeterror () ;
}
flushlist ( p ) ;
if ( curcmd < 82 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 899 ) ;
}
{
helpptr = 5 ;
helpline [4 ]= 900 ;
helpline [3 ]= 901 ;
helpline [2 ]= 902 ;
helpline [1 ]= 903 ;
helpline [0 ]= 904 ;
}
if ( curcmd == 42 )
helpline [2 ]= 905 ;
putgeterror () ;
scannerstatus = 2 ;
do {
getnext () ;
if ( curcmd == 39 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
} while ( ! ( curcmd >= 82 ) ) ;
scannerstatus = 0 ;
}
} while ( ! ( curcmd > 82 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
dorandomseed ( void )
#else
dorandomseed ( )
#endif
{
getxnext () ;
if ( curcmd != 77 )
{
missingerr ( 460 ) ;
{
helpptr = 1 ;
helpline [0 ]= 910 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 911 ) ;
{
helpptr = 2 ;
helpline [1 ]= 912 ;
helpline [0 ]= 913 ;
}
putgetflusherror ( 0 ) ;
}
else {
initrandoms ( curexp ) ;
if ( selector >= 2 )
{
oldsetting = selector ;
selector = 2 ;
printnl ( 914 ) ;
printscaled ( curexp ) ;
printchar ( 125 ) ;
printnl ( 283 ) ;
selector = oldsetting ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
doprotection ( void )
#else
doprotection ( )
#endif
{
char m ;
halfword t ;
m = curmod ;
do {
getsymbol () ;
t = eqtb [cursym ].lhfield ;
if ( m == 0 )
{
if ( t >= 86 )
eqtb [cursym ].lhfield = t - 86 ;
}
else if ( t < 86 )
eqtb [cursym ].lhfield = t + 86 ;
getxnext () ;
} while ( ! ( curcmd != 82 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
defdelims ( void )
#else
defdelims ( )
#endif
{
halfword ldelim, rdelim ;
getclearsymbol () ;
ldelim = cursym ;
getclearsymbol () ;
rdelim = cursym ;
eqtb [ldelim ].lhfield = 31 ;
eqtb [ldelim ].v.RH = rdelim ;
eqtb [rdelim ].lhfield = 62 ;
eqtb [rdelim ].v.RH = ldelim ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
dointerim ( void )
#else
dointerim ( )
#endif
{
getxnext () ;
if ( curcmd != 40 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 920 ) ;
}
if ( cursym == 0 )
print ( 925 ) ;
else print ( hash [cursym ].v.RH ) ;
print ( 926 ) ;
{
helpptr = 1 ;
helpline [0 ]= 927 ;
}
backerror () ;
}
else {
saveinternal ( curmod ) ;
backinput () ;
}
dostatement () ;
}
void
#ifdef HAVE_PROTOTYPES
dolet ( void )
#else
dolet ( )
#endif
{
halfword l ;
getsymbol () ;
l = cursym ;
getxnext () ;
if ( curcmd != 51 )
if ( curcmd != 77 )
{
missingerr ( 61 ) ;
{
helpptr = 3 ;
helpline [2 ]= 928 ;
helpline [1 ]= 669 ;
helpline [0 ]= 929 ;
}
backerror () ;
}
getsymbol () ;
switch ( curcmd )
{case 10 :
case 53 :
case 44 :
case 49 :
incr ( mem [curmod ].hhfield .lhfield ) ;
break ;
default:
;
break ;
}
clearsymbol ( l , false ) ;
eqtb [l ].lhfield = curcmd ;
if ( curcmd == 41 )
eqtb [l ].v.RH = 0 ;
else eqtb [l ].v.RH = curmod ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
donewinternal ( void )
#else
donewinternal ( )
#endif
{
do {
if ( intptr == maxinternal )
overflow ( 930 , maxinternal ) ;
getclearsymbol () ;
incr ( intptr ) ;
eqtb [cursym ].lhfield = 40 ;
eqtb [cursym ].v.RH = intptr ;
intname [intptr ]= hash [cursym ].v.RH ;
internal [intptr ]= 0 ;
getxnext () ;
} while ( ! ( curcmd != 82 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshow ( void )
#else
doshow ( )
#endif
{
do {
getxnext () ;
scanexpression () ;
printnl ( 761 ) ;
printexp ( 0 , 2 ) ;
flushcurexp ( 0 ) ;
} while ( ! ( curcmd != 82 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
disptoken ( void )
#else
disptoken ( )
#endif
{
printnl ( 936 ) ;
if ( cursym == 0 )
{
if ( curcmd == 42 )
printscaled ( curmod ) ;
else if ( curcmd == 38 )
{
gpointer = curmod ;
printcapsule () ;
}
else {
printchar ( 34 ) ;
print ( curmod ) ;
printchar ( 34 ) ;
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
}
}
else {
print ( hash [cursym ].v.RH ) ;
printchar ( 61 ) ;
if ( eqtb [cursym ].lhfield >= 86 )
print ( 937 ) ;
printcmdmod ( curcmd , curmod ) ;
if ( curcmd == 10 )
{
println () ;
showmacro ( curmod , 0 , 100000L ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
doshowtoken ( void )
#else
doshowtoken ( )
#endif
{
do {
getnext () ;
disptoken () ;
getxnext () ;
} while ( ! ( curcmd != 82 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshowstats ( void )
#else
doshowstats ( )
#endif
{
printnl ( 946 ) ;
;
#ifdef STAT
printint ( varused ) ;
printchar ( 38 ) ;
printint ( dynused ) ;
if ( false )
#endif /* STAT */
print ( 356 ) ;
print ( 557 ) ;
printint ( himemmin - lomemmax - 1 ) ;
print ( 947 ) ;
println () ;
printnl ( 948 ) ;
printint ( strptr - initstrptr ) ;
printchar ( 38 ) ;
printint ( poolptr - initpoolptr ) ;
print ( 557 ) ;
printint ( maxstrings - maxstrptr ) ;
printchar ( 38 ) ;
printint ( poolsize - maxpoolptr ) ;
print ( 947 ) ;
println () ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zdispvar ( halfword p )
#else
zdispvar ( p )
halfword p ;
#endif
{
halfword q ;
integer n ;
if ( mem [p ].hhfield .b0 == 21 )
{
q = mem [p + 1 ].hhfield .lhfield ;
do {
dispvar ( q ) ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == 17 ) ) ;
q = mem [p + 1 ].hhfield .v.RH ;
while ( mem [q ].hhfield .b1 == 3 ) {
dispvar ( q ) ;
q = mem [q ].hhfield .v.RH ;
}
}
else if ( mem [p ].hhfield .b0 >= 22 )
{
printnl ( 283 ) ;
printvariablename ( p ) ;
if ( mem [p ].hhfield .b0 > 22 )
print ( 661 ) ;
print ( 949 ) ;
if ( fileoffset >= maxprintline - 20 )
n = 5 ;
else n = maxprintline - fileoffset - 15 ;
showmacro ( mem [p + 1 ].cint , 0 , n ) ;
}
else if ( mem [p ].hhfield .b0 != 0 )
{
printnl ( 283 ) ;
printvariablename ( p ) ;
printchar ( 61 ) ;
printexp ( p , 0 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
doshowvar ( void )
#else
doshowvar ( )
#endif
{
/* 30 */ do {
getnext () ;
if ( cursym > 0 )
if ( cursym <= 9769 )
if ( curcmd == 41 )
if ( curmod != 0 )
{
dispvar ( curmod ) ;
goto lab30 ;
}
disptoken () ;
lab30: getxnext () ;
} while ( ! ( curcmd != 82 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshowdependencies ( void )
#else
doshowdependencies ( )
#endif
{
halfword p ;
p = mem [13 ].hhfield .v.RH ;
while ( p != 13 ) {
if ( interesting ( p ) )
{
printnl ( 283 ) ;
printvariablename ( p ) ;
if ( mem [p ].hhfield .b0 == 17 )
printchar ( 61 ) ;
else print ( 764 ) ;
printdependency ( mem [p + 1 ].hhfield .v.RH , mem [p ].hhfield .b0
) ;
}
p = mem [p + 1 ].hhfield .v.RH ;
while ( mem [p ].hhfield .lhfield != 0 ) p = mem [p ].hhfield .v.RH ;
p = mem [p ].hhfield .v.RH ;
}
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
doshowwhatever ( void )
#else
doshowwhatever ( )
#endif
{
if ( interaction == 3 )
;
switch ( curmod )
{case 0 :
doshowtoken () ;
break ;
case 1 :
doshowstats () ;
break ;
case 2 :
doshow () ;
break ;
case 3 :
doshowvar () ;
break ;
case 4 :
doshowdependencies () ;
break ;
}
if ( internal [32 ]> 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 950 ) ;
}
if ( interaction < 3 )
{
helpptr = 0 ;
decr ( errorcount ) ;
}
else {
helpptr = 1 ;
helpline [0 ]= 951 ;
}
if ( curcmd == 83 )
error () ;
else putgeterror () ;
}
}
boolean
#ifdef HAVE_PROTOTYPES
scanwith ( void )
#else
scanwith ( )
#endif
{
register boolean Result; smallnumber t ;
boolean result ;
t = curmod ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
result = false ;
if ( curtype != t )
{
disperr ( 0 , 959 ) ;
{
helpptr = 2 ;
helpline [1 ]= 960 ;
helpline [0 ]= 961 ;
}
if ( t == 6 )
helpline [1 ]= 962 ;
putgetflusherror ( 0 ) ;
}
else if ( curtype == 6 )
result = true ;
else {
curexp = roundunscaled ( curexp ) ;
if ( ( abs ( curexp ) < 4 ) && ( curexp != 0 ) )
result = true ;
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 963 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 961 ;
}
putgetflusherror ( 0 ) ;
}
}
Result = result ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zfindedgesvar ( halfword t )
#else
zfindedgesvar ( t )
halfword t ;
#endif
{
halfword p ;
p = findvariable ( t ) ;
curedges = 0 ;
if ( p == 0 )
{
obliterated ( t ) ;
putgeterror () ;
}
else if ( mem [p ].hhfield .b0 != 11 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 786 ) ;
}
showtokenlist ( t , 0 , 1000 , 0 ) ;
print ( 964 ) ;
printtype ( mem [p ].hhfield .b0 ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 965 ;
helpline [0 ]= 966 ;
}
putgeterror () ;
}
else curedges = mem [p + 1 ].cint ;
flushnodelist ( t ) ;
}
void
#ifdef HAVE_PROTOTYPES
doaddto ( void )
#else
doaddto ( )
#endif
{
/* 30 45 */ halfword lhs, rhs ;
integer w ;
halfword p ;
halfword q ;
char addtotype ;
getxnext () ;
varflag = 68 ;
scanprimary () ;
if ( curtype != 20 )
{
disperr ( 0 , 967 ) ;
{
helpptr = 4 ;
helpline [3 ]= 968 ;
helpline [2 ]= 969 ;
helpline [1 ]= 970 ;
helpline [0 ]= 966 ;
}
putgetflusherror ( 0 ) ;
}
else {
lhs = curexp ;
addtotype = curmod ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
if ( addtotype == 2 )
{
findedgesvar ( lhs ) ;
if ( curedges == 0 )
flushcurexp ( 0 ) ;
else if ( curtype != 11 )
{
disperr ( 0 , 971 ) ;
{
helpptr = 2 ;
helpline [1 ]= 972 ;
helpline [0 ]= 966 ;
}
putgetflusherror ( 0 ) ;
}
else {
mergeedges ( curexp ) ;
flushcurexp ( 0 ) ;
}
}
else {
if ( curtype == 14 )
pairtopath () ;
if ( curtype != 9 )
{
disperr ( 0 , 971 ) ;
{
helpptr = 2 ;
helpline [1 ]= 973 ;
helpline [0 ]= 966 ;
}
putgetflusherror ( 0 ) ;
flushtokenlist ( lhs ) ;
}
else {
rhs = curexp ;
w = 1 ;
curpen = 3 ;
while ( curcmd == 66 ) if ( scanwith () )
if ( curtype == 16 )
w = curexp ;
else {
if ( mem [curpen ].hhfield .lhfield == 0 )
tosspen ( curpen ) ;
else decr ( mem [curpen ].hhfield .lhfield ) ;
curpen = curexp ;
}
findedgesvar ( lhs ) ;
if ( curedges == 0 )
tossknotlist ( rhs ) ;
else {
lhs = 0 ;
curpathtype = addtotype ;
if ( mem [rhs ].hhfield .b0 == 0 )
if ( curpathtype == 0 )
if ( mem [rhs ].hhfield .v.RH == rhs )
{
mem [rhs + 5 ].cint = mem [rhs + 1 ].cint ;
mem [rhs + 6 ].cint = mem [rhs + 2 ].cint ;
mem [rhs + 3 ].cint = mem [rhs + 1 ].cint ;
mem [rhs + 4 ].cint = mem [rhs + 2 ].cint ;
mem [rhs ].hhfield .b0 = 1 ;
mem [rhs ].hhfield .b1 = 1 ;
}
else {
p = htapypoc ( rhs ) ;
q = mem [p ].hhfield .v.RH ;
mem [pathtail + 5 ].cint = mem [q + 5 ].cint ;
mem [pathtail + 6 ].cint = mem [q + 6 ].cint ;
mem [pathtail ].hhfield .b1 = mem [q ].hhfield .b1 ;
mem [pathtail ].hhfield .v.RH = mem [q ].hhfield .v.RH ;
freenode ( q , 7 ) ;
mem [p + 5 ].cint = mem [rhs + 5 ].cint ;
mem [p + 6 ].cint = mem [rhs + 6 ].cint ;
mem [p ].hhfield .b1 = mem [rhs ].hhfield .b1 ;
mem [p ].hhfield .v.RH = mem [rhs ].hhfield .v.RH ;
freenode ( rhs , 7 ) ;
rhs = p ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 974 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 975 ;
helpline [0 ]= 966 ;
}
putgeterror () ;
tossknotlist ( rhs ) ;
goto lab45 ;
}
else if ( curpathtype == 0 )
lhs = htapypoc ( rhs ) ;
curwt = w ;
rhs = makespec ( rhs , mem [curpen + 9 ].cint , internal [5 ]) ;
if ( turningnumber <= 0 )
if ( curpathtype != 0 )
if ( internal [39 ]> 0 )
if ( ( turningnumber < 0 ) && ( mem [curpen ].hhfield .v.RH == 0 )
)
curwt = - (integer) curwt ;
else {
if ( turningnumber == 0 )
if ( ( internal [39 ]<= 65536L ) && ( mem [curpen ].hhfield
.v.RH == 0 ) )
goto lab30 ;
else printstrange ( 976 ) ;
else printstrange ( 977 ) ;
{
helpptr = 3 ;
helpline [2 ]= 978 ;
helpline [1 ]= 979 ;
helpline [0 ]= 980 ;
}
putgeterror () ;
}
lab30: ;
if ( mem [curpen + 9 ].cint == 0 )
fillspec ( rhs ) ;
else fillenvelope ( rhs ) ;
if ( lhs != 0 )
{
revturns = true ;
lhs = makespec ( lhs , mem [curpen + 9 ].cint , internal [5 ])
;
revturns = false ;
if ( mem [curpen + 9 ].cint == 0 )
fillspec ( lhs ) ;
else fillenvelope ( lhs ) ;
}
lab45: ;
}
if ( mem [curpen ].hhfield .lhfield == 0 )
tosspen ( curpen ) ;
else decr ( mem [curpen ].hhfield .lhfield ) ;
}
}
}
}
scaled
#ifdef HAVE_PROTOTYPES
ztfmcheck ( smallnumber m )
#else
ztfmcheck ( m )
smallnumber m ;
#endif
{
register scaled Result; if ( abs ( internal [m ]) >= 134217728L )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 997 ) ;
}
print ( intname [m ]) ;
print ( 998 ) ;
{
helpptr = 1 ;
helpline [0 ]= 999 ;
}
putgeterror () ;
if ( internal [m ]> 0 )
Result = 134217727L ;
else Result = -134217727L ;
}
else Result = internal [m ];
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
doshipout ( void )
#else
doshipout ( )
#endif
{
/* 10 */ integer c ;
getxnext () ;
varflag = 83 ;
scanexpression () ;
if ( curtype != 20 )
if ( curtype == 11 )
curedges = curexp ;
else {
{
disperr ( 0 , 967 ) ;
{
helpptr = 4 ;
helpline [3 ]= 968 ;
helpline [2 ]= 969 ;
helpline [1 ]= 970 ;
helpline [0 ]= 966 ;
}
putgetflusherror ( 0 ) ;
}
goto lab10 ;
}
else {
findedgesvar ( curexp ) ;
curtype = 1 ;
}
if ( curedges != 0 )
{
c = roundunscaled ( internal [18 ]) % 256 ;
if ( c < 0 )
c = c + 256 ;
if ( c < bc )
bc = c ;
if ( c > ec )
ec = c ;
charexists [c ]= true ;
gfdx [c ]= internal [24 ];
gfdy [c ]= internal [25 ];
tfmwidth [c ]= tfmcheck ( 20 ) ;
tfmheight [c ]= tfmcheck ( 21 ) ;
tfmdepth [c ]= tfmcheck ( 22 ) ;
tfmitalcorr [c ]= tfmcheck ( 23 ) ;
if ( internal [34 ]>= 0 )
shipout ( c ) ;
}
flushcurexp ( 0 ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
dodisplay ( void )
#else
dodisplay ( )
#endif
{
/* 45 50 10 */ halfword e ;
getxnext () ;
varflag = 73 ;
scanprimary () ;
if ( curtype != 20 )
{
disperr ( 0 , 967 ) ;
{
helpptr = 4 ;
helpline [3 ]= 968 ;
helpline [2 ]= 969 ;
helpline [1 ]= 970 ;
helpline [0 ]= 966 ;
}
putgetflusherror ( 0 ) ;
}
else {
e = curexp ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
goto lab50 ;
curexp = roundunscaled ( curexp ) ;
if ( curexp < 0 )
goto lab45 ;
if ( curexp > 15 )
goto lab45 ;
if ( ! windowopen [curexp ])
goto lab45 ;
findedgesvar ( e ) ;
if ( curedges != 0 )
dispedges ( curexp ) ;
goto lab10 ;
lab45: curexp = curexp * 65536L ;
lab50: disperr ( 0 , 981 ) ;
{
helpptr = 1 ;
helpline [0 ]= 982 ;
}
putgetflusherror ( 0 ) ;
flushtokenlist ( e ) ;
}
lab10: ;
}
boolean
#ifdef HAVE_PROTOTYPES
zgetpair ( commandcode c )
#else
zgetpair ( c )
commandcode c ;
#endif
{
register boolean Result; halfword p ;
boolean b ;
if ( curcmd != c )
Result = false ;
else {
getxnext () ;
scanexpression () ;
if ( nicepair ( curexp , curtype ) )
{
p = mem [curexp + 1 ].cint ;
curx = mem [p + 1 ].cint ;
cury = mem [p + 3 ].cint ;
b = true ;
}
else b = false ;
flushcurexp ( 0 ) ;
Result = b ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
doopenwindow ( void )
#else
doopenwindow ( )
#endif
{
/* 45 10 */ integer k ;
scaled r0, c0, r1, c1 ;
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
goto lab45 ;
k = roundunscaled ( curexp ) ;
if ( k < 0 )
goto lab45 ;
if ( k > 15 )
goto lab45 ;
if ( ! getpair ( 70 ) )
goto lab45 ;
r0 = curx ;
c0 = cury ;
if ( ! getpair ( 71 ) )
goto lab45 ;
r1 = curx ;
c1 = cury ;
if ( ! getpair ( 72 ) )
goto lab45 ;
openawindow ( k , r0 , c0 , r1 , c1 , curx , cury ) ;
goto lab10 ;
lab45: {
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 983 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 984 ;
helpline [0 ]= 985 ;
}
putgeterror () ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
docull ( void )
#else
docull ( )
#endif
{
/* 45 10 */ halfword e ;
char keeping ;
integer w, win, wout ;
w = 1 ;
getxnext () ;
varflag = 67 ;
scanprimary () ;
if ( curtype != 20 )
{
disperr ( 0 , 967 ) ;
{
helpptr = 4 ;
helpline [3 ]= 968 ;
helpline [2 ]= 969 ;
helpline [1 ]= 970 ;
helpline [0 ]= 966 ;
}
putgetflusherror ( 0 ) ;
}
else {
e = curexp ;
curtype = 1 ;
keeping = curmod ;
if ( ! getpair ( 67 ) )
goto lab45 ;
while ( ( curcmd == 66 ) && ( curmod == 16 ) ) if ( scanwith () )
w = curexp ;
if ( curx > cury )
goto lab45 ;
if ( keeping == 0 )
{
if ( ( curx > 0 ) || ( cury < 0 ) )
goto lab45 ;
wout = w ;
win = 0 ;
}
else {
if ( ( curx <= 0 ) && ( cury >= 0 ) )
goto lab45 ;
wout = 0 ;
win = w ;
}
findedgesvar ( e ) ;
if ( curedges != 0 )
culledges ( floorunscaled ( curx + 65535L ) , floorunscaled ( cury ) ,
wout , win ) ;
goto lab10 ;
lab45: {
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 986 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 987 ;
}
putgeterror () ;
flushtokenlist ( e ) ;
}
lab10: ;
}
|
